mini-coder 0.0.22 → 0.0.23

package/dist/mc.js

@@ -3,10 +3,10 @@
 
 // src/index.ts
 import { writeSync } from "fs";
-import * as c24 from "yoctocolors";
+import * as c23 from "yoctocolors";
 
 // src/agent/agent.ts
-import * as c13 from "yoctocolors";
+import * as c12 from "yoctocolors";
 
 // src/cli/load-markdown-configs.ts
 import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
@@ -14,13 +14,13 @@ import { homedir as homedir4 } from "os";
 import { basename, join as join5 } from "path";
 
 // src/cli/config-conflicts.ts
-import * as c9 from "yoctocolors";
+import * as c8 from "yoctocolors";
 
 // src/cli/output.ts
 import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join4 } from "path";
-import * as c8 from "yoctocolors";
+import * as c7 from "yoctocolors";
 
 // src/cli/custom-commands.ts
 import { existsSync, readFileSync } from "fs";
@@ -290,159 +290,6 @@ function parseAppError(err) {
   return { headline: firstLine };
 }
 
-// src/cli/live-output.ts
-import * as c from "yoctocolors";
-
-// src/cli/terminal-io.ts
-class TerminalIO {
-  rawModeEnabled = false;
-  interruptHandler = null;
-  setInterruptHandler(handler) {
-    this.interruptHandler = handler;
-  }
-  beforeWriteCallback = null;
-  setBeforeWriteCallback(cb) {
-    this.beforeWriteCallback = cb;
-  }
-  skipCallback = false;
-  stdoutWrite(text) {
-    if (text && this.beforeWriteCallback && !this.skipCallback) {
-      this.skipCallback = true;
-      this.beforeWriteCallback();
-      this.skipCallback = false;
-    }
-    this.doStdoutWrite(text);
-  }
-  doStdoutWrite(text) {
-    process.stdout.write(text);
-  }
-  stderrWrite(text) {
-    if (text && this.beforeWriteCallback && !this.skipCallback) {
-      this.skipCallback = true;
-      this.beforeWriteCallback();
-      this.skipCallback = false;
-    }
-    this.doStderrWrite(text);
-  }
-  doStderrWrite(text) {
-    process.stderr.write(text);
-  }
-  get isTTY() {
-    return process.stdin.isTTY;
-  }
-  get isStdoutTTY() {
-    return process.stdout.isTTY;
-  }
-  get isStderrTTY() {
-    return process.stderr.isTTY;
-  }
-  get stdoutColumns() {
-    return process.stdout.columns ?? 0;
-  }
-  setRawMode(enable) {
-    if (this.isTTY) {
-      process.stdin.setRawMode(enable);
-      this.rawModeEnabled = enable;
-    }
-  }
-  restoreTerminal() {
-    try {
-      if (this.isStderrTTY) {
-        this.stderrWrite("\x1B[?25h");
-        this.stderrWrite("\r\x1B[2K");
-      }
-    } catch {}
-    try {
-      if (this.rawModeEnabled) {
-        this.setRawMode(false);
-      }
-    } catch {}
-  }
-  registerCleanup() {
-    const cleanup = () => this.restoreTerminal();
-    process.on("exit", cleanup);
-    process.on("SIGTERM", () => {
-      cleanup();
-      process.exit(143);
-    });
-    process.on("SIGINT", () => {
-      if (this.interruptHandler) {
-        this.interruptHandler();
-      } else {
-        cleanup();
-        process.exit(130);
-      }
-    });
-    process.on("uncaughtException", (err) => {
-      cleanup();
-      throw err;
-    });
-    process.on("unhandledRejection", (reason) => {
-      cleanup();
-      throw reason instanceof Error ? reason : new Error(String(reason));
-    });
-  }
-  onStdinData(handler) {
-    process.stdin.on("data", handler);
-    return () => process.stdin.off("data", handler);
-  }
-}
-var terminal = new TerminalIO;
-
-// src/cli/live-output.ts
-var LIVE_OUTPUT_PREFIX = `    ${c.dim("\u2502")} `;
-function write(text) {
-  terminal.stdoutWrite(text);
-}
-function writeln(text = "") {
-  terminal.stdoutWrite(`${text}
-`);
-}
-
-class LiveOutputBlock {
-  pending = "";
-  lineOpen = false;
-  append(chunk) {
-    if (!chunk)
-      return;
-    this.pending += chunk.replace(/\r\n/g, `
-`).replace(/\r/g, `
-`);
-    this.flushCompleteLines();
-  }
-  finish() {
-    if (this.pending.length > 0) {
-      this.openLine();
-      write(this.pending);
-      this.pending = "";
-    }
-    if (this.lineOpen) {
-      writeln();
-      this.lineOpen = false;
-    }
-  }
-  flushCompleteLines() {
-    let boundary = this.pending.indexOf(`
-`);
-    while (boundary !== -1) {
-      const line = this.pending.slice(0, boundary);
-      this.openLine();
-      write(line);
-      writeln();
-      this.lineOpen = false;
-      this.pending = this.pending.slice(boundary + 1);
-      boundary = this.pending.indexOf(`
-`);
-    }
-  }
-  openLine() {
-    if (this.lineOpen)
-      return;
-    write(LIVE_OUTPUT_PREFIX);
-    this.lineOpen = true;
-  }
-}
-
 // src/cli/skills.ts
 import {
   closeSync,
@@ -567,7 +414,7 @@ function warnInvalidSkill(filePath, reason) {
   if (warnedInvalidSkills.has(key))
     return;
   warnedInvalidSkills.add(key);
-  writeln2(`${G.warn} skipping invalid skill ${filePath}: ${reason}`);
+  writeln(`${G.warn} skipping invalid skill ${filePath}: ${reason}`);
 }
 function validateSkill(candidate) {
   const meta = getCandidateFrontmatter(candidate);
@@ -639,7 +486,105 @@ function loadSkillContent(name, cwd, homeDir) {
 }
 
 // src/cli/spinner.ts
-import * as c2 from "yoctocolors";
+import * as c from "yoctocolors";
+
+// src/cli/terminal-io.ts
+class TerminalIO {
+  rawModeEnabled = false;
+  interruptHandler = null;
+  setInterruptHandler(handler) {
+    this.interruptHandler = handler;
+  }
+  beforeWriteCallback = null;
+  setBeforeWriteCallback(cb) {
+    this.beforeWriteCallback = cb;
+  }
+  skipCallback = false;
+  stdoutWrite(text) {
+    if (text && this.beforeWriteCallback && !this.skipCallback) {
+      this.skipCallback = true;
+      this.beforeWriteCallback();
+      this.skipCallback = false;
+    }
+    this.doStdoutWrite(text);
+  }
+  doStdoutWrite(text) {
+    process.stdout.write(text);
+  }
+  stderrWrite(text) {
+    if (text && this.beforeWriteCallback && !this.skipCallback) {
+      this.skipCallback = true;
+      this.beforeWriteCallback();
+      this.skipCallback = false;
+    }
+    this.doStderrWrite(text);
+  }
+  doStderrWrite(text) {
+    process.stderr.write(text);
+  }
+  get isTTY() {
+    return process.stdin.isTTY;
+  }
+  get isStdoutTTY() {
+    return process.stdout.isTTY;
+  }
+  get isStderrTTY() {
+    return process.stderr.isTTY;
+  }
+  get stdoutColumns() {
+    return process.stdout.columns ?? 0;
+  }
+  setRawMode(enable) {
+    if (this.isTTY) {
+      process.stdin.setRawMode(enable);
+      this.rawModeEnabled = enable;
+    }
+  }
+  restoreTerminal() {
+    try {
+      if (this.isStderrTTY) {
+        this.stderrWrite("\x1B[?25h");
+        this.stderrWrite("\r\x1B[2K");
+      }
+    } catch {}
+    try {
+      if (this.rawModeEnabled) {
+        this.setRawMode(false);
+      }
+    } catch {}
+  }
+  registerCleanup() {
+    const cleanup = () => this.restoreTerminal();
+    process.on("exit", cleanup);
+    process.on("SIGTERM", () => {
+      cleanup();
+      process.exit(143);
+    });
+    process.on("SIGINT", () => {
+      if (this.interruptHandler) {
+        this.interruptHandler();
+      } else {
+        cleanup();
+        process.exit(130);
+      }
+    });
+    process.on("uncaughtException", (err) => {
+      cleanup();
+      throw err;
+    });
+    process.on("unhandledRejection", (reason) => {
+      cleanup();
+      throw reason instanceof Error ? reason : new Error(String(reason));
+    });
+  }
+  onStdinData(handler) {
+    process.stdin.on("data", handler);
+    return () => process.stdin.off("data", handler);
+  }
+}
+var terminal = new TerminalIO;
+
+// src/cli/spinner.ts
 var SPINNER_FRAMES = ["\u28FE", "\u28FD", "\u28FB", "\u28BF", "\u287F", "\u28DF", "\u28EF", "\u28F7"];
 
 class Spinner {
@@ -675,15 +620,15 @@ class Spinner {
   }
   _tick() {
     const f = SPINNER_FRAMES[this.frame++ % SPINNER_FRAMES.length] ?? "\u28FE";
-    const label = this.label ? c2.dim(` ${this.label}`) : "";
-    terminal.stderrWrite(`\r${c2.dim(f)}${label}`);
+    const label = this.label ? c.dim(` ${this.label}`) : "";
+    terminal.stderrWrite(`\r${c.dim(f)}${label}`);
   }
 }
 
 // src/cli/status-bar.ts
-import * as c3 from "yoctocolors";
+import * as c2 from "yoctocolors";
 var ANSI_ESCAPE = "\x1B";
-var STATUS_SEP = c3.dim("  \xB7  ");
+var STATUS_SEP = c2.dim("  \xB7  ");
 function stripAnsi(s) {
   if (!s.includes(ANSI_ESCAPE))
     return s;
@@ -705,12 +650,12 @@ function buildContextSegment(opts) {
   if (opts.contextTokens <= 0)
     return null;
   if (opts.contextWindow === null) {
-    return c3.dim(`ctx ${fmtTokens(opts.contextTokens)}`);
+    return c2.dim(`ctx ${fmtTokens(opts.contextTokens)}`);
   }
   const pct = Math.round(opts.contextTokens / opts.contextWindow * 100);
   const pctStr = `${pct}%`;
-  const pctColored = pct >= 90 ? c3.red(pctStr) : pct >= 75 ? c3.yellow(pctStr) : c3.dim(pctStr);
-  return c3.dim(`ctx ${fmtTokens(opts.contextTokens)}/${fmtTokens(opts.contextWindow)} `) + pctColored;
+  const pctColored = pct >= 90 ? c2.red(pctStr) : pct >= 75 ? c2.yellow(pctStr) : c2.dim(pctStr);
+  return c2.dim(`ctx ${fmtTokens(opts.contextTokens)}/${fmtTokens(opts.contextWindow)} `) + pctColored;
 }
 function renderStatusLine(segments) {
   return segments.join(STATUS_SEP);
@@ -747,26 +692,26 @@ function fitStatusSegments(required, optional, cols) {
     return truncatePlainText(fixedPrefix, cols);
   const maxTailLen = Math.max(8, cols - fixedPrefix.length - sepLen);
   const truncatedTail = truncatePlainText(plainRequired[1] ?? "", maxTailLen);
-  return `${required[0]}${STATUS_SEP}${c3.dim(truncatedTail)}`;
+  return `${required[0]}${STATUS_SEP}${c2.dim(truncatedTail)}`;
 }
 function renderStatusBar(opts) {
   const cols = Math.max(20, terminal.stdoutColumns || 80);
   const required = [
-    c3.cyan(opts.model),
-    c3.dim(`#${opts.sessionId.slice(0, 8)}`)
+    c2.cyan(opts.model),
+    c2.dim(`#${opts.sessionId.slice(0, 8)}`)
   ];
   const optional = [];
   if (opts.provider && opts.provider !== "zen") {
-    optional.push(c3.dim(opts.provider));
+    optional.push(c2.dim(opts.provider));
   }
   if (opts.activeAgent)
-    optional.push(c3.green(`@${opts.activeAgent}`));
+    optional.push(c2.green(`@${opts.activeAgent}`));
   if (opts.thinkingEffort)
-    optional.push(c3.dim(`\u2726 ${opts.thinkingEffort}`));
+    optional.push(c2.dim(`\u2726 ${opts.thinkingEffort}`));
   if (opts.gitBranch)
-    optional.push(c3.dim(`\u2387 ${opts.gitBranch}`));
+    optional.push(c2.dim(`\u2387 ${opts.gitBranch}`));
   if (opts.inputTokens > 0 || opts.outputTokens > 0) {
-    optional.push(c3.dim(`tok ${fmtTokens(opts.inputTokens)}/${fmtTokens(opts.outputTokens)}`));
+    optional.push(c2.dim(`tok ${fmtTokens(opts.inputTokens)}/${fmtTokens(opts.outputTokens)}`));
   }
   const contextSegment = buildContextSegment({
     contextTokens: opts.contextTokens,
@@ -774,14 +719,14 @@ function renderStatusBar(opts) {
   });
   if (contextSegment)
     optional.push(contextSegment);
-  optional.push(c3.dim(opts.cwd));
+  optional.push(c2.dim(opts.cwd));
   const out = fitStatusSegments(required, optional, cols);
   terminal.stdoutWrite(`${out}
 `);
 }
 
 // src/cli/stream-render.ts
-import * as c7 from "yoctocolors";
+import * as c6 from "yoctocolors";
 
 // src/llm-api/model-routing.ts
 function parseModelString(modelString) {
@@ -866,7 +811,7 @@ function isToolCallPart(part) {
 function hasObjectToolCallInput(part) {
   return isToolCallPart(part) && "input" in part && isRecord(part.input) && !Array.isArray(part.input);
 }
-var TOOL_RUNTIME_INPUT_KEYS = new Set(["cwd", "onOutput"]);
+var TOOL_RUNTIME_INPUT_KEYS = new Set(["cwd"]);
 function stripToolRuntimeInputFields(messages) {
   let mutated = false;
   const result = messages.map((message) => {
@@ -1181,9 +1126,9 @@ function extractAssistantText(newMessages) {
 }
 
 // src/cli/live-reasoning.ts
-import * as c4 from "yoctocolors";
+import * as c3 from "yoctocolors";
 function styleReasoningText(text) {
-  return c4.italic(c4.dim(text));
+  return c3.italic(c3.dim(text));
 }
 
 class LiveReasoningBlock {
@@ -1209,27 +1154,27 @@ class LiveReasoningBlock {
     if (!this.blockOpen)
       return;
     if (this.lineOpen)
-      writeln2();
+      writeln();
     this.blockOpen = false;
     this.lineOpen = false;
   }
   openBlock() {
     if (this.blockOpen)
       return;
-    writeln2(`${G.info} ${c4.dim("reasoning")}`);
+    writeln(`${G.info} ${c3.dim("reasoning")}`);
     this.blockOpen = true;
   }
   writeText(text) {
     if (!this.lineOpen) {
-      write2("  ");
+      write("  ");
       this.lineOpen = true;
     }
-    write2(styleReasoningText(text));
+    write(styleReasoningText(text));
   }
   endLine() {
     if (!this.lineOpen)
-      write2("  ");
-    writeln2();
+      write("  ");
+    writeln();
     this.lineOpen = false;
   }
 }
@@ -1288,14 +1233,17 @@ class StreamRenderContent {
     return this.inText;
   }
   appendTextDelta(delta, renderedVisibleOutput) {
-    const text = delta ?? "";
+    let text = delta ?? "";
     if (!text)
       return;
     if (!this.inText) {
+      text = text.trimStart();
+      if (!text)
+        return;
       this.spinner.stop();
       if (renderedVisibleOutput)
-        writeln2();
-      write2(`${G.reply} `);
+        writeln();
+      write(`${G.reply} `);
       this.inText = true;
       if (terminal.isStdoutTTY)
         this.highlighter = createHighlighter();
@@ -1310,10 +1258,10 @@ class StreamRenderContent {
         if (isFirstLine && colored.startsWith("\x1B[2K\r")) {
           colored = `\x1B[2K\r${G.reply} ${colored.slice(5)}`;
         }
-        write2(colored);
+        write(colored);
       }
     } else {
-      write2(text);
+      write(text);
     }
   }
   appendReasoningDelta(delta) {
@@ -1340,43 +1288,43 @@ ${text}`;
         if (isFirstLine && finalColored.startsWith("\x1B[2K\r")) {
           finalColored = `\x1B[2K\r${G.reply} ${finalColored.slice(5)}`;
         }
-        write2(finalColored);
+        write(finalColored);
       }
     }
-    writeln2();
+    writeln();
     this.inText = false;
   }
 }
 
 // src/cli/tool-render.ts
-import * as c6 from "yoctocolors";
+import * as c5 from "yoctocolors";
 
 // src/cli/tool-result-renderers.ts
-import * as c5 from "yoctocolors";
+import * as c4 from "yoctocolors";
 function writePreviewLines(opts) {
   if (!opts.value.trim())
     return;
   const lines = opts.value.split(`
 `);
-  writeln2(`    ${c5.dim(opts.label)} ${c5.dim(`(${lines.length} lines)`)}`);
+  writeln(`    ${c4.dim(opts.label)} ${c4.dim(`(${lines.length} lines)`)}`);
   if (!Number.isFinite(opts.maxLines) || lines.length <= opts.maxLines) {
     for (const line of lines) {
-      writeln2(`    ${opts.lineColor("\u2502")} ${line}`);
+      writeln(`    ${opts.lineColor("\u2502")} ${line}`);
     }
     return;
   }
   const headCount = Math.max(1, Math.ceil(opts.maxLines / 2));
   const tailCount = Math.max(0, Math.floor(opts.maxLines / 2));
   for (const line of lines.slice(0, headCount)) {
-    writeln2(`    ${opts.lineColor("\u2502")} ${line}`);
+    writeln(`    ${opts.lineColor("\u2502")} ${line}`);
   }
   const hiddenLines = Math.max(0, lines.length - (headCount + tailCount));
   if (hiddenLines > 0) {
-    writeln2(`    ${opts.lineColor("\u2502")} ${c5.dim(`\u2026 +${hiddenLines} lines`)}`);
+    writeln(`    ${opts.lineColor("\u2502")} ${c4.dim(`\u2026 +${hiddenLines} lines`)}`);
   }
   if (tailCount > 0) {
     for (const line of lines.slice(-tailCount)) {
-      writeln2(`    ${opts.lineColor("\u2502")} ${line}`);
+      writeln(`    ${opts.lineColor("\u2502")} ${line}`);
     }
   }
 }
@@ -1401,15 +1349,6 @@ function getSingleShellLine(value) {
 }
 function buildShellSummaryParts(opts) {
   const parts = [`exit ${opts.exitCode}`];
-  if (opts.streamedOutput) {
-    if (opts.stdoutLines === 0 && opts.stderrLines === 0) {
-      parts.push("no output");
-    }
-    if (opts.stderrLines > 0) {
-      parts.push(`stderr ${opts.stderrLines}L`);
-    }
-    return parts;
-  }
   if (opts.stderrLines === 0 && opts.stdoutSingleLine !== null && opts.stdoutSingleLine.length > 0) {
     parts.push(`out: ${truncateOneLine(opts.stdoutSingleLine, 100, opts.verboseOutput)}`);
     return parts;
@@ -1437,28 +1376,23 @@ function renderShellResult(result, opts) {
   if (!r || typeof r.stdout !== "string" || typeof r.stderr !== "string") {
     return false;
   }
-  const streamedOutput = r.streamedOutput === true;
   const verboseOutput = opts?.verboseOutput === true;
   const stdoutLines = countShellLines(r.stdout);
   const stderrLines = countShellLines(r.stderr);
   const stdoutSingleLine = getSingleShellLine(r.stdout);
-  const badge = r.timedOut ? c5.yellow("timeout") : r.success ? c5.green("done") : c5.red("error");
+  const badge = r.timedOut ? c4.yellow("timeout") : r.success ? c4.green("done") : c4.red("error");
   const parts = buildShellSummaryParts({
     exitCode: r.exitCode,
     stdoutLines,
     stderrLines,
     stdoutSingleLine,
-    streamedOutput,
     verboseOutput
   });
-  writeln2(`    ${badge} ${c5.dim(parts.join(" \xB7 "))}`);
-  if (streamedOutput) {
-    return true;
-  }
+  writeln(`    ${badge} ${c4.dim(parts.join(" \xB7 "))}`);
   writePreviewLines({
     label: "stderr",
     value: r.stderr,
-    lineColor: c5.red,
+    lineColor: c4.red,
     maxLines: verboseOutput ? Number.POSITIVE_INFINITY : 10
   });
   if (shouldPreviewShellStdout({
@@ -1470,7 +1404,7 @@ function renderShellResult(result, opts) {
     writePreviewLines({
       label: "stdout",
       value: r.stdout,
-      lineColor: c5.dim,
+      lineColor: c4.dim,
       maxLines: verboseOutput ? Number.POSITIVE_INFINITY : 20
     });
   }
@@ -1480,8 +1414,8 @@ function renderSubagentResult(result, _opts) {
   const r = result;
   if (!r || typeof r !== "object")
     return false;
-  const label = r.agentName ? ` ${c5.dim(c5.cyan(`[@${r.agentName}]`))}` : "";
-  writeln2(`    ${G.agent}${label} ${c5.dim(`subagent done (${r.inputTokens ?? 0}in / ${r.outputTokens ?? 0}out tokens)`)}`);
+  const label = r.agentName ? ` ${c4.dim(c4.cyan(`[@${r.agentName}]`))}` : "";
+  writeln(`    ${G.agent}${label} ${c4.dim(`subagent done (${r.inputTokens ?? 0}in / ${r.outputTokens ?? 0}out tokens)`)}`);
   return true;
 }
 function buildSkillDescriptionPart(description, verboseOutput = false) {
@@ -1489,21 +1423,21 @@ function buildSkillDescriptionPart(description, verboseOutput = false) {
   if (!trimmed)
     return "";
   if (verboseOutput)
-    return `  ${c5.dim("\xB7")}  ${c5.dim(trimmed)}`;
-  return `  ${c5.dim("\xB7")}  ${c5.dim(trimmed.length > 60 ? `${trimmed.slice(0, 57)}\u2026` : trimmed)}`;
+    return `  ${c4.dim("\xB7")}  ${c4.dim(trimmed)}`;
+  return `  ${c4.dim("\xB7")}  ${c4.dim(trimmed.length > 60 ? `${trimmed.slice(0, 57)}\u2026` : trimmed)}`;
 }
 function renderSkillSummaryLine(skill, opts) {
   const name = skill.name ?? "(unknown)";
   const source = skill.source ?? "unknown";
-  const labelPrefix = opts?.label ? `${c5.dim(opts.label)}  ` : "";
-  writeln2(`    ${G.info} ${labelPrefix}${name}  ${c5.dim("\xB7")}  ${c5.dim(source)}${buildSkillDescriptionPart(skill.description, opts?.verboseOutput === true)}`);
+  const labelPrefix = opts?.label ? `${c4.dim(opts.label)}  ` : "";
+  writeln(`    ${G.info} ${labelPrefix}${name}  ${c4.dim("\xB7")}  ${c4.dim(source)}${buildSkillDescriptionPart(skill.description, opts?.verboseOutput === true)}`);
 }
 function renderListSkillsResult(result, opts) {
   const r = result;
   if (!Array.isArray(r?.skills))
     return false;
   if (r.skills.length === 0) {
-    writeln2(`    ${G.info} ${c5.dim("no skills")}`);
+    writeln(`    ${G.info} ${c4.dim("no skills")}`);
     return true;
   }
   const maxSkills = opts?.verboseOutput ? r.skills.length : 6;
@@ -1513,7 +1447,7 @@ function renderListSkillsResult(result, opts) {
     });
   }
   if (r.skills.length > maxSkills) {
-    writeln2(`    ${c5.dim(`+${r.skills.length - maxSkills} more skills`)}`);
+    writeln(`    ${c4.dim(`+${r.skills.length - maxSkills} more skills`)}`);
   }
   return true;
 }
@@ -1522,7 +1456,7 @@ function renderReadSkillResult(result, _opts) {
   if (!r || typeof r !== "object")
     return false;
   if (!r.skill) {
-    writeln2(`    ${G.info} ${c5.dim("skill")}  ${c5.dim("(not found)")}`);
+    writeln(`    ${G.info} ${c4.dim("skill")}  ${c4.dim("(not found)")}`);
     return true;
   }
   renderSkillSummaryLine(r.skill, {
@@ -1536,19 +1470,19 @@ function renderWebSearchResult(result, opts) {
   if (!Array.isArray(r?.results))
     return false;
   if (r.results.length === 0) {
-    writeln2(`    ${G.info} ${c5.dim("no results")}`);
+    writeln(`    ${G.info} ${c4.dim("no results")}`);
     return true;
   }
   const maxResults = opts?.verboseOutput ? r.results.length : 5;
   for (const item of r.results.slice(0, maxResults)) {
     const title = (item.title?.trim() || item.url || "(untitled)").replace(/\s+/g, " ");
-    const score = typeof item.score === "number" ? c5.dim(` (${item.score.toFixed(2)})`) : "";
-    writeln2(`    ${c5.dim("\u2022")} ${title}${score}`);
+    const score = typeof item.score === "number" ? c4.dim(` (${item.score.toFixed(2)})`) : "";
+    writeln(`    ${c4.dim("\u2022")} ${title}${score}`);
     if (item.url)
-      writeln2(`      ${c5.dim(item.url)}`);
+      writeln(`      ${c4.dim(item.url)}`);
   }
   if (r.results.length > maxResults) {
-    writeln2(`    ${c5.dim(`  +${r.results.length - maxResults} more`)}`);
+    writeln(`    ${c4.dim(`  +${r.results.length - maxResults} more`)}`);
   }
   return true;
 }
@@ -1557,23 +1491,23 @@ function renderWebContentResult(result, opts) {
   if (!Array.isArray(r?.results))
     return false;
   if (r.results.length === 0) {
-    writeln2(`    ${G.info} ${c5.dim("no pages")}`);
+    writeln(`    ${G.info} ${c4.dim("no pages")}`);
     return true;
   }
   const maxPages = opts?.verboseOutput ? r.results.length : 3;
   for (const item of r.results.slice(0, maxPages)) {
     const title = (item.title?.trim() || item.url || "(untitled)").replace(/\s+/g, " ");
-    writeln2(`    ${c5.dim("\u2022")} ${title}`);
+    writeln(`    ${c4.dim("\u2022")} ${title}`);
     if (item.url)
-      writeln2(`      ${c5.dim(item.url)}`);
+      writeln(`      ${c4.dim(item.url)}`);
     const preview = (item.text ?? "").replace(/\s+/g, " ").trim();
     if (preview) {
       const trimmed = opts?.verboseOutput || preview.length <= 220 ? preview : `${preview.slice(0, 217)}\u2026`;
-      writeln2(`      ${c5.dim(trimmed)}`);
+      writeln(`      ${c4.dim(trimmed)}`);
     }
   }
   if (r.results.length > maxPages) {
-    writeln2(`    ${c5.dim(`  +${r.results.length - maxPages} more`)}`);
+    writeln(`    ${c4.dim(`  +${r.results.length - maxPages} more`)}`);
   }
   return true;
 }
@@ -1586,7 +1520,7 @@ function renderMcpResult(result, opts) {
       const lines = block.text.split(`
 `).slice(0, maxLines);
       for (const line of lines)
-        writeln2(`    ${c5.dim("\u2502")} ${line}`);
+        writeln(`    ${c4.dim("\u2502")} ${line}`);
     }
   }
   return true;
@@ -1629,40 +1563,40 @@ function buildToolCallLine(name, args) {
     const prompt = typeof a.prompt === "string" ? a.prompt : "";
     const short = prompt.length > 60 ? `${prompt.slice(0, 57)}\u2026` : prompt;
     const agentName = typeof a.agentName === "string" && a.agentName ? a.agentName : "";
-    const label = agentName ? ` ${c6.dim(c6.cyan(`[@${agentName}]`))}` : "";
-    return `${G.agent}${label} ${c6.dim("\u2014")} ${short}`;
+    const label = agentName ? ` ${c5.dim(c5.cyan(`[@${agentName}]`))}` : "";
+    return `${G.agent}${label} ${c5.dim("\u2014")} ${short}`;
   }
   if (name === "shell") {
     const cmd = String(a.command ?? "").trim();
     if (!cmd)
-      return `${G.run} ${c6.dim("shell")}`;
+      return `${G.run} ${c5.dim("shell")}`;
     const shortCmd = cmd.length > 72 ? `${cmd.slice(0, 69)}\u2026` : cmd;
     return `${G.run} ${shortCmd}`;
   }
   if (name === "listSkills") {
-    return `${G.search} ${c6.dim("list skills")}`;
+    return `${G.search} ${c5.dim("list skills")}`;
   }
   if (name === "readSkill") {
     const skillName = typeof a.name === "string" ? a.name : "";
-    return `${G.read} ${c6.dim("read skill")}${skillName ? ` ${skillName}` : ""}`;
+    return `${G.read} ${c5.dim("read skill")}${skillName ? ` ${skillName}` : ""}`;
   }
   if (name.startsWith("mcp_")) {
-    return `${G.mcp} ${c6.dim(name)}`;
+    return `${G.mcp} ${c5.dim(name)}`;
   }
-  return `${toolGlyph(name)} ${c6.dim(name)}`;
+  return `${toolGlyph(name)} ${c5.dim(name)}`;
 }
 function renderToolCall(toolName, args) {
-  writeln2(`  ${buildToolCallLine(toolName, args)}`);
+  writeln(`  ${buildToolCallLine(toolName, args)}`);
 }
 function formatErrorBadge(result) {
   const msg = typeof result === "string" ? result : result instanceof Error ? result.message : JSON.stringify(result);
   const oneLiner = msg.split(`
 `)[0] ?? msg;
-  return `${G.err} ${c6.red(oneLiner)}`;
+  return `${G.err} ${c5.red(oneLiner)}`;
 }
 function renderToolResult(toolName, result, isError, opts) {
   if (isError) {
-    writeln2(`    ${formatErrorBadge(result)}`);
+    writeln(`    ${formatErrorBadge(result)}`);
     return;
   }
   if (renderToolResultByName(toolName, result, opts)) {
@@ -1670,10 +1604,10 @@ function renderToolResult(toolName, result, isError, opts) {
   }
   const text = JSON.stringify(result);
   if (opts?.verboseOutput || text.length <= 120) {
-    writeln2(`    ${c6.dim(text)}`);
+    writeln(`    ${c5.dim(text)}`);
     return;
   }
-  writeln2(`    ${c6.dim(`${text.slice(0, 117)}\u2026`)}`);
+  writeln(`    ${c5.dim(`${text.slice(0, 117)}\u2026`)}`);
 }
 
 // src/cli/stream-render.ts
@@ -1702,7 +1636,7 @@ async function renderTurn(events, spinner, opts) {
       case "text-delta": {
         liveReasoning.finish();
         content.appendTextDelta(event.delta, renderedVisibleOutput);
-        if (event.delta)
+        if (content.hasOpenContent())
           renderedVisibleOutput = true;
         break;
       }
@@ -1713,7 +1647,7 @@ async function renderTurn(events, spinner, opts) {
         if (showReasoning && delta) {
           spinner.stop();
           if (renderedVisibleOutput && !liveReasoning.isOpen())
-            writeln2();
+            writeln();
           liveReasoning.append(delta);
           renderedVisibleOutput = true;
         }
@@ -1728,7 +1662,7 @@ async function renderTurn(events, spinner, opts) {
         content.flushOpenContent();
         spinner.stop();
         if (renderedVisibleOutput)
-          writeln2();
+          writeln();
         renderToolCall(event.toolName, event.args);
         renderedVisibleOutput = true;
         spinner.start(event.toolName);
@@ -1750,7 +1684,7 @@ async function renderTurn(events, spinner, opts) {
         content.flushOpenContent();
         spinner.stop();
         const removedKb = (event.removedBytes / 1024).toFixed(1);
-        writeln2(`${G.info} ${c7.dim("context pruned")}  ${c7.dim(event.mode)}  ${c7.dim(`\u2013${event.removedMessageCount} messages`)}  ${c7.dim(`\u2013${removedKb} KB`)}`);
+        writeln(`${G.info} ${c6.dim("context pruned")}  ${c6.dim(event.mode)}  ${c6.dim(`\u2013${event.removedMessageCount} messages`)}  ${c6.dim(`\u2013${removedKb} KB`)}`);
         renderedVisibleOutput = true;
         break;
       }
@@ -1759,7 +1693,7 @@ async function renderTurn(events, spinner, opts) {
         content.flushOpenContent();
         spinner.stop();
         if (!renderedVisibleOutput)
-          writeln2();
+          writeln();
         inputTokens = event.inputTokens;
         outputTokens = event.outputTokens;
         contextTokens = event.contextTokens;
@@ -1791,7 +1725,7 @@ async function renderTurn(events, spinner, opts) {
 
 // src/cli/output.ts
 var HOME = homedir3();
-var PACKAGE_VERSION = "0.0.22";
+var PACKAGE_VERSION = "0.0.23";
 function tildePath(p) {
   return p.startsWith(HOME) ? `~${p.slice(HOME.length)}` : p;
 }
@@ -1801,38 +1735,38 @@ function restoreTerminal() {
 function registerTerminalCleanup() {
   terminal.registerCleanup();
 }
-function writeln2(text = "") {
+function writeln(text = "") {
   terminal.stdoutWrite(`${text}
 `);
 }
-function write2(text) {
+function write(text) {
   terminal.stdoutWrite(text);
 }
 function renderUserMessage(text) {
   const lines = text.split(`
 `);
   if (lines.length === 0) {
-    writeln2(`${G.prompt}`);
+    writeln(`${G.prompt}`);
     return;
   }
-  writeln2(`${G.prompt} ${lines[0] ?? ""}`);
+  writeln(`${G.prompt} ${lines[0] ?? ""}`);
   for (const line of lines.slice(1)) {
-    writeln2(`  ${line}`);
+    writeln(`  ${line}`);
   }
 }
 var G = {
-  prompt: c8.green("\u203A"),
-  reply: c8.cyan("\u25C6"),
-  search: c8.yellow("?"),
-  read: c8.dim("\u2190"),
-  write: c8.green("\u270E"),
-  run: c8.dim("$"),
-  agent: c8.cyan("\u21E2"),
-  mcp: c8.yellow("\u2699"),
-  ok: c8.green("\u2714"),
-  err: c8.red("\u2716"),
-  warn: c8.yellow("!"),
-  info: c8.dim("\xB7")
+  prompt: c7.green("\u203A"),
+  reply: c7.cyan("\u25C6"),
+  search: c7.yellow("?"),
+  read: c7.dim("\u2190"),
+  write: c7.green("\u270E"),
+  run: c7.dim("$"),
+  agent: c7.cyan("\u21E2"),
+  mcp: c7.yellow("\u2699"),
+  ok: c7.green("\u2714"),
+  err: c7.red("\u2716"),
+  warn: c7.yellow("!"),
+  info: c7.dim("\xB7")
 };
 var PREFIX = {
   user: G.prompt,
@@ -1854,9 +1788,9 @@ class RenderedError extends Error {
 function renderError(err, context = "render") {
   logError(err, context);
   const parsed = parseAppError(err);
-  writeln2(`${G.err} ${c8.red(parsed.headline)}`);
+  writeln(`${G.err} ${c7.red(parsed.headline)}`);
   if (parsed.hint) {
-    writeln2(`  ${c8.dim(parsed.hint)}`);
+    writeln(`  ${c7.dim(parsed.hint)}`);
   }
 }
 function discoverContextFiles(cwd) {
@@ -1876,11 +1810,11 @@ function discoverContextFiles(cwd) {
   return found;
 }
 function renderBanner(model, cwd) {
-  writeln2();
+  writeln();
   const title = PACKAGE_VERSION ? `mini-coder \xB7 v${PACKAGE_VERSION}` : "mini-coder";
-  writeln2(`  ${c8.cyan("mc")}  ${c8.dim(title)}`);
-  writeln2(`  ${c8.dim(model)}  ${c8.dim("\xB7")}  ${c8.dim(tildePath(cwd))}`);
-  writeln2(`  ${c8.dim("/help for commands  \xB7  esc cancel  \xB7  ctrl+c/ctrl+d exit")}`);
+  writeln(`  ${c7.cyan("mc")}  ${c7.dim(title)}`);
+  writeln(`  ${c7.dim(model)}  ${c7.dim("\xB7")}  ${c7.dim(tildePath(cwd))}`);
+  writeln(`  ${c7.dim("/help for commands  \xB7  esc cancel  \xB7  ctrl+c/ctrl+d exit")}`);
   const items = [];
   const contextFiles = discoverContextFiles(cwd);
   if (contextFiles.length > 0)
@@ -1895,27 +1829,19 @@ function renderBanner(model, cwd) {
   if (commands.size > 0)
     items.push(`${commands.size} custom cmd${commands.size > 1 ? "s" : ""}`);
   if (items.length > 0) {
-    writeln2(`  ${c8.dim(items.join("  \xB7  "))}`);
+    writeln(`  ${c7.dim(items.join("  \xB7  "))}`);
   }
-  writeln2();
+  writeln();
 }
 
 class CliReporter {
   spinner = new Spinner;
-  liveOutput = new LiveOutputBlock;
-  haltSpinner() {
+  info(msg) {
     this.spinner.stop();
+    writeln(`${G.info} ${c7.dim(msg)}`);
   }
-  haltSpinnerAndFlushLiveOutput() {
+  error(msg, hint) {
     this.spinner.stop();
-    this.liveOutput.finish();
-  }
-  info(msg) {
-    this.haltSpinnerAndFlushLiveOutput();
-    writeln2(`${G.info} ${c8.dim(msg)}`);
-  }
-  error(msg, hint) {
-    this.haltSpinnerAndFlushLiveOutput();
     if (typeof msg === "string") {
       renderError(msg, hint);
     } else {
@@ -1923,29 +1849,23 @@ class CliReporter {
     }
   }
   warn(msg) {
-    this.haltSpinnerAndFlushLiveOutput();
-    writeln2(`${G.warn} ${msg}`);
+    this.spinner.stop();
+    writeln(`${G.warn} ${msg}`);
   }
   writeText(text) {
-    this.haltSpinnerAndFlushLiveOutput();
-    writeln2(text);
-  }
-  streamChunk(text) {
-    this.haltSpinner();
-    this.liveOutput.append(text);
+    this.spinner.stop();
+    writeln(text);
   }
   startSpinner(label) {
     this.spinner.start(label);
   }
   stopSpinner() {
-    this.haltSpinner();
+    this.spinner.stop();
   }
   async renderTurn(events, opts) {
-    this.liveOutput.finish();
     return renderTurn(events, this.spinner, opts);
   }
   renderStatusBar(data) {
-    this.liveOutput.finish();
     renderStatusBar(data);
   }
   restoreTerminal() {
@@ -1965,8 +1885,8 @@ function warnConventionConflicts(kind, scope, agentsNames, claudeNames) {
   if (conflicts.length === 0)
     return;
   conflicts.sort((a, b) => a.localeCompare(b));
-  const list = conflicts.map((n) => c9.cyan(n)).join(c9.dim(", "));
-  writeln2(`${G.warn} conflicting ${kind} in ${scope} .agents and .claude: ${list} ${c9.dim("\u2014 using .agents version")}`);
+  const list = conflicts.map((n) => c8.cyan(n)).join(c8.dim(", "));
+  writeln(`${G.warn} conflicting ${kind} in ${scope} .agents and .claude: ${list} ${c8.dim("\u2014 using .agents version")}`);
 }
 
 // src/cli/frontmatter.ts
@@ -2627,10 +2547,10 @@ function setPreferredGoogleCachedContent(contentId) {
   }
 }
 // src/agent/session-runner.ts
-import * as c12 from "yoctocolors";
+import * as c11 from "yoctocolors";
 
 // src/cli/input.ts
-import * as c10 from "yoctocolors";
+import * as c9 from "yoctocolors";
 
 // src/cli/input-buffer.ts
 var PASTE_TOKEN_START = 57344;
@@ -3064,7 +2984,7 @@ function watchForCancel(abortController, options) {
   process.stdin.on("data", onData);
   return cleanup;
 }
-var PROMPT = c10.green("\u25B6 ");
+var PROMPT = c9.green("\u25B6 ");
 var PROMPT_RAW_LEN = 2;
 async function readline(opts) {
   const cwd = opts.cwd ?? process.cwd();
@@ -3113,7 +3033,7 @@ async function readline(opts) {
     process.stdout.write(`${CLEAR_LINE}${prompt}${display}${CSI}${PROMPT_RAW_LEN + displayCursor + 1}G`);
   }
   function renderSearchPrompt() {
-    process.stdout.write(`${CLEAR_LINE}${c10.cyan("search:")} ${searchQuery}\u2588`);
+    process.stdout.write(`${CLEAR_LINE}${c9.cyan("search:")} ${searchQuery}\u2588`);
   }
   function applyHistory() {
     if (histIdx < history.length) {
@@ -4565,10 +4485,6 @@ function normalizeUnknownError(error) {
   return new Error(stringifyUnknown(error));
 }
 
-// src/llm-api/turn-anthropic-oauth.ts
-import Anthropic from "@anthropic-ai/sdk";
-import { zodSchema } from "ai";
-
 // src/llm-api/turn-context.ts
 import { pruneMessages } from "ai";
 var DEFAULT_TOOL_RESULT_PAYLOAD_CAP_BYTES = 16 * 1024;
@@ -4769,994 +4685,184 @@ function annotateAnthropicCacheBreakpoints(turnMessages, systemPrompt) {
   };
 }
 
-// src/llm-api/turn-request.ts
-import { stepCountIs } from "ai";
+// src/llm-api/turn-execution.ts
+import { dynamicTool, jsonSchema } from "ai";
 
-// src/llm-api/provider-options.ts
-var ANTHROPIC_BUDGET = {
-  low: 4096,
-  medium: 8192,
-  high: 16384,
-  xhigh: 32768
-};
-var GEMINI_BUDGET = {
-  low: 4096,
-  medium: 8192,
-  high: 16384,
-  xhigh: 24575
-};
-function clampEffort(effort, max) {
-  const ORDER = ["low", "medium", "high", "xhigh"];
-  const effortIdx = ORDER.indexOf(effort);
-  const maxIdx = ORDER.indexOf(max);
-  return ORDER[Math.min(effortIdx, maxIdx)];
+// src/llm-api/turn-stream-events.ts
+function shouldLogStreamChunk(c10) {
+  return c10.type !== "text-delta" && c10.type !== "reasoning" && c10.type !== "reasoning-delta";
 }
-function getAnthropicThinkingOptions(modelId, effort) {
-  const isAdaptive = /^claude-3-7/.test(modelId) || /^claude-sonnet-4/.test(modelId) || /^claude-opus-4/.test(modelId);
-  if (isAdaptive) {
-    const isOpus = /^claude-opus-4/.test(modelId);
-    const mapped = effort === "xhigh" ? isOpus ? "max" : "high" : effort;
-    return { anthropic: { thinking: { type: "adaptive" }, effort: mapped } };
-  }
-  return {
-    anthropic: {
-      thinking: { type: "enabled", budgetTokens: ANTHROPIC_BUDGET[effort] },
-      betas: ["interleaved-thinking-2025-05-14"]
+function extractToolArgs(c10) {
+  return c10.input ?? c10.args;
+}
+function hasRenderableToolArgs(args) {
+  if (args === null || args === undefined)
+    return false;
+  if (typeof args === "string")
+    return args.trim().length > 0;
+  if (Array.isArray(args))
+    return args.length > 0;
+  if (typeof args === "object")
+    return Object.keys(args).length > 0;
+  return true;
+}
+function mapStreamChunkToTurnEvent(c10) {
+  switch (c10.type) {
+    case "text-delta": {
+      const delta = typeof c10.text === "string" ? c10.text : "";
+      return {
+        type: "text-delta",
+        delta
+      };
     }
-  };
+    case "reasoning-delta":
+    case "reasoning": {
+      const delta = getReasoningDeltaFromStreamChunk(c10);
+      if (delta === null)
+        return null;
+      return {
+        type: "reasoning-delta",
+        delta
+      };
+    }
+    case "tool-input-start": {
+      const args = extractToolArgs(c10);
+      const hasStableToolCallId = typeof c10.toolCallId === "string" && c10.toolCallId.trim().length > 0;
+      if (hasStableToolCallId && !hasRenderableToolArgs(args))
+        return null;
+      return {
+        type: "tool-call-start",
+        toolCallId: String(c10.toolCallId ?? ""),
+        toolName: String(c10.toolName ?? ""),
+        args
+      };
+    }
+    case "tool-call": {
+      return {
+        type: "tool-call-start",
+        toolCallId: String(c10.toolCallId ?? ""),
+        toolName: String(c10.toolName ?? ""),
+        args: extractToolArgs(c10)
+      };
+    }
+    case "tool-result": {
+      return {
+        type: "tool-result",
+        toolCallId: String(c10.toolCallId ?? ""),
+        toolName: String(c10.toolName ?? ""),
+        result: "output" in c10 ? c10.output : ("result" in c10) ? c10.result : undefined,
+        isError: "isError" in c10 ? Boolean(c10.isError) : false
+      };
+    }
+    case "tool-error":
+      return {
+        type: "tool-result",
+        toolCallId: String(c10.toolCallId ?? ""),
+        toolName: String(c10.toolName ?? ""),
+        result: c10.error ?? "Tool execution failed",
+        isError: true
+      };
+    case "error": {
+      throw normalizeUnknownError(c10.error);
+    }
+    default:
+      return null;
+  }
 }
-function getOpenAIThinkingOptions(modelId, effort) {
-  const supportsXhigh = /^gpt-5\.[2-9]/.test(modelId) || /^o4/.test(modelId);
-  const clamped = supportsXhigh ? effort : clampEffort(effort, "high");
-  return { openai: { reasoningEffort: clamped, reasoningSummary: "auto" } };
+
+// src/llm-api/turn-execution.ts
+function isZodSchema(s) {
+  return s !== null && typeof s === "object" && "_def" in s;
 }
-function getGeminiThinkingOptions(modelId, effort) {
-  if (/^gemini-3/.test(modelId)) {
-    return {
-      google: {
-        thinkingConfig: {
-          includeThoughts: true,
-          thinkingLevel: clampEffort(effort, "high")
-        }
+function toCoreTool(def) {
+  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);
+      } catch (err) {
+        throw normalizeUnknownError(err);
       }
-    };
+    }
+  });
+}
+function buildToolSet(tools) {
+  const toolSet = {};
+  for (const def of tools) {
+    toolSet[def.name] = toCoreTool(def);
   }
+  return toolSet;
+}
+function createTurnStepTracker(opts) {
+  let stepCount = 0;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let contextTokens = 0;
+  let partialMessages = [];
   return {
-    google: {
-      thinkingConfig: {
-        includeThoughts: true,
-        thinkingBudget: GEMINI_BUDGET[effort]
-      }
-    }
+    onStepFinish: (step) => {
+      opts.onStepLog({
+        stepNumber: stepCount + 1,
+        finishReason: step.finishReason,
+        usage: step.usage
+      });
+      inputTokens += step.usage?.inputTokens ?? 0;
+      outputTokens += step.usage?.outputTokens ?? 0;
+      contextTokens = step.usage?.inputTokens ?? contextTokens;
+      stepCount += 1;
+      const s = step;
+      partialMessages = s.response?.messages ?? s.messages ?? partialMessages;
+    },
+    getState: () => ({
+      stepCount,
+      inputTokens,
+      outputTokens,
+      contextTokens,
+      partialMessages
+    })
   };
 }
-var THINKING_STRATEGIES = [
-  {
-    supports: isAnthropicModelFamily,
-    build: getAnthropicThinkingOptions
-  },
-  {
-    supports: isOpenAIReasoningModelFamily,
-    build: getOpenAIThinkingOptions
-  },
-  {
-    supports: isGeminiModelFamily,
-    build: getGeminiThinkingOptions
-  }
-];
-function getThinkingProviderOptions(modelString, effort) {
-  if (!supportsThinking(modelString))
+var TOOL_RESULT_CHUNK_TYPES = new Set(["tool-result", "tool-error"]);
+function normalizeToolCallId(raw) {
+  if (typeof raw !== "string")
     return null;
-  const { modelId } = parseModelString(modelString);
-  for (const strategy of THINKING_STRATEGIES) {
-    if (!strategy.supports(modelString))
-      continue;
-    return strategy.build(modelId, effort);
-  }
-  return null;
+  const trimmed = raw.trim();
+  return trimmed ? trimmed : null;
 }
-var CACHE_FAMILY_RULES = [
-  [isAnthropicModelFamily, "anthropic"],
-  [isGeminiModelFamily, "google"]
-];
-function getCacheFamily(modelString) {
-  for (const [match, family] of CACHE_FAMILY_RULES) {
-    if (match(modelString))
-      return family;
-  }
-  return "none";
+function normalizeToolName(raw) {
+  if (typeof raw !== "string")
+    return "tool";
+  const trimmed = raw.trim();
+  return trimmed || "tool";
 }
-function getCachingProviderOptions(modelString, opts) {
-  if (!opts.enabled)
+function isRecord5(value) {
+  return value !== null && typeof value === "object";
+}
+function normalizeTextPartId(raw) {
+  if (typeof raw !== "string")
     return null;
-  const family = getCacheFamily(modelString);
-  if (family === "google" && opts.googleCachedContent && opts.googleExplicitCachingCompatible !== false) {
-    return { google: { cachedContent: opts.googleCachedContent } };
-  }
-  return null;
-}
-
-// src/llm-api/turn-prepare-messages.ts
-function prepareTurnMessages(input) {
-  const {
-    messages,
-    modelString,
-    toolCount,
-    systemPrompt,
-    pruningMode,
-    toolResultPayloadCapBytes,
-    promptCachingEnabled
-  } = input;
-  const apiLogOn = isApiLogEnabled();
-  const strippedRuntimeToolFields = stripToolRuntimeInputFields(messages);
-  if (strippedRuntimeToolFields !== messages && apiLogOn) {
-    logApiEvent("runtime tool input fields stripped", { modelString });
-  }
-  const geminiResult = sanitizeGeminiToolMessagesWithMetadata(strippedRuntimeToolFields, modelString, toolCount > 0);
-  if (geminiResult.repaired && apiLogOn) {
-    logApiEvent("gemini tool history repaired", {
-      modelString,
-      reason: geminiResult.reason,
-      repairedFromIndex: geminiResult.repairedFromIndex,
-      droppedMessageCount: geminiResult.droppedMessageCount,
-      tailOnlyAffected: geminiResult.tailOnlyAffected
-    });
-  }
-  const openaiStripped = stripOpenAIHistoryTransforms(geminiResult.messages, modelString);
-  if (openaiStripped !== geminiResult.messages && apiLogOn) {
-    logApiEvent("openai history transforms applied", { modelString });
-  }
-  const normalised = normalizeOpenAICompatibleToolCallInputs(openaiStripped, modelString);
-  if (normalised !== openaiStripped && apiLogOn) {
-    logApiEvent("openai-compatible tool input normalized", { modelString });
-  }
-  const preStats = apiLogOn ? getMessageDiagnostics(normalised) : getMessageStats(normalised);
-  if (apiLogOn)
-    logApiEvent("turn context pre-prune", preStats);
-  const pruned = applyContextPruning(normalised, pruningMode);
-  const postStats = apiLogOn ? getMessageDiagnostics(pruned) : getMessageStats(pruned);
-  if (apiLogOn)
-    logApiEvent("turn context post-prune", postStats);
-  const compacted = compactToolResultPayloads(pruned, toolResultPayloadCapBytes);
-  if (compacted !== pruned && apiLogOn) {
-    logApiEvent("turn context post-compaction", {
-      capBytes: toolResultPayloadCapBytes,
-      diagnostics: getMessageDiagnostics(compacted)
-    });
-  }
-  let finalMessages = compacted;
-  let finalSystemPrompt = systemPrompt;
-  const cacheFamily = getCacheFamily(modelString);
-  if (cacheFamily === "anthropic" && promptCachingEnabled) {
-    const annotated = annotateAnthropicCacheBreakpoints(compacted, systemPrompt);
-    finalMessages = annotated.messages;
-    finalSystemPrompt = annotated.systemPrompt;
-    if (apiLogOn) {
-      logApiEvent("Anthropic prompt caching", annotated.diagnostics);
-    }
-  }
-  if (isAnthropicModelFamily(modelString) && isAnthropicOAuth()) {
-    const prefix = `You are Claude Code, Anthropic's official CLI for Claude.
-`;
-    if (finalSystemPrompt) {
-      finalSystemPrompt = prefix + finalSystemPrompt;
-    } else {
-      const sysMsg = finalMessages.find((m) => m.role === "system");
-      if (sysMsg && typeof sysMsg.content === "string") {
-        const idx = finalMessages.indexOf(sysMsg);
-        finalMessages[idx] = { ...sysMsg, content: prefix + sysMsg.content };
-      }
-    }
-  }
-  const wasPruned = (pruningMode === "balanced" || pruningMode === "aggressive") && (postStats.messageCount < preStats.messageCount || postStats.totalBytes < preStats.totalBytes);
-  return {
-    messages: finalMessages,
-    systemPrompt: finalSystemPrompt,
-    pruned: wasPruned,
-    prePruneMessageCount: preStats.messageCount,
-    prePruneTotalBytes: preStats.totalBytes,
-    postPruneMessageCount: postStats.messageCount,
-    postPruneTotalBytes: postStats.totalBytes
-  };
-}
-
-// src/llm-api/turn-provider-options.ts
-function isRecord5(value) {
-  return value !== null && typeof value === "object";
-}
-function mergeDeep(target, source) {
-  const output = { ...target };
-  for (const key in source) {
-    const sVal = source[key];
-    const tVal = target[key];
-    output[key] = isRecord5(sVal) && isRecord5(tVal) ? { ...tVal, ...sVal } : sVal;
-  }
-  return output;
-}
-function buildTurnProviderOptions(input) {
-  const {
-    modelString,
-    thinkingEffort,
-    promptCachingEnabled,
-    openaiPromptCacheRetention,
-    googleCachedContent,
-    toolCount,
-    hasSystemPrompt
-  } = input;
-  const thinkingOpts = thinkingEffort ? getThinkingProviderOptions(modelString, thinkingEffort) : null;
-  const reasoningSummaryRequested = isRecord5(thinkingOpts) && isRecord5(thinkingOpts.openai) && typeof thinkingOpts.openai.reasoningSummary === "string";
-  const cacheFamily = getCacheFamily(modelString);
-  const cacheOpts = getCachingProviderOptions(modelString, {
-    enabled: promptCachingEnabled,
-    openaiRetention: openaiPromptCacheRetention,
-    googleCachedContent,
-    googleExplicitCachingCompatible: toolCount === 0 && !hasSystemPrompt
-  });
-  const baseProviderOpts = {
-    ...thinkingOpts ?? {},
-    ...isOpenAIGPT(modelString) ? {
-      openai: {
-        store: false,
-        ...isRecord5(thinkingOpts?.openai) ? thinkingOpts.openai : {}
-      }
-    } : {}
-  };
-  const providerOptions = cacheOpts ? mergeDeep(baseProviderOpts, cacheOpts) : baseProviderOpts;
-  return {
-    cacheFamily,
-    thinkingOpts,
-    cacheOpts,
-    providerOptions,
-    reasoningSummaryRequested
-  };
-}
-
-// src/llm-api/turn-request.ts
-function buildTurnPreparation(input) {
-  const providerOptionsResult = buildTurnProviderOptions({
-    modelString: input.modelString,
-    thinkingEffort: input.thinkingEffort,
-    promptCachingEnabled: input.promptCachingEnabled,
-    openaiPromptCacheRetention: input.openaiPromptCacheRetention,
-    googleCachedContent: input.googleCachedContent,
-    toolCount: input.toolCount,
-    hasSystemPrompt: Boolean(input.systemPrompt)
-  });
-  const prepared = prepareTurnMessages({
-    messages: input.messages,
-    modelString: input.modelString,
-    toolCount: input.toolCount,
-    systemPrompt: input.systemPrompt,
-    pruningMode: input.pruningMode,
-    toolResultPayloadCapBytes: input.toolResultPayloadCapBytes,
-    promptCachingEnabled: input.promptCachingEnabled
-  });
-  return { providerOptionsResult, prepared };
-}
-function buildStreamTextRequest(input) {
-  return {
-    model: input.model,
-    maxOutputTokens: 16384,
-    messages: input.prepared.messages,
-    tools: input.toolSet,
-    stopWhen: stepCountIs(input.maxSteps),
-    onStepFinish: input.onStepFinish,
-    prepareStep: ({ stepNumber }) => {
-      if (stepNumber >= input.maxSteps - 1) {
-        return { activeTools: [] };
-      }
-      return;
-    },
-    ...input.prepared.systemPrompt ? { system: input.prepared.systemPrompt } : {},
-    ...Object.keys(input.providerOptions).length > 0 ? {
-      providerOptions: input.providerOptions
-    } : {},
-    ...input.signal ? { abortSignal: input.signal } : {},
-    onError: () => {},
-    timeout: { chunkMs: 120000 }
-  };
-}
-
-// src/llm-api/turn-anthropic-oauth.ts
-var MAX_STEPS = 50;
-var MAX_OUTPUT_TOKENS = 16384;
-var CC_VERSION = "2.1.75";
-var cachedClient = null;
-function getClient(token) {
-  if (cachedClient?.token === token && cachedClient.client)
-    return cachedClient.client;
-  const client = new Anthropic({
-    apiKey: null,
-    authToken: token,
-    maxRetries: 5,
-    dangerouslyAllowBrowser: true,
-    defaultHeaders: {
-      accept: "application/json",
-      "anthropic-dangerous-direct-browser-access": "true",
-      "anthropic-beta": "claude-code-20250219,oauth-2025-04-20",
-      "user-agent": `claude-cli/${CC_VERSION}`,
-      "x-app": "cli"
-    }
-  });
-  cachedClient = { token, client };
-  return client;
-}
-function supportsAdaptiveThinking(modelId) {
-  return modelId.includes("opus-4-6") || modelId.includes("sonnet-4-6");
-}
-function mapEffort(effort, modelId) {
-  if (!effort)
-    return;
-  const map = {
-    low: "low",
-    medium: "medium",
-    high: "high",
-    xhigh: modelId.includes("opus-4-6") ? "max" : "high"
-  };
-  return map[effort];
-}
-function coreToAnthropicMessages(messages) {
-  let systemPrompt;
-  const params = [];
-  const toolUseIds = new Set;
-  for (const msg of messages) {
-    if (msg.role !== "assistant" || !Array.isArray(msg.content))
-      continue;
-    for (const part of msg.content) {
-      if (part.type === "tool-call" && part.toolCallId) {
-        toolUseIds.add(part.toolCallId);
-      }
-    }
-  }
-  for (const msg of messages) {
-    if (msg.role === "system") {
-      systemPrompt = typeof msg.content === "string" ? msg.content : Array.isArray(msg.content) ? msg.content.filter((p) => p.type === "text").map((p) => p.text).join(`
-`) : undefined;
-      continue;
-    }
-    if (msg.role === "user") {
-      if (typeof msg.content === "string") {
-        if (msg.content.trim())
-          params.push({ role: "user", content: msg.content });
-        continue;
-      }
-      if (Array.isArray(msg.content)) {
-        const blocks = [];
-        for (const part of msg.content) {
-          if (part.type === "text" && part.text?.trim()) {
-            blocks.push({ type: "text", text: part.text });
-          } else if (part.type === "tool-result") {
-            if (!toolUseIds.has(part.toolCallId))
-              continue;
-            blocks.push({
-              type: "tool_result",
-              tool_use_id: part.toolCallId,
-              content: typeof part.result === "string" ? part.result : JSON.stringify(part.result ?? part.output ?? ""),
-              is_error: part.isError ?? false
-            });
-          } else if (part.type === "image") {
-            blocks.push({
-              type: "image",
-              source: {
-                type: "base64",
-                media_type: part.mimeType ?? "image/png",
-                data: part.data
-              }
-            });
-          }
-        }
-        if (blocks.length > 0)
-          params.push({ role: "user", content: blocks });
-      }
-      continue;
-    }
-    if (msg.role === "assistant") {
-      if (typeof msg.content === "string") {
-        if (msg.content.trim())
-          params.push({ role: "assistant", content: msg.content });
-        continue;
-      }
-      if (Array.isArray(msg.content)) {
-        const blocks = [];
-        for (const part of msg.content) {
-          if (part.type === "text" && part.text?.trim()) {
-            blocks.push({ type: "text", text: part.text });
-          } else if (part.type === "tool-call") {
-            blocks.push({
-              type: "tool_use",
-              id: part.toolCallId,
-              name: part.toolName,
-              input: part.args ?? {}
-            });
-          } else if (part.type === "thinking") {
-            if (part.redacted && part.signature) {
-              blocks.push({
-                type: "redacted_thinking",
-                data: part.signature
-              });
-            } else if (part.text?.trim() && part.signature?.trim()) {
-              blocks.push({
-                type: "thinking",
-                thinking: part.text,
-                signature: part.signature
-              });
-            }
-          }
-        }
-        if (blocks.length > 0)
-          params.push({ role: "assistant", content: blocks });
-      }
-    }
-  }
-  return { system: systemPrompt, params };
-}
-function convertTools(tools) {
-  return tools.map((tool) => {
-    const schema = zodSchema(tool.schema).jsonSchema;
-    return {
-      name: tool.name,
-      description: tool.description,
-      input_schema: {
-        type: "object",
-        properties: schema.properties ?? {},
-        required: schema.required ?? []
-      }
-    };
-  });
-}
-function buildCoreMessages(assistantText, thinkingBlocks, toolCalls, toolResults) {
-  const messages = [];
-  const parts = [];
-  for (const tb of thinkingBlocks) {
-    if (tb.redacted) {
-      parts.push({
-        type: "thinking",
-        text: "[Reasoning redacted]",
-        signature: tb.signature,
-        redacted: true
-      });
-    } else {
-      parts.push({
-        type: "thinking",
-        text: tb.text,
-        signature: tb.signature
-      });
-    }
-  }
-  if (assistantText.trim()) {
-    parts.push({ type: "text", text: assistantText });
-  }
-  for (const tc of toolCalls) {
-    parts.push({
-      type: "tool-call",
-      toolCallId: tc.id,
-      toolName: tc.name,
-      args: tc.args
-    });
-  }
-  if (parts.length > 0) {
-    messages.push({
-      role: "assistant",
-      content: parts
-    });
-  }
-  if (toolResults.length > 0) {
-    const resultParts = toolResults.map((tr) => ({
-      type: "tool-result",
-      toolCallId: tr.toolCallId,
-      toolName: tr.toolName,
-      result: tr.result,
-      isError: tr.isError
-    }));
-    messages.push({
-      role: "user",
-      content: resultParts
-    });
-  }
-  return messages;
-}
-function parseStreamingJson(partial) {
-  try {
-    return JSON.parse(partial);
-  } catch {
-    try {
-      let fixed = partial;
-      const opens = (fixed.match(/{/g) || []).length;
-      const closes = (fixed.match(/}/g) || []).length;
-      for (let i = 0;i < opens - closes; i++)
-        fixed += "}";
-      return JSON.parse(fixed);
-    } catch {
-      return {};
-    }
-  }
-}
-async function* runTurnAnthropicOAuth(options) {
-  const {
-    token,
-    modelString,
-    messages,
-    tools,
-    systemPrompt,
-    signal,
-    thinkingEffort,
-    pruningMode = "balanced",
-    promptCachingEnabled = true,
-    toolResultPayloadCapBytes = DEFAULT_TOOL_RESULT_PAYLOAD_CAP_BYTES
-  } = options;
-  const modelId = modelString.replace(/^anthropic\//, "");
-  const client = getClient(token);
-  const anthropicTools = convertTools(tools);
-  const toolExecutors = new Map(tools.map((t) => [t.name, t.execute]));
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-  let contextTokens = 0;
-  let stepCount = 0;
-  const allNewMessages = [];
-  try {
-    const { prepared } = buildTurnPreparation({
-      modelString,
-      messages,
-      thinkingEffort,
-      promptCachingEnabled,
-      openaiPromptCacheRetention: "in_memory",
-      googleCachedContent: null,
-      toolCount: tools.length,
-      systemPrompt,
-      pruningMode,
-      toolResultPayloadCapBytes
-    });
-    logApiEvent("turn start", {
-      modelString,
-      messageCount: messages.length,
-      reasoningSummaryRequested: false,
-      pruningMode,
-      toolResultPayloadCapBytes
-    });
-    if (prepared.pruned) {
-      yield {
-        type: "context-pruned",
-        mode: pruningMode,
-        beforeMessageCount: prepared.prePruneMessageCount,
-        afterMessageCount: prepared.postPruneMessageCount,
-        removedMessageCount: prepared.prePruneMessageCount - prepared.postPruneMessageCount,
-        beforeTotalBytes: prepared.prePruneTotalBytes,
-        afterTotalBytes: prepared.postPruneTotalBytes,
-        removedBytes: prepared.prePruneTotalBytes - prepared.postPruneTotalBytes
-      };
-    }
-    const { system: extractedSystem, params: anthropicMessages } = coreToAnthropicMessages(prepared.messages);
-    const ccPrefix = "You are Claude Code, Anthropic's official CLI for Claude.";
-    const sysText = prepared.systemPrompt ?? extractedSystem;
-    const systemBlocks = [
-      {
-        type: "text",
-        text: ccPrefix,
-        cache_control: { type: "ephemeral" }
-      }
-    ];
-    if (sysText) {
-      const clean = sysText.startsWith(ccPrefix) ? sysText.slice(ccPrefix.length).replace(/^\n/, "") : sysText;
-      if (clean.trim()) {
-        systemBlocks.push({
-          type: "text",
-          text: clean,
-          cache_control: { type: "ephemeral" }
-        });
-      }
-    }
-    const currentMessages = [...anthropicMessages];
-    while (stepCount < MAX_STEPS) {
-      stepCount++;
-      const isLastStep = stepCount >= MAX_STEPS;
-      const params = {
-        model: modelId,
-        max_tokens: MAX_OUTPUT_TOKENS,
-        system: systemBlocks,
-        messages: currentMessages,
-        tools: isLastStep ? [] : anthropicTools,
-        stream: true
-      };
-      if (thinkingEffort && supportsAdaptiveThinking(modelId)) {
-        params.thinking = { type: "adaptive" };
-        const effort = mapEffort(thinkingEffort, modelId);
-        if (effort) {
-          params.output_config = {
-            effort
-          };
-        }
-      }
-      for (const m of currentMessages) {
-        if (!Array.isArray(m.content))
-          continue;
-        for (const block of m.content) {
-          if (typeof block === "object" && block !== null) {
-            delete block.cache_control;
-          }
-        }
-      }
-      const lastMsg = currentMessages.length > 0 ? currentMessages[currentMessages.length - 1] : undefined;
-      if (lastMsg && lastMsg.role === "user" && Array.isArray(lastMsg.content)) {
-        const lastBlock = lastMsg.content[lastMsg.content.length - 1];
-        if (lastBlock && typeof lastBlock === "object") {
-          lastBlock.cache_control = {
-            type: "ephemeral"
-          };
-        }
-      }
-      if (isApiLogEnabled()) {
-        logApiEvent("Provider Request", {
-          url: "https://api.anthropic.com/v1/messages",
-          method: "POST",
-          model: modelId,
-          messageCount: currentMessages.length,
-          toolCount: params.tools?.length ?? 0
-        });
-      }
-      const stream = client.messages.stream(params, { signal });
-      let assistantText = "";
-      const thinkingBlocks = [];
-      const toolCalls = [];
-      let partialJson = "";
-      let currentToolId = "";
-      let currentToolName = "";
-      let stepInputTokens = 0;
-      let stepOutputTokens = 0;
-      let stopReason;
-      for await (const event of stream) {
-        if (event.type === "message_start") {
-          stepInputTokens = event.message.usage.input_tokens || 0;
-          stepOutputTokens = event.message.usage.output_tokens || 0;
-        } else if (event.type === "content_block_start") {
-          if (event.content_block.type === "text") {} else if (event.content_block.type === "thinking") {
-            thinkingBlocks.push({
-              text: "",
-              signature: ""
-            });
-          } else if (event.content_block.type === "redacted_thinking") {
-            thinkingBlocks.push({
-              text: "[Reasoning redacted]",
-              signature: event.content_block.data,
-              redacted: true
-            });
-          } else if (event.content_block.type === "tool_use") {
-            currentToolId = event.content_block.id;
-            currentToolName = event.content_block.name;
-            partialJson = "";
-          }
-        } else if (event.type === "content_block_delta") {
-          if (event.delta.type === "text_delta") {
-            assistantText += event.delta.text;
-            yield { type: "text-delta", delta: event.delta.text };
-          } else if (event.delta.type === "thinking_delta") {
-            const tb = thinkingBlocks[thinkingBlocks.length - 1];
-            if (tb)
-              tb.text += event.delta.thinking;
-            yield {
-              type: "reasoning-delta",
-              delta: event.delta.thinking
-            };
-          } else if (event.delta.type === "input_json_delta") {
-            partialJson += event.delta.partial_json;
-          } else if (event.delta.type === "signature_delta") {
-            const tb = thinkingBlocks[thinkingBlocks.length - 1];
-            if (tb)
-              tb.signature += event.delta.signature;
-          }
-        } else if (event.type === "content_block_stop") {
-          if (currentToolId && currentToolName) {
-            const args = parseStreamingJson(partialJson);
-            toolCalls.push({
-              id: currentToolId,
-              name: currentToolName,
-              args
-            });
-            yield {
-              type: "tool-call-start",
-              toolCallId: currentToolId,
-              toolName: currentToolName,
-              args
-            };
-            currentToolId = "";
-            currentToolName = "";
-            partialJson = "";
-          }
-        } else if (event.type === "message_delta") {
-          if (event.delta.stop_reason) {
-            stopReason = event.delta.stop_reason;
-          }
-          if (event.usage.output_tokens != null) {
-            stepOutputTokens = event.usage.output_tokens;
-          }
-        }
-      }
-      totalInputTokens += stepInputTokens;
-      totalOutputTokens += stepOutputTokens;
-      contextTokens = stepInputTokens;
-      logApiEvent("step finish", {
-        stepNumber: stepCount,
-        finishReason: stopReason,
-        usage: {
-          inputTokens: stepInputTokens,
-          outputTokens: stepOutputTokens
-        }
-      });
-      const toolResults = [];
-      if (stopReason === "tool_use" && toolCalls.length > 0) {
-        for (const tc of toolCalls) {
-          const executor = toolExecutors.get(tc.name);
-          let result;
-          let isError = false;
-          if (!executor) {
-            result = `Unknown tool: ${tc.name}`;
-            isError = true;
-          } else {
-            try {
-              result = await executor(tc.args);
-            } catch (err) {
-              result = normalizeUnknownError(err).message;
-              isError = true;
-            }
-          }
-          toolResults.push({
-            toolCallId: tc.id,
-            toolName: tc.name,
-            result,
-            isError
-          });
-          yield {
-            type: "tool-result",
-            toolCallId: tc.id,
-            toolName: tc.name,
-            result,
-            isError
-          };
-        }
-      }
-      const stepMessages = buildCoreMessages(assistantText, thinkingBlocks, toolCalls, toolResults);
-      allNewMessages.push(...stepMessages);
-      if (stopReason !== "tool_use" || toolCalls.length === 0) {
-        break;
-      }
-      const assistantBlocks = [];
-      for (const tb of thinkingBlocks) {
-        if (tb.redacted) {
-          assistantBlocks.push({
-            type: "redacted_thinking",
-            data: tb.signature
-          });
-        } else if (tb.text.trim() && tb.signature.trim()) {
-          assistantBlocks.push({
-            type: "thinking",
-            thinking: tb.text,
-            signature: tb.signature
-          });
-        }
-      }
-      if (assistantText.trim()) {
-        assistantBlocks.push({ type: "text", text: assistantText });
-      }
-      for (const tc of toolCalls) {
-        assistantBlocks.push({
-          type: "tool_use",
-          id: tc.id,
-          name: tc.name,
-          input: tc.args
-        });
-      }
-      currentMessages.push({
-        role: "assistant",
-        content: assistantBlocks
-      });
-      const resultBlocks = toolResults.map((tr) => ({
-        type: "tool_result",
-        tool_use_id: tr.toolCallId,
-        content: typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result ?? ""),
-        is_error: tr.isError
-      }));
-      currentMessages.push({ role: "user", content: resultBlocks });
-    }
-    logApiEvent("turn complete", {
-      newMessagesCount: allNewMessages.length,
-      inputTokens: totalInputTokens,
-      outputTokens: totalOutputTokens
-    });
-    yield {
-      type: "turn-complete",
-      inputTokens: totalInputTokens,
-      outputTokens: totalOutputTokens,
-      contextTokens,
-      messages: allNewMessages
-    };
-  } catch (err) {
-    const normalizedError = normalizeUnknownError(err);
-    logApiEvent("turn error", normalizedError);
-    yield {
-      type: "turn-error",
-      error: normalizedError,
-      partialMessages: allNewMessages
-    };
-  }
-}
-
-// src/llm-api/turn-execution.ts
-import { dynamicTool, jsonSchema } from "ai";
-
-// src/llm-api/turn-stream-events.ts
-function shouldLogStreamChunk(c11) {
-  return c11.type !== "text-delta" && c11.type !== "reasoning" && c11.type !== "reasoning-delta";
-}
-function extractToolArgs(c11) {
-  return c11.input ?? c11.args;
-}
-function hasRenderableToolArgs(args) {
-  if (args === null || args === undefined)
-    return false;
-  if (typeof args === "string")
-    return args.trim().length > 0;
-  if (Array.isArray(args))
-    return args.length > 0;
-  if (typeof args === "object")
-    return Object.keys(args).length > 0;
-  return true;
-}
-function mapStreamChunkToTurnEvent(c11) {
-  switch (c11.type) {
-    case "text-delta": {
-      const delta = typeof c11.text === "string" ? c11.text : "";
-      return {
-        type: "text-delta",
-        delta
-      };
-    }
-    case "reasoning-delta":
-    case "reasoning": {
-      const delta = getReasoningDeltaFromStreamChunk(c11);
-      if (delta === null)
-        return null;
-      return {
-        type: "reasoning-delta",
-        delta
-      };
-    }
-    case "tool-input-start": {
-      const args = extractToolArgs(c11);
-      const hasStableToolCallId = typeof c11.toolCallId === "string" && c11.toolCallId.trim().length > 0;
-      if (hasStableToolCallId && !hasRenderableToolArgs(args))
-        return null;
-      return {
-        type: "tool-call-start",
-        toolCallId: String(c11.toolCallId ?? ""),
-        toolName: String(c11.toolName ?? ""),
-        args
-      };
-    }
-    case "tool-call": {
-      return {
-        type: "tool-call-start",
-        toolCallId: String(c11.toolCallId ?? ""),
-        toolName: String(c11.toolName ?? ""),
-        args: extractToolArgs(c11)
-      };
-    }
-    case "tool-result": {
-      return {
-        type: "tool-result",
-        toolCallId: String(c11.toolCallId ?? ""),
-        toolName: String(c11.toolName ?? ""),
-        result: "output" in c11 ? c11.output : ("result" in c11) ? c11.result : undefined,
-        isError: "isError" in c11 ? Boolean(c11.isError) : false
-      };
-    }
-    case "tool-error":
-      return {
-        type: "tool-result",
-        toolCallId: String(c11.toolCallId ?? ""),
-        toolName: String(c11.toolName ?? ""),
-        result: c11.error ?? "Tool execution failed",
-        isError: true
-      };
-    case "error": {
-      throw normalizeUnknownError(c11.error);
-    }
-    default:
-      return null;
-  }
-}
-
-// src/llm-api/turn-execution.ts
-function isZodSchema(s) {
-  return s !== null && typeof s === "object" && "_def" in s;
-}
-function toCoreTool(def) {
-  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);
-      } catch (err) {
-        throw normalizeUnknownError(err);
-      }
-    }
-  });
-}
-function buildToolSet(tools) {
-  const toolSet = {};
-  for (const def of tools) {
-    toolSet[def.name] = toCoreTool(def);
-  }
-  return toolSet;
-}
-function createTurnStepTracker(opts) {
-  let stepCount = 0;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let contextTokens = 0;
-  let partialMessages = [];
-  return {
-    onStepFinish: (step) => {
-      opts.onStepLog({
-        stepNumber: stepCount + 1,
-        finishReason: step.finishReason,
-        usage: step.usage
-      });
-      inputTokens += step.usage?.inputTokens ?? 0;
-      outputTokens += step.usage?.outputTokens ?? 0;
-      contextTokens = step.usage?.inputTokens ?? contextTokens;
-      stepCount += 1;
-      const s = step;
-      partialMessages = s.response?.messages ?? s.messages ?? partialMessages;
-    },
-    getState: () => ({
-      stepCount,
-      inputTokens,
-      outputTokens,
-      contextTokens,
-      partialMessages
-    })
-  };
-}
-var TOOL_RESULT_CHUNK_TYPES = new Set(["tool-result", "tool-error"]);
-function normalizeToolCallId(raw) {
-  if (typeof raw !== "string")
-    return null;
-  const trimmed = raw.trim();
-  return trimmed ? trimmed : null;
-}
-function normalizeToolName(raw) {
-  if (typeof raw !== "string")
-    return "tool";
-  const trimmed = raw.trim();
-  return trimmed || "tool";
-}
-function isRecord6(value) {
-  return value !== null && typeof value === "object";
-}
-function normalizeTextPartId(raw) {
-  if (typeof raw !== "string")
-    return null;
-  const trimmed = raw.trim();
-  return trimmed ? trimmed : null;
-}
-function getOpenAITextPhase2(chunk) {
-  const providerData = isRecord6(chunk.providerMetadata) ? chunk.providerMetadata : isRecord6(chunk.providerOptions) ? chunk.providerOptions : null;
-  if (!providerData)
-    return null;
-  const openai = providerData.openai;
-  if (!isRecord6(openai))
-    return null;
-  return openai.phase === "commentary" || openai.phase === "final_answer" ? openai.phase : null;
-}
-function extractTextDelta(chunk) {
-  if (typeof chunk.text === "string")
-    return chunk.text;
-  if (typeof chunk.textDelta === "string")
-    return chunk.textDelta;
-  if (typeof chunk.delta === "string")
-    return chunk.delta;
-  return "";
+  const trimmed = raw.trim();
+  return trimmed ? trimmed : null;
+}
+function getOpenAITextPhase2(chunk) {
+  const providerData = isRecord5(chunk.providerMetadata) ? chunk.providerMetadata : isRecord5(chunk.providerOptions) ? chunk.providerOptions : null;
+  if (!providerData)
+    return null;
+  const openai = providerData.openai;
+  if (!isRecord5(openai))
+    return null;
+  return openai.phase === "commentary" || openai.phase === "final_answer" ? openai.phase : null;
+}
+function extractTextDelta(chunk) {
+  if (typeof chunk.text === "string")
+    return chunk.text;
+  if (typeof chunk.textDelta === "string")
+    return chunk.textDelta;
+  if (typeof chunk.delta === "string")
+    return chunk.delta;
+  return "";
 }
 
 class StreamTextPhaseTracker {
@@ -5857,84 +4963,376 @@ class StreamToolCallTracker {
     }
     return { chunk, suppressTurnEvent: false };
   }
-  trackRenderableStart(chunk, toolName, existingToolCallId) {
-    const toolCallId = existingToolCallId ?? this.nextSyntheticToolCallId();
-    this.trackStart(toolName, toolCallId);
-    if (toolCallId === chunk.toolCallId)
-      return chunk;
-    return { ...chunk, toolCallId };
+  trackRenderableStart(chunk, toolName, existingToolCallId) {
+    const toolCallId = existingToolCallId ?? this.nextSyntheticToolCallId();
+    this.trackStart(toolName, toolCallId);
+    if (toolCallId === chunk.toolCallId)
+      return chunk;
+    return { ...chunk, toolCallId };
+  }
+  nextSyntheticToolCallId() {
+    this.syntheticCount += 1;
+    return `synthetic-tool-call-${this.syntheticCount}`;
+  }
+  trackStart(toolName, toolCallId) {
+    const pending = this.pendingByTool.get(toolName) ?? [];
+    pending.push(toolCallId);
+    this.pendingByTool.set(toolName, pending);
+  }
+  trackDeferredStart(toolName) {
+    this.deferredStartsByTool.set(toolName, (this.deferredStartsByTool.get(toolName) ?? 0) + 1);
+  }
+  consumeDeferredStart(toolName) {
+    const count = this.deferredStartsByTool.get(toolName) ?? 0;
+    if (count <= 0)
+      return;
+    if (count === 1) {
+      this.deferredStartsByTool.delete(toolName);
+      return;
+    }
+    this.deferredStartsByTool.set(toolName, count - 1);
+  }
+  consumeTracked(toolName, toolCallId) {
+    const pending = this.pendingByTool.get(toolName);
+    if (!pending || pending.length === 0)
+      return;
+    const idx = pending.indexOf(toolCallId);
+    if (idx === -1)
+      return;
+    pending.splice(idx, 1);
+    if (pending.length === 0)
+      this.pendingByTool.delete(toolName);
+  }
+  consumeNextTracked(toolName) {
+    const pending = this.pendingByTool.get(toolName);
+    if (!pending || pending.length === 0)
+      return null;
+    const toolCallId = pending.shift() ?? null;
+    if (pending.length === 0)
+      this.pendingByTool.delete(toolName);
+    return toolCallId;
+  }
+}
+async function* mapFullStreamToTurnEvents(stream, opts) {
+  const toolCallTracker = new StreamToolCallTracker;
+  const textPhaseTracker = new StreamTextPhaseTracker;
+  for await (const originalChunk of stream) {
+    const prepared = toolCallTracker.prepare(originalChunk);
+    const chunk = prepared.chunk;
+    const route = textPhaseTracker.route(chunk);
+    if (!prepared.suppressTurnEvent && route !== "skip" && shouldLogStreamChunk(chunk)) {
+      opts.onChunk?.(chunk);
+    }
+    if (prepared.suppressTurnEvent || route === "skip")
+      continue;
+    const event = route === "reasoning" ? mapCommentaryChunkToTurnEvent(chunk) : mapStreamChunkToTurnEvent(chunk);
+    if (event)
+      yield event;
+  }
+}
+
+// src/llm-api/turn-request.ts
+import { stepCountIs } from "ai";
+
+// src/llm-api/provider-options.ts
+var ANTHROPIC_BUDGET = {
+  low: 4096,
+  medium: 8192,
+  high: 16384,
+  xhigh: 32768
+};
+var GEMINI_BUDGET = {
+  low: 4096,
+  medium: 8192,
+  high: 16384,
+  xhigh: 24575
+};
+function clampEffort(effort, max) {
+  const ORDER = ["low", "medium", "high", "xhigh"];
+  const effortIdx = ORDER.indexOf(effort);
+  const maxIdx = ORDER.indexOf(max);
+  return ORDER[Math.min(effortIdx, maxIdx)];
+}
+function getAnthropicThinkingOptions(modelId, effort) {
+  const isAdaptive = /^claude-3-7/.test(modelId) || /^claude-sonnet-4/.test(modelId) || /^claude-opus-4/.test(modelId);
+  if (isAdaptive) {
+    const isOpus = /^claude-opus-4/.test(modelId);
+    const mapped = effort === "xhigh" ? isOpus ? "max" : "high" : effort;
+    return { anthropic: { thinking: { type: "adaptive" }, effort: mapped } };
+  }
+  return {
+    anthropic: {
+      thinking: { type: "enabled", budgetTokens: ANTHROPIC_BUDGET[effort] },
+      betas: ["interleaved-thinking-2025-05-14"]
+    }
+  };
+}
+function getOpenAIThinkingOptions(modelId, effort) {
+  const supportsXhigh = /^gpt-5\.[2-9]/.test(modelId) || /^o4/.test(modelId);
+  const clamped = supportsXhigh ? effort : clampEffort(effort, "high");
+  return { openai: { reasoningEffort: clamped, reasoningSummary: "auto" } };
+}
+function getGeminiThinkingOptions(modelId, effort) {
+  if (/^gemini-3/.test(modelId)) {
+    return {
+      google: {
+        thinkingConfig: {
+          includeThoughts: true,
+          thinkingLevel: clampEffort(effort, "high")
+        }
+      }
+    };
+  }
+  return {
+    google: {
+      thinkingConfig: {
+        includeThoughts: true,
+        thinkingBudget: GEMINI_BUDGET[effort]
+      }
+    }
+  };
+}
+var THINKING_STRATEGIES = [
+  {
+    supports: isAnthropicModelFamily,
+    build: getAnthropicThinkingOptions
+  },
+  {
+    supports: isOpenAIReasoningModelFamily,
+    build: getOpenAIThinkingOptions
+  },
+  {
+    supports: isGeminiModelFamily,
+    build: getGeminiThinkingOptions
+  }
+];
+function getThinkingProviderOptions(modelString, effort) {
+  if (!supportsThinking(modelString))
+    return null;
+  const { modelId } = parseModelString(modelString);
+  for (const strategy of THINKING_STRATEGIES) {
+    if (!strategy.supports(modelString))
+      continue;
+    return strategy.build(modelId, effort);
+  }
+  return null;
+}
+var CACHE_FAMILY_RULES = [
+  [isAnthropicModelFamily, "anthropic"],
+  [isGeminiModelFamily, "google"]
+];
+function getCacheFamily(modelString) {
+  for (const [match, family] of CACHE_FAMILY_RULES) {
+    if (match(modelString))
+      return family;
+  }
+  return "none";
+}
+function getCachingProviderOptions(modelString, opts) {
+  if (!opts.enabled)
+    return null;
+  const family = getCacheFamily(modelString);
+  if (family === "google" && opts.googleCachedContent && opts.googleExplicitCachingCompatible !== false) {
+    return { google: { cachedContent: opts.googleCachedContent } };
+  }
+  return null;
+}
+
+// src/llm-api/turn-prepare-messages.ts
+function prepareTurnMessages(input) {
+  const {
+    messages,
+    modelString,
+    toolCount,
+    systemPrompt,
+    pruningMode,
+    toolResultPayloadCapBytes,
+    promptCachingEnabled
+  } = input;
+  const apiLogOn = isApiLogEnabled();
+  const strippedRuntimeToolFields = stripToolRuntimeInputFields(messages);
+  if (strippedRuntimeToolFields !== messages && apiLogOn) {
+    logApiEvent("runtime tool input fields stripped", { modelString });
+  }
+  const geminiResult = sanitizeGeminiToolMessagesWithMetadata(strippedRuntimeToolFields, modelString, toolCount > 0);
+  if (geminiResult.repaired && apiLogOn) {
+    logApiEvent("gemini tool history repaired", {
+      modelString,
+      reason: geminiResult.reason,
+      repairedFromIndex: geminiResult.repairedFromIndex,
+      droppedMessageCount: geminiResult.droppedMessageCount,
+      tailOnlyAffected: geminiResult.tailOnlyAffected
+    });
   }
-  nextSyntheticToolCallId() {
-    this.syntheticCount += 1;
-    return `synthetic-tool-call-${this.syntheticCount}`;
+  const openaiStripped = stripOpenAIHistoryTransforms(geminiResult.messages, modelString);
+  if (openaiStripped !== geminiResult.messages && apiLogOn) {
+    logApiEvent("openai history transforms applied", { modelString });
   }
-  trackStart(toolName, toolCallId) {
-    const pending = this.pendingByTool.get(toolName) ?? [];
-    pending.push(toolCallId);
-    this.pendingByTool.set(toolName, pending);
+  const normalised = normalizeOpenAICompatibleToolCallInputs(openaiStripped, modelString);
+  if (normalised !== openaiStripped && apiLogOn) {
+    logApiEvent("openai-compatible tool input normalized", { modelString });
   }
-  trackDeferredStart(toolName) {
-    this.deferredStartsByTool.set(toolName, (this.deferredStartsByTool.get(toolName) ?? 0) + 1);
+  const preStats = apiLogOn ? getMessageDiagnostics(normalised) : getMessageStats(normalised);
+  if (apiLogOn)
+    logApiEvent("turn context pre-prune", preStats);
+  const pruned = applyContextPruning(normalised, pruningMode);
+  const postStats = apiLogOn ? getMessageDiagnostics(pruned) : getMessageStats(pruned);
+  if (apiLogOn)
+    logApiEvent("turn context post-prune", postStats);
+  const compacted = compactToolResultPayloads(pruned, toolResultPayloadCapBytes);
+  if (compacted !== pruned && apiLogOn) {
+    logApiEvent("turn context post-compaction", {
+      capBytes: toolResultPayloadCapBytes,
+      diagnostics: getMessageDiagnostics(compacted)
+    });
   }
-  consumeDeferredStart(toolName) {
-    const count = this.deferredStartsByTool.get(toolName) ?? 0;
-    if (count <= 0)
-      return;
-    if (count === 1) {
-      this.deferredStartsByTool.delete(toolName);
-      return;
+  let finalMessages = compacted;
+  let finalSystemPrompt = systemPrompt;
+  const cacheFamily = getCacheFamily(modelString);
+  if (cacheFamily === "anthropic" && promptCachingEnabled) {
+    const annotated = annotateAnthropicCacheBreakpoints(compacted, systemPrompt);
+    finalMessages = annotated.messages;
+    finalSystemPrompt = annotated.systemPrompt;
+    if (apiLogOn) {
+      logApiEvent("Anthropic prompt caching", annotated.diagnostics);
     }
-    this.deferredStartsByTool.set(toolName, count - 1);
-  }
-  consumeTracked(toolName, toolCallId) {
-    const pending = this.pendingByTool.get(toolName);
-    if (!pending || pending.length === 0)
-      return;
-    const idx = pending.indexOf(toolCallId);
-    if (idx === -1)
-      return;
-    pending.splice(idx, 1);
-    if (pending.length === 0)
-      this.pendingByTool.delete(toolName);
   }
-  consumeNextTracked(toolName) {
-    const pending = this.pendingByTool.get(toolName);
-    if (!pending || pending.length === 0)
-      return null;
-    const toolCallId = pending.shift() ?? null;
-    if (pending.length === 0)
-      this.pendingByTool.delete(toolName);
-    return toolCallId;
+  if (isAnthropicModelFamily(modelString) && isAnthropicOAuth()) {
+    const ccIdentity = "You are Claude Code, Anthropic's official CLI for Claude.";
+    const ccSystemMsg = {
+      role: "system",
+      content: ccIdentity,
+      providerOptions: {
+        anthropic: { cacheControl: { type: "ephemeral" } }
+      }
+    };
+    if (finalSystemPrompt) {
+      finalMessages = [ccSystemMsg, ...finalMessages];
+    } else {
+      const sysIdx = finalMessages.findIndex((m) => m.role === "system");
+      if (sysIdx >= 0) {
+        finalMessages = [
+          ...finalMessages.slice(0, sysIdx),
+          ccSystemMsg,
+          ...finalMessages.slice(sysIdx)
+        ];
+      } else {
+        finalMessages = [ccSystemMsg, ...finalMessages];
+      }
+    }
   }
+  const wasPruned = (pruningMode === "balanced" || pruningMode === "aggressive") && (postStats.messageCount < preStats.messageCount || postStats.totalBytes < preStats.totalBytes);
+  return {
+    messages: finalMessages,
+    systemPrompt: finalSystemPrompt,
+    pruned: wasPruned,
+    prePruneMessageCount: preStats.messageCount,
+    prePruneTotalBytes: preStats.totalBytes,
+    postPruneMessageCount: postStats.messageCount,
+    postPruneTotalBytes: postStats.totalBytes
+  };
 }
-async function* mapFullStreamToTurnEvents(stream, opts) {
-  const toolCallTracker = new StreamToolCallTracker;
-  const textPhaseTracker = new StreamTextPhaseTracker;
-  for await (const originalChunk of stream) {
-    const prepared = toolCallTracker.prepare(originalChunk);
-    const chunk = prepared.chunk;
-    const route = textPhaseTracker.route(chunk);
-    if (!prepared.suppressTurnEvent && route !== "skip" && shouldLogStreamChunk(chunk)) {
-      opts.onChunk?.(chunk);
-    }
-    if (prepared.suppressTurnEvent || route === "skip")
-      continue;
-    const event = route === "reasoning" ? mapCommentaryChunkToTurnEvent(chunk) : mapStreamChunkToTurnEvent(chunk);
-    if (event)
-      yield event;
+
+// src/llm-api/turn-provider-options.ts
+function isRecord6(value) {
+  return value !== null && typeof value === "object";
+}
+function mergeDeep(target, source) {
+  const output = { ...target };
+  for (const key in source) {
+    const sVal = source[key];
+    const tVal = target[key];
+    output[key] = isRecord6(sVal) && isRecord6(tVal) ? { ...tVal, ...sVal } : sVal;
   }
+  return output;
+}
+function buildTurnProviderOptions(input) {
+  const {
+    modelString,
+    thinkingEffort,
+    promptCachingEnabled,
+    openaiPromptCacheRetention,
+    googleCachedContent,
+    toolCount,
+    hasSystemPrompt
+  } = input;
+  const thinkingOpts = thinkingEffort ? getThinkingProviderOptions(modelString, thinkingEffort) : null;
+  const reasoningSummaryRequested = isRecord6(thinkingOpts) && isRecord6(thinkingOpts.openai) && typeof thinkingOpts.openai.reasoningSummary === "string";
+  const cacheFamily = getCacheFamily(modelString);
+  const cacheOpts = getCachingProviderOptions(modelString, {
+    enabled: promptCachingEnabled,
+    openaiRetention: openaiPromptCacheRetention,
+    googleCachedContent,
+    googleExplicitCachingCompatible: toolCount === 0 && !hasSystemPrompt
+  });
+  const baseProviderOpts = {
+    ...thinkingOpts ?? {},
+    ...isOpenAIGPT(modelString) ? {
+      openai: {
+        store: false,
+        ...isRecord6(thinkingOpts?.openai) ? thinkingOpts.openai : {}
+      }
+    } : {}
+  };
+  const providerOptions = cacheOpts ? mergeDeep(baseProviderOpts, cacheOpts) : baseProviderOpts;
+  return {
+    cacheFamily,
+    thinkingOpts,
+    cacheOpts,
+    providerOptions,
+    reasoningSummaryRequested
+  };
+}
+
+// src/llm-api/turn-request.ts
+function buildTurnPreparation(input) {
+  const providerOptionsResult = buildTurnProviderOptions({
+    modelString: input.modelString,
+    thinkingEffort: input.thinkingEffort,
+    promptCachingEnabled: input.promptCachingEnabled,
+    openaiPromptCacheRetention: input.openaiPromptCacheRetention,
+    googleCachedContent: input.googleCachedContent,
+    toolCount: input.toolCount,
+    hasSystemPrompt: Boolean(input.systemPrompt)
+  });
+  const prepared = prepareTurnMessages({
+    messages: input.messages,
+    modelString: input.modelString,
+    toolCount: input.toolCount,
+    systemPrompt: input.systemPrompt,
+    pruningMode: input.pruningMode,
+    toolResultPayloadCapBytes: input.toolResultPayloadCapBytes,
+    promptCachingEnabled: input.promptCachingEnabled
+  });
+  return { providerOptionsResult, prepared };
+}
+function buildStreamTextRequest(input) {
+  return {
+    model: input.model,
+    maxOutputTokens: 16384,
+    messages: input.prepared.messages,
+    tools: input.toolSet,
+    stopWhen: stepCountIs(input.maxSteps),
+    onStepFinish: input.onStepFinish,
+    prepareStep: ({ stepNumber }) => {
+      if (stepNumber >= input.maxSteps - 1) {
+        return { activeTools: [] };
+      }
+      return;
+    },
+    ...input.prepared.systemPrompt ? { system: input.prepared.systemPrompt } : {},
+    ...Object.keys(input.providerOptions).length > 0 ? {
+      providerOptions: input.providerOptions
+    } : {},
+    ...input.signal ? { abortSignal: input.signal } : {},
+    onError: () => {},
+    timeout: { chunkMs: 120000 }
+  };
 }
 
 // src/llm-api/turn.ts
-var MAX_STEPS2 = 50;
+var MAX_STEPS = 50;
 async function* runTurn(options) {
-  if (options.modelString.startsWith("anthropic/") && isLoggedIn("anthropic")) {
-    const token = await getAccessToken("anthropic");
-    if (token) {
-      yield* runTurnAnthropicOAuth({ ...options, token });
-      return;
-    }
-  }
   const {
     model,
     modelString,
@@ -6006,7 +5404,7 @@ async function* runTurn(options) {
       onStepFinish: stepTracker.onStepFinish,
       signal,
       providerOptions: providerOptionsResult.providerOptions,
-      maxSteps: MAX_STEPS2
+      maxSteps: MAX_STEPS
     }));
     result.response.catch(() => {});
     for await (const event of mapFullStreamToTurnEvents(result.fullStream, {
@@ -6049,7 +5447,7 @@ async function* runTurn(options) {
 }
 
 // src/session/manager.ts
-import * as c11 from "yoctocolors";
+import * as c10 from "yoctocolors";
 function newSession(model, cwd) {
   const id = generateSessionId();
   const row = createSession({ id, cwd, model });
@@ -6068,19 +5466,19 @@ function touchActiveSession(session) {
 function printSessionList() {
   const sessions = listSessions(20);
   if (sessions.length === 0) {
-    writeln2(c11.dim("No sessions found."));
+    writeln(c10.dim("No sessions found."));
     return;
   }
-  writeln2(`
-${c11.bold("Recent sessions:")}`);
+  writeln(`
+${c10.bold("Recent sessions:")}`);
   for (const s of sessions) {
     const date = new Date(s.updated_at).toLocaleString();
     const cwd = tildePath(s.cwd);
-    const title = s.title || c11.dim("(untitled)");
-    writeln2(`  ${c11.dim(s.id.padEnd(14))} ${title.padEnd(30)} ${c11.cyan(s.model.split("/").pop() ?? s.model).padEnd(20)} ${c11.dim(cwd)}  ${c11.dim(date)}`);
+    const title = s.title || c10.dim("(untitled)");
+    writeln(`  ${c10.dim(s.id.padEnd(14))} ${title.padEnd(30)} ${c10.cyan(s.model.split("/").pop() ?? s.model).padEnd(20)} ${c10.dim(cwd)}  ${c10.dim(date)}`);
   }
-  writeln2(`
-${c11.dim("Use")} mc --resume <id> ${c11.dim("to continue a session.")}`);
+  writeln(`
+${c10.dim("Use")} mc --resume <id> ${c10.dim("to continue a session.")}`);
 }
 function getMostRecentSession() {
   const sessions = listSessions(1);
@@ -6310,7 +5708,7 @@ class SessionRunner {
       }
       this.session = resumed;
       this.currentModel = this.session.model;
-      this.reporter.info(`Resumed session ${this.session.id} (${c12.cyan(this.currentModel)})`);
+      this.reporter.info(`Resumed session ${this.session.id} (${c11.cyan(this.currentModel)})`);
     } else {
       this.session = newSession(this.currentModel, this.cwd);
     }
@@ -6774,13 +6172,12 @@ ${input.command}`], {
       reader.cancel().catch(() => {});
     }
   }, timeout);
-  async function collectStream(stream, onChunk) {
+  async function collectStream(stream) {
     const reader = stream.getReader();
     readers.push(reader);
     const chunks = [];
     let totalBytes = 0;
     let truncated = false;
-    const decoder = new TextDecoder;
     while (true) {
       try {
         const { done, value } = await reader.read();
@@ -6788,7 +6185,6 @@ ${input.command}`], {
           break;
         if (!value)
           continue;
-        onChunk?.(decoder.decode(value, { stream: true }));
         if (totalBytes + value.length > MAX_OUTPUT_BYTES) {
           chunks.push(value.slice(0, MAX_OUTPUT_BYTES - totalBytes));
           truncated = true;
@@ -6808,28 +6204,11 @@ ${input.command}`], {
   let stdout = "";
   let stderr = "";
   let exitCode = 1;
-  const onOutput = input.onOutput;
-  const hasOutputHandler = typeof onOutput === "function";
-  let streamedAnyOutput = false;
-  let streamedEndsWithNewline = true;
-  const emitOutput = (chunk) => {
-    if (!chunk || !hasOutputHandler)
-      return;
-    const handled = onOutput(chunk);
-    if (handled === false)
-      return;
-    streamedAnyOutput = true;
-    streamedEndsWithNewline = /[\r\n]$/.test(chunk);
-  };
   try {
     [stdout, stderr] = await Promise.all([
-      collectStream(proc.stdout, hasOutputHandler ? emitOutput : undefined),
-      collectStream(proc.stderr, hasOutputHandler ? emitOutput : undefined)
+      collectStream(proc.stdout),
+      collectStream(proc.stderr)
     ]);
-    if (streamedAnyOutput && !streamedEndsWithNewline) {
-      emitOutput(`
-`);
-    }
     exitCode = await proc.exited;
   } finally {
     clearTimeout(timer);
@@ -6845,8 +6224,7 @@ ${input.command}`], {
     stderr: stderr.trimEnd(),
     exitCode,
     success: exitCode === 0,
-    timedOut,
-    streamedOutput: streamedAnyOutput
+    timedOut
   };
 }
 var shellTool = {
@@ -6919,22 +6297,9 @@ function withCwdDefault(tool, cwd) {
     }
   };
 }
-function withShellOutput(tool, onOutput) {
-  const originalExecute = tool.execute;
-  return {
-    ...tool,
-    execute: async (input) => {
-      const patched = {
-        ...typeof input === "object" && input !== null ? input : {},
-        onOutput
-      };
-      return originalExecute(patched);
-    }
-  };
-}
 function buildToolSet2(opts) {
-  const { cwd, onShellOutput } = opts;
-  const shell = onShellOutput ? withShellOutput(withCwdDefault(shellTool, cwd), onShellOutput) : withCwdDefault(shellTool, cwd);
+  const { cwd } = opts;
+  const shell = withCwdDefault(shellTool, cwd);
   const tools = [
     shell,
     withCwdDefault(listSkillsTool, cwd),
@@ -6963,17 +6328,10 @@ async function initAgent(opts) {
   const cwd = opts.cwd;
   let currentModel = opts.model;
   const { runSubagent, killAll } = createSubagentRunner(cwd, () => currentModel);
-  let verboseOutputEnabled = opts.initialVerboseOutput;
   const agents = loadAgents(cwd);
   const tools = buildToolSet2({
     cwd,
     runSubagent,
-    onShellOutput: (chunk) => {
-      if (!verboseOutputEnabled)
-        return false;
-      opts.reporter.streamChunk(chunk);
-      return true;
-    },
     availableAgents: subagentAgents(agents)
   });
   const mcpTools = [];
@@ -6997,7 +6355,7 @@ async function initAgent(opts) {
   for (const row of listMcpServers()) {
     try {
       await connectAndAddMcp(row.name);
-      opts.reporter.info(`MCP: connected ${c13.cyan(row.name)}`);
+      opts.reporter.info(`MCP: connected ${c12.cyan(row.name)}`);
     } catch (e) {
       opts.reporter.error(`MCP: failed to connect ${row.name}: ${String(e)}`);
     }
@@ -7062,7 +6420,6 @@ async function initAgent(opts) {
     },
     setVerboseOutput: (verbose) => {
       runner.verboseOutput = verbose;
-      verboseOutputEnabled = verbose;
       setPreferredVerboseOutput(verbose);
     },
     get pruningMode() {
@@ -7120,7 +6477,7 @@ async function initAgent(opts) {
 }
 
 // src/cli/args.ts
-import * as c14 from "yoctocolors";
+import * as c13 from "yoctocolors";
 function parseArgs(argv) {
   const args = {
     model: null,
@@ -7184,11 +6541,11 @@ function parseArgs(argv) {
   return args;
 }
 function printHelp() {
-  writeln2(`${c14.bold("mini-coder")} \u2014 a small, fast CLI coding agent
+  writeln(`${c13.bold("mini-coder")} \u2014 a small, fast CLI coding agent
 `);
-  writeln2(`${c14.bold("Usage:")}  mc [options] [prompt]
+  writeln(`${c13.bold("Usage:")}  mc [options] [prompt]
 `);
-  writeln2(`${c14.bold("Options:")}`);
+  writeln(`${c13.bold("Options:")}`);
   const opts = [
     ["-m, --model <id>", "Model to use (e.g. zen/claude-sonnet-4-6)"],
     ["-c, --continue", "Continue the most recent session"],
@@ -7198,10 +6555,10 @@ function printHelp() {
     ["-h, --help", "Show this help"]
   ];
   for (const [flag, desc] of opts) {
-    writeln2(`  ${c14.cyan((flag ?? "").padEnd(22))} ${c14.dim(desc ?? "")}`);
+    writeln(`  ${c13.cyan((flag ?? "").padEnd(22))} ${c13.dim(desc ?? "")}`);
   }
-  writeln2(`
-${c14.bold("Provider env vars:")}`);
+  writeln(`
+${c13.bold("Provider env vars:")}`);
   const envs = [
     ["OPENCODE_API_KEY", "OpenCode Zen (recommended)"],
     ["ANTHROPIC_API_KEY", "Anthropic direct"],
@@ -7212,22 +6569,22 @@ ${c14.bold("Provider env vars:")}`);
     ["OLLAMA_BASE_URL", "Ollama base URL (default: http://localhost:11434)"]
   ];
   for (const [env, desc] of envs) {
-    writeln2(`  ${c14.yellow((env ?? "").padEnd(22))} ${c14.dim(desc ?? "")}`);
+    writeln(`  ${c13.yellow((env ?? "").padEnd(22))} ${c13.dim(desc ?? "")}`);
   }
-  writeln2(`
-${c14.bold("Examples:")}`);
-  writeln2(`  mc                           ${c14.dim("# interactive session")}`);
-  writeln2(`  mc "explain this codebase"   ${c14.dim("# one-shot prompt then exit")}`);
-  writeln2(`  mc -c                        ${c14.dim("# continue last session")}`);
-  writeln2(`  mc -m ollama/llama3.2        ${c14.dim("# use local Ollama model")}`);
-  writeln2(`  mc -l                        ${c14.dim("# list sessions")}`);
+  writeln(`
+${c13.bold("Examples:")}`);
+  writeln(`  mc                           ${c13.dim("# interactive session")}`);
+  writeln(`  mc "explain this codebase"   ${c13.dim("# one-shot prompt then exit")}`);
+  writeln(`  mc -c                        ${c13.dim("# continue last session")}`);
+  writeln(`  mc -m ollama/llama3.2        ${c13.dim("# use local Ollama model")}`);
+  writeln(`  mc -l                        ${c13.dim("# list sessions")}`);
 }
 
 // src/cli/bootstrap.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join12 } from "path";
-import * as c15 from "yoctocolors";
+import * as c14 from "yoctocolors";
 var REVIEW_COMMAND_CONTENT = `---
 description: Review recent changes for correctness, code quality, and performance
 context: fork
@@ -7251,7 +6608,7 @@ function bootstrapGlobalDefaults() {
   if (!existsSync8(reviewPath)) {
     mkdirSync4(commandsDir, { recursive: true });
     writeFileSync3(reviewPath, REVIEW_COMMAND_CONTENT, "utf-8");
-    writeln2(`${c15.green("\u2713")} created ${c15.dim("~/.agents/commands/review.md")} ${c15.dim("(edit it to customise your reviews)")}`);
+    writeln(`${c14.green("\u2713")} created ${c14.dim("~/.agents/commands/review.md")} ${c14.dim("(edit it to customise your reviews)")}`);
   }
 }
 
@@ -7316,7 +6673,6 @@ class HeadlessReporter {
   error(_msg, _hint) {}
   warn(_msg) {}
   writeText(_text) {}
-  streamChunk(_text) {}
   startSpinner(_label) {}
   stopSpinner() {}
   async renderTurn(events, _opts) {
@@ -7366,7 +6722,7 @@ class HeadlessReporter {
 }
 
 // src/cli/input-loop.ts
-import * as c23 from "yoctocolors";
+import * as c22 from "yoctocolors";
 
 // src/cli/cli-helpers.ts
 async function getGitBranch(cwd) {
@@ -7387,67 +6743,67 @@ async function getGitBranch(cwd) {
 }
 
 // src/cli/commands.ts
-import * as c22 from "yoctocolors";
+import * as c21 from "yoctocolors";
 
 // src/cli/commands-agent.ts
-import * as c16 from "yoctocolors";
+import * as c15 from "yoctocolors";
 function handleAgentCommand(ctx, args) {
   const raw = args.trim();
   const agents = loadAgents(ctx.cwd);
   if (!raw) {
     if (agents.size === 0) {
-      writeln2(c16.dim("  no agents found  (~/.agents/agents/ or .agents/agents/)"));
-      writeln2(c16.dim("  /agent <name>  to activate  \xB7  /agent off  to deactivate"));
+      writeln(c15.dim("  no agents found  (~/.agents/agents/ or .agents/agents/)"));
+      writeln(c15.dim("  /agent <name>  to activate  \xB7  /agent off  to deactivate"));
       return;
     }
-    writeln2();
-    writeln2(c16.dim("  agents:"));
+    writeln();
+    writeln(c15.dim("  agents:"));
     for (const agent2 of agents.values()) {
-      const modeTag = agent2.mode ? c16.dim(` [${agent2.mode}]`) : "";
-      const srcTag = agent2.source === "local" ? c16.dim(" (local)") : c16.dim(" (global)");
-      const active = ctx.activeAgent === agent2.name ? c16.cyan(" \u25C0 active") : "";
-      writeln2(`  ${c16.magenta(`@${agent2.name}`.padEnd(26))} ${c16.dim(agent2.description)}${modeTag}${srcTag}${active}`);
-    }
-    writeln2();
-    writeln2(c16.dim("  /agent <name>  to activate  \xB7  /agent off  to deactivate"));
-    writeln2();
+      const modeTag = agent2.mode ? c15.dim(` [${agent2.mode}]`) : "";
+      const srcTag = agent2.source === "local" ? c15.dim(" (local)") : c15.dim(" (global)");
+      const active = ctx.activeAgent === agent2.name ? c15.cyan(" \u25C0 active") : "";
+      writeln(`  ${c15.magenta(`@${agent2.name}`.padEnd(26))} ${c15.dim(agent2.description)}${modeTag}${srcTag}${active}`);
+    }
+    writeln();
+    writeln(c15.dim("  /agent <name>  to activate  \xB7  /agent off  to deactivate"));
+    writeln();
     return;
   }
   if (raw.toLowerCase() === "off" || raw.toLowerCase() === "none") {
     ctx.setActiveAgent(null);
-    writeln2(`${PREFIX.info} ${c16.dim("active agent cleared")}`);
+    writeln(`${PREFIX.info} ${c15.dim("active agent cleared")}`);
     return;
   }
   const agent = agents.get(raw);
   if (!agent) {
-    writeln2(`${PREFIX.error} agent ${c16.cyan(raw)} not found`);
+    writeln(`${PREFIX.error} agent ${c15.cyan(raw)} not found`);
     return;
   }
   ctx.setActiveAgent(raw, agent.systemPrompt);
-  writeln2(`${PREFIX.success} active agent \u2192 ${c16.cyan(raw)} ${c16.dim("(instructions appended to system prompt)")}`);
+  writeln(`${PREFIX.success} active agent \u2192 ${c15.cyan(raw)} ${c15.dim("(instructions appended to system prompt)")}`);
 }
 
 // src/cli/commands-config.ts
-import * as c17 from "yoctocolors";
+import * as c16 from "yoctocolors";
 function handleBooleanToggleCommand(opts) {
   const mode = opts.args.trim().toLowerCase();
   if (!mode) {
     const nextValue = !opts.current;
     opts.set(nextValue);
-    writeln2(`${PREFIX.success} ${opts.label} ${nextValue ? c17.green("on") : c17.dim("off")}`);
+    writeln(`${PREFIX.success} ${opts.label} ${nextValue ? c16.green("on") : c16.dim("off")}`);
     return;
   }
   if (mode === "on") {
     opts.set(true);
-    writeln2(`${PREFIX.success} ${opts.label} ${c17.green("on")}`);
+    writeln(`${PREFIX.success} ${opts.label} ${c16.green("on")}`);
     return;
   }
   if (mode === "off") {
     opts.set(false);
-    writeln2(`${PREFIX.success} ${opts.label} ${c17.dim("off")}`);
+    writeln(`${PREFIX.success} ${opts.label} ${c16.dim("off")}`);
     return;
   }
-  writeln2(`${PREFIX.error} usage: ${opts.usage}`);
+  writeln(`${PREFIX.error} usage: ${opts.usage}`);
 }
 function handleReasoningCommand(ctx, args) {
   handleBooleanToggleCommand({
@@ -7471,105 +6827,105 @@ function handleContextCommand(ctx, args) {
   const [subcommand, value] = args.trim().split(/\s+/, 2);
   if (!subcommand) {
     const capText = ctx.toolResultPayloadCapBytes <= 0 ? "off" : `${Math.round(ctx.toolResultPayloadCapBytes / 1024)}KB (${ctx.toolResultPayloadCapBytes} bytes)`;
-    writeln2(`${PREFIX.info} pruning=${c17.cyan(ctx.pruningMode)}  tool-result-cap=${c17.cyan(capText)}`);
-    writeln2(c17.dim("  usage: /context prune <off|balanced|aggressive>"));
-    writeln2(c17.dim("         /context cap <off|bytes|kb>"));
+    writeln(`${PREFIX.info} pruning=${c16.cyan(ctx.pruningMode)}  tool-result-cap=${c16.cyan(capText)}`);
+    writeln(c16.dim("  usage: /context prune <off|balanced|aggressive>"));
+    writeln(c16.dim("         /context cap <off|bytes|kb>"));
     return;
   }
   if (subcommand === "prune") {
     if (value === "off" || value === "balanced" || value === "aggressive") {
       ctx.setPruningMode(value);
-      writeln2(`${PREFIX.success} context pruning \u2192 ${c17.cyan(value)}`);
+      writeln(`${PREFIX.success} context pruning \u2192 ${c16.cyan(value)}`);
       return;
     }
-    writeln2(`${PREFIX.error} usage: /context prune <off|balanced|aggressive>`);
+    writeln(`${PREFIX.error} usage: /context prune <off|balanced|aggressive>`);
     return;
   }
   if (subcommand !== "cap") {
-    writeln2(`${PREFIX.error} usage: /context <prune|cap> ...`);
+    writeln(`${PREFIX.error} usage: /context <prune|cap> ...`);
     return;
   }
   if (!value) {
-    writeln2(`${PREFIX.error} usage: /context cap <off|bytes|kb>`);
+    writeln(`${PREFIX.error} usage: /context cap <off|bytes|kb>`);
     return;
   }
   if (value === "off") {
     ctx.setToolResultPayloadCapBytes(0);
-    writeln2(`${PREFIX.success} tool-result payload cap disabled`);
+    writeln(`${PREFIX.success} tool-result payload cap disabled`);
     return;
   }
   const capMatch = value.match(/^(\d+)(kb)?$/i);
   if (!capMatch) {
-    writeln2(`${PREFIX.error} invalid cap: ${c17.cyan(value)}`);
+    writeln(`${PREFIX.error} invalid cap: ${c16.cyan(value)}`);
     return;
   }
   const base = Number.parseInt(capMatch[1] ?? "", 10);
   const capBytes = (capMatch[2] ?? "").toLowerCase() === "kb" ? base * 1024 : base;
   if (!Number.isFinite(capBytes) || capBytes < 0) {
-    writeln2(`${PREFIX.error} invalid cap: ${c17.cyan(value)}`);
+    writeln(`${PREFIX.error} invalid cap: ${c16.cyan(value)}`);
     return;
   }
   ctx.setToolResultPayloadCapBytes(capBytes);
-  writeln2(`${PREFIX.success} tool-result payload cap \u2192 ${c17.cyan(`${capBytes} bytes`)}`);
+  writeln(`${PREFIX.success} tool-result payload cap \u2192 ${c16.cyan(`${capBytes} bytes`)}`);
 }
 function handleCacheCommand(ctx, args) {
   const [subcommand, value] = args.trim().split(/\s+/, 2);
   if (!subcommand) {
-    const geminiCache = ctx.googleCachedContent ? c17.cyan(ctx.googleCachedContent) : "off";
-    writeln2(`${PREFIX.info} prompt-caching=${ctx.promptCachingEnabled ? c17.green("on") : c17.dim("off")}  openai-retention=${c17.cyan(ctx.openaiPromptCacheRetention)}  gemini-cache=${geminiCache}`);
-    writeln2(c17.dim("  usage: /cache <on|off>"));
-    writeln2(c17.dim("         /cache openai <in_memory|24h>"));
-    writeln2(c17.dim("         /cache gemini <off|cachedContents/...>"));
+    const geminiCache = ctx.googleCachedContent ? c16.cyan(ctx.googleCachedContent) : "off";
+    writeln(`${PREFIX.info} prompt-caching=${ctx.promptCachingEnabled ? c16.green("on") : c16.dim("off")}  openai-retention=${c16.cyan(ctx.openaiPromptCacheRetention)}  gemini-cache=${geminiCache}`);
+    writeln(c16.dim("  usage: /cache <on|off>"));
+    writeln(c16.dim("         /cache openai <in_memory|24h>"));
+    writeln(c16.dim("         /cache gemini <off|cachedContents/...>"));
     return;
   }
   if (subcommand === "on" || subcommand === "off") {
     ctx.setPromptCachingEnabled(subcommand === "on");
-    writeln2(`${PREFIX.success} prompt caching \u2192 ${subcommand === "on" ? c17.green("on") : c17.dim("off")}`);
+    writeln(`${PREFIX.success} prompt caching \u2192 ${subcommand === "on" ? c16.green("on") : c16.dim("off")}`);
     return;
   }
   if (subcommand === "openai") {
     if (value === "in_memory" || value === "24h") {
       ctx.setOpenAIPromptCacheRetention(value);
-      writeln2(`${PREFIX.success} openai prompt cache retention \u2192 ${c17.cyan(value)}`);
+      writeln(`${PREFIX.success} openai prompt cache retention \u2192 ${c16.cyan(value)}`);
       return;
     }
-    writeln2(`${PREFIX.error} usage: /cache openai <in_memory|24h>`);
+    writeln(`${PREFIX.error} usage: /cache openai <in_memory|24h>`);
     return;
   }
   if (subcommand !== "gemini") {
-    writeln2(`${PREFIX.error} usage: /cache <on|off|openai|gemini> ...`);
+    writeln(`${PREFIX.error} usage: /cache <on|off|openai|gemini> ...`);
     return;
   }
   if (!value) {
-    writeln2(`${PREFIX.error} usage: /cache gemini <off|cachedContents/...>`);
+    writeln(`${PREFIX.error} usage: /cache gemini <off|cachedContents/...>`);
     return;
   }
   if (value === "off") {
     ctx.setGoogleCachedContent(null);
-    writeln2(`${PREFIX.success} gemini cached content \u2192 ${c17.dim("off")}`);
+    writeln(`${PREFIX.success} gemini cached content \u2192 ${c16.dim("off")}`);
     return;
   }
   ctx.setGoogleCachedContent(value);
-  writeln2(`${PREFIX.success} gemini cached content \u2192 ${c17.cyan(value)}`);
+  writeln(`${PREFIX.success} gemini cached content \u2192 ${c16.cyan(value)}`);
 }
 
 // src/cli/commands-help.ts
-import * as c18 from "yoctocolors";
+import * as c17 from "yoctocolors";
 function renderEntries(entries) {
   for (const [label, description] of entries) {
-    writeln2(`  ${c18.cyan(label.padEnd(28))} ${c18.dim(description)}`);
+    writeln(`  ${c17.cyan(label.padEnd(28))} ${c17.dim(description)}`);
   }
 }
 function renderHelpCommand(ctx, custom) {
-  writeln2();
-  writeln2(`  ${c18.dim("session")}`);
+  writeln();
+  writeln(`  ${c17.dim("session")}`);
   renderEntries([
     ["/new", "start a fresh session"],
     ["/undo", "remove the last conversation turn"],
     ["/exit", "quit"]
   ]);
-  writeln2();
-  writeln2(`  ${c18.dim("model + context")}`);
+  writeln();
+  writeln(`  ${c17.dim("model + context")}`);
   renderEntries([
     ["/model [id]", "list or switch models"],
     ["/reasoning [on|off]", "toggle reasoning display"],
@@ -7584,8 +6940,8 @@ function renderHelpCommand(ctx, custom) {
     ["/logout <provider>", "clear OAuth tokens"],
     ["/help", "show this help"]
   ]);
-  writeln2();
-  writeln2(`  ${c18.dim("prompt")}`);
+  writeln();
+  writeln(`  ${c17.dim("prompt")}`);
   renderEntries([
     ["ask normally", "send a prompt to the current agent"],
     ["!cmd", "run a shell command and keep the result in context"],
@@ -7593,63 +6949,63 @@ function renderHelpCommand(ctx, custom) {
     ["@skill", "inject a skill into the prompt (Tab to complete)"]
   ]);
   if (custom.size > 0) {
-    writeln2();
-    writeln2(`  ${c18.dim("custom commands")}`);
+    writeln();
+    writeln(`  ${c17.dim("custom commands")}`);
     for (const cmd of custom.values()) {
-      const source = cmd.source === "local" ? c18.dim("local") : c18.dim("global");
-      writeln2(`  ${c18.green(`/${cmd.name}`.padEnd(28))} ${c18.dim(cmd.description)} ${c18.dim("\xB7")} ${source}`);
+      const source = cmd.source === "local" ? c17.dim("local") : c17.dim("global");
+      writeln(`  ${c17.green(`/${cmd.name}`.padEnd(28))} ${c17.dim(cmd.description)} ${c17.dim("\xB7")} ${source}`);
     }
   }
   const agents = loadAgents(ctx.cwd);
   if (agents.size > 0) {
-    writeln2();
-    writeln2(`  ${c18.dim("agents")}`);
+    writeln();
+    writeln(`  ${c17.dim("agents")}`);
     for (const agent of agents.values()) {
-      const mode = agent.mode ? c18.dim(agent.mode) : c18.dim("agent");
-      const source = agent.source === "local" ? c18.dim("local") : c18.dim("global");
-      writeln2(`  ${c18.magenta(agent.name.padEnd(28))} ${c18.dim(agent.description)} ${c18.dim("\xB7")} ${mode} ${c18.dim("\xB7")} ${source}`);
+      const mode = agent.mode ? c17.dim(agent.mode) : c17.dim("agent");
+      const source = agent.source === "local" ? c17.dim("local") : c17.dim("global");
+      writeln(`  ${c17.magenta(agent.name.padEnd(28))} ${c17.dim(agent.description)} ${c17.dim("\xB7")} ${mode} ${c17.dim("\xB7")} ${source}`);
     }
   }
   const skills = loadSkillsIndex(ctx.cwd);
   if (skills.size > 0) {
-    writeln2();
-    writeln2(`  ${c18.dim("skills")}`);
+    writeln();
+    writeln(`  ${c17.dim("skills")}`);
     for (const skill of skills.values()) {
-      const source = skill.source === "local" ? c18.dim("local") : c18.dim("global");
-      writeln2(`  ${c18.yellow(`@${skill.name}`.padEnd(28))} ${c18.dim(skill.description)} ${c18.dim("\xB7")} ${source}`);
+      const source = skill.source === "local" ? c17.dim("local") : c17.dim("global");
+      writeln(`  ${c17.yellow(`@${skill.name}`.padEnd(28))} ${c17.dim(skill.description)} ${c17.dim("\xB7")} ${source}`);
     }
   }
-  writeln2();
-  writeln2(`  ${c18.dim("keys")}  ${c18.dim("esc")} cancel response  ${c18.dim("\xB7")}  ${c18.dim("ctrl+c / ctrl+d")} exit  ${c18.dim("\xB7")}  ${c18.dim("ctrl+r")} history search  ${c18.dim("\xB7")}  ${c18.dim("\u2191\u2193")} history`);
-  writeln2();
+  writeln();
+  writeln(`  ${c17.dim("keys")}  ${c17.dim("esc")} cancel response  ${c17.dim("\xB7")}  ${c17.dim("ctrl+c / ctrl+d")} exit  ${c17.dim("\xB7")}  ${c17.dim("ctrl+r")} history search  ${c17.dim("\xB7")}  ${c17.dim("\u2191\u2193")} history`);
+  writeln();
 }
 
 // src/cli/commands-login.ts
-import * as c19 from "yoctocolors";
+import * as c18 from "yoctocolors";
 function renderLoginHelp() {
-  writeln2();
-  writeln2(`  ${c19.dim("usage:")}`);
-  writeln2(`    /login                 ${c19.dim("show login status")}`);
-  writeln2(`    /login <provider>      ${c19.dim("login via OAuth")}`);
-  writeln2(`    /logout <provider>     ${c19.dim("clear saved tokens")}`);
-  writeln2();
-  writeln2(`  ${c19.dim("providers:")}`);
+  writeln();
+  writeln(`  ${c18.dim("usage:")}`);
+  writeln(`    /login                 ${c18.dim("show login status")}`);
+  writeln(`    /login <provider>      ${c18.dim("login via OAuth")}`);
+  writeln(`    /logout <provider>     ${c18.dim("clear saved tokens")}`);
+  writeln();
+  writeln(`  ${c18.dim("providers:")}`);
   for (const p of getOAuthProviders()) {
-    const status = isLoggedIn(p.id) ? c19.green("logged in") : c19.dim("not logged in");
-    writeln2(`    ${c19.cyan(p.id.padEnd(20))} ${p.name} ${c19.dim("\xB7")} ${status}`);
+    const status = isLoggedIn(p.id) ? c18.green("logged in") : c18.dim("not logged in");
+    writeln(`    ${c18.cyan(p.id.padEnd(20))} ${p.name} ${c18.dim("\xB7")} ${status}`);
   }
-  writeln2();
+  writeln();
 }
 function renderStatus() {
   const loggedIn = listLoggedInProviders();
   if (loggedIn.length === 0) {
-    writeln2(`${PREFIX.info} ${c19.dim("no OAuth logins \u2014 use")} /login <provider>`);
+    writeln(`${PREFIX.info} ${c18.dim("no OAuth logins \u2014 use")} /login <provider>`);
     return;
   }
   for (const id of loggedIn) {
     const provider = getOAuthProvider(id);
     const name = provider?.name ?? id;
-    writeln2(`${PREFIX.success} ${c19.cyan(id)} ${c19.dim(name)}`);
+    writeln(`${PREFIX.success} ${c18.cyan(id)} ${c18.dim(name)}`);
   }
 }
 async function handleLoginCommand(ctx, args) {
@@ -7664,13 +7020,13 @@ async function handleLoginCommand(ctx, args) {
   }
   const provider = getOAuthProvider(providerId);
   if (!provider) {
-    writeln2(`${PREFIX.error} unknown provider "${providerId}" \u2014 available: ${getOAuthProviders().map((p) => p.id).join(", ")}`);
+    writeln(`${PREFIX.error} unknown provider "${providerId}" \u2014 available: ${getOAuthProviders().map((p) => p.id).join(", ")}`);
     return;
   }
   if (isLoggedIn(providerId)) {
     const token = await getAccessToken(providerId);
     if (token) {
-      writeln2(`${PREFIX.success} already logged in to ${c19.cyan(provider.name)}`);
+      writeln(`${PREFIX.success} already logged in to ${c18.cyan(provider.name)}`);
       return;
     }
   }
@@ -7679,43 +7035,43 @@ async function handleLoginCommand(ctx, args) {
     await login(providerId, {
       onOpenUrl: (url, instructions) => {
         ctx.stopSpinner();
-        writeln2(`${PREFIX.info} ${instructions}`);
-        writeln2();
-        writeln2(`  ${c19.cyan(url)}`);
-        writeln2();
+        writeln(`${PREFIX.info} ${instructions}`);
+        writeln();
+        writeln(`  ${c18.cyan(url)}`);
+        writeln();
         const open = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
         Bun.spawn([open, url], { stdout: "ignore", stderr: "ignore" });
         ctx.startSpinner("waiting for browser callback");
       },
       onProgress: (msg) => {
         ctx.stopSpinner();
-        writeln2(`${PREFIX.info} ${c19.dim(msg)}`);
+        writeln(`${PREFIX.info} ${c18.dim(msg)}`);
         ctx.startSpinner("exchanging tokens");
       }
     });
     ctx.stopSpinner();
-    writeln2(`${PREFIX.success} logged in to ${c19.cyan(provider.name)}`);
+    writeln(`${PREFIX.success} logged in to ${c18.cyan(provider.name)}`);
   } catch (err) {
     ctx.stopSpinner();
-    writeln2(`${PREFIX.error} login failed: ${err.message}`);
+    writeln(`${PREFIX.error} login failed: ${err.message}`);
   }
 }
 function handleLogoutCommand(_ctx, args) {
   const providerId = args.trim().toLowerCase();
   if (!providerId) {
-    writeln2(`${PREFIX.error} usage: /logout <provider>`);
+    writeln(`${PREFIX.error} usage: /logout <provider>`);
     return;
   }
   if (!isLoggedIn(providerId)) {
-    writeln2(`${PREFIX.info} ${c19.dim("not logged in to")} ${providerId}`);
+    writeln(`${PREFIX.info} ${c18.dim("not logged in to")} ${providerId}`);
     return;
   }
   logout(providerId);
-  writeln2(`${PREFIX.success} logged out of ${c19.cyan(providerId)}`);
+  writeln(`${PREFIX.success} logged out of ${c18.cyan(providerId)}`);
 }
 
 // src/cli/commands-mcp.ts
-import * as c20 from "yoctocolors";
+import * as c19 from "yoctocolors";
 async function handleMcpCommand(ctx, args) {
   const parts = args.trim().split(/\s+/);
   const sub = parts[0] ?? "list";
@@ -7723,28 +7079,28 @@ async function handleMcpCommand(ctx, args) {
     case "list": {
       const servers = listMcpServers();
       if (servers.length === 0) {
-        writeln2(c20.dim("  no MCP servers configured"));
-        writeln2(c20.dim("  /mcp add <name> http <url>  \xB7  /mcp add <name> stdio <cmd> [args...]"));
+        writeln(c19.dim("  no MCP servers configured"));
+        writeln(c19.dim("  /mcp add <name> http <url>  \xB7  /mcp add <name> stdio <cmd> [args...]"));
         return;
       }
-      writeln2();
+      writeln();
       for (const s of servers) {
-        const detail = s.url ? c20.dim(`  ${s.url}`) : s.command ? c20.dim(`  ${s.command}`) : "";
-        writeln2(`  ${c20.yellow("\u2699")} ${c20.bold(s.name)}  ${c20.dim(s.transport)}${detail}`);
+        const detail = s.url ? c19.dim(`  ${s.url}`) : s.command ? c19.dim(`  ${s.command}`) : "";
+        writeln(`  ${c19.yellow("\u2699")} ${c19.bold(s.name)}  ${c19.dim(s.transport)}${detail}`);
       }
       return;
     }
     case "add": {
       const [, name, transport, ...rest] = parts;
       if (!name || !transport || rest.length === 0) {
-        writeln2(`${PREFIX.error} usage: /mcp add <name> http <url>`);
-        writeln2(`${PREFIX.error}        /mcp add <name> stdio <cmd> [args...]`);
+        writeln(`${PREFIX.error} usage: /mcp add <name> http <url>`);
+        writeln(`${PREFIX.error}        /mcp add <name> stdio <cmd> [args...]`);
         return;
       }
       if (transport === "http") {
         const url = rest[0];
         if (!url) {
-          writeln2(`${PREFIX.error} usage: /mcp add <name> http <url>`);
+          writeln(`${PREFIX.error} usage: /mcp add <name> http <url>`);
           return;
         }
         upsertMcpServer({
@@ -7758,7 +7114,7 @@ async function handleMcpCommand(ctx, args) {
       } else if (transport === "stdio") {
         const [command, ...cmdArgs] = rest;
         if (!command) {
-          writeln2(`${PREFIX.error} usage: /mcp add <name> stdio <cmd> [args...]`);
+          writeln(`${PREFIX.error} usage: /mcp add <name> stdio <cmd> [args...]`);
           return;
         }
         upsertMcpServer({
@@ -7770,14 +7126,14 @@ async function handleMcpCommand(ctx, args) {
           env: null
         });
       } else {
-        writeln2(`${PREFIX.error} unknown transport: ${transport}  (use http or stdio)`);
+        writeln(`${PREFIX.error} unknown transport: ${transport}  (use http or stdio)`);
         return;
       }
       try {
         await ctx.connectMcpServer(name);
-        writeln2(`${PREFIX.success} mcp server ${c20.cyan(name)} added and connected`);
+        writeln(`${PREFIX.success} mcp server ${c19.cyan(name)} added and connected`);
       } catch (e) {
-        writeln2(`${PREFIX.success} mcp server ${c20.cyan(name)} saved  ${c20.dim(`(connection failed: ${String(e)})`)}`);
+        writeln(`${PREFIX.success} mcp server ${c19.cyan(name)} saved  ${c19.dim(`(connection failed: ${String(e)})`)}`);
       }
       return;
     }
@@ -7785,21 +7141,21 @@ async function handleMcpCommand(ctx, args) {
     case "rm": {
       const [, name] = parts;
       if (!name) {
-        writeln2(`${PREFIX.error} usage: /mcp remove <name>`);
+        writeln(`${PREFIX.error} usage: /mcp remove <name>`);
         return;
       }
       deleteMcpServer(name);
-      writeln2(`${PREFIX.success} mcp server ${c20.cyan(name)} removed`);
+      writeln(`${PREFIX.success} mcp server ${c19.cyan(name)} removed`);
       return;
     }
     default:
-      writeln2(`${PREFIX.error} unknown: /mcp ${sub}`);
-      writeln2(c20.dim("  subcommands: list \xB7 add \xB7 remove"));
+      writeln(`${PREFIX.error} unknown: /mcp ${sub}`);
+      writeln(c19.dim("  subcommands: list \xB7 add \xB7 remove"));
   }
 }
 
 // src/cli/commands-model.ts
-import * as c21 from "yoctocolors";
+import * as c20 from "yoctocolors";
 var THINKING_EFFORTS = ["low", "medium", "high", "xhigh"];
 function parseThinkingEffort(value) {
   return THINKING_EFFORTS.includes(value) ? value : null;
@@ -7818,21 +7174,21 @@ function renderModelUpdatedMessage(ctx, modelId, effortArg) {
   if (effortArg) {
     if (effortArg === "off") {
       ctx.setThinkingEffort(null);
-      writeln2(`${PREFIX.success} model \u2192 ${c21.cyan(modelId)} ${c21.dim("(thinking disabled)")}`);
+      writeln(`${PREFIX.success} model \u2192 ${c20.cyan(modelId)} ${c20.dim("(thinking disabled)")}`);
       return;
     }
     const effort = parseThinkingEffort(effortArg);
     if (effort) {
       ctx.setThinkingEffort(effort);
-      writeln2(`${PREFIX.success} model \u2192 ${c21.cyan(modelId)} ${c21.dim(`(\u2726 ${effort})`)}`);
+      writeln(`${PREFIX.success} model \u2192 ${c20.cyan(modelId)} ${c20.dim(`(\u2726 ${effort})`)}`);
       return;
     }
-    writeln2(`${PREFIX.success} model \u2192 ${c21.cyan(modelId)}`);
-    writeln2(`${PREFIX.error} unknown effort level ${c21.cyan(effortArg)} (use low, medium, high, xhigh, off)`);
+    writeln(`${PREFIX.success} model \u2192 ${c20.cyan(modelId)}`);
+    writeln(`${PREFIX.error} unknown effort level ${c20.cyan(effortArg)} (use low, medium, high, xhigh, off)`);
     return;
   }
-  const effortTag = ctx.thinkingEffort ? c21.dim(` (\u2726 ${ctx.thinkingEffort})`) : "";
-  writeln2(`${PREFIX.success} model \u2192 ${c21.cyan(modelId)}${effortTag}`);
+  const effortTag = ctx.thinkingEffort ? c20.dim(` (\u2726 ${ctx.thinkingEffort})`) : "";
+  writeln(`${PREFIX.success} model \u2192 ${c20.cyan(modelId)}${effortTag}`);
 }
 async function handleModelSet(ctx, args) {
   const parts = args.trim().split(/\s+/).filter(Boolean);
@@ -7845,7 +7201,7 @@ async function handleModelSet(ctx, args) {
     const snapshot = await fetchAvailableModels();
     const match = findModelIdByAlias(idArg, snapshot.models.map((model) => model.id));
     if (!match) {
-      writeln2(`${PREFIX.error} unknown model ${c21.cyan(idArg)}  ${c21.dim("\u2014 run /models for the full list")}`);
+      writeln(`${PREFIX.error} unknown model ${c20.cyan(idArg)}  ${c20.dim("\u2014 run /models for the full list")}`);
       return;
     }
     modelId = match;
@@ -7856,30 +7212,30 @@ async function handleModelSet(ctx, args) {
 function handleModelEffort(ctx, effortArg) {
   if (effortArg === "off") {
     ctx.setThinkingEffort(null);
-    writeln2(`${PREFIX.success} thinking effort disabled`);
+    writeln(`${PREFIX.success} thinking effort disabled`);
     return;
   }
   const effort = parseThinkingEffort(effortArg);
   if (!effort) {
-    writeln2(`${PREFIX.error} usage: /model effort <low|medium|high|xhigh|off>`);
+    writeln(`${PREFIX.error} usage: /model effort <low|medium|high|xhigh|off>`);
     return;
   }
   ctx.setThinkingEffort(effort);
-  writeln2(`${PREFIX.success} thinking effort \u2192 ${c21.cyan(effort)}`);
+  writeln(`${PREFIX.success} thinking effort \u2192 ${c20.cyan(effort)}`);
 }
 async function renderModelList(ctx) {
   ctx.startSpinner("fetching models");
   const snapshot = await fetchAvailableModels();
   ctx.stopSpinner();
   if (snapshot.models.length === 0) {
-    writeln2(`${PREFIX.error} No models found. Check your API keys or Ollama connection.`);
-    writeln2(c21.dim("  Set OPENCODE_API_KEY for Zen, or start Ollama for local models."));
+    writeln(`${PREFIX.error} No models found. Check your API keys or Ollama connection.`);
+    writeln(c20.dim("  Set OPENCODE_API_KEY for Zen, or start Ollama for local models."));
     return;
   }
   if (snapshot.stale) {
     const lastSync = snapshot.lastSyncAt ? new Date(snapshot.lastSyncAt).toLocaleString() : "never";
     const refreshTag = snapshot.refreshing ? " (refreshing in background)" : "";
-    writeln2(c21.dim(`  model metadata is stale (last sync: ${lastSync})${refreshTag}`));
+    writeln(c20.dim(`  model metadata is stale (last sync: ${lastSync})${refreshTag}`));
   }
   const modelsByProvider = new Map;
   for (const model of snapshot.models) {
@@ -7890,22 +7246,22 @@ async function renderModelList(ctx) {
       modelsByProvider.set(model.provider, [model]);
     }
   }
-  writeln2();
+  writeln();
   for (const [provider, providerModels] of modelsByProvider) {
-    writeln2(c21.bold(`  ${provider}`));
+    writeln(c20.bold(`  ${provider}`));
     for (const model of providerModels) {
       const isCurrent = ctx.currentModel === model.id;
-      const freeTag = model.free ? c21.green(" free") : "";
-      const contextTag = model.context ? c21.dim(` ${Math.round(model.context / 1000)}k`) : "";
-      const effortTag = isCurrent && ctx.thinkingEffort ? c21.dim(` \u2726 ${ctx.thinkingEffort}`) : "";
-      const currentTag = isCurrent ? c21.cyan(" \u25C0") : "";
-      writeln2(`    ${c21.dim("\xB7")} ${model.displayName}${freeTag}${contextTag}${currentTag}${effortTag}`);
-      writeln2(`      ${c21.dim(model.id)}`);
+      const freeTag = model.free ? c20.green(" free") : "";
+      const contextTag = model.context ? c20.dim(` ${Math.round(model.context / 1000)}k`) : "";
+      const effortTag = isCurrent && ctx.thinkingEffort ? c20.dim(` \u2726 ${ctx.thinkingEffort}`) : "";
+      const currentTag = isCurrent ? c20.cyan(" \u25C0") : "";
+      writeln(`    ${c20.dim("\xB7")} ${model.displayName}${freeTag}${contextTag}${currentTag}${effortTag}`);
+      writeln(`      ${c20.dim(model.id)}`);
     }
   }
-  writeln2();
-  writeln2(c21.dim("  /model <id>  to switch  \xB7  e.g. /model zen/claude-sonnet-4-6"));
-  writeln2(c21.dim("  /model effort <low|medium|high|xhigh|off>  to set thinking effort"));
+  writeln();
+  writeln(c20.dim("  /model <id>  to switch  \xB7  e.g. /model zen/claude-sonnet-4-6"));
+  writeln(c20.dim("  /model effort <low|medium|high|xhigh|off>  to set thinking effort"));
 }
 async function handleModelCommand(ctx, args) {
   const parts = args.trim().split(/\s+/).filter(Boolean);
@@ -7926,9 +7282,9 @@ async function handleUndo(ctx) {
   try {
     const ok = await ctx.undoLastTurn();
     if (ok) {
-      writeln2(`${PREFIX.success} ${c22.dim("last conversation turn removed")}`);
+      writeln(`${PREFIX.success} ${c21.dim("last conversation turn removed")}`);
     } else {
-      writeln2(`${PREFIX.info} ${c22.dim("nothing to undo")}`);
+      writeln(`${PREFIX.info} ${c21.dim("nothing to undo")}`);
     }
   } finally {
     ctx.stopSpinner();
@@ -7941,11 +7297,11 @@ function handleNew(ctx) {
 }
 async function handleCustomCommand(cmd, args, ctx) {
   const prompt = await expandTemplate(cmd.template, args, ctx.cwd);
-  const label = c22.cyan(cmd.name);
+  const label = c21.cyan(cmd.name);
   const srcPath = cmd.source === "local" ? `.agents/commands/${cmd.name}.md` : `~/.agents/commands/${cmd.name}.md`;
-  const src = c22.dim(`[${srcPath}]`);
-  writeln2(`${PREFIX.info} ${label} ${src}`);
-  writeln2();
+  const src = c21.dim(`[${srcPath}]`);
+  writeln(`${PREFIX.info} ${label} ${src}`);
+  writeln();
   const fork = cmd.context === "fork" || cmd.subtask === true;
   if (!fork) {
     return { type: "inject-user-message", text: prompt };
@@ -7957,8 +7313,8 @@ async function handleCustomCommand(cmd, args, ctx) {
   try {
     ctx.startSpinner("subagent");
     const output = await ctx.runSubagent(prompt, cmd.agent, cmd.model, abortController.signal);
-    write2(output.result);
-    writeln2();
+    write(output.result);
+    writeln();
     return {
       type: "inject-user-message",
       text: `/${cmd.name} output:
@@ -7971,7 +7327,7 @@ ${output.result}
     if (isAbortError(e)) {
       return { type: "handled" };
     }
-    writeln2(`${PREFIX.error} /${cmd.name} failed: ${String(e)}`);
+    writeln(`${PREFIX.error} /${cmd.name} failed: ${String(e)}`);
     return { type: "handled" };
   } finally {
     stopWatcher();
@@ -8028,7 +7384,7 @@ async function handleCommand(command, args, ctx) {
     case "q":
       return { type: "exit" };
     default: {
-      writeln2(`${PREFIX.error} unknown: /${command}  ${c22.dim("\u2014 /help for commands")}`);
+      writeln(`${PREFIX.error} unknown: /${command}  ${c21.dim("\u2014 /help for commands")}`);
       return { type: "unknown", command };
     }
   }
@@ -8124,7 +7480,7 @@ async function runInputLoop(opts) {
     }
     switch (input.type) {
       case "eof":
-        reporter.writeText(c23.dim("Goodbye."));
+        reporter.writeText(c22.dim("Goodbye."));
         return;
       case "interrupt":
         gitBranchCache.refreshInBackground();
@@ -8132,7 +7488,7 @@ async function runInputLoop(opts) {
       case "command": {
         const result = await handleCommand(input.command, input.args, cmdCtx);
         if (result.type === "exit") {
-          reporter.writeText(c23.dim("Goodbye."));
+          reporter.writeText(c22.dim("Goodbye."));
           return;
         }
         if (result.type === "inject-user-message") {
@@ -8150,13 +7506,7 @@ async function runInputLoop(opts) {
         const result = await runShellCommand({
           command: input.command,
           timeout: 30000,
-          cwd,
-          ...cmdCtx.verboseOutput ? {
-            onOutput: (chunk) => {
-              reporter.streamChunk(chunk);
-              return true;
-            }
-          } : {}
+          cwd
         });
         renderToolResult("shell", result, false, {
           verboseOutput: cmdCtx.verboseOutput
@@ -8211,8 +7561,8 @@ async function resolvePromptInput(promptArg, opts) {
 
 // src/cli/structured-output.ts
 import { createTwoFilesPatch } from "diff";
-function writeJsonLine(write3, payload) {
-  write3(`${JSON.stringify(payload)}
+function writeJsonLine(write2, payload) {
+  write2(`${JSON.stringify(payload)}
 `);
 }
 
@@ -8268,7 +7618,7 @@ async function main() {
     if (last) {
       sessionId = last.id;
     } else {
-      writeln2(c24.dim("No previous session found, starting fresh."));
+      writeln(c23.dim("No previous session found, starting fresh."));
     }
   } else if (args.sessionId) {
     sessionId = args.sessionId;
@@ -8335,7 +7685,7 @@ async function main() {
       const { text: resolvedText, images: refImages } = await resolveFileRefs(prompt, args.cwd);
       await runner.processUserInput(resolvedText, refImages);
       const { totalIn, totalOut } = runner.getStatusInfo();
-      writeln2(`${G.info} ${c24.dim(`${totalIn.toLocaleString()} in / ${totalOut.toLocaleString()} out tokens`)}`);
+      writeln(`${G.info} ${c23.dim(`${totalIn.toLocaleString()} in / ${totalOut.toLocaleString()} out tokens`)}`);
       return;
     }
     await runInputLoop({