reasonix 0.4.23 → 0.4.26

package/dist/cli/index.js

@@ -7,7 +7,7 @@ import {
   memoryEnabled,
   readProjectMemory,
   sanitizeMemoryName
-} from "./chunk-K6MR4SWS.js";
+} from "./chunk-2BYEKJHX.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -1893,6 +1893,10 @@ var CacheFirstLoop = class {
           usage = resp.usage;
         }
       } catch (err) {
+        if (signal.aborted) {
+          yield { turn: this._turn, role: "done", content: "" };
+          return;
+        }
         yield {
           turn: this._turn,
           role: "error",
@@ -2212,6 +2216,74 @@ import { promises as fs } from "fs";
 import * as pathMod from "path";
 var DEFAULT_MAX_READ_BYTES = 2 * 1024 * 1024;
 var DEFAULT_MAX_LIST_BYTES = 256 * 1024;
+var SKIP_DIR_NAMES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".hg",
+  ".svn",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  "target",
+  // Rust / Java
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".cache",
+  "coverage"
+]);
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".tiff",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".xz",
+  ".7z",
+  ".rar",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".class",
+  ".jar",
+  ".war",
+  ".o",
+  ".obj",
+  ".lib",
+  ".a",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".mp3",
+  ".mp4",
+  ".mov",
+  ".avi",
+  ".webm",
+  ".wasm",
+  ".pyc",
+  ".pyo"
+]);
+function isLikelyBinaryByName(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot < 0) return false;
+  return BINARY_EXTENSIONS.has(name.slice(dot).toLowerCase());
+}
 function registerFilesystemTools(registry, opts) {
   const rootDir = pathMod.resolve(opts.rootDir);
   const allowWriting = opts.allowWriting !== false;
@@ -2221,7 +2293,12 @@ function registerFilesystemTools(registry, opts) {
     if (typeof raw !== "string" || raw.length === 0) {
       throw new Error("path must be a non-empty string");
     }
-    const resolved = pathMod.resolve(rootDir, raw);
+    let normalized = raw;
+    while (normalized.startsWith("/") || normalized.startsWith("\\")) {
+      normalized = normalized.slice(1);
+    }
+    if (normalized.length === 0) normalized = ".";
+    const resolved = pathMod.resolve(rootDir, normalized);
     const normRoot = pathMod.resolve(rootDir);
     const rel = pathMod.relative(normRoot, resolved);
     if (rel.startsWith("..") || pathMod.isAbsolute(rel)) {
@@ -2387,6 +2464,114 @@ function registerFilesystemTools(registry, opts) {
       return matches.length === 0 ? "(no matches)" : matches.join("\n");
     }
   });
+  registry.register({
+    name: "search_content",
+    description: "Recursively grep file CONTENTS for a substring or regex. This is the right tool for 'find all places that call X', 'where is Y referenced', 'what files contain Z'. Different from search_files (which matches FILE NAMES). Returns one match per line in 'path:line: text' format. Skips dependency / VCS / build directories (node_modules, .git, dist, build, .next, target, .venv) and binary files by default.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Substring (or regex) to search file contents for."
+        },
+        path: {
+          type: "string",
+          description: "Directory to start the search at (default: sandbox root)."
+        },
+        glob: {
+          type: "string",
+          description: "Optional file-name suffix or substring filter. Examples: '.ts' (only TypeScript), 'test' (any file with 'test' in the name). Reduces noise when you know the file shape."
+        },
+        case_sensitive: {
+          type: "boolean",
+          description: "When true, match case exactly. Default false (case-insensitive)."
+        },
+        include_deps: {
+          type: "boolean",
+          description: "When true, also search inside node_modules / .git / dist / build / etc. Off by default \u2014 most exploration questions are about the user's own code."
+        }
+      },
+      required: ["pattern"]
+    },
+    fn: async (args) => {
+      const startAbs = safePath(args.path ?? ".");
+      const caseSensitive = args.case_sensitive === true;
+      const includeDeps = args.include_deps === true;
+      const nameFilter = typeof args.glob === "string" ? args.glob.toLowerCase() : null;
+      let re = null;
+      try {
+        re = new RegExp(args.pattern, caseSensitive ? "" : "i");
+      } catch {
+        re = null;
+      }
+      const needle = caseSensitive ? args.pattern : args.pattern.toLowerCase();
+      const matches = [];
+      let totalBytes = 0;
+      let scanned = 0;
+      let truncated = false;
+      const walk2 = async (dir) => {
+        if (truncated) return;
+        let entries;
+        try {
+          entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        for (const e of entries) {
+          if (truncated) return;
+          if (e.isDirectory()) {
+            if (!includeDeps && SKIP_DIR_NAMES.has(e.name)) continue;
+            await walk2(pathMod.join(dir, e.name));
+            continue;
+          }
+          if (!e.isFile()) continue;
+          if (nameFilter && !e.name.toLowerCase().includes(nameFilter)) continue;
+          if (isLikelyBinaryByName(e.name)) continue;
+          const full = pathMod.join(dir, e.name);
+          let stat;
+          try {
+            stat = await fs.stat(full);
+          } catch {
+            continue;
+          }
+          if (stat.size > 2 * 1024 * 1024) continue;
+          let raw;
+          try {
+            raw = await fs.readFile(full);
+          } catch {
+            continue;
+          }
+          const firstNul = raw.indexOf(0);
+          if (firstNul !== -1 && firstNul < 8 * 1024) continue;
+          const text = raw.toString("utf8");
+          const rel = pathMod.relative(rootDir, full);
+          const lines = text.split(/\r?\n/);
+          for (let li = 0; li < lines.length; li++) {
+            const line = lines[li];
+            const lineForCheck = caseSensitive ? line : line.toLowerCase();
+            const hit = re ? re.test(line) : lineForCheck.includes(needle);
+            if (!hit) continue;
+            const display = line.length > 200 ? `${line.slice(0, 200)}\u2026` : line;
+            const out = `${rel}:${li + 1}: ${display}`;
+            if (totalBytes + out.length + 1 > maxListBytes) {
+              matches.push(`[\u2026 truncated at ${maxListBytes} bytes \u2014 refine pattern or path \u2026]`);
+              truncated = true;
+              return;
+            }
+            matches.push(out);
+            totalBytes += out.length + 1;
+          }
+          scanned++;
+        }
+      };
+      await walk2(startAbs);
+      if (matches.length === 0) {
+        return scanned === 0 ? "(no files scanned \u2014 path empty or all files filtered out)" : `(no matches across ${scanned} file${scanned === 1 ? "" : "s"})`;
+      }
+      return 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.",
@@ -2459,10 +2644,10 @@ function registerFilesystemTools(registry, opts) {
       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 header2 = `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}
+      return `${header2}
 ${diff}`;
     }
   });
@@ -2713,6 +2898,127 @@ function registerPlanTool(registry, opts = {}) {
   return registry;
 }
 
+// src/tools/subagent.ts
+var DEFAULT_MAX_RESULT_CHARS2 = 8e3;
+var DEFAULT_MAX_ITERS = 16;
+var DEFAULT_SUBAGENT_MODEL = "deepseek-chat";
+var SUBAGENT_TOOL_NAME = "spawn_subagent";
+var NEVER_INHERITED_TOOLS = /* @__PURE__ */ new Set([SUBAGENT_TOOL_NAME, "submit_plan"]);
+async function spawnSubagent(opts) {
+  const model = opts.model ?? DEFAULT_SUBAGENT_MODEL;
+  const maxToolIters = opts.maxToolIters ?? DEFAULT_MAX_ITERS;
+  const maxResultChars = opts.maxResultChars ?? DEFAULT_MAX_RESULT_CHARS2;
+  const sink = opts.sink;
+  const startedAt = Date.now();
+  const taskPreview = opts.task.length > 30 ? `${opts.task.slice(0, 30)}\u2026` : opts.task;
+  sink?.current?.({
+    kind: "start",
+    task: taskPreview,
+    iter: 0,
+    elapsedMs: 0
+  });
+  const childTools = forkRegistryExcluding(opts.parentRegistry, NEVER_INHERITED_TOOLS);
+  const childPrefix = new ImmutablePrefix({
+    system: opts.system,
+    toolSpecs: childTools.specs()
+  });
+  const childLoop = new CacheFirstLoop({
+    client: opts.client,
+    prefix: childPrefix,
+    tools: childTools,
+    model,
+    maxToolIters,
+    hooks: [],
+    stream: false
+  });
+  const onParentAbort = () => childLoop.abort();
+  opts.parentSignal?.addEventListener("abort", onParentAbort, { once: true });
+  let final = "";
+  let errorMessage;
+  let toolIter = 0;
+  try {
+    for await (const ev of childLoop.step(opts.task)) {
+      if (ev.role === "tool") {
+        toolIter++;
+        sink?.current?.({
+          kind: "progress",
+          task: taskPreview,
+          iter: toolIter,
+          elapsedMs: Date.now() - startedAt
+        });
+      }
+      if (ev.role === "assistant_final") {
+        final = ev.content ?? "";
+      }
+      if (ev.role === "error") {
+        errorMessage = ev.error ?? "subagent error";
+      }
+    }
+  } catch (err) {
+    errorMessage = err.message;
+  } finally {
+    opts.parentSignal?.removeEventListener("abort", onParentAbort);
+  }
+  if (!errorMessage && !final) {
+    errorMessage = opts.parentSignal?.aborted ? "subagent aborted before producing an answer" : "subagent ended without producing an answer";
+  }
+  const elapsedMs = Date.now() - startedAt;
+  const turns = childLoop.stats.turns.length;
+  const costUsd2 = childLoop.stats.totalCost;
+  const truncated = final.length > maxResultChars ? `${final.slice(0, maxResultChars)}
+
+[\u2026truncated ${final.length - maxResultChars} chars; ask the subagent for a tighter summary if you need more.]` : final;
+  sink?.current?.({
+    kind: "end",
+    task: taskPreview,
+    iter: toolIter,
+    elapsedMs,
+    summary: errorMessage ? void 0 : truncated.slice(0, 120),
+    error: errorMessage,
+    turns
+  });
+  return {
+    success: !errorMessage,
+    output: errorMessage ? "" : truncated,
+    error: errorMessage,
+    turns,
+    toolIters: toolIter,
+    elapsedMs,
+    costUsd: costUsd2
+  };
+}
+function formatSubagentResult(r) {
+  if (!r.success) {
+    return JSON.stringify({
+      success: false,
+      error: r.error ?? "unknown subagent error",
+      turns: r.turns,
+      tool_iters: r.toolIters,
+      elapsed_ms: r.elapsedMs
+    });
+  }
+  return JSON.stringify({
+    success: true,
+    output: r.output,
+    turns: r.turns,
+    tool_iters: r.toolIters,
+    elapsed_ms: r.elapsedMs,
+    cost_usd: r.costUsd
+  });
+}
+function forkRegistryExcluding(parent, exclude) {
+  const child = new ToolRegistry();
+  for (const spec of parent.specs()) {
+    const name = spec.function.name;
+    if (exclude.has(name)) continue;
+    const def = parent.get(name);
+    if (!def) continue;
+    child.register(def);
+  }
+  if (parent.planMode) child.setPlanMode(true);
+  return child;
+}
+
 // src/tools/shell.ts
 import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync3, statSync as statSync2 } from "fs";
@@ -2910,7 +3216,7 @@ function prepareSpawn(argv, opts = {}) {
     const cmdline = [resolved, ...tail].map(quoteForCmdExe).join(" ");
     return {
       bin: "cmd.exe",
-      args: ["/d", "/s", "/c", cmdline],
+      args: ["/d", "/s", "/c", withUtf8Codepage(cmdline)],
       // windowsVerbatimArguments prevents Node from re-quoting the /c
       // payload — we've already composed an exact cmd.exe command
       // line. Without this Node wraps our already-quoted string in
@@ -2922,12 +3228,36 @@ function prepareSpawn(argv, opts = {}) {
     const cmdline = [head, ...tail].map(quoteForCmdExe).join(" ");
     return {
       bin: "cmd.exe",
-      args: ["/d", "/s", "/c", cmdline],
+      args: ["/d", "/s", "/c", withUtf8Codepage(cmdline)],
       spawnOverrides: { windowsVerbatimArguments: true }
     };
   }
+  if (isPowerShellExe(resolved)) {
+    const patched = injectPowerShellUtf8(tail);
+    if (patched) {
+      return { bin: resolved, args: patched, spawnOverrides: {} };
+    }
+  }
   return { bin: resolved, args: [...tail], spawnOverrides: {} };
 }
+function isPowerShellExe(resolved) {
+  return /(?:^|[\\/])(?:powershell|pwsh)(?:\.exe)?$/i.test(resolved);
+}
+function injectPowerShellUtf8(args) {
+  const prelude = "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8;$OutputEncoding=[System.Text.Encoding]::UTF8;";
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i] ?? "";
+    if (/^-(?:Command|c)$/i.test(a) && i + 1 < args.length) {
+      const out = [...args];
+      out[i + 1] = `${prelude}${args[i + 1] ?? ""}`;
+      return out;
+    }
+  }
+  return null;
+}
+function withUtf8Codepage(cmdline) {
+  return `chcp 65001 >nul & ${cmdline}`;
+}
 function isBareWindowsName(s) {
   if (!s) return false;
   if (s.includes("/") || s.includes("\\")) return false;
@@ -3005,11 +3335,11 @@ function registerShellTools(registry, opts) {
   return registry;
 }
 function formatCommandResult(cmd, r) {
-  const header = r.timedOut ? `$ ${cmd}
+  const header2 = r.timedOut ? `$ ${cmd}
 [killed after timeout]` : `$ ${cmd}
 [exit ${r.exitCode ?? "?"}]`;
-  return r.output ? `${header}
-${r.output}` : header;
+  return r.output ? `${header2}
+${r.output}` : header2;
 }
 
 // src/tools/web.ts
@@ -3174,9 +3504,9 @@ function registerWebTools(registry, opts = {}) {
         throw new Error("web_fetch: url must start with http:// or https://");
       }
       const page = await webFetch(args.url, { maxChars: maxFetchChars, signal: ctx?.signal });
-      const header = page.title ? `${page.title}
+      const header2 = page.title ? `${page.title}
 ${page.url}` : page.url;
-      return `${header}
+      return `${header2}
 
 ${page.text}`;
     }
@@ -4582,28 +4912,163 @@ function isNpxInstall() {
   return false;
 }
 
+// src/usage.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync8, statSync as statSync3 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname6, join as join6 } from "path";
+function defaultUsageLogPath(homeDirOverride) {
+  return join6(homeDirOverride ?? homedir5(), ".reasonix", "usage.jsonl");
+}
+function appendUsage(input) {
+  const record = {
+    ts: input.now ?? Date.now(),
+    session: input.session,
+    model: input.model,
+    promptTokens: input.usage.promptTokens,
+    completionTokens: input.usage.completionTokens,
+    cacheHitTokens: input.usage.promptCacheHitTokens,
+    cacheMissTokens: input.usage.promptCacheMissTokens,
+    costUsd: costUsd(input.model, input.usage),
+    claudeEquivUsd: claudeEquivalentCost(input.usage)
+  };
+  const path = input.path ?? defaultUsageLogPath();
+  try {
+    mkdirSync5(dirname6(path), { recursive: true });
+    appendFileSync2(path, `${JSON.stringify(record)}
+`, "utf8");
+  } catch {
+  }
+  return record;
+}
+function readUsageLog(path = defaultUsageLogPath()) {
+  if (!existsSync6(path)) return [];
+  let raw;
+  try {
+    raw = readFileSync8(path, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const rec = JSON.parse(line);
+      if (isValidRecord(rec)) out.push(rec);
+    } catch {
+    }
+  }
+  return out;
+}
+function isValidRecord(rec) {
+  if (!rec || typeof rec !== "object") return false;
+  const r = rec;
+  return typeof r.ts === "number" && typeof r.model === "string" && typeof r.promptTokens === "number" && typeof r.completionTokens === "number" && typeof r.cacheHitTokens === "number" && typeof r.cacheMissTokens === "number" && typeof r.costUsd === "number" && typeof r.claudeEquivUsd === "number";
+}
+function bucketCacheHitRatio(b) {
+  const denom = b.cacheHitTokens + b.cacheMissTokens;
+  return denom > 0 ? b.cacheHitTokens / denom : 0;
+}
+function bucketSavingsFraction(b) {
+  return b.claudeEquivUsd > 0 ? 1 - b.costUsd / b.claudeEquivUsd : 0;
+}
+function emptyBucket(label, since) {
+  return {
+    label,
+    since,
+    turns: 0,
+    promptTokens: 0,
+    completionTokens: 0,
+    cacheHitTokens: 0,
+    cacheMissTokens: 0,
+    costUsd: 0,
+    claudeEquivUsd: 0
+  };
+}
+function addToBucket(b, r) {
+  b.turns += 1;
+  b.promptTokens += r.promptTokens;
+  b.completionTokens += r.completionTokens;
+  b.cacheHitTokens += r.cacheHitTokens;
+  b.cacheMissTokens += r.cacheMissTokens;
+  b.costUsd += r.costUsd;
+  b.claudeEquivUsd += r.claudeEquivUsd;
+}
+function aggregateUsage(records, opts = {}) {
+  const now = opts.now ?? Date.now();
+  const day = 24 * 60 * 60 * 1e3;
+  const today = emptyBucket("today", now - day);
+  const week = emptyBucket("week", now - 7 * day);
+  const month = emptyBucket("month", now - 30 * day);
+  const all = emptyBucket("all-time", 0);
+  const modelCounts = /* @__PURE__ */ new Map();
+  const sessionCounts = /* @__PURE__ */ new Map();
+  let firstSeen = null;
+  let lastSeen = null;
+  for (const r of records) {
+    addToBucket(all, r);
+    if (r.ts >= today.since) addToBucket(today, r);
+    if (r.ts >= week.since) addToBucket(week, r);
+    if (r.ts >= month.since) addToBucket(month, r);
+    modelCounts.set(r.model, (modelCounts.get(r.model) ?? 0) + 1);
+    const sessKey = r.session ?? "(ephemeral)";
+    sessionCounts.set(sessKey, (sessionCounts.get(sessKey) ?? 0) + 1);
+    if (firstSeen === null || r.ts < firstSeen) firstSeen = r.ts;
+    if (lastSeen === null || r.ts > lastSeen) lastSeen = r.ts;
+  }
+  const byModel = Array.from(modelCounts.entries()).map(([model, turns]) => ({ model, turns })).sort((a, b) => b.turns - a.turns);
+  const bySession = Array.from(sessionCounts.entries()).map(([session, turns]) => ({ session, turns })).sort((a, b) => b.turns - a.turns);
+  return {
+    buckets: [today, week, month, all],
+    byModel,
+    bySession,
+    firstSeen,
+    lastSeen
+  };
+}
+function formatLogSize(path = defaultUsageLogPath()) {
+  if (!existsSync6(path)) return "";
+  try {
+    const s = statSync3(path);
+    const bytes = s.size;
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  } catch {
+    return "";
+  }
+}
+
 // src/cli/commands/chat.tsx
-import { existsSync as existsSync6, statSync as statSync3 } from "fs";
+import { existsSync as existsSync8, statSync as statSync4 } from "fs";
 import { render } from "ink";
 import React15, { useState as useState7 } from "react";
 
+// src/cli/ui/App.tsx
+import { Box as Box11, Static, Text as Text11, useApp, useInput as useInput4 } from "ink";
+import React12, { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState5 } from "react";
+
 // src/tools/skills.ts
 function registerSkillTools(registry, opts = {}) {
-  const store = new SkillStore({ homeDir: opts.homeDir, projectRoot: opts.projectRoot });
+  const store = new SkillStore({
+    homeDir: opts.homeDir,
+    projectRoot: opts.projectRoot,
+    disableBuiltins: opts.disableBuiltins
+  });
+  const subagentRunner = opts.subagentRunner;
   registry.register({
     name: "run_skill",
-    description: "Load the full body of a user-defined skill into this conversation. Call when the pinned Skills index (in the system prompt) lists a skill whose description matches what's being asked. Returns the skill's markdown instructions \u2014 read them and continue the loop, calling whatever filesystem / shell / web tools the skill's prose requires. Skills are user content; follow their instructions, but keep Reasonix's own safety rules (no destructive ops without confirmation, etc.).",
+    description: "Invoke a playbook from the Skills index pinned in the system prompt. Each entry is a self-contained instruction block. Skills marked with \u{1F9EC} in the index spawn an isolated subagent \u2014 only the final distilled answer comes back, the model's tool calls + reasoning during the run never enter your context. Plain skills are inlined: the body becomes a tool result you read and follow. For \u{1F9EC} subagent skills, supply 'arguments' describing the concrete task \u2014 they'll be the only context the subagent has.",
     readOnly: true,
     parameters: {
       type: "object",
       properties: {
         name: {
           type: "string",
-          description: "Skill identifier as it appears in the pinned Skills index (e.g. 'review', 'security-review'). Case-sensitive."
+          description: "Skill identifier as it appears in the pinned Skills index (e.g. 'explore', 'review', 'security-review'). Case-sensitive."
         },
         arguments: {
           type: "string",
-          description: "Optional free-form arguments the caller wants the skill to act on. Forwarded verbatim as an 'Arguments:' line appended to the skill body; the skill's own instructions decide how to consume them."
+          description: "Free-form arguments the skill should act on. For inline skills: appended to the body as an 'Arguments:' line; the skill's own instructions decide how to consume them. For \u{1F9EC} subagent skills: REQUIRED \u2014 becomes the entire task description the subagent receives, since it has no other context."
         }
       },
       required: ["name"]
@@ -4622,7 +5087,20 @@ function registerSkillTools(registry, opts = {}) {
         });
       }
       const rawArgs = typeof args.arguments === "string" ? args.arguments.trim() : "";
-      const header = [
+      if (skill.runAs === "subagent") {
+        if (!subagentRunner) {
+          return JSON.stringify({
+            error: `run_skill: skill ${JSON.stringify(name)} is marked runAs=subagent but no subagent runner is configured for this session. Skill authors who need isolation should run inside reasonix code (or a library setup that passes subagentRunner to registerSkillTools).`
+          });
+        }
+        if (!rawArgs) {
+          return JSON.stringify({
+            error: `run_skill: skill ${JSON.stringify(name)} is a subagent and requires 'arguments' \u2014 the subagent has no other context, so describe the concrete task in the arguments field.`
+          });
+        }
+        return subagentRunner(skill, rawArgs);
+      }
+      const header2 = [
         `# Skill: ${skill.name}`,
         skill.description ? `> ${skill.description}` : "",
         `(scope: ${skill.scope} \xB7 ${skill.path})`
@@ -4630,7 +5108,7 @@ function registerSkillTools(registry, opts = {}) {
       const argsBlock = rawArgs ? `
 
 Arguments: ${rawArgs}` : "";
-      return `${header}
+      return `${header2}
 
 ${skill.body}${argsBlock}`;
     }
@@ -4638,10 +5116,6 @@ ${skill.body}${argsBlock}`;
   return registry;
 }
 
-// src/cli/ui/App.tsx
-import { Box as Box11, Static, Text as Text11, useApp, useInput as useInput4 } from "ink";
-import React12, { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState5 } from "react";
-
 // src/cli/ui/EventLog.tsx
 import { Box as Box3, Text as Text3 } from "ink";
 import React4 from "react";
@@ -4714,7 +5188,7 @@ function stripMath(s) {
   ).replace(/\\sqrt\s*\{([^{}]+)\}/g, (_m, g) => `\u221A(${g.trim()})`).replace(/\\boxed\s*\{([^{}]+)\}/g, (_m, g) => `\u3010${g.trim()}\u3011`).replace(/\\text\s*\{([^{}]+)\}/g, (_m, g) => g.trim()).replace(/\\overline\s*\{([^{}]+)\}/g, (_m, g) => `${g.trim()}\u0304`).replace(/\\hat\s*\{([^{}]+)\}/g, (_m, g) => `${g.trim()}\u0302`).replace(/\\vec\s*\{([^{}]+)\}/g, (_m, g) => `\u2192${g.trim()}`).replace(/\\cdot/g, "\xB7").replace(/\\times/g, "\xD7").replace(/\\div/g, "\xF7").replace(/\\pm/g, "\xB1").replace(/\\mp/g, "\u2213").replace(/\\leq/g, "\u2264").replace(/\\geq/g, "\u2265").replace(/\\neq/g, "\u2260").replace(/\\approx/g, "\u2248").replace(/\\in\b/g, "\u2208").replace(/\\notin\b/g, "\u2209").replace(/\\infty/g, "\u221E").replace(/\\sum\b/g, "\u03A3").replace(/\\prod\b/g, "\u03A0").replace(/\\int\b/g, "\u222B").replace(/\\alpha/g, "\u03B1").replace(/\\beta/g, "\u03B2").replace(/\\gamma/g, "\u03B3").replace(/\\delta/g, "\u03B4").replace(/\\theta/g, "\u03B8").replace(/\\lambda/g, "\u03BB").replace(/\\mu/g, "\u03BC").replace(/\\pi/g, "\u03C0").replace(/\\sigma/g, "\u03C3").replace(/\\phi/g, "\u03C6").replace(/\\omega/g, "\u03C9").replace(/\\implies\b/g, "\u21D2").replace(/\\iff\b/g, "\u21D4").replace(/\\to\b/g, "\u2192").replace(/\\rightarrow/g, "\u2192").replace(/\\Rightarrow/g, "\u21D2").replace(/\\leftarrow/g, "\u2190").replace(/\\Leftarrow/g, "\u21D0").replace(/\\ldots/g, "\u2026").replace(/\\cdots/g, "\u22EF").replace(/\\quad/g, "  ").replace(/\\qquad/g, "    ").replace(/\\,/g, " ").replace(/\\;/g, " ").replace(/\\!/g, "").replace(/\\\\/g, "\n").replace(/\^\{([\w+-]+)\}/g, (_m, g) => toSuperscript(g)).replace(/\^([0-9+\-n])/g, (_m, g) => toSuperscript(g)).replace(/_\{([\w+-]+)\}/g, (_m, g) => toSubscript(g)).replace(/_([0-9+\-])/g, (_m, g) => toSubscript(g)).replace(/\\[a-zA-Z]+\s*\{([^{}]+)\}\s*\{([^{}]+)\}/g, "($1)/($2)").replace(/\\[a-zA-Z]+\s*\{([^{}]+)\}/g, "$1").replace(/\\[a-zA-Z]+/g, "").replace(/[ \t]{2,}/g, " ");
 }
 var INLINE_RE = /(\*\*([^*\n]+?)\*\*|```([^\n]+?)```|`([^`\n]+?)`|(?<![*\w])\*([^*\n]+?)\*(?!\w))/g;
-function InlineMd({ text }) {
+function InlineMd({ text, padTo }) {
   const parts = [];
   let last = 0;
   let idx = 0;
@@ -4746,8 +5220,20 @@ function InlineMd({ text }) {
   if (last < text.length) {
     parts.push(/* @__PURE__ */ React2.createElement(Text2, { key: `t${idx++}` }, text.slice(last)));
   }
+  if (padTo !== void 0) {
+    const seen = visibleWidth(text);
+    if (seen < padTo) {
+      parts.push(/* @__PURE__ */ React2.createElement(Text2, { key: `pad${idx++}` }, " ".repeat(padTo - seen)));
+    }
+  }
   return /* @__PURE__ */ React2.createElement(Text2, null, parts);
 }
+function stripInlineMarkup(s) {
+  return s.replace(/\*\*([^*\n]+?)\*\*/g, "$1").replace(/```([^\n]+?)```/g, (_m, c) => c.replace(/^(\w+)\s+/, "")).replace(/`([^`\n]+?)`/g, "$1").replace(/(?<![*\w])\*([^*\n]+?)\*(?!\w)/g, "$1");
+}
+function visibleWidth(s) {
+  return displayWidth(stripInlineMarkup(s));
+}
 function parseBlocks(raw) {
   const lines = raw.split(/\r?\n/);
   const out = [];
@@ -4854,21 +5340,51 @@ function parseBlocks(raw) {
       out.push({ kind: "heading", level: hm[1].length, text: hm[2].trim() });
       continue;
     }
-    if (line.includes("|")) {
+    if (/^\s*┌─+┐\s*$/.test(line)) {
+      let j = i + 1;
+      const bodyLines = [];
+      while (j < lines.length && !/^\s*└─+┘\s*$/.test(lines[j])) {
+        const inner = lines[j];
+        const m = inner.match(/^\s*│\s?(.*?)\s?│\s*$/);
+        bodyLines.push(m ? m[1] ?? "" : inner);
+        j++;
+      }
+      if (j < lines.length) {
+        flushPara();
+        flushList();
+        out.push({ kind: "code", lang: "", text: bodyLines.join("\n") });
+        i = j;
+        continue;
+      }
+    }
+    if (line.includes("|") || line.includes("\u2502")) {
       const next = (lines[i + 1] ?? "").trim();
-      if (/^\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)+\|?\s*$/.test(next)) {
+      const isGfmSep = /^\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)+\|?\s*$/.test(next);
+      const isBoxSep = /^[│─┼┬┴┌┐└┘├┤\s]+$/.test(next) && /─{2,}/.test(next);
+      if (isGfmSep || isBoxSep) {
         flushPara();
         flushList();
-        const header = splitTableRow(line);
+        const header2 = splitTableRow(line);
+        const colCount = header2.length;
         const rows = [];
         let j = i + 2;
         while (j < lines.length) {
           const r = lines[j].replace(/\s+$/g, "");
-          if (r.trim() === "" || !r.includes("|")) break;
+          if (r.trim() === "") break;
+          if (!r.includes("|") && !r.includes("\u2502")) {
+            const prev = rows[rows.length - 1];
+            if (prev && prev.length === colCount) {
+              const lastIdx = prev.length - 1;
+              prev[lastIdx] = `${prev[lastIdx] ?? ""} ${r.trim()}`;
+              j++;
+              continue;
+            }
+            break;
+          }
           rows.push(splitTableRow(r));
           j++;
         }
-        out.push({ kind: "table", header, rows });
+        out.push({ kind: "table", header: header2, rows });
         i = j - 1;
         continue;
       }
@@ -4923,7 +5439,7 @@ function BlockView({ block }) {
 }
 function splitTableRow(line) {
   const SENTINEL = "\0";
-  const masked = line.replace(/\\\|/g, SENTINEL);
+  const masked = line.replace(/\\\|/g, SENTINEL).replace(/│/g, "|");
   const trimmed = masked.trim().replace(/^\||\|$/g, "");
   return trimmed.split("|").map((c) => c.trim().replace(new RegExp(SENTINEL, "g"), "|"));
 }
@@ -4931,24 +5447,19 @@ 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] ?? ""));
+    const cellLengths = [visibleWidth(block.header[c] ?? "")];
+    for (const r of block.rows) cellLengths.push(visibleWidth(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, { key: `h-${ci}`, bold: true, color: "cyan" }, /* @__PURE__ */ React2.createElement(InlineMd, { text: cell, padTo: 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 " : "")
+      /* @__PURE__ */ React2.createElement(Text2, { key: `c-${ri}-${ci}` }, /* @__PURE__ */ React2.createElement(InlineMd, { text: row2[ci] ?? "", padTo: widths[ci] ?? 3 }), ci < colCount - 1 ? " \u2502 " : "")
     )))
   )));
 }
@@ -5593,6 +6104,114 @@ function formatTokens(n) {
 
 // src/cli/ui/slash.ts
 import { spawnSync } from "child_process";
+
+// src/cli/commands/stats.ts
+import { existsSync as existsSync7, readFileSync as readFileSync9 } from "fs";
+function statsCommand(opts) {
+  if (opts.transcript) {
+    transcriptSummary(opts.transcript);
+    return;
+  }
+  dashboard(opts);
+}
+function transcriptSummary(path) {
+  if (!existsSync7(path)) {
+    console.error(`no such transcript: ${path}`);
+    process.exit(1);
+  }
+  const lines = readFileSync9(path, "utf8").split(/\r?\n/).filter(Boolean);
+  let assistantTurns = 0;
+  let toolCalls = 0;
+  let lastTurn = 0;
+  for (const line of lines) {
+    try {
+      const rec = JSON.parse(line);
+      if (rec.role === "assistant_final") assistantTurns++;
+      if (rec.role === "tool") toolCalls++;
+      if (typeof rec.turn === "number") lastTurn = Math.max(lastTurn, rec.turn);
+    } catch {
+    }
+  }
+  console.log(`transcript:       ${path}`);
+  console.log(`assistant turns:  ${assistantTurns}`);
+  console.log(`tool invocations: ${toolCalls}`);
+  console.log(`last turn index:  ${lastTurn}`);
+}
+function dashboard(opts) {
+  const path = opts.logPath ?? defaultUsageLogPath();
+  const records = readUsageLog(path);
+  if (records.length === 0) {
+    console.log("no usage data yet.");
+    console.log("");
+    console.log(`  ${path}`);
+    console.log("");
+    console.log("run `reasonix chat`, `reasonix code`, or `reasonix run <task>` \u2014 every turn");
+    console.log("appends one line to the log and `reasonix stats` will roll it up.");
+    return;
+  }
+  const agg = aggregateUsage(records, { now: opts.now });
+  console.log(renderDashboard(agg, path));
+}
+function renderDashboard(agg, logPath) {
+  const lines = [];
+  const size = formatLogSize(logPath);
+  lines.push(`Reasonix usage \u2014 ${logPath}${size ? ` (${size})` : ""}`);
+  lines.push("");
+  lines.push(header());
+  lines.push(divider());
+  for (const b of agg.buckets) {
+    lines.push(bucketRow(b));
+  }
+  lines.push("");
+  if (agg.byModel.length > 0) {
+    const totalTurns = agg.buckets[agg.buckets.length - 1]?.turns ?? 0;
+    const top = agg.byModel[0];
+    if (top && totalTurns > 0) {
+      const pct2 = (top.turns / totalTurns * 100).toFixed(0);
+      lines.push(`most used model:   ${top.model} (${pct2}% of turns)`);
+    }
+  }
+  if (agg.bySession.length > 0) {
+    const top = agg.bySession[0];
+    if (top) lines.push(`top session:       ${top.session} (${top.turns} turns)`);
+  }
+  if (agg.firstSeen) {
+    lines.push(`tracked since:     ${new Date(agg.firstSeen).toISOString().slice(0, 10)}`);
+  }
+  return lines.join("\n");
+}
+function header() {
+  return [
+    pad("", 10),
+    pad("turns", 8, "right"),
+    pad("cache hit", 10, "right"),
+    pad("cost (USD)", 14, "right"),
+    pad("vs Claude", 14, "right"),
+    pad("saved", 10, "right")
+  ].join("  ");
+}
+function divider() {
+  return "-".repeat(70);
+}
+function bucketRow(b) {
+  const hit = bucketCacheHitRatio(b);
+  const savings = bucketSavingsFraction(b);
+  return [
+    pad(b.label, 10),
+    pad(b.turns.toString(), 8, "right"),
+    pad(b.turns > 0 ? `${(hit * 100).toFixed(1)}%` : "\u2014", 10, "right"),
+    pad(b.turns > 0 ? `$${b.costUsd.toFixed(6)}` : "\u2014", 14, "right"),
+    pad(b.turns > 0 ? `$${b.claudeEquivUsd.toFixed(4)}` : "\u2014", 14, "right"),
+    pad(b.turns > 0 && savings > 0 ? `${(savings * 100).toFixed(1)}%` : "\u2014", 10, "right")
+  ].join("  ");
+}
+function pad(s, width, align = "left") {
+  if (s.length >= width) return s;
+  const fill = " ".repeat(width - s.length);
+  return align === "right" ? `${fill}${s}` : `${s}${fill}`;
+}
+
+// src/cli/ui/slash.ts
 var SLASH_COMMANDS = [
   { cmd: "help", summary: "show the full command reference" },
   { cmd: "status", summary: "current model, flags, context, session" },
@@ -5625,6 +6244,10 @@ var SLASH_COMMANDS = [
     cmd: "update",
     summary: "show current vs latest version + the shell command to upgrade"
   },
+  {
+    cmd: "stats",
+    summary: "cross-session cost dashboard (today / week / month / all-time \xB7 cache hit \xB7 vs Claude)"
+  },
   { cmd: "think", summary: "dump the last turn's full R1 reasoning (reasoner only)" },
   { cmd: "retry", summary: "truncate & resend your last message (fresh sample)" },
   { cmd: "compact", argsHint: "[cap]", summary: "shrink oversized tool results in the log" },
@@ -5805,6 +6428,9 @@ function handleSlash(cmd, args, loop, ctx = {}) {
     case "update": {
       return handleUpdateSlash(ctx);
     }
+    case "stats": {
+      return handleStatsSlash();
+    }
     case "think":
     case "reasoning": {
       const raw = loop.scratch.reasoning;
@@ -6041,6 +6667,24 @@ ${entry.text}`
       return { unknown: true, info: `unknown command: /${cmd}  (try /help)` };
   }
 }
+function handleStatsSlash() {
+  const path = defaultUsageLogPath();
+  const records = readUsageLog(path);
+  if (records.length === 0) {
+    return {
+      info: [
+        "no usage data yet.",
+        "",
+        `  ${path}`,
+        "",
+        "every turn you run here appends one record \u2014 this session's turns",
+        "will show up in the dashboard once you send a message."
+      ].join("\n")
+    };
+  }
+  const agg = aggregateUsage(records);
+  return { info: renderDashboard(agg, path) };
+}
 function handleUpdateSlash(ctx) {
   const latest = ctx.latestVersion ?? null;
   const lines = [`current: reasonix ${VERSION}`];
@@ -6185,12 +6829,12 @@ function handleSkillSlash(args, ctx) {
     };
   }
   const extra = args.slice(1).join(" ").trim();
-  const header = `# Skill: ${skill.name}${skill.description ? `
+  const header2 = `# Skill: ${skill.name}${skill.description ? `
 > ${skill.description}` : ""}`;
   const argsLine = extra ? `
 
 Arguments: ${extra}` : "";
-  const payload = `${header}
+  const payload = `${header2}
 
 ${skill.body}${argsLine}`;
   return {
@@ -6368,9 +7012,9 @@ function appendSection(lines, label, section) {
 }
 function formatToolList(history) {
   const total = history.length;
-  const header = `Tool calls in this session (${total}, most recent first):`;
+  const header2 = `Tool calls in this session (${total}, most recent first):`;
   const shown = Math.min(total, 10);
-  const lines = [header];
+  const lines = [header2];
   for (let i = 0; i < shown; i++) {
     const entry = history[total - 1 - i];
     if (!entry) continue;
@@ -6451,6 +7095,7 @@ function App({
   const abortedThisTurn = useRef2(false);
   const [ongoingTool, setOngoingTool] = useState5(null);
   const [toolProgress, setToolProgress] = useState5(null);
+  const [subagentActivity, setSubagentActivity] = useState5(null);
   const [statusLine, setStatusLine] = useState5(null);
   const [balance, setBalance] = useState5(null);
   const [latestVersion, setLatestVersion] = useState5(null);
@@ -6507,9 +7152,30 @@ function App({
     });
   }, [slashMatches]);
   const loopRef = useRef2(null);
+  const subagentSinkRef = useRef2({ current: null });
   const loop = useMemo(() => {
     if (loopRef.current) return loopRef.current;
     const client = new DeepSeekClient();
+    if (tools && !tools.has("run_skill")) {
+      registerSkillTools(tools, {
+        projectRoot: codeMode?.rootDir,
+        subagentRunner: async (skill, task) => {
+          const result = await spawnSubagent({
+            client,
+            parentRegistry: tools,
+            // Skill body is the subagent's persona/playbook; the user-
+            // supplied task is what to actually do inside it.
+            system: skill.body,
+            task,
+            // Per-skill model override (frontmatter `model: ...`),
+            // else falls through to spawnSubagent's default.
+            model: skill.model,
+            sink: subagentSinkRef.current
+          });
+          return formatSubagentResult(result);
+        }
+      });
+    }
     const prefix = new ImmutablePrefix({
       system,
       toolSpecs: tools?.specs()
@@ -6527,7 +7193,7 @@ function App({
     });
     loopRef.current = l;
     return l;
-  }, [model, system, harvest2, branch, session, tools]);
+  }, [model, system, harvest2, branch, session, tools, codeMode]);
   useEffect2(() => {
     loop.hooks = hookList;
   }, [loop, hookList]);
@@ -6567,6 +7233,40 @@ function App({
       if (progressSink.current) progressSink.current = null;
     };
   }, [progressSink]);
+  useEffect2(() => {
+    subagentSinkRef.current.current = (ev) => {
+      if (ev.kind === "start") {
+        setSubagentActivity({
+          task: ev.task,
+          iter: ev.iter ?? 0,
+          elapsedMs: ev.elapsedMs ?? 0
+        });
+        return;
+      }
+      if (ev.kind === "progress") {
+        setSubagentActivity({
+          task: ev.task,
+          iter: ev.iter ?? 0,
+          elapsedMs: ev.elapsedMs ?? 0
+        });
+        return;
+      }
+      setSubagentActivity(null);
+      const seconds = ((ev.elapsedMs ?? 0) / 1e3).toFixed(1);
+      const summary2 = ev.error ? `\u{1F9EC} subagent "${ev.task}" failed after ${seconds}s \xB7 ${ev.iter ?? 0} tool call(s) \u2014 ${ev.error}` : `\u{1F9EC} subagent "${ev.task}" done in ${seconds}s \xB7 ${ev.iter ?? 0} tool call(s) \xB7 ${ev.turns ?? 0} turn(s)`;
+      setHistorical((prev) => [
+        ...prev,
+        {
+          id: `subagent-end-${Date.now()}`,
+          role: "info",
+          text: summary2
+        }
+      ]);
+    };
+    return () => {
+      subagentSinkRef.current.current = null;
+    };
+  }, []);
   const sessionBannerShown = useRef2(false);
   useEffect2(() => {
     if (sessionBannerShown.current) return;
@@ -6864,6 +7564,13 @@ function App({
             const repairNote = ev.repair ? describeRepair(ev.repair) : "";
             setStreaming(null);
             setSummary(loop.stats.summary());
+            if (ev.stats?.usage) {
+              appendUsage({
+                session: session ?? null,
+                model: ev.stats.model,
+                usage: ev.stats.usage
+              });
+            }
             const finalText = ev.content || streamRef.text;
             const iterReasoning = streamRef.reasoning || void 0;
             const iterId = `${assistantId}-i${assistantIterCounter.current++}`;
@@ -7006,6 +7713,7 @@ function App({
       mcpSpecs,
       mcpServers,
       planMode,
+      session,
       slashSelected,
       togglePlanMode,
       writeTranscript
@@ -7169,7 +7877,7 @@ Stay in plan mode \u2014 address the feedback (explore more if needed), then sub
       balance,
       updateAvailable
     }
-  ), /* @__PURE__ */ React12.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React12.createElement(EventRow, { key: item.id, event: item })), !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && streaming ? /* @__PURE__ */ React12.createElement(Box11, { marginY: 1 }, /* @__PURE__ */ React12.createElement(EventRow, { event: streaming })) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && ongoingTool ? /* @__PURE__ */ React12.createElement(OngoingToolRow, { tool: ongoingTool, progress: toolProgress }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !ongoingTool && statusLine ? /* @__PURE__ */ React12.createElement(StatusRow, { text: statusLine }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && busy && !streaming && !ongoingTool && !statusLine ? /* @__PURE__ */ React12.createElement(StatusRow, { text: "processing\u2026" }) : null, stagedInput ? /* @__PURE__ */ React12.createElement(
+  ), /* @__PURE__ */ React12.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React12.createElement(EventRow, { key: item.id, event: item })), !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && streaming ? /* @__PURE__ */ React12.createElement(Box11, { marginY: 1 }, /* @__PURE__ */ React12.createElement(EventRow, { event: streaming })) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && ongoingTool ? /* @__PURE__ */ React12.createElement(OngoingToolRow, { tool: ongoingTool, progress: toolProgress }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && subagentActivity ? /* @__PURE__ */ React12.createElement(SubagentRow, { activity: subagentActivity }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !ongoingTool && statusLine ? /* @__PURE__ */ React12.createElement(StatusRow, { text: statusLine }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && busy && !streaming && !ongoingTool && !statusLine ? /* @__PURE__ */ React12.createElement(StatusRow, { text: "processing\u2026" }) : null, stagedInput ? /* @__PURE__ */ React12.createElement(
     PlanRefineInput,
     {
       mode: stagedInput.mode,
@@ -7199,6 +7907,13 @@ function StatusRow({ text }) {
   const elapsed = useElapsedSeconds();
   return /* @__PURE__ */ React12.createElement(Box11, { marginY: 1 }, /* @__PURE__ */ React12.createElement(Text11, { color: "magenta" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React12.createElement(Text11, { color: "magenta" }, ` ${text}`), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, ` ${elapsed}s`));
 }
+function SubagentRow({
+  activity
+}) {
+  const tick = useTick();
+  const seconds = (activity.elapsedMs / 1e3).toFixed(1);
+  return /* @__PURE__ */ React12.createElement(Box11, { paddingLeft: 2 }, /* @__PURE__ */ React12.createElement(Text11, { color: "magenta" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React12.createElement(Text11, { color: "magenta" }, ` \u{1F9EC} subagent: ${activity.task}`), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, ` \xB7 iter ${activity.iter} \xB7 ${seconds}s`));
+}
 function OngoingToolRow({
   tool,
   progress
@@ -7268,8 +7983,8 @@ function formatEditResults(results) {
   });
   const ok = results.filter((r) => r.status === "applied" || r.status === "created").length;
   const total = results.length;
-  const header = `\u25B8 edit blocks: ${ok}/${total} applied \u2014 /undo to roll back, or \`git diff\` to review`;
-  return [header, ...lines].join("\n");
+  const header2 = `\u25B8 edit blocks: ${ok}/${total} applied \u2014 /undo to roll back, or \`git diff\` to review`;
+  return [header2, ...lines].join("\n");
 }
 function formatPendingPreview(blocks) {
   const lines = blocks.map((b) => {
@@ -7278,8 +7993,8 @@ 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 (or y) to commit \xB7 /discard (or n) to drop`;
-  return [header, ...lines].join("\n");
+  const header2 = `\u25B8 ${blocks.length} pending edit block(s) \u2014 /apply (or y) to commit \xB7 /discard (or n) to drop`;
+  return [header2, ...lines].join("\n");
 }
 function countLines2(s) {
   if (s.length === 0) return 0;
@@ -7517,14 +8232,13 @@ async function chatCommand(opts) {
   if (!opts.seedTools) {
     if (!tools) tools = new ToolRegistry();
     registerMemoryTools(tools, {});
-    registerSkillTools(tools);
   }
   let sessionPreview;
   if (opts.session && !opts.forceResume && !opts.forceNew) {
     const prior = loadSessionMessages(opts.session);
     if (prior.length > 0) {
       const p = sessionPath(opts.session);
-      const mtime = existsSync6(p) ? statSync3(p).mtime : /* @__PURE__ */ new Date();
+      const mtime = existsSync8(p) ? statSync4(p).mtime : /* @__PURE__ */ new Date();
       sessionPreview = { messageCount: prior.length, lastActive: mtime };
     }
   } else if (opts.session && opts.forceNew) {
@@ -7557,7 +8271,7 @@ async function chatCommand(opts) {
 // src/cli/commands/code.tsx
 import { basename, resolve as resolve5 } from "path";
 async function codeCommand(opts = {}) {
-  const { codeSystemPrompt: codeSystemPrompt2 } = await import("./prompt-VDN5U3YE.js");
+  const { codeSystemPrompt: codeSystemPrompt2 } = await import("./prompt-6DMLWG2H.js");
   const rootDir = resolve5(opts.dir ?? process.cwd());
   const session = opts.noSession ? void 0 : `code-${sanitizeName(basename(rootDir))}`;
   const tools = new ToolRegistry();
@@ -7573,7 +8287,6 @@ async function codeCommand(opts = {}) {
   });
   registerPlanTool(tools);
   registerMemoryTools(tools, { projectRoot: rootDir });
-  registerSkillTools(tools, { projectRoot: rootDir });
   process.stderr.write(
     `\u25B8 reasonix code: rooted at ${rootDir}, session "${session ?? "(ephemeral)"}" \xB7 ${tools.size} native tool(s)
 `
@@ -7867,7 +8580,7 @@ function mcpListCommand(opts) {
   console.log("Popular MCP servers you can bridge into Reasonix:");
   console.log("");
   for (const entry of MCP_CATALOG) {
-    console.log(`  ${pad(entry.name, 12)} ${entry.summary}`);
+    console.log(`  ${pad2(entry.name, 12)} ${entry.summary}`);
     console.log(`               ${mcpCommandFor(entry)}`);
     if (entry.note) console.log(`               \xB7 ${entry.note}`);
     console.log("");
@@ -7880,7 +8593,7 @@ function mcpListCommand(opts) {
     "        https://mcp.so                                   \u2014  community-maintained catalog"
   );
 }
-function pad(s, width) {
+function pad2(s, width) {
   return s.length >= width ? s : s + " ".repeat(width - s.length);
 }
 
@@ -8149,6 +8862,9 @@ async function runCommand2(opts) {
 [error] ${ev.error}
 `);
       if (ev.role === "done") process.stdout.write("\n");
+      if (ev.role === "assistant_final" && ev.stats?.usage) {
+        appendUsage({ session: null, model: ev.stats.model, usage: ev.stats.usage });
+      }
       if (transcriptStream && ev.role !== "assistant_delta") {
         writeRecord(transcriptStream, recordFromLoopEvent(ev, { model: opts.model, prefixHash }));
       }
@@ -8545,32 +9261,6 @@ async function setupCommand(_opts = {}) {
   await waitUntilExit();
 }
 
-// src/cli/commands/stats.ts
-import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
-function statsCommand(opts) {
-  if (!existsSync7(opts.transcript)) {
-    console.error(`no such transcript: ${opts.transcript}`);
-    process.exit(1);
-  }
-  const lines = readFileSync8(opts.transcript, "utf8").split(/\r?\n/).filter(Boolean);
-  let assistantTurns = 0;
-  let toolCalls = 0;
-  let lastTurn = 0;
-  for (const line of lines) {
-    try {
-      const rec = JSON.parse(line);
-      if (rec.role === "assistant_final") assistantTurns++;
-      if (rec.role === "tool") toolCalls++;
-      if (typeof rec.turn === "number") lastTurn = Math.max(lastTurn, rec.turn);
-    } catch {
-    }
-  }
-  console.log(`transcript:       ${opts.transcript}`);
-  console.log(`assistant turns:  ${assistantTurns}`);
-  console.log(`tool invocations: ${toolCalls}`);
-  console.log(`last turn index:  ${lastTurn}`);
-}
-
 // src/cli/commands/update.ts
 import { spawn as spawn4 } from "child_process";
 function planUpdate(input) {
@@ -8796,7 +9486,9 @@ program.command("run <task>").description("Run a single task non-interactively,
     mcpPrefix: opts.mcpPrefix
   });
 });
-program.command("stats <transcript>").description("Summarize a JSONL transcript produced by `reasonix chat --transcript`.").action((transcript) => {
+program.command("stats [transcript]").description(
+  "Show usage dashboard (today / week / month / all-time \xB7 turns \xB7 cache hit \xB7 cost \xB7 savings vs Claude). Pass a transcript path to fall back to the per-file summary (assistant turns + tool calls)."
+).action((transcript) => {
   statsCommand({ transcript });
 });
 program.command("sessions [name]").description("List saved chat sessions, or inspect one by name.").option("-v, --verbose", "Include system prompts + tool-call metadata when inspecting").action((name, opts) => {