mini-coder 0.0.7 → 0.0.9

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 join15 } from "path";
+import { join as join16 } from "path";
 import * as c7 from "yoctocolors";
 
 // src/cli/agents.ts
@@ -94,7 +94,7 @@ function zenEndpointFor(modelId) {
   if (modelId.startsWith("claude-"))
     return zenAnthropic()(modelId);
   if (modelId.startsWith("gpt-"))
-    return zenOpenAI()(modelId);
+    return zenOpenAI().responses(modelId);
   if (modelId.startsWith("gemini-"))
     return zenGoogle()(modelId);
   return zenCompat()(modelId);
@@ -176,6 +176,15 @@ function directGoogle() {
   }
   return _directGoogle;
 }
+function parseModelString(modelString) {
+  const slashIdx = modelString.indexOf("/");
+  if (slashIdx === -1)
+    return { provider: modelString, modelId: "" };
+  return {
+    provider: modelString.slice(0, slashIdx),
+    modelId: modelString.slice(slashIdx + 1)
+  };
+}
 var CONTEXT_WINDOW_TABLE = [
   [/^claude-/, 200000],
   [/^gemini-/, 1e6],
@@ -187,7 +196,7 @@ var CONTEXT_WINDOW_TABLE = [
   [/^qwen3-/, 131000]
 ];
 function getContextWindow(modelString) {
-  const modelId = modelString.includes("/") ? modelString.slice(modelString.indexOf("/") + 1) : modelString;
+  const { modelId } = parseModelString(modelString);
   for (const [pattern, tokens] of CONTEXT_WINDOW_TABLE) {
     if (pattern.test(modelId))
       return tokens;
@@ -208,7 +217,7 @@ function resolveModel(modelString) {
     case "anthropic":
       return directAnthropic()(modelId);
     case "openai":
-      return directOpenAI()(modelId);
+      return modelId.startsWith("gpt-") ? directOpenAI().responses(modelId) : directOpenAI()(modelId);
     case "google":
       return directGoogle()(modelId);
     case "ollama": {
@@ -521,16 +530,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 +783,8 @@ function renderChunk(text, inFence) {
 }
 
 // src/cli/output.ts
-var HOME = homedir3();
-var PACKAGE_VERSION = "0.0.6";
+var HOME = homedir4();
+var PACKAGE_VERSION = "0.0.8";
 function tildePath(p) {
   return p.startsWith(HOME) ? `~${p.slice(HOME.length)}` : p;
 }
@@ -668,8 +807,6 @@ function registerTerminalCleanup() {
     process.exit(143);
   });
   process.on("SIGINT", () => {
-    if (process.listenerCount("SIGINT") > 1)
-      return;
     cleanup();
     process.exit(130);
   });
@@ -856,10 +993,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 +1009,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 +1150,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 +1308,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 +1363,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 +1457,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 +1476,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 +1534,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 +1547,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 +1567,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 +1765,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 +1793,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 +1943,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 +1995,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 +2017,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 +2054,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) {
@@ -2240,30 +2410,51 @@ var MAX_STEPS = 50;
 function isZodSchema(s) {
   return s !== null && typeof s === "object" && "_def" in s;
 }
-function toCoreTool(def) {
+function toCoreTool(def, claimWarning) {
   const schema = isZodSchema(def.schema) ? def.schema : jsonSchema(def.schema);
   return dynamicTool({
     description: def.description,
     inputSchema: schema,
     execute: async (input) => {
       try {
-        return await def.execute(input);
+        const result = await def.execute(input);
+        if (claimWarning()) {
+          const warning = `
+
+<system-message>You have reached the maximum number of tool calls. ` + "No more tools will be available after this result. " + "Respond with a status update and list what still needs to be done.</system-message>";
+          const str = typeof result === "string" ? result : JSON.stringify(result);
+          return str + warning;
+        }
+        return result;
       } catch (err) {
         throw err instanceof Error ? err : new Error(String(err));
       }
     }
   });
 }
+function isOpenAIGPT(modelString) {
+  const { provider, modelId } = parseModelString(modelString);
+  return (provider === "openai" || provider === "zen") && modelId.startsWith("gpt-");
+}
 async function* runTurn(options) {
-  const { model, messages, tools, systemPrompt, signal } = options;
+  const { model, modelString, messages, tools, systemPrompt, signal } = options;
+  let stepCount = 0;
+  let warningClaimed = false;
+  function claimWarning() {
+    if (stepCount !== MAX_STEPS - 2 || warningClaimed)
+      return false;
+    warningClaimed = true;
+    return true;
+  }
   const toolSet = {};
   for (const def of tools) {
-    toolSet[def.name] = toCoreTool(def);
+    toolSet[def.name] = toCoreTool(def, claimWarning);
   }
   let inputTokens = 0;
   let outputTokens = 0;
   let contextTokens = 0;
   try {
+    const useInstructions = systemPrompt !== undefined && isOpenAIGPT(modelString);
     const streamOpts = {
       model,
       messages,
@@ -2273,11 +2464,28 @@ async function* runTurn(options) {
         inputTokens += step.usage?.inputTokens ?? 0;
         outputTokens += step.usage?.outputTokens ?? 0;
         contextTokens = step.usage?.inputTokens ?? contextTokens;
+        stepCount++;
+        warningClaimed = false;
       },
-      ...systemPrompt ? { system: systemPrompt } : {},
+      prepareStep: ({ stepNumber }) => {
+        if (stepNumber >= MAX_STEPS - 1) {
+          return { activeTools: [] };
+        }
+        return;
+      },
+      ...systemPrompt && !useInstructions ? { system: systemPrompt } : {},
+      ...useInstructions ? {
+        providerOptions: {
+          openai: {
+            instructions: systemPrompt,
+            store: false
+          }
+        }
+      } : {},
       ...signal ? { abortSignal: signal } : {}
     };
     const result = streamText(streamOpts);
+    result.response.catch(() => {});
     for await (const chunk of result.fullStream) {
       if (signal?.aborted)
         break;
@@ -2402,7 +2610,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 +2701,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 +2750,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 +2817,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 +3014,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 +3024,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,15 +3039,15 @@ var createTool = {
 };
 
 // src/tools/glob.ts
-import { join as join9, relative as relative3 } from "path";
-import { z as z3 } from "zod";
+import { join as join10, relative as relative3 } from "path";
+import { z as z4 } from "zod";
 
 // src/tools/ignore.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import ignore from "ignore";
 async function loadGitignore(cwd) {
   try {
-    const gitignore = await Bun.file(join8(cwd, ".gitignore")).text();
+    const gitignore = await Bun.file(join9(cwd, ".gitignore")).text();
     return ignore().add(gitignore);
   } catch {
     return null;
@@ -2782,9 +3055,9 @@ async function loadGitignore(cwd) {
 }
 
 // src/tools/glob.ts
-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")
+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 = {
@@ -2807,7 +3080,7 @@ var globTool = {
       if (ignored)
         continue;
       try {
-        const fullPath = join9(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 {
@@ -2820,14 +3093,14 @@ var globTool = {
     if (truncated)
       matches.pop();
     matches.sort((a, b) => b.mtime - a.mtime);
-    const files = matches.map((m) => relative3(cwd, join9(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 join10 } 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;
@@ -2873,12 +3146,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",
@@ -2917,7 +3190,7 @@ var grepTool = {
         if (ignoreGlob.some((g) => g.match(relPath) || g.match(firstSegment))) {
           continue;
         }
-        const fullPath = join10(cwd, relPath);
+        const fullPath = join11(cwd, relPath);
         let text;
         try {
           text = await Bun.file(fullPath).text();
@@ -2968,8 +3241,8 @@ var grepTool = {
 
 // src/tools/hooks.ts
 import { constants, accessSync } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join11 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join12 } from "path";
 function isExecutable(filePath) {
   try {
     accessSync(filePath, constants.X_OK);
@@ -2981,8 +3254,8 @@ function isExecutable(filePath) {
 function findHook(toolName, cwd) {
   const scriptName = `post-${toolName}`;
   const candidates = [
-    join11(cwd, ".agents", "hooks", scriptName),
-    join11(homedir6(), ".agents", "hooks", scriptName)
+    join12(cwd, ".agents", "hooks", scriptName),
+    join12(homedir7(), ".agents", "hooks", scriptName)
   ];
   for (const p of candidates) {
     if (isExecutable(p))
@@ -3071,13 +3344,13 @@ function hookEnvForRead(input, cwd) {
 }
 
 // src/tools/insert.ts
-import { join as join12, 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 = {
@@ -3086,7 +3359,7 @@ var insertTool = {
   schema: InsertSchema,
   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 : join13(cwd, input.path);
     const relPath = relative4(cwd, filePath);
     const file = Bun.file(filePath);
     if (!await file.exists()) {
@@ -3131,12 +3404,12 @@ function parseAnchor(value) {
 }
 
 // src/tools/read.ts
-import { join as join13, 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;
@@ -3146,7 +3419,7 @@ var readTool = {
   schema: ReadSchema,
   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 : join14(cwd, input.path);
     const file = Bun.file(filePath);
     const exists = await file.exists();
     if (!exists) {
@@ -3179,13 +3452,13 @@ var readTool = {
 };
 
 // src/tools/replace.ts
-import { join as join14, 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 = {
@@ -3194,7 +3467,7 @@ var replaceTool = {
   schema: ReplaceSchema,
   execute: async (input) => {
     const cwd = input.cwd ?? process.cwd();
-    const filePath = input.path.startsWith("/") ? input.path : join14(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()) {
@@ -3252,11 +3525,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 = {
@@ -3268,6 +3541,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,
@@ -3321,6 +3595,11 @@ var shellTool = {
     } finally {
       clearTimeout(timer);
       restoreTerminal();
+      if (wasRaw) {
+        try {
+          process.stdin.setRawMode(true);
+        } catch {}
+      }
     }
     return {
       stdout: stdout.trimEnd(),
@@ -3333,12 +3612,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(", ")}.` : "";
@@ -3347,7 +3626,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);
     }
   };
 }
@@ -3396,7 +3675,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),
@@ -3408,17 +3687,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
@@ -3440,9 +3727,9 @@ async function getGitBranch(cwd) {
 }
 function loadContextFile(cwd) {
   const candidates = [
-    join15(cwd, "AGENTS.md"),
-    join15(cwd, "CLAUDE.md"),
-    join15(getConfigDir(), "AGENTS.md")
+    join16(cwd, "AGENTS.md"),
+    join16(cwd, "CLAUDE.md"),
+    join16(getConfigDir(), "AGENTS.md")
   ];
   for (const p of candidates) {
     if (existsSync6(p)) {
@@ -3453,7 +3740,19 @@ function loadContextFile(cwd) {
   }
   return null;
 }
-function buildSystemPrompt(cwd) {
+var CODEX_AUTONOMY = `
+# Autonomy and persistence
+- You are an autonomous senior engineer. Once given a direction, proactively gather context, implement, test, and refine without waiting for additional prompts at each step.
+- Persist until the task is fully handled end-to-end within the current turn: do not stop at analysis or partial work; carry changes through to implementation and verification.
+- Bias to action: default to implementing with reasonable assumptions. Do not end your turn with clarifications or requests to "proceed" unless you are truly blocked on information only the user can provide.
+- Do NOT output an upfront plan, preamble, or status update before working. Start making tool calls immediately.
+- Do NOT ask "shall I proceed?", "shall I start?", "reply X to continue", or any equivalent. Just start.
+- If something is ambiguous, pick the most reasonable interpretation, implement it, and note the assumption at the end.`;
+function isCodexModel(modelString) {
+  const { modelId } = parseModelString(modelString);
+  return modelId.includes("codex");
+}
+function buildSystemPrompt(cwd, modelString) {
   const contextFile = loadContextFile(cwd);
   const cwdDisplay = tildePath(cwd);
   const now = new Date().toLocaleString(undefined, { hour12: false });
@@ -3468,8 +3767,10 @@ Guidelines:
 - Prefer small, targeted edits over large rewrites.
 - Always read a file before editing it.
 - Use glob to discover files, grep to find patterns, read to inspect contents.
-- Use shell for tests, builds, and git operations.
-- When in doubt, ask the user before making destructive changes.`;
+- Use shell for tests, builds, and git operations.`;
+  if (modelString && isCodexModel(modelString)) {
+    prompt += CODEX_AUTONOMY;
+  }
   if (contextFile) {
     prompt += `
 
@@ -3519,61 +3820,52 @@ 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) {
       throw new Error(`Unknown agent "${agentName}". Available agents: ${[...allAgents.keys()].join(", ") || "(none)"}`);
     }
     const model = modelOverride ?? agentConfig?.model ?? currentModel;
-    const systemPrompt = agentConfig?.systemPrompt ?? buildSystemPrompt(cwd);
+    const systemPrompt = agentConfig?.systemPrompt ?? buildSystemPrompt(cwd, model);
     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,
+      modelString: model,
       messages: subMessages,
       tools: subTools,
       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({
@@ -3760,12 +4052,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++;
@@ -3774,7 +4064,7 @@ ${out}
 
 <system-message>PLAN MODE ACTIVE: Help the user gather context for the plan -- READ ONLY</system-message>` : ralphMode ? `${resolvedText}
 
-<system-message>RALPH MODE: You are in an autonomous loop. When the task is fully complete (all tests pass, no outstanding issues), output exactly \`/ralph\` as your final message to exit the loop. Otherwise, keep working.</system-message>` : resolvedText;
+<system-message>RALPH MODE: You are in an autonomous loop. You MUST make actual file changes (create, edit, or write files) to complete the requested task before outputting \`/ralph\`. Reading files, running tests, or exploring the codebase does NOT count as doing the work. Only output \`/ralph\` as your final message after all requested changes are implemented and tests pass.</system-message>` : resolvedText;
     const userMsg = allImages.length > 0 ? {
       role: "user",
       content: [
@@ -3787,11 +4077,8 @@ ${out}
       ]
     } : { role: "user", content: coreContent };
     if (wasAborted) {
-      process.removeListener("SIGINT", onSigInt);
-      const stubMsg = {
-        role: "assistant",
-        content: "[interrupted]"
-      };
+      stopWatcher();
+      const stubMsg = makeInterruptMessage("user");
       session.messages.push(userMsg, stubMsg);
       saveMessages(session.id, [userMsg, stubMsg], thisTurn);
       coreHistory.push(userMsg, stubMsg);
@@ -3803,26 +4090,15 @@ ${out}
     saveMessages(session.id, [userMsg], thisTurn);
     coreHistory.push(userMsg);
     const llm = resolveModel(currentModel);
-    const systemPrompt = buildSystemPrompt(cwd);
+    const systemPrompt = buildSystemPrompt(cwd, currentModel);
     let lastAssistantText = "";
-    let turnRolledBack = false;
-    const rollbackTurn = () => {
-      if (turnRolledBack)
-        return;
-      turnRolledBack = true;
-      coreHistory.pop();
-      session.messages.pop();
-      deleteLastTurn(session.id, thisTurn);
-      if (snapped)
-        deleteSnapshot(session.id, thisTurn);
-      snapshotStack.pop();
-      turnIndex--;
-    };
+    let errorStubSaved = false;
     try {
       snapshotStack.push(snapped ? thisTurn : null);
       spinner.start("thinking");
       const events = runTurn({
         model: llm,
+        modelString: currentModel,
         messages: coreHistory,
         tools: planMode ? [...buildReadOnlyToolSet({ cwd }), ...mcpTools] : tools,
         systemPrompt,
@@ -3833,16 +4109,17 @@ ${out}
         coreHistory.push(...newMessages);
         session.messages.push(...newMessages);
         saveMessages(session.id, newMessages, thisTurn);
-      } else if (wasAborted) {
-        const stubMsg = {
-          role: "assistant",
-          content: "[interrupted]"
-        };
+        if (wasAborted) {
+          const note = makeInterruptMessage("user");
+          coreHistory.push(note);
+          session.messages.push(note);
+          saveMessages(session.id, [note], thisTurn);
+        }
+      } else {
+        const stubMsg = makeInterruptMessage("user");
         coreHistory.push(stubMsg);
         session.messages.push(stubMsg);
         saveMessages(session.id, [stubMsg], thisTurn);
-      } else {
-        rollbackTurn();
       }
       lastAssistantText = extractAssistantText(newMessages);
       totalIn += inputTokens;
@@ -3850,10 +4127,16 @@ ${out}
       lastContextTokens = contextTokens;
       touchActiveSession(session);
     } catch (err) {
-      rollbackTurn();
+      if (!errorStubSaved) {
+        errorStubSaved = true;
+        const stubMsg = makeInterruptMessage("error");
+        coreHistory.push(stubMsg);
+        session.messages.push(stubMsg);
+        saveMessages(session.id, [stubMsg], thisTurn);
+      }
       throw err;
     } finally {
-      process.removeListener("SIGINT", onSigInt);
+      stopWatcher();
       if (wasAborted)
         ralphMode = false;
     }
@@ -3878,6 +4161,10 @@ ${out}
     });
   }
 }
+function makeInterruptMessage(reason) {
+  const text = reason === "user" ? "<system-message>Response was interrupted by the user.</system-message>" : "<system-message>Response was interrupted due to an error.</system-message>";
+  return { role: "assistant", content: text };
+}
 function extractAssistantText(newMessages) {
   const parts = [];
   for (const msg of newMessages) {
@@ -3917,7 +4204,7 @@ ${skill.content}
       result = result.slice(0, match.index) + replacement + result.slice((match.index ?? 0) + match[0].length);
       continue;
     }
-    const filePath = ref.startsWith("/") ? ref : join15(cwd, ref);
+    const filePath = ref.startsWith("/") ? ref : join16(cwd, ref);
     if (isImageFilename(ref)) {
       const attachment = await loadImageFile(filePath);
       if (attachment) {
@@ -3945,6 +4232,7 @@ ${preview}
 
 // src/index.ts
 registerTerminalCleanup();
+initErrorLog();
 function parseArgs(argv) {
   const args = {
     model: null,
@@ -4063,11 +4351,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);
 });