mini-coder 0.0.6 → 0.0.8

package/dist/mc.js

@@ -6,7 +6,7 @@ import * as c8 from "yoctocolors";
 
 // src/agent/agent.ts
 import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 import * as c7 from "yoctocolors";
 
 // src/cli/agents.ts
@@ -521,16 +521,146 @@ function generateSessionId() {
 
 // src/cli/custom-commands.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { homedir as homedir4 } from "os";
-import { basename as basename2, join as join3 } from "path";
+import { homedir as homedir5 } from "os";
+import { basename as basename2, join as join4 } from "path";
 
 // src/cli/config-conflicts.ts
 import * as c3 from "yoctocolors";
 
 // src/cli/output.ts
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import * as c2 from "yoctocolors";
 
+// src/cli/error-log.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+var writer = null;
+function initErrorLog() {
+  if (writer)
+    return;
+  const dirPath = join3(homedir3(), ".config", "mini-coder");
+  const logPath = join3(dirPath, "errors.log");
+  mkdirSync2(dirPath, { recursive: true });
+  writer = Bun.file(logPath).writer();
+  process.on("uncaughtException", (err) => {
+    logError(err, "uncaught");
+    process.exit(1);
+  });
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null;
+}
+function logError(err, context) {
+  if (!writer)
+    return;
+  let entry = `[${new Date().toISOString()}]`;
+  if (context)
+    entry += ` context=${context}`;
+  entry += `
+`;
+  if (isObject(err)) {
+    if (typeof err.name === "string")
+      entry += `  name: ${err.name}
+`;
+    if (typeof err.message === "string")
+      entry += `  message: ${err.message}
+`;
+    if ("statusCode" in err)
+      entry += `  statusCode: ${err.statusCode}
+`;
+    if ("url" in err)
+      entry += `  url: ${err.url}
+`;
+    if ("isRetryable" in err)
+      entry += `  isRetryable: ${err.isRetryable}
+`;
+    if (typeof err.stack === "string") {
+      const indentedStack = err.stack.split(`
+`).map((line, i) => i === 0 ? line : `  ${line}`).join(`
+`);
+      entry += `  stack: ${indentedStack}
+`;
+    }
+  } else {
+    entry += `  value: ${String(err)}
+`;
+  }
+  entry += `---
+`;
+  writer.write(entry);
+  writer.flush();
+}
+
+// src/cli/error-parse.ts
+import {
+  APICallError,
+  LoadAPIKeyError,
+  NoContentGeneratedError,
+  NoSuchModelError,
+  RetryError
+} from "ai";
+function parseAppError(err) {
+  if (typeof err === "string") {
+    return { headline: err };
+  }
+  if (err instanceof RetryError) {
+    const inner = parseAppError(err.lastError);
+    return {
+      headline: `Retries exhausted: ${inner.headline}`,
+      ...inner.hint ? { hint: inner.hint } : {}
+    };
+  }
+  if (err instanceof APICallError) {
+    if (err.statusCode === 429) {
+      return {
+        headline: "Rate limit hit",
+        hint: "Wait a moment and retry, or switch model with /model"
+      };
+    }
+    if (err.statusCode === 401 || err.statusCode === 403) {
+      return {
+        headline: "Auth failed",
+        hint: "Check the relevant provider API key env var"
+      };
+    }
+    return {
+      headline: `API error ${err.statusCode ?? "unknown"}`,
+      ...err.url ? { hint: err.url } : {}
+    };
+  }
+  if (err instanceof NoContentGeneratedError) {
+    return {
+      headline: "Model returned empty response",
+      hint: "Try rephrasing or switching model with /model"
+    };
+  }
+  if (err instanceof LoadAPIKeyError) {
+    return {
+      headline: "API key not found",
+      hint: "Set the relevant provider env var"
+    };
+  }
+  if (err instanceof NoSuchModelError) {
+    return {
+      headline: "Model not found",
+      hint: "Use /model to pick a valid model"
+    };
+  }
+  const isObj = typeof err === "object" && err !== null;
+  const code = isObj && "code" in err ? String(err.code) : undefined;
+  const message = isObj && "message" in err ? String(err.message) : String(err);
+  if (code === "ECONNREFUSED" || message.includes("ECONNREFUSED")) {
+    return {
+      headline: "Connection failed",
+      hint: "Check network or local server"
+    };
+  }
+  const firstLine = message.split(`
+`)[0]?.trim() || "Unknown error";
+  return { headline: firstLine };
+}
+
 // src/cli/markdown.ts
 import * as c from "yoctocolors";
 function renderInline(text) {
@@ -644,8 +774,8 @@ function renderChunk(text, inFence) {
 }
 
 // src/cli/output.ts
-var HOME = homedir3();
-var PACKAGE_VERSION = "0.1.0";
+var HOME = homedir4();
+var PACKAGE_VERSION = "0.0.7";
 function tildePath(p) {
   return p.startsWith(HOME) ? `~${p.slice(HOME.length)}` : p;
 }
@@ -668,8 +798,6 @@ function registerTerminalCleanup() {
     process.exit(143);
   });
   process.on("SIGINT", () => {
-    if (process.listenerCount("SIGINT") > 1)
-      return;
     cleanup();
     process.exit(130);
   });
@@ -856,10 +984,6 @@ function renderToolResultInline(toolName, result, isError, indent) {
     return;
   }
   if (toolName === "subagent") {
-    const r = result;
-    if (r.inputTokens || r.outputTokens) {
-      writeln(`${indent}${G.ok} ${c2.dim(`\u2191${r.inputTokens ?? 0} \u2193${r.outputTokens ?? 0}`)}`);
-    }
     return;
   }
   if (toolName.startsWith("mcp_")) {
@@ -876,16 +1000,48 @@ function renderToolResultInline(toolName, result, isError, indent) {
   const text = JSON.stringify(result);
   writeln(`${indent}${G.info} ${c2.dim(text.length > 80 ? `${text.slice(0, 77)}\u2026` : text)}`);
 }
-function renderSubagentActivity(activity, indent, maxDepth) {
-  for (const entry of activity) {
-    writeln(`${indent}${toolCallLine(entry.toolName, entry.args)}`);
-    if (entry.toolName === "subagent" && maxDepth > 0) {
-      const nested = entry.result;
-      if (nested?.activity?.length) {
-        renderSubagentActivity(nested.activity, `${indent}  `, maxDepth - 1);
+function formatSubagentLabel(laneId, parentLabel) {
+  const numStr = parentLabel ? `${parentLabel.replace(/[\[\]]/g, "")}.${laneId}` : `${laneId}`;
+  return c2.dim(c2.cyan(`[${numStr}]`));
+}
+var laneBuffers = new Map;
+function renderSubagentEvent(event, opts) {
+  const { laneId, parentLabel, activeLanes } = opts;
+  const labelStr = formatSubagentLabel(laneId, parentLabel);
+  const prefix = activeLanes.size > 1 ? `${labelStr} ` : "";
+  if (event.type === "text-delta") {
+    const buf = (laneBuffers.get(laneId) ?? "") + event.delta;
+    const lines = buf.split(`
+`);
+    if (lines.length > 1) {
+      for (let i = 0;i < lines.length - 1; i++) {
+        writeln(`${prefix}${lines[i]}`);
       }
+      laneBuffers.set(laneId, lines[lines.length - 1] ?? "");
+    } else {
+      laneBuffers.set(laneId, buf);
+    }
+  } else if (event.type === "tool-call-start") {
+    writeln(`${prefix}${toolCallLine(event.toolName, event.args)}`);
+  } else if (event.type === "tool-result") {
+    renderToolResultInline(event.toolName, event.result, event.isError, `${prefix}  `);
+  } else if (event.type === "turn-complete") {
+    const buf = laneBuffers.get(laneId);
+    if (buf) {
+      writeln(`${prefix}${buf}`);
+      laneBuffers.delete(laneId);
+    }
+    if (event.inputTokens > 0 || event.outputTokens > 0) {
+      writeln(`${prefix}${c2.dim(`\u2191${event.inputTokens} \u2193${event.outputTokens}`)}`);
+    }
+  } else if (event.type === "turn-error") {
+    laneBuffers.delete(laneId);
+    logError(event.error, "turn");
+    const parsed = parseAppError(event.error);
+    writeln(`${prefix}${G.err} ${c2.red(parsed.headline)}`);
+    if (parsed.hint) {
+      writeln(`${prefix}  ${c2.dim(parsed.hint)}`);
     }
-    renderToolResultInline(entry.toolName, entry.result, entry.isError, `${indent}  `);
   }
 }
 function renderToolResult(toolName, result, isError) {
@@ -985,22 +1141,6 @@ function renderToolResult(toolName, result, isError) {
     return;
   }
   if (toolName === "subagent") {
-    const r = result;
-    if (r.activity?.length) {
-      renderSubagentActivity(r.activity, "    ", 1);
-    }
-    if (r.result) {
-      const lines = r.result.split(`
-`);
-      const preview = lines.slice(0, 8);
-      for (const line of preview)
-        writeln(`    ${c2.dim("\u2502")} ${line}`);
-      if (lines.length > 8)
-        writeln(`    ${c2.dim(`\u2502 \u2026 +${lines.length - 8} lines`)}`);
-    }
-    if (r.inputTokens || r.outputTokens) {
-      writeln(`    ${c2.dim(`\u2191${r.inputTokens ?? 0} \u2193${r.outputTokens ?? 0}`)}`);
-    }
     return;
   }
   if (toolName.startsWith("mcp_")) {
@@ -1159,9 +1299,12 @@ async function renderTurn(events, spinner) {
         if (isAbort) {
           writeln(`${G.warn} ${c2.dim("interrupted")}`);
         } else {
-          const msg = event.error.message.split(`
-`)[0] ?? event.error.message;
-          writeln(`${G.err} ${c2.red(msg)}`);
+          logError(event.error, "turn");
+          const parsed = parseAppError(event.error);
+          writeln(`${G.err} ${c2.red(parsed.headline)}`);
+          if (parsed.hint) {
+            writeln(`  ${c2.dim(parsed.hint)}`);
+          }
         }
         break;
       }
@@ -1211,9 +1354,13 @@ function renderBanner(model, cwd) {
   writeln(`  ${c2.dim("/help for commands  \xB7  ctrl+d to exit")}`);
   writeln();
 }
-function renderError(err) {
-  const msg = err instanceof Error ? err.message : String(err);
-  writeln(`${G.err} ${c2.red(msg)}`);
+function renderError(err, context = "render") {
+  logError(err, context);
+  const parsed = parseAppError(err);
+  writeln(`${G.err} ${c2.red(parsed.headline)}`);
+  if (parsed.hint) {
+    writeln(`  ${c2.dim(parsed.hint)}`);
+  }
 }
 function renderInfo(msg) {
   writeln(`${G.info} ${c2.dim(msg)}`);
@@ -1301,7 +1448,7 @@ function loadFromDir2(dir, source) {
     if (!entry.endsWith(".md"))
       continue;
     const name = basename2(entry, ".md");
-    const filePath = join3(dir, entry);
+    const filePath = join4(dir, entry);
     let raw;
     try {
       raw = readFileSync2(filePath, "utf-8");
@@ -1320,10 +1467,10 @@ function loadFromDir2(dir, source) {
   return commands;
 }
 function loadCustomCommands(cwd) {
-  const globalAgentsDir = join3(homedir4(), ".agents", "commands");
-  const globalClaudeDir = join3(homedir4(), ".claude", "commands");
-  const localAgentsDir = join3(cwd, ".agents", "commands");
-  const localClaudeDir = join3(cwd, ".claude", "commands");
+  const globalAgentsDir = join4(homedir5(), ".agents", "commands");
+  const globalClaudeDir = join4(homedir5(), ".claude", "commands");
+  const localAgentsDir = join4(cwd, ".agents", "commands");
+  const localClaudeDir = join4(cwd, ".claude", "commands");
   const globalAgents = loadFromDir2(globalAgentsDir, "global");
   const globalClaude = loadFromDir2(globalClaudeDir, "global");
   const localAgents = loadFromDir2(localAgentsDir, "local");
@@ -1378,8 +1525,8 @@ async function expandTemplate(template, args, cwd) {
 
 // src/cli/skills.ts
 import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join4 } from "path";
+import { homedir as homedir6 } from "os";
+import { join as join5 } from "path";
 function loadFromDir3(dir, source) {
   const skills = new Map;
   if (!existsSync4(dir))
@@ -1391,9 +1538,9 @@ function loadFromDir3(dir, source) {
     return skills;
   }
   for (const entry of entries) {
-    const skillFile = join4(dir, entry, "SKILL.md");
+    const skillFile = join5(dir, entry, "SKILL.md");
     try {
-      if (!statSync(join4(dir, entry)).isDirectory())
+      if (!statSync(join5(dir, entry)).isDirectory())
         continue;
       if (!existsSync4(skillFile))
         continue;
@@ -1411,10 +1558,10 @@ function loadFromDir3(dir, source) {
   return skills;
 }
 function loadSkills(cwd) {
-  const globalAgentsDir = join4(homedir5(), ".agents", "skills");
-  const globalClaudeDir = join4(homedir5(), ".claude", "skills");
-  const localAgentsDir = join4(cwd, ".agents", "skills");
-  const localClaudeDir = join4(cwd, ".claude", "skills");
+  const globalAgentsDir = join5(homedir6(), ".agents", "skills");
+  const globalClaudeDir = join5(homedir6(), ".claude", "skills");
+  const localAgentsDir = join5(cwd, ".agents", "skills");
+  const localClaudeDir = join5(cwd, ".claude", "skills");
   const globalAgents = loadFromDir3(globalAgentsDir, "global");
   const globalClaude = loadFromDir3(globalClaudeDir, "global");
   const localAgents = loadFromDir3(localAgentsDir, "local");
@@ -1609,10 +1756,6 @@ async function handleReview(ctx, args) {
   writeln();
   try {
     const output = await ctx.runSubagent(REVIEW_PROMPT(ctx.cwd, focus));
-    if (output.activity.length) {
-      renderSubagentActivity(output.activity, "  ", 1);
-      writeln();
-    }
     write(renderMarkdown(output.result));
     writeln();
     return {
@@ -1641,10 +1784,6 @@ async function handleCustomCommand(cmd, args, ctx) {
   writeln();
   try {
     const output = await ctx.runSubagent(prompt, cmd.model);
-    if (output.activity.length) {
-      renderSubagentActivity(output.activity, "  ", 1);
-      writeln();
-    }
     write(renderMarkdown(output.result));
     writeln();
     return {
@@ -1795,7 +1934,7 @@ async function loadImageFile(filePath) {
 }
 
 // src/cli/input.ts
-import { join as join5, relative } from "path";
+import { join as join6, relative } from "path";
 import * as c5 from "yoctocolors";
 var ESC = "\x1B";
 var CSI = `${ESC}[`;
@@ -1847,7 +1986,7 @@ async function getAtCompletions(prefix, cwd) {
     for await (const file of glob.scan({ cwd, onlyFiles: true })) {
       if (file.includes("node_modules") || file.includes(".git"))
         continue;
-      results.push(`@${relative(cwd, join5(cwd, file))}`);
+      results.push(`@${relative(cwd, join6(cwd, file))}`);
       if (results.length >= MAX)
         break;
     }
@@ -1869,7 +2008,7 @@ async function tryExtractImageFromPaste(pasted, cwd) {
     }
   }
   if (!trimmed.includes(" ") && isImageFilename(trimmed)) {
-    const filePath = trimmed.startsWith("/") ? trimmed : join5(cwd, trimmed);
+    const filePath = trimmed.startsWith("/") ? trimmed : join6(cwd, trimmed);
     const attachment = await loadImageFile(filePath);
     if (attachment) {
       const name = filePath.split("/").pop() ?? trimmed;
@@ -1906,6 +2045,28 @@ async function readKey(reader) {
     return "";
   return new TextDecoder().decode(value);
 }
+function watchForInterrupt(abortController) {
+  if (!process.stdin.isTTY)
+    return () => {};
+  const onData = (chunk) => {
+    for (const byte of chunk) {
+      if (byte === 3) {
+        cleanup();
+        abortController.abort();
+        return;
+      }
+    }
+  };
+  const cleanup = () => {
+    process.stdin.removeListener("data", onData);
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+  };
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.on("data", onData);
+  return cleanup;
+}
 var PASTE_SENTINEL = "\x00PASTE\x00";
 var PASTE_SENTINEL_LEN = PASTE_SENTINEL.length;
 function pasteLabel(text) {
@@ -2278,6 +2439,7 @@ async function* runTurn(options) {
       ...signal ? { abortSignal: signal } : {}
     };
     const result = streamText(streamOpts);
+    result.response.catch(() => {});
     for await (const chunk of result.fullStream) {
       if (signal?.aborted)
         break;
@@ -2402,7 +2564,7 @@ async function connectMcpServer(config) {
 
 // src/tools/snapshot.ts
 import { readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 async function gitBytes(args, cwd) {
   try {
     const proc = Bun.spawn(["git", ...args], {
@@ -2493,7 +2655,7 @@ async function takeSnapshot(cwd, sessionId, turnIndex) {
       return false;
     const files = [];
     for (const entry of entries) {
-      const absPath = join6(repoRoot, entry.path);
+      const absPath = join7(repoRoot, entry.path);
       if (!entry.existsOnDisk) {
         const { bytes, code } = await gitBytes(["show", `HEAD:${entry.path}`], repoRoot);
         if (code === 0) {
@@ -2542,7 +2704,7 @@ async function restoreSnapshot(cwd, sessionId, turnIndex) {
     const root = repoRoot ?? cwd;
     let anyFailed = false;
     for (const file of files) {
-      const absPath = join6(root, file.path);
+      const absPath = join7(root, file.path);
       if (!file.existed) {
         try {
           if (await Bun.file(absPath).exists()) {
@@ -2609,10 +2771,75 @@ function getMostRecentSession() {
   return sessions[0] ?? null;
 }
 
-// src/tools/create.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
-import { dirname, join as join7, relative as relative2 } from "path";
+// src/tools/exa.ts
 import { z as z2 } from "zod";
+var ExaSearchSchema = z2.object({
+  query: z2.string().describe("The search query")
+});
+var webSearchTool = {
+  name: "webSearch",
+  description: "Search the web for a query using Exa.",
+  schema: ExaSearchSchema,
+  execute: async (input) => {
+    const apiKey = process.env.EXA_API_KEY;
+    if (!apiKey) {
+      throw new Error("EXA_API_KEY is not set.");
+    }
+    const response = await fetch("https://api.exa.ai/search", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify({
+        query: input.query,
+        type: "auto",
+        numResults: 10,
+        contents: { text: { maxCharacters: 4000 } }
+      })
+    });
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Exa API error: ${response.status} ${response.statusText} - ${errorBody}`);
+    }
+    return await response.json();
+  }
+};
+var ExaContentSchema = z2.object({
+  urls: z2.array(z2.string()).max(3).describe("Array of URLs to retrieve content for (max 3)")
+});
+var webContentTool = {
+  name: "webContent",
+  description: "Get the full content of specific URLs using Exa.",
+  schema: ExaContentSchema,
+  execute: async (input) => {
+    const apiKey = process.env.EXA_API_KEY;
+    if (!apiKey) {
+      throw new Error("EXA_API_KEY is not set.");
+    }
+    const response = await fetch("https://api.exa.ai/contents", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify({
+        urls: input.urls,
+        text: { maxCharacters: 1e4 }
+      })
+    });
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Exa API error: ${response.status} ${response.statusText} - ${errorBody}`);
+    }
+    return await response.json();
+  }
+};
+
+// src/tools/create.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { dirname, join as join8, relative as relative2 } from "path";
+import { z as z3 } from "zod";
 
 // src/tools/diff.ts
 function generateDiff(filePath, before, after) {
@@ -2741,9 +2968,9 @@ ${lines.join(`
 }
 
 // src/tools/create.ts
-var CreateSchema = z2.object({
-  path: z2.string().describe("File path to write (absolute or relative to cwd)"),
-  content: z2.string().describe("Full content to write to the file")
+var CreateSchema = z3.object({
+  path: z3.string().describe("File path to write (absolute or relative to cwd)"),
+  content: z3.string().describe("Full content to write to the file")
 });
 var createTool = {
   name: "create",
@@ -2751,11 +2978,11 @@ var createTool = {
   schema: CreateSchema,
   execute: async (input) => {
     const cwd = input.cwd ?? process.cwd();
-    const filePath = input.path.startsWith("/") ? input.path : join7(cwd, input.path);
+    const filePath = input.path.startsWith("/") ? input.path : join8(cwd, input.path);
     const relPath = relative2(cwd, filePath);
     const dir = dirname(filePath);
     if (!existsSync5(dir))
-      mkdirSync2(dir, { recursive: true });
+      mkdirSync3(dir, { recursive: true });
     const file = Bun.file(filePath);
     const created = !await file.exists();
     const before = created ? "" : await file.text();
@@ -2766,11 +2993,25 @@ var createTool = {
 };
 
 // src/tools/glob.ts
-import { join as join8, relative as relative3 } from "path";
-import { z as z3 } from "zod";
-var GlobSchema = z3.object({
-  pattern: z3.string().describe("Glob pattern to match files against, e.g. '**/*.ts'"),
-  ignore: z3.array(z3.string()).optional().describe("Glob patterns to exclude")
+import { join as join10, relative as relative3 } from "path";
+import { z as z4 } from "zod";
+
+// src/tools/ignore.ts
+import { join as join9 } from "path";
+import ignore from "ignore";
+async function loadGitignore(cwd) {
+  try {
+    const gitignore = await Bun.file(join9(cwd, ".gitignore")).text();
+    return ignore().add(gitignore);
+  } catch {
+    return null;
+  }
+}
+
+// src/tools/glob.ts
+var GlobSchema = z4.object({
+  pattern: z4.string().describe("Glob pattern to match files against, e.g. '**/*.ts'"),
+  ignore: z4.array(z4.string()).optional().describe("Glob patterns to exclude")
 });
 var MAX_RESULTS = 500;
 var globTool = {
@@ -2779,26 +3020,21 @@ var globTool = {
   schema: GlobSchema,
   execute: async (input) => {
     const cwd = input.cwd ?? process.cwd();
-    const defaultIgnore = [
-      "node_modules/**",
-      ".git/**",
-      "dist/**",
-      "*.db",
-      "*.db-shm",
-      "*.db-wal"
-    ];
+    const defaultIgnore = [".git/**", "node_modules/**"];
     const ignorePatterns = [...defaultIgnore, ...input.ignore ?? []];
+    const ignoreGlobs = ignorePatterns.map((pat) => new Bun.Glob(pat));
+    const ig = await loadGitignore(cwd);
     const glob = new Bun.Glob(input.pattern);
     const matches = [];
-    for await (const file of glob.scan({ cwd, onlyFiles: true })) {
-      const ignored = ignorePatterns.some((pat) => {
-        const ig = new Bun.Glob(pat);
-        return ig.match(file);
-      });
+    for await (const file of glob.scan({ cwd, onlyFiles: true, dot: true })) {
+      if (ig?.ignores(file))
+        continue;
+      const firstSegment = file.split("/")[0] ?? "";
+      const ignored = ignoreGlobs.some((g) => g.match(file) || g.match(firstSegment));
       if (ignored)
         continue;
       try {
-        const fullPath = join8(cwd, file);
+        const fullPath = join10(cwd, file);
         const stat = await Bun.file(fullPath).stat?.() ?? null;
         matches.push({ path: file, mtime: stat?.mtime?.getTime() ?? 0 });
       } catch {
@@ -2811,14 +3047,14 @@ var globTool = {
     if (truncated)
       matches.pop();
     matches.sort((a, b) => b.mtime - a.mtime);
-    const files = matches.map((m) => relative3(cwd, join8(cwd, m.path)));
+    const files = matches.map((m) => relative3(cwd, join10(cwd, m.path)));
     return { files, count: files.length, truncated };
   }
 };
 
 // src/tools/grep.ts
-import { join as join9 } from "path";
-import { z as z4 } from "zod";
+import { join as join11 } from "path";
+import { z as z5 } from "zod";
 
 // src/tools/hashline.ts
 var FNV_OFFSET_BASIS = 2166136261;
@@ -2864,12 +3100,12 @@ function findLineByHash(lines, hash, hintLine) {
 }
 
 // src/tools/grep.ts
-var GrepSchema = z4.object({
-  pattern: z4.string().describe("Regular expression to search for"),
-  include: z4.string().optional().describe("Glob pattern to filter files, e.g. '*.ts' or '*.{ts,tsx}'"),
-  contextLines: z4.number().int().min(0).max(10).optional().default(2).describe("Lines of context to include around each match"),
-  caseSensitive: z4.boolean().optional().default(true),
-  maxResults: z4.number().int().min(1).max(200).optional().default(50)
+var GrepSchema = z5.object({
+  pattern: z5.string().describe("Regular expression to search for"),
+  include: z5.string().optional().describe("Glob pattern to filter files, e.g. '*.ts' or '*.{ts,tsx}'"),
+  contextLines: z5.number().int().min(0).max(10).optional().default(2).describe("Lines of context to include around each match"),
+  caseSensitive: z5.boolean().optional().default(true),
+  maxResults: z5.number().int().min(1).max(200).optional().default(50)
 });
 var DEFAULT_IGNORE = [
   "node_modules",
@@ -2895,15 +3131,20 @@ var grepTool = {
     const ignoreGlob = DEFAULT_IGNORE.map((p) => new Bun.Glob(p));
     const allMatches = [];
     let truncated = false;
+    const ig = await loadGitignore(cwd);
     outer:
       for await (const relPath of fileGlob.scan({
         cwd,
-        onlyFiles: true
+        onlyFiles: true,
+        dot: true
       })) {
-        if (ignoreGlob.some((g) => g.match(relPath) || g.match(relPath.split("/")[0] ?? ""))) {
+        if (ig?.ignores(relPath))
+          continue;
+        const firstSegment = relPath.split("/")[0] ?? "";
+        if (ignoreGlob.some((g) => g.match(relPath) || g.match(firstSegment))) {
           continue;
         }
-        const fullPath = join9(cwd, relPath);
+        const fullPath = join11(cwd, relPath);
         let text;
         try {
           text = await Bun.file(fullPath).text();
@@ -2954,8 +3195,8 @@ var grepTool = {
 
 // src/tools/hooks.ts
 import { constants, accessSync } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join10 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join12 } from "path";
 function isExecutable(filePath) {
   try {
     accessSync(filePath, constants.X_OK);
@@ -2967,8 +3208,8 @@ function isExecutable(filePath) {
 function findHook(toolName, cwd) {
   const scriptName = `post-${toolName}`;
   const candidates = [
-    join10(cwd, ".agents", "hooks", scriptName),
-    join10(homedir6(), ".agents", "hooks", scriptName)
+    join12(cwd, ".agents", "hooks", scriptName),
+    join12(homedir7(), ".agents", "hooks", scriptName)
   ];
   for (const p of candidates) {
     if (isExecutable(p))
@@ -3057,13 +3298,13 @@ function hookEnvForRead(input, cwd) {
 }
 
 // src/tools/insert.ts
-import { join as join11, relative as relative4 } from "path";
-import { z as z5 } from "zod";
-var InsertSchema = z5.object({
-  path: z5.string().describe("File path to edit (absolute or relative to cwd)"),
-  anchor: z5.string().describe('Anchor line from a prior read/grep, e.g. "11:a3"'),
-  position: z5.enum(["before", "after"]).describe('Insert the content "before" or "after" the anchor line'),
-  content: z5.string().describe("Text to insert")
+import { join as join13, relative as relative4 } from "path";
+import { z as z6 } from "zod";
+var InsertSchema = z6.object({
+  path: z6.string().describe("File path to edit (absolute or relative to cwd)"),
+  anchor: z6.string().describe('Anchor line from a prior read/grep, e.g. "11:a3"'),
+  position: z6.enum(["before", "after"]).describe('Insert the content "before" or "after" the anchor line'),
+  content: z6.string().describe("Text to insert")
 });
 var HASH_NOT_FOUND_ERROR = "Hash not found. Re-read the file to get current anchors.";
 var insertTool = {
@@ -3072,7 +3313,7 @@ var insertTool = {
   schema: InsertSchema,
   execute: async (input) => {
     const cwd = input.cwd ?? process.cwd();
-    const filePath = input.path.startsWith("/") ? input.path : join11(cwd, input.path);
+    const filePath = input.path.startsWith("/") ? input.path : join13(cwd, input.path);
     const relPath = relative4(cwd, filePath);
     const file = Bun.file(filePath);
     if (!await file.exists()) {
@@ -3117,12 +3358,12 @@ function parseAnchor(value) {
 }
 
 // src/tools/read.ts
-import { join as join12, relative as relative5 } from "path";
-import { z as z6 } from "zod";
-var ReadSchema = z6.object({
-  path: z6.string().describe("File path to read (absolute or relative to cwd)"),
-  line: z6.number().int().min(1).optional().describe("1-indexed starting line (default: 1)"),
-  count: z6.number().int().min(1).max(500).optional().describe("Lines to read (default: 500, max: 500)")
+import { join as join14, relative as relative5 } from "path";
+import { z as z7 } from "zod";
+var ReadSchema = z7.object({
+  path: z7.string().describe("File path to read (absolute or relative to cwd)"),
+  line: z7.number().int().min(1).optional().describe("1-indexed starting line (default: 1)"),
+  count: z7.number().int().min(1).max(500).optional().describe("Lines to read (default: 500, max: 500)")
 });
 var MAX_COUNT = 500;
 var MAX_BYTES = 1e6;
@@ -3132,7 +3373,7 @@ var readTool = {
   schema: ReadSchema,
   execute: async (input) => {
     const cwd = input.cwd ?? process.cwd();
-    const filePath = input.path.startsWith("/") ? input.path : join12(cwd, input.path);
+    const filePath = input.path.startsWith("/") ? input.path : join14(cwd, input.path);
     const file = Bun.file(filePath);
     const exists = await file.exists();
     if (!exists) {
@@ -3165,13 +3406,13 @@ var readTool = {
 };
 
 // src/tools/replace.ts
-import { join as join13, relative as relative6 } from "path";
-import { z as z7 } from "zod";
-var ReplaceSchema = z7.object({
-  path: z7.string().describe("File path to edit (absolute or relative to cwd)"),
-  startAnchor: z7.string().describe('Start anchor from a prior read/grep, e.g. "11:a3"'),
-  endAnchor: z7.string().optional().describe('End anchor (inclusive), e.g. "33:0e". Omit to target only the startAnchor line.'),
-  newContent: z7.string().optional().describe("Replacement text. Omit or pass empty string to delete the range.")
+import { join as join15, relative as relative6 } from "path";
+import { z as z8 } from "zod";
+var ReplaceSchema = z8.object({
+  path: z8.string().describe("File path to edit (absolute or relative to cwd)"),
+  startAnchor: z8.string().describe('Start anchor from a prior read/grep, e.g. "11:a3"'),
+  endAnchor: z8.string().optional().describe('End anchor (inclusive), e.g. "33:0e". Omit to target only the startAnchor line.'),
+  newContent: z8.string().optional().describe("Replacement text. Omit or pass empty string to delete the range.")
 });
 var HASH_NOT_FOUND_ERROR2 = "Hash not found. Re-read the file to get current anchors.";
 var replaceTool = {
@@ -3180,7 +3421,7 @@ var replaceTool = {
   schema: ReplaceSchema,
   execute: async (input) => {
     const cwd = input.cwd ?? process.cwd();
-    const filePath = input.path.startsWith("/") ? input.path : join13(cwd, input.path);
+    const filePath = input.path.startsWith("/") ? input.path : join15(cwd, input.path);
     const relPath = relative6(cwd, filePath);
     const file = Bun.file(filePath);
     if (!await file.exists()) {
@@ -3238,11 +3479,11 @@ function parseAnchor2(value, name) {
 }
 
 // src/tools/shell.ts
-import { z as z8 } from "zod";
-var ShellSchema = z8.object({
-  command: z8.string().describe("Shell command to execute"),
-  timeout: z8.number().int().min(1000).max(300000).optional().default(30000).describe("Timeout in milliseconds (default: 30s, max: 5min)"),
-  env: z8.record(z8.string(), z8.string()).optional().describe("Additional environment variables to set")
+import { z as z9 } from "zod";
+var ShellSchema = z9.object({
+  command: z9.string().describe("Shell command to execute"),
+  timeout: z9.number().int().min(1000).max(300000).optional().default(30000).describe("Timeout in milliseconds (default: 30s, max: 5min)"),
+  env: z9.record(z9.string(), z9.string()).optional().describe("Additional environment variables to set")
 });
 var MAX_OUTPUT_BYTES = 1e4;
 var shellTool = {
@@ -3254,6 +3495,7 @@ var shellTool = {
     const timeout = input.timeout ?? 30000;
     const env = Object.assign({}, process.env, input.env ?? {});
     let timedOut = false;
+    const wasRaw = process.stdin.isTTY ? process.stdin.isRaw : false;
     const proc = Bun.spawn(["bash", "-c", input.command], {
       cwd,
       env,
@@ -3307,6 +3549,11 @@ var shellTool = {
     } finally {
       clearTimeout(timer);
       restoreTerminal();
+      if (wasRaw) {
+        try {
+          process.stdin.setRawMode(true);
+        } catch {}
+      }
     }
     return {
       stdout: stdout.trimEnd(),
@@ -3319,12 +3566,12 @@ var shellTool = {
 };
 
 // src/tools/subagent.ts
-import { z as z9 } from "zod";
-var SubagentInput = z9.object({
-  prompt: z9.string().describe("The task or question to give the subagent"),
-  agentName: z9.string().optional().describe("Name of a custom agent to use (from .agents/agents/). Omit to use a generic subagent.")
+import { z as z10 } from "zod";
+var SubagentInput = z10.object({
+  prompt: z10.string().describe("The task or question to give the subagent"),
+  agentName: z10.string().optional().describe("Name of a custom agent to use (from .agents/agents/). Omit to use a generic subagent.")
 });
-function createSubagentTool(runSubagent, availableAgents) {
+function createSubagentTool(runSubagent, availableAgents, parentLabel) {
   const agentSection = availableAgents.size > 0 ? `
 
 When the user's message contains @<agent-name>, delegate to that agent by setting agentName to the exact agent name. Available custom agents: ${[...availableAgents.entries()].map(([name, cfg]) => `"${name}" (${cfg.description})`).join(", ")}.` : "";
@@ -3333,7 +3580,7 @@ When the user's message contains @<agent-name>, delegate to that agent by settin
     description: `Spawn a sub-agent to handle a focused subtask. Use this for parallel exploration, specialised analysis, or tasks that benefit from a fresh context window. The subagent has access to all the same tools.${agentSection}`,
     schema: SubagentInput,
     execute: async (input) => {
-      return runSubagent(input.prompt, input.agentName);
+      return runSubagent(input.prompt, input.agentName, parentLabel);
     }
   };
 }
@@ -3382,7 +3629,7 @@ function buildToolSet(opts) {
   const { cwd, onHook } = opts;
   const depth = opts.depth ?? 0;
   const lookupHook = createHookCache(HOOKABLE_TOOLS, cwd);
-  return [
+  const tools = [
     withHooks(withCwdDefault(globTool, cwd), lookupHook, cwd, (_, input) => hookEnvForGlob(input, cwd), onHook),
     withHooks(withCwdDefault(grepTool, cwd), lookupHook, cwd, (_, input) => hookEnvForGrep(input, cwd), onHook),
     withHooks(withCwdDefault(readTool, cwd), lookupHook, cwd, (_, input) => hookEnvForRead(input, cwd), onHook),
@@ -3394,17 +3641,25 @@ function buildToolSet(opts) {
       if (depth >= MAX_SUBAGENT_DEPTH) {
         throw new Error(`Subagent depth limit reached (max ${MAX_SUBAGENT_DEPTH}). ` + `Cannot spawn another subagent from depth ${depth}.`);
       }
-      return opts.runSubagent(prompt, depth + 1, agentName);
-    }, opts.availableAgents)
+      return opts.runSubagent(prompt, depth + 1, agentName, undefined, opts.parentLabel);
+    }, opts.availableAgents, opts.parentLabel)
   ];
+  if (process.env.EXA_API_KEY) {
+    tools.push(webSearchTool, webContentTool);
+  }
+  return tools;
 }
 function buildReadOnlyToolSet(opts) {
   const { cwd } = opts;
-  return [
+  const tools = [
     withCwdDefault(globTool, cwd),
     withCwdDefault(grepTool, cwd),
     withCwdDefault(readTool, cwd)
   ];
+  if (process.env.EXA_API_KEY) {
+    tools.push(webSearchTool, webContentTool);
+  }
+  return tools;
 }
 
 // src/agent/agent.ts
@@ -3426,9 +3681,9 @@ async function getGitBranch(cwd) {
 }
 function loadContextFile(cwd) {
   const candidates = [
-    join14(cwd, "AGENTS.md"),
-    join14(cwd, "CLAUDE.md"),
-    join14(getConfigDir(), "AGENTS.md")
+    join16(cwd, "AGENTS.md"),
+    join16(cwd, "CLAUDE.md"),
+    join16(getConfigDir(), "AGENTS.md")
   ];
   for (const p of candidates) {
     if (existsSync6(p)) {
@@ -3505,7 +3760,9 @@ async function runAgent(opts) {
   }
   let turnIndex = getMaxTurnIndex(session.id) + 1;
   const coreHistory = [...session.messages];
-  const runSubagent = async (prompt, depth = 0, agentName, modelOverride) => {
+  let nextLaneId = 1;
+  const activeLanes = new Set;
+  const runSubagent = async (prompt, depth = 0, agentName, modelOverride, parentLabel) => {
     const allAgents = loadAgents(cwd);
     const agentConfig = agentName ? allAgents.get(agentName) : undefined;
     if (agentName && !agentConfig) {
@@ -3514,19 +3771,21 @@ async function runAgent(opts) {
     const model = modelOverride ?? agentConfig?.model ?? currentModel;
     const systemPrompt = agentConfig?.systemPrompt ?? buildSystemPrompt(cwd);
     const subMessages = [{ role: "user", content: prompt }];
+    const laneId = nextLaneId++;
+    activeLanes.add(laneId);
+    const laneLabel = formatSubagentLabel(laneId, parentLabel);
     const subTools = buildToolSet({
       cwd,
       depth,
       runSubagent,
       onHook: renderHook,
-      availableAgents: allAgents
+      availableAgents: allAgents,
+      parentLabel: laneLabel
     });
     const subLlm = resolveModel(model);
     let result = "";
     let inputTokens = 0;
     let outputTokens = 0;
-    const activity = [];
-    const pendingCalls = new Map;
     const events = runTurn({
       model: subLlm,
       messages: subMessages,
@@ -3534,32 +3793,18 @@ async function runAgent(opts) {
       systemPrompt
     });
     for await (const event of events) {
+      spinner.stop();
+      renderSubagentEvent(event, { laneId, parentLabel, activeLanes });
+      spinner.start("thinking");
       if (event.type === "text-delta")
         result += event.delta;
-      if (event.type === "tool-call-start") {
-        pendingCalls.set(event.toolCallId, {
-          toolName: event.toolName,
-          args: event.args
-        });
-      }
-      if (event.type === "tool-result") {
-        const pending = pendingCalls.get(event.toolCallId);
-        if (pending) {
-          pendingCalls.delete(event.toolCallId);
-          activity.push({
-            toolName: pending.toolName,
-            args: pending.args,
-            result: event.result,
-            isError: event.isError
-          });
-        }
-      }
       if (event.type === "turn-complete") {
         inputTokens = event.inputTokens;
         outputTokens = event.outputTokens;
       }
     }
-    return { result, inputTokens, outputTokens, activity };
+    activeLanes.delete(laneId);
+    return { result, inputTokens, outputTokens };
   };
   const agents = loadAgents(cwd);
   const tools = buildToolSet({
@@ -3746,12 +3991,10 @@ ${out}
   async function processUserInput(text, pastedImages = []) {
     const abortController = new AbortController;
     let wasAborted = false;
-    const onSigInt = () => {
+    abortController.signal.addEventListener("abort", () => {
       wasAborted = true;
-      abortController.abort();
-      process.removeListener("SIGINT", onSigInt);
-    };
-    process.on("SIGINT", onSigInt);
+    });
+    const stopWatcher = watchForInterrupt(abortController);
     const { text: resolvedText, images: refImages } = await resolveFileRefs(text, cwd);
     const allImages = [...pastedImages, ...refImages];
     const thisTurn = turnIndex++;
@@ -3773,7 +4016,7 @@ ${out}
       ]
     } : { role: "user", content: coreContent };
     if (wasAborted) {
-      process.removeListener("SIGINT", onSigInt);
+      stopWatcher();
       const stubMsg = {
         role: "assistant",
         content: "[interrupted]"
@@ -3839,7 +4082,7 @@ ${out}
       rollbackTurn();
       throw err;
     } finally {
-      process.removeListener("SIGINT", onSigInt);
+      stopWatcher();
       if (wasAborted)
         ralphMode = false;
     }
@@ -3903,7 +4146,7 @@ ${skill.content}
       result = result.slice(0, match.index) + replacement + result.slice((match.index ?? 0) + match[0].length);
       continue;
     }
-    const filePath = ref.startsWith("/") ? ref : join14(cwd, ref);
+    const filePath = ref.startsWith("/") ? ref : join16(cwd, ref);
     if (isImageFilename(ref)) {
       const attachment = await loadImageFile(filePath);
       if (attachment) {
@@ -3931,6 +4174,7 @@ ${preview}
 
 // src/index.ts
 registerTerminalCleanup();
+initErrorLog();
 function parseArgs(argv) {
   const args = {
     model: null,
@@ -4049,11 +4293,11 @@ async function main() {
       agentOpts.initialPrompt = args.prompt;
     await runAgent(agentOpts);
   } catch (err) {
-    renderError(err);
+    renderError(err, "agent");
     process.exit(1);
   }
 }
 main().catch((err) => {
-  console.error(err);
+  renderError(err, "main");
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mini-coder",
-	"version": "0.0.6",
+	"version": "0.0.8",
 	"description": "A small, fast CLI coding agent",
 	"module": "src/index.ts",
 	"type": "module",
@@ -22,6 +22,7 @@
 		"@ai-sdk/openai-compatible": "^2.0.30",
 		"@modelcontextprotocol/sdk": "^1.26.0",
 		"ai": "^6.0.94",
+		"ignore": "^7.0.5",
 		"ollama-ai-provider": "^1.2.0",
 		"yoctocolors": "^2.1.1",
 		"zod": "^4.3.6"

package/better-errors.md

@@ -1,96 +0,0 @@
-# Better Errors — Implementation Plan
-
-## Overview
-
-Add structured error logging to file and friendly error parsing for display. Three concerns: (1) log full error details to `~/.config/mini-coder/errors.log`, (2) map known AI SDK errors to terse user-facing messages, (3) wire both into existing error surfaces.
-
----
-
-## Files to Create
-
-| File | Purpose |
-|---|---|
-| `src/cli/error-log.ts` | `initErrorLog()`, `logError()` |
-| `src/cli/error-parse.ts` | `parseAppError()` |
-
-## Files to Modify
-
-| File | Change |
-|---|---|
-| `src/index.ts` | Call `initErrorLog()` at startup; use `logError` + `parseAppError` in top-level catch and `main().catch()` |
-| `src/cli/output.ts` | Update `renderError(err: unknown)` to call log + parse; update `turn-error` branch in `renderTurn()` |
-| `src/agent/agent.ts` | Pass `unknown` to `renderError()` — no logic change needed if signature widens correctly |
-
----
-
-## Implementation Steps
-
-1. **Create `src/cli/error-log.ts`**
-   - Module-level `let writer: ReturnType<ReturnType<typeof Bun.file>['writer']> | null = null`
-   - `initErrorLog()`: if `writer` is not null, return early (idempotency). Otherwise resolve path `~/.config/mini-coder/errors.log`, open with `Bun.file(path).writer()` (truncates on open), assign to `writer`. Register `process.on('uncaughtException', (err) => { logError(err, 'uncaught'); process.exit(1) })`.
-   - `logError(err: unknown, context?: string)`: if `writer` is null, return. Build log entry string (see Log Format), call `writer.write(entry)`. Keep sync-ish by not awaiting — `write()` on a Bun file writer is buffered; call `writer.flush()` after each write so data lands before a crash.
-   - Extract error fields via type-narrowing helpers (not exported): `isObject(err)`, read `.name`, `.message`, `.stack`, `.statusCode`, `.url`, `.isRetryable` defensively.
-
-2. **Create `src/cli/error-parse.ts`**
-   - Import AI SDK error classes: `APICallError`, `RetryError`, `NoContentGeneratedError`, `LoadAPIKeyError`, `NoSuchModelError` from `ai`.
-   - Export `parseAppError(err: unknown): { headline: string; hint?: string }`.
-   - Implement as a chain of `instanceof` checks (see Error Parse Table). For `RetryError`, recurse on `.lastError` and prepend `"Retries exhausted: "` to `headline`.
-   - Fallback: extract first non-empty line of `(err as any)?.message ?? String(err)`, no hint.
-   - Network check: before the fallback, check if `(err as any)?.code === 'ECONNREFUSED'` or message includes `'ECONNREFUSED'`.
-
-3. **Update `src/cli/output.ts`**
-   - Change `renderError` signature from `(msg: string)` to `(err: unknown)`. Inside: call `logError(err, 'render')`, call `parseAppError(err)`, print `✖ red(headline)`, if `hint` print a dim indented hint line (e.g. `  dim(hint)`).
-   - In `renderTurn()` `turn-error` branch (non-abort path): replace raw `event.error.message` display with `logError(event.error, 'turn')` then `parseAppError(event.error)` → print `✖ red(headline)`, optional dim hint. Keep the abort quiet-note branch unchanged.
-   - All callers of `renderError` that currently pass a string (e.g. in `agent.ts`) — check each call site; if passing a plain string, wrap in `new Error(string)` or let `parseAppError` fallback handle a string gracefully (add string branch at top of `parseAppError`: `if (typeof err === 'string') return { headline: err }`).
-
-4. **Update `src/index.ts`**
-   - After `registerTerminalCleanup()` (or equivalent startup call), add `initErrorLog()`.
-   - Top-level `catch` around `runAgent()`: replace any raw print with `logError(err, 'agent')` + `parseAppError(err)` → print `✖ red(headline)` + dim hint, then `process.exit(1)`.
-   - `main().catch()`: same pattern — `logError(err, 'main')` + parse + print + `process.exit(1)`. Remove bare `console.error(err)`.
-
-5. **Tests (`src/cli/error-parse.test.ts`)**
-   - Test `parseAppError` for each mapped error type.
-   - Construct real instances where possible (e.g. `new APICallError({ ... })`); check `headline` and `hint` values.
-   - Test `RetryError` unwrapping.
-   - Test fallback for plain `Error` and plain string.
-   - No mocks, no file I/O, no server calls.
-
----
-
-## Error Parse Table
-
-| Condition | `headline` | `hint` |
-|---|---|---|
-| `APICallError` with `statusCode === 429` | `"Rate limit hit"` | `"Wait a moment and retry, or switch model with /model"` |
-| `APICallError` with `statusCode === 401 \|\| 403` | `"Auth failed"` | `"Check the relevant provider API key env var"` |
-| `APICallError` other | `"API error \${statusCode}"` | `url` if present |
-| `RetryError` | `"Retries exhausted: \${inner.headline}"` | inner `hint` |
-| `NoContentGeneratedError` | `"Model returned empty response"` | `"Try rephrasing or switching model with /model"` |
-| `LoadAPIKeyError` | `"API key not found"` | `"Set the relevant provider env var"` |
-| `NoSuchModelError` | `"Model not found"` | `"Use /model to pick a valid model"` |
-| `code === 'ECONNREFUSED'` or message contains `'ECONNREFUSED'` | `"Connection failed"` | `"Check network or local server"` |
-| `string` input | string value | — |
-| fallback | first line of `err.message` | — |
-
-> `AbortError` is never passed to `parseAppError` — abort is handled at the call sites before reaching these functions.
-
----
-
-## Log Format
-
-```
-[2026-02-25T22:38:53.123Z] context=turn
-  name: APICallError
-  message: 429 Too Many Requests
-  statusCode: 429
-  url: https://api.anthropic.com/v1/messages
-  isRetryable: true
-  stack: APICallError: 429 Too Many Requests
-    at ...
----
-```
-
-- Each entry ends with `---\n`.
-- Extra fields (`statusCode`, `url`, `isRetryable`) are only emitted if present on the error object.
-- Stack is indented two spaces per line.
-- File is truncated on each app start (writer opened without append flag).