mini-coder 0.0.3

package/dist/mc.js

@@ -0,0 +1,3727 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/index.ts
+import * as c7 from "yoctocolors";
+
+// src/agent/agent.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join11 } from "path";
+import * as c6 from "yoctocolors";
+
+// src/cli/commands.ts
+import * as c3 from "yoctocolors";
+
+// src/llm-api/providers.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { createOllama } from "ollama-ai-provider";
+var ZEN_BASE = "https://opencode.ai/zen/v1";
+var ZEN_ANTHROPIC_MODELS = new Set([
+  "claude-opus-4-6",
+  "claude-opus-4-5",
+  "claude-opus-4-1",
+  "claude-sonnet-4-6",
+  "claude-sonnet-4-5",
+  "claude-sonnet-4",
+  "claude-haiku-4-5",
+  "claude-3-5-haiku"
+]);
+var ZEN_OPENAI_MODELS = new Set([
+  "gpt-5.2",
+  "gpt-5.2-codex",
+  "gpt-5.1",
+  "gpt-5.1-codex",
+  "gpt-5.1-codex-max",
+  "gpt-5.1-codex-mini",
+  "gpt-5",
+  "gpt-5-codex",
+  "gpt-5-nano"
+]);
+var ZEN_GOOGLE_MODELS = new Set([
+  "gemini-3.1-pro",
+  "gemini-3-pro",
+  "gemini-3-flash"
+]);
+var _zenAnthropic = null;
+var _zenOpenAI = null;
+var _zenCompat = null;
+function getZenApiKey() {
+  const key = process.env.OPENCODE_API_KEY;
+  if (!key)
+    throw new Error("OPENCODE_API_KEY is not set");
+  return key;
+}
+function zenAnthropic() {
+  if (!_zenAnthropic) {
+    _zenAnthropic = createAnthropic({
+      apiKey: getZenApiKey(),
+      baseURL: ZEN_BASE
+    });
+  }
+  return _zenAnthropic;
+}
+function zenOpenAI() {
+  if (!_zenOpenAI) {
+    _zenOpenAI = createOpenAI({
+      apiKey: getZenApiKey(),
+      baseURL: ZEN_BASE
+    });
+  }
+  return _zenOpenAI;
+}
+function zenGoogle(modelId) {
+  return createGoogleGenerativeAI({
+    apiKey: getZenApiKey(),
+    baseURL: ZEN_BASE
+  });
+}
+function zenCompat() {
+  if (!_zenCompat) {
+    _zenCompat = createOpenAICompatible({
+      name: "zen-compat",
+      apiKey: getZenApiKey(),
+      baseURL: ZEN_BASE
+    });
+  }
+  return _zenCompat;
+}
+var _directAnthropic = null;
+var _directOpenAI = null;
+var _directGoogle = null;
+function directAnthropic() {
+  if (!_directAnthropic) {
+    const key = process.env.ANTHROPIC_API_KEY;
+    if (!key)
+      throw new Error("ANTHROPIC_API_KEY is not set");
+    _directAnthropic = createAnthropic({ apiKey: key });
+  }
+  return _directAnthropic;
+}
+function directOpenAI() {
+  if (!_directOpenAI) {
+    const key = process.env.OPENAI_API_KEY;
+    if (!key)
+      throw new Error("OPENAI_API_KEY is not set");
+    _directOpenAI = createOpenAI({ apiKey: key });
+  }
+  return _directOpenAI;
+}
+function directGoogle() {
+  if (!_directGoogle) {
+    const key = process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
+    if (!key)
+      throw new Error("GOOGLE_API_KEY or GEMINI_API_KEY is not set");
+    _directGoogle = createGoogleGenerativeAI({ apiKey: key });
+  }
+  return _directGoogle;
+}
+var CONTEXT_WINDOW_TABLE = [
+  [/^claude-/, 200000],
+  [/^gemini-/, 1e6],
+  [/^gpt-5/, 128000],
+  [/^gpt-4/, 128000],
+  [/^kimi-k2/, 262000],
+  [/^minimax-m2/, 196000],
+  [/^glm-/, 128000],
+  [/^qwen3-/, 131000]
+];
+function getContextWindow(modelString) {
+  const modelId = modelString.includes("/") ? modelString.slice(modelString.indexOf("/") + 1) : modelString;
+  for (const [pattern, tokens] of CONTEXT_WINDOW_TABLE) {
+    if (pattern.test(modelId))
+      return tokens;
+  }
+  return null;
+}
+function resolveModel(modelString) {
+  const slashIdx = modelString.indexOf("/");
+  if (slashIdx === -1) {
+    throw new Error(`Invalid model string "${modelString}". Expected format: "<provider>/<model-id>"`);
+  }
+  const provider = modelString.slice(0, slashIdx);
+  const modelId = modelString.slice(slashIdx + 1);
+  switch (provider) {
+    case "zen": {
+      if (ZEN_ANTHROPIC_MODELS.has(modelId)) {
+        return zenAnthropic()(modelId);
+      }
+      if (ZEN_OPENAI_MODELS.has(modelId)) {
+        return zenOpenAI()(modelId);
+      }
+      if (ZEN_GOOGLE_MODELS.has(modelId)) {
+        return zenGoogle(modelId)(modelId);
+      }
+      return zenCompat()(modelId);
+    }
+    case "anthropic":
+      return directAnthropic()(modelId);
+    case "openai":
+      return directOpenAI()(modelId);
+    case "google":
+      return directGoogle()(modelId);
+    case "ollama": {
+      const baseURL = process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
+      const ollamaProvider = createOllama({ baseURL });
+      return ollamaProvider(modelId);
+    }
+    default:
+      throw new Error(`Unknown provider "${provider}". Supported: zen, anthropic, openai, google, ollama`);
+  }
+}
+function autoDiscoverModel() {
+  if (process.env.OPENCODE_API_KEY)
+    return "zen/claude-sonnet-4-6";
+  if (process.env.ANTHROPIC_API_KEY)
+    return "anthropic/claude-sonnet-4-5-20250929";
+  if (process.env.OPENAI_API_KEY)
+    return "openai/gpt-4o";
+  if (process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY)
+    return "google/gemini-2.0-flash";
+  return "ollama/llama3.2";
+}
+async function fetchZenModels() {
+  const key = process.env.OPENCODE_API_KEY;
+  if (!key)
+    return [];
+  try {
+    const res = await fetch(`${ZEN_BASE}/models`, {
+      headers: { Authorization: `Bearer ${key}` },
+      signal: AbortSignal.timeout(8000)
+    });
+    if (!res.ok)
+      return [];
+    const json = await res.json();
+    const models = json.data ?? [];
+    return models.map((m) => ({
+      id: `zen/${m.id}`,
+      displayName: m.id,
+      provider: "zen",
+      context: m.context_window,
+      free: m.id.endsWith("-free") || m.id === "gpt-5-nano" || m.id === "big-pickle"
+    }));
+  } catch {
+    return [];
+  }
+}
+async function fetchOllamaModels() {
+  const base = process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
+  try {
+    const res = await fetch(`${base}/api/tags`, {
+      signal: AbortSignal.timeout(3000)
+    });
+    if (!res.ok)
+      return [];
+    const json = await res.json();
+    return (json.models ?? []).map((m) => ({
+      id: `ollama/${m.name}`,
+      displayName: m.name + (m.details?.parameter_size ? ` (${m.details.parameter_size})` : ""),
+      provider: "ollama"
+    }));
+  } catch {
+    return [];
+  }
+}
+async function fetchAvailableModels() {
+  const [zen, ollama] = await Promise.all([
+    fetchZenModels(),
+    fetchOllamaModels()
+  ]);
+  return [...zen, ...ollama];
+}
+
+// src/session/db.ts
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync, unlinkSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function getConfigDir() {
+  return join(homedir(), ".config", "mini-coder");
+}
+function getDbPath() {
+  const dir = getConfigDir();
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+  return join(dir, "sessions.db");
+}
+var DB_VERSION = 3;
+var SCHEMA = `
+  CREATE TABLE IF NOT EXISTS sessions (
+    id          TEXT PRIMARY KEY,
+    title       TEXT NOT NULL DEFAULT '',
+    cwd         TEXT NOT NULL,
+    model       TEXT NOT NULL,
+    created_at  INTEGER NOT NULL,
+    updated_at  INTEGER NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS messages (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id  TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+    payload     TEXT NOT NULL,
+    turn_index  INTEGER NOT NULL DEFAULT 0,
+    created_at  INTEGER NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS prompt_history (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    text        TEXT NOT NULL,
+    created_at  INTEGER NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS mcp_servers (
+    name        TEXT PRIMARY KEY,
+    transport   TEXT NOT NULL,
+    url         TEXT,
+    command     TEXT,
+    args        TEXT,
+    env         TEXT,
+    created_at  INTEGER NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_messages_session
+    ON messages(session_id, id);
+
+  CREATE INDEX IF NOT EXISTS idx_messages_turn
+    ON messages(session_id, turn_index);
+
+  CREATE INDEX IF NOT EXISTS idx_sessions_updated
+    ON sessions(updated_at DESC);
+
+  CREATE TABLE IF NOT EXISTS settings (
+    key         TEXT PRIMARY KEY,
+    value       TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS snapshots (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id  TEXT    NOT NULL,
+    turn_index  INTEGER NOT NULL,
+    path        TEXT    NOT NULL,
+    content     BLOB,
+    existed     INTEGER NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_snapshots_turn
+    ON snapshots(session_id, turn_index);
+`;
+var _db = null;
+function getDb() {
+  if (!_db) {
+    const dbPath = getDbPath();
+    let db = new Database(dbPath, { create: true });
+    db.exec("PRAGMA journal_mode=WAL;");
+    db.exec("PRAGMA foreign_keys=ON;");
+    const version = db.query("PRAGMA user_version").get()?.user_version ?? 0;
+    if (version !== DB_VERSION) {
+      try {
+        db.close();
+      } catch {}
+      for (const path of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+        if (existsSync(path))
+          unlinkSync(path);
+      }
+      db = new Database(dbPath, { create: true });
+      db.exec("PRAGMA journal_mode=WAL;");
+      db.exec("PRAGMA foreign_keys=ON;");
+      db.exec(SCHEMA);
+      db.exec(`PRAGMA user_version = ${DB_VERSION};`);
+    } else {
+      db.exec(SCHEMA);
+    }
+    _db = db;
+  }
+  return _db;
+}
+function createSession(opts) {
+  const db = getDb();
+  const now = Date.now();
+  db.run(`INSERT INTO sessions (id, title, cwd, model, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?)`, [opts.id, opts.title ?? "", opts.cwd, opts.model, now, now]);
+  const session = getSession(opts.id);
+  if (!session) {
+    throw new Error(`Failed to create session ${opts.id}`);
+  }
+  return session;
+}
+function getSession(id) {
+  return getDb().query("SELECT * FROM sessions WHERE id = ?").get(id) ?? null;
+}
+function touchSession(id, model) {
+  getDb().run("UPDATE sessions SET updated_at = ?, model = ? WHERE id = ?", [
+    Date.now(),
+    model,
+    id
+  ]);
+}
+function listSessions(limit = 20) {
+  return getDb().query("SELECT * FROM sessions ORDER BY updated_at DESC LIMIT ?").all(limit);
+}
+function saveMessages(sessionId, msgs, turnIndex = 0) {
+  const db = getDb();
+  const stmt = db.prepare(`INSERT INTO messages (session_id, payload, turn_index, created_at)
+     VALUES (?, ?, ?, ?)`);
+  const now = Date.now();
+  for (const msg of msgs) {
+    stmt.run(sessionId, JSON.stringify(msg), turnIndex, now);
+  }
+}
+function getMaxTurnIndex(sessionId) {
+  const row = getDb().query("SELECT MAX(turn_index) AS max_turn FROM messages WHERE session_id = ?").get(sessionId);
+  return row?.max_turn ?? -1;
+}
+function deleteLastTurn(sessionId, turnIndex) {
+  const target = turnIndex !== undefined ? turnIndex : getMaxTurnIndex(sessionId);
+  if (target < 0)
+    return false;
+  getDb().run("DELETE FROM messages WHERE session_id = ? AND turn_index = ?", [
+    sessionId,
+    target
+  ]);
+  return true;
+}
+function loadMessages(sessionId) {
+  const rows = getDb().query("SELECT payload FROM messages WHERE session_id = ? ORDER BY id ASC").all(sessionId);
+  return rows.map((row) => JSON.parse(row.payload));
+}
+function addPromptHistory(text) {
+  if (!text.trim())
+    return;
+  getDb().run("INSERT INTO prompt_history (text, created_at) VALUES (?, ?)", [
+    text.trim(),
+    Date.now()
+  ]);
+}
+function getPromptHistory(limit = 200) {
+  const rows = getDb().query("SELECT text FROM prompt_history ORDER BY id DESC LIMIT ?").all(limit);
+  return rows.map((r) => r.text).reverse();
+}
+function listMcpServers() {
+  return getDb().query("SELECT name, transport, url, command, args, env FROM mcp_servers ORDER BY name").all();
+}
+function upsertMcpServer(server) {
+  getDb().run(`INSERT INTO mcp_servers (name, transport, url, command, args, env, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(name) DO UPDATE SET
+       transport = excluded.transport,
+       url       = excluded.url,
+       command   = excluded.command,
+       args      = excluded.args,
+       env       = excluded.env`, [
+    server.name,
+    server.transport,
+    server.url ?? null,
+    server.command ?? null,
+    server.args ?? null,
+    server.env ?? null,
+    Date.now()
+  ]);
+}
+function deleteMcpServer(name) {
+  getDb().run("DELETE FROM mcp_servers WHERE name = ?", [name]);
+}
+function getSetting(key) {
+  const row = getDb().query("SELECT value FROM settings WHERE key = ?").get(key);
+  return row?.value ?? null;
+}
+function setSetting(key, value) {
+  getDb().run(`INSERT INTO settings (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`, [key, value]);
+}
+function getPreferredModel() {
+  return getSetting("preferred_model");
+}
+function setPreferredModel(model) {
+  setSetting("preferred_model", model);
+}
+function saveSnapshot(sessionId, turnIndex, files) {
+  const db = getDb();
+  const stmt = db.prepare(`INSERT INTO snapshots (session_id, turn_index, path, content, existed)
+     VALUES (?, ?, ?, ?, ?)`);
+  const insert = db.transaction(() => {
+    for (const f of files) {
+      stmt.run(sessionId, turnIndex, f.path, f.content ?? null, f.existed ? 1 : 0);
+    }
+  });
+  insert();
+}
+function loadSnapshot(sessionId, turnIndex) {
+  const rows = getDb().query("SELECT path, content, existed FROM snapshots WHERE session_id = ? AND turn_index = ?").all(sessionId, turnIndex);
+  return rows.map((r) => ({
+    path: r.path,
+    content: r.content ?? null,
+    existed: r.existed === 1
+  }));
+}
+function deleteSnapshot(sessionId, turnIndex) {
+  getDb().run("DELETE FROM snapshots WHERE session_id = ? AND turn_index = ?", [
+    sessionId,
+    turnIndex
+  ]);
+}
+function deleteAllSnapshots(sessionId) {
+  getDb().run("DELETE FROM snapshots WHERE session_id = ?", [sessionId]);
+}
+function generateSessionId() {
+  const ts = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 7);
+  return `${ts}-${rand}`;
+}
+
+// src/cli/markdown.ts
+import * as c from "yoctocolors";
+function renderInline(text) {
+  let out = "";
+  let i = 0;
+  let prevWasBoldClose = false;
+  while (i < text.length) {
+    if (text[i] === "`") {
+      const end = text.indexOf("`", i + 1);
+      if (end !== -1) {
+        out += c.yellow(text.slice(i, end + 1));
+        i = end + 1;
+        prevWasBoldClose = false;
+        continue;
+      }
+    }
+    if (text.slice(i, i + 2) === "**" && text[i + 2] !== "*") {
+      const end = text.indexOf("**", i + 2);
+      if (end !== -1) {
+        out += c.bold(text.slice(i + 2, end));
+        i = end + 2;
+        prevWasBoldClose = true;
+        continue;
+      }
+    }
+    if (text[i] === "*" && text[i + 1] !== "*" && (prevWasBoldClose || text[i - 1] !== "*")) {
+      const end = text.indexOf("*", i + 1);
+      if (end !== -1 && text[end - 1] !== "*") {
+        out += c.dim(text.slice(i + 1, end));
+        i = end + 1;
+        prevWasBoldClose = false;
+        continue;
+      }
+    }
+    out += text[i];
+    i++;
+    prevWasBoldClose = false;
+  }
+  return out;
+}
+function renderLine(raw, inFence) {
+  if (/^(`{3,}|~{3,})/.test(raw)) {
+    return { output: c.dim(raw), inFence: !inFence };
+  }
+  if (inFence) {
+    return { output: c.yellow(raw), inFence: true };
+  }
+  if (/^(-{3,}|\*{3,}|={3,})\s*$/.test(raw)) {
+    return { output: c.dim("\u2500".repeat(40)), inFence: false };
+  }
+  const h3 = raw.match(/^(#{3,})\s+(.*)/);
+  if (h3)
+    return { output: c.bold(renderInline(h3[2] ?? "")), inFence: false };
+  const h2 = raw.match(/^##\s+(.*)/);
+  if (h2)
+    return {
+      output: c.bold(c.cyan(renderInline(h2[1] ?? ""))),
+      inFence: false
+    };
+  const h1 = raw.match(/^#\s+(.*)/);
+  if (h1)
+    return {
+      output: c.bold(c.cyan(renderInline(h1[1] ?? ""))),
+      inFence: false
+    };
+  const bq = raw.match(/^>\s?(.*)/);
+  if (bq)
+    return {
+      output: c.dim(`\u2502 ${renderInline(bq[1] ?? "")}`),
+      inFence: false
+    };
+  const ul = raw.match(/^(\s*)[*\-+]\s+(.*)/);
+  if (ul) {
+    const indent = ul[1] ?? "";
+    return {
+      output: `${indent}${c.dim("\xB7")} ${renderInline(ul[2] ?? "")}`,
+      inFence: false
+    };
+  }
+  const ol = raw.match(/^(\s*)(\d+)\.\s+(.*)/);
+  if (ol) {
+    const indent = ol[1] ?? "";
+    const num = ol[2] ?? "";
+    return {
+      output: `${indent}${c.dim(`${num}.`)} ${renderInline(ol[3] ?? "")}`,
+      inFence: false
+    };
+  }
+  return { output: renderInline(raw), inFence: false };
+}
+function renderMarkdown(text) {
+  let inFence = false;
+  return text.split(`
+`).map((raw) => {
+    const r = renderLine(raw, inFence);
+    inFence = r.inFence;
+    return r.output;
+  }).join(`
+`);
+}
+function renderChunk(text, inFence) {
+  let fence = inFence;
+  const output = text.split(`
+`).map((raw) => {
+    const r = renderLine(raw, fence);
+    fence = r.inFence;
+    return r.output;
+  }).join(`
+`);
+  return { output, inFence: fence };
+}
+
+// src/cli/output.ts
+import { homedir as homedir2 } from "os";
+import * as c2 from "yoctocolors";
+var HOME = homedir2();
+var PACKAGE_VERSION = "0.0.3";
+function restoreTerminal() {
+  try {
+    process.stderr.write("\x1B[?25h");
+    process.stderr.write("\r\x1B[2K");
+  } catch {}
+  try {
+    if (process.stdin.isTTY && process.stdin.isRaw) {
+      process.stdin.setRawMode(false);
+    }
+  } catch {}
+}
+function registerTerminalCleanup() {
+  const cleanup = () => restoreTerminal();
+  process.on("exit", cleanup);
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
+  process.on("SIGINT", () => {
+    if (process.listenerCount("SIGINT") > 1)
+      return;
+    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));
+  });
+}
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+
+class Spinner {
+  frame = 0;
+  timer = null;
+  label = "";
+  start(label = "") {
+    this.label = label;
+    if (this.timer)
+      return;
+    process.stderr.write("\x1B[?25l");
+    this._tick();
+    this.timer = setInterval(() => this._tick(), 80);
+  }
+  stop() {
+    if (!this.timer)
+      return;
+    clearInterval(this.timer);
+    this.timer = null;
+    process.stderr.write("\r\x1B[2K\x1B[?25h");
+  }
+  update(label) {
+    this.label = label;
+  }
+  _tick() {
+    const f = FRAMES[this.frame++ % FRAMES.length] ?? "\u280B";
+    const label = this.label ? c2.dim(` ${this.label}`) : "";
+    process.stderr.write(`\r${c2.dim(f)}${label}`);
+  }
+}
+function writeln(text = "") {
+  process.stdout.write(`${text}
+`);
+}
+function write(text) {
+  process.stdout.write(text);
+}
+function stripHashlinePrefix(text) {
+  return text.replace(/^\d+:[0-9a-f]{2}\| /, "");
+}
+var G = {
+  prompt: c2.green("\u203A"),
+  reply: c2.cyan("\u25C6"),
+  search: c2.yellow("?"),
+  read: c2.dim("\u2190"),
+  write: c2.green("\u270E"),
+  run: c2.dim("$"),
+  agent: c2.cyan("\u21E2"),
+  mcp: c2.yellow("\u2699"),
+  ok: c2.green("\u2714"),
+  err: c2.red("\u2716"),
+  warn: c2.yellow("!"),
+  info: c2.dim("\xB7"),
+  diff_add: c2.green("+"),
+  diff_del: c2.red("-"),
+  diff_hdr: c2.cyan("@")
+};
+function toolGlyph(name) {
+  if (name === "glob" || name === "grep")
+    return G.search;
+  if (name === "read")
+    return G.read;
+  if (name === "create" || name === "replace" || name === "insert")
+    return G.write;
+  if (name === "shell")
+    return G.run;
+  if (name === "subagent")
+    return G.agent;
+  if (name.startsWith("mcp_"))
+    return G.mcp;
+  return G.info;
+}
+function toolCallLine(name, args) {
+  const a = args && typeof args === "object" ? args : {};
+  if (name === "glob") {
+    const pattern = String(a.pattern ?? "");
+    const cwd = a.cwd ? String(a.cwd) : "";
+    return `${G.search} ${c2.dim("glob")} ${c2.bold(pattern)}${cwd ? c2.dim(` in ${cwd}`) : ""}`;
+  }
+  if (name === "grep") {
+    const flags = [
+      a.include ? String(a.include) : null,
+      a.caseSensitive === false ? "i" : null
+    ].filter(Boolean).join(" ");
+    const pattern = String(a.pattern ?? "");
+    return `${G.search} ${c2.dim("grep")} ${c2.bold(pattern)}${flags ? c2.dim(`  ${flags}`) : ""}`;
+  }
+  if (name === "read") {
+    const line = Number.isFinite(a.line) ? Number(a.line) : null;
+    const count = Number.isFinite(a.count) ? Number(a.count) : null;
+    const range = line || count ? c2.dim(`:${line ?? 1}${count ? `+${count}` : ""}`) : "";
+    return `${G.read} ${c2.dim("read")} ${String(a.path ?? "")}${range}`;
+  }
+  if (name === "create") {
+    return `${G.write} ${c2.dim("create")} ${c2.bold(String(a.path ?? ""))}`;
+  }
+  if (name === "replace") {
+    const range = a.endAnchor ? c2.dim(` ${a.startAnchor}\u2013${a.endAnchor}`) : c2.dim(` ${a.startAnchor}`);
+    const verb = a.newContent === undefined || a.newContent === "" ? "delete" : "replace";
+    return `${G.write} ${c2.dim(verb)} ${c2.bold(String(a.path ?? ""))}${range}`;
+  }
+  if (name === "insert") {
+    return `${G.write} ${c2.dim(`insert ${a.position ?? ""}`)} ${c2.bold(String(a.path ?? ""))}${c2.dim(` @ ${a.anchor}`)}`;
+  }
+  if (name === "shell") {
+    const cmd = String(a.command ?? "");
+    const shortCmd = cmd.length > 72 ? `${cmd.slice(0, 69)}\u2026` : cmd;
+    return `${G.run} ${c2.dim("$")} ${shortCmd}`;
+  }
+  if (name === "subagent") {
+    const prompt = String(a.prompt ?? "");
+    const shortPrompt = prompt.length > 60 ? `${prompt.slice(0, 57)}\u2026` : prompt;
+    return `${G.agent} ${c2.dim("subagent")} ${c2.dim(shortPrompt)}`;
+  }
+  if (name.startsWith("mcp_")) {
+    return `${G.mcp} ${c2.dim(name)}`;
+  }
+  return `${toolGlyph(name)} ${c2.dim(name)}`;
+}
+function renderToolCall(toolName, args) {
+  writeln(`  ${toolCallLine(toolName, args)}`);
+}
+function renderHook(toolName, scriptPath, success) {
+  const short = scriptPath.replace(HOME, "~");
+  if (success) {
+    writeln(`    ${G.ok} ${c2.dim(`hook post-${toolName}`)}`);
+  } else {
+    writeln(`    ${G.err} ${c2.red(`hook post-${toolName} failed`)} ${c2.dim(short)}`);
+  }
+}
+function renderToolResultInline(toolName, result, isError, indent) {
+  if (isError) {
+    const msg = typeof result === "string" ? result : result instanceof Error ? result.message : JSON.stringify(result);
+    const oneLiner = msg.split(`
+`)[0] ?? msg;
+    writeln(`${indent}${G.err} ${c2.red(oneLiner)}`);
+    return;
+  }
+  if (toolName === "glob") {
+    const r = result;
+    const n = r.files.length;
+    writeln(`${indent}${G.info} ${c2.dim(n === 0 ? "no matches" : `${n} file${n === 1 ? "" : "s"}${r.truncated ? " (capped)" : ""}`)}`);
+    return;
+  }
+  if (toolName === "grep") {
+    const r = result;
+    const n = r.matches.length;
+    writeln(`${indent}${G.info} ${c2.dim(n === 0 ? "no matches" : `${n} match${n === 1 ? "" : "es"}${r.truncated ? " (capped)" : ""}`)}`);
+    return;
+  }
+  if (toolName === "read") {
+    const r = result;
+    writeln(`${indent}${G.info} ${c2.dim(`${r.totalLines} lines${r.truncated ? " (truncated)" : ""}`)}`);
+    return;
+  }
+  if (toolName === "create") {
+    const r = result;
+    const verb = r.created ? c2.green("created") : c2.dim("overwritten");
+    writeln(`${indent}${G.ok} ${verb} ${r.path}`);
+    return;
+  }
+  if (toolName === "replace" || toolName === "insert") {
+    const r = result;
+    const verb = toolName === "insert" ? "inserted" : r.deleted ? "deleted" : "replaced";
+    writeln(`${indent}${G.ok} ${c2.dim(verb)} ${r.path}`);
+    return;
+  }
+  if (toolName === "shell") {
+    const r = result;
+    const badge = r.timedOut ? c2.yellow("timeout") : r.success ? c2.green(`\u2714 ${r.exitCode}`) : c2.red(`\u2716 ${r.exitCode}`);
+    writeln(`${indent}${badge}`);
+    return;
+  }
+  if (toolName === "subagent") {
+    const r = result;
+    if (r.inputTokens || r.outputTokens) {
+      writeln(`${indent}${G.ok} ${c2.dim(`\u2191${r.inputTokens ?? 0} \u2193${r.outputTokens ?? 0}`)}`);
+    }
+    return;
+  }
+  if (toolName.startsWith("mcp_")) {
+    const content = Array.isArray(result) ? result : [result];
+    const first = content[0];
+    if (first?.type === "text" && first.text) {
+      const oneLiner = first.text.split(`
+`)[0] ?? "";
+      if (oneLiner)
+        writeln(`${indent}${G.info} ${c2.dim(oneLiner.length > 80 ? `${oneLiner.slice(0, 77)}\u2026` : oneLiner)}`);
+    }
+    return;
+  }
+  const text = JSON.stringify(result);
+  writeln(`${indent}${G.info} ${c2.dim(text.length > 80 ? `${text.slice(0, 77)}\u2026` : text)}`);
+}
+function renderSubagentActivity(activity, indent, maxDepth) {
+  for (const entry of activity) {
+    writeln(`${indent}${toolCallLine(entry.toolName, entry.args)}`);
+    if (entry.toolName === "subagent" && maxDepth > 0) {
+      const nested = entry.result;
+      if (nested?.activity?.length) {
+        renderSubagentActivity(nested.activity, `${indent}  `, maxDepth - 1);
+      }
+    }
+    renderToolResultInline(entry.toolName, entry.result, entry.isError, `${indent}  `);
+  }
+}
+function renderToolResult(toolName, result, isError) {
+  if (isError) {
+    const msg = typeof result === "string" ? result : result instanceof Error ? result.message : JSON.stringify(result);
+    const oneLiner = msg.split(`
+`)[0] ?? msg;
+    writeln(`    ${G.err} ${c2.red(oneLiner)}`);
+    return;
+  }
+  if (toolName === "glob") {
+    const r = result;
+    const files = r.files;
+    if (files.length === 0) {
+      writeln(`    ${G.info} ${c2.dim("no matches")}`);
+      return;
+    }
+    const show = files.slice(0, 12);
+    const rest = files.length - show.length;
+    const prefix = commonPrefix(show);
+    for (const f of show) {
+      const rel = prefix && f.startsWith(prefix) ? c2.dim(prefix) + f.slice(prefix.length) : f;
+      writeln(`    ${c2.dim("\xB7")} ${rel}`);
+    }
+    if (rest > 0)
+      writeln(`    ${c2.dim(`  +${rest} more`)}`);
+    if (r.truncated)
+      writeln(`    ${c2.dim("  (results capped)")}`);
+    return;
+  }
+  if (toolName === "grep") {
+    const r = result;
+    if (r.matches.length === 0) {
+      writeln(`    ${G.info} ${c2.dim("no matches")}`);
+      return;
+    }
+    const seen = new Set;
+    let shown = 0;
+    for (const m of r.matches) {
+      if (shown >= 10)
+        break;
+      const key = m.file;
+      const fileLabel = seen.has(key) ? c2.dim(" ".repeat(m.file.length + 1)) : c2.dim(`${m.file}:`);
+      seen.add(key);
+      writeln(`    ${fileLabel}${c2.dim(String(m.line))}  ${stripHashlinePrefix(m.text).trim()}`);
+      shown++;
+    }
+    const rest = r.matches.length - shown;
+    if (rest > 0)
+      writeln(`    ${c2.dim(`  +${rest} more`)}`);
+    if (r.truncated)
+      writeln(`    ${c2.dim("  (results capped)")}`);
+    return;
+  }
+  if (toolName === "read") {
+    const r = result;
+    const linesReturned = r.content ? r.content.split(`
+`).length : 0;
+    const endLine = linesReturned > 0 ? r.line + linesReturned - 1 : r.line;
+    const range = r.line === 1 && endLine === r.totalLines ? `${r.totalLines} lines` : `lines ${r.line}\u2013${endLine} of ${r.totalLines}`;
+    writeln(`    ${G.info} ${c2.dim(`${r.path}  ${range}${r.truncated ? "  (truncated)" : ""}`)}`);
+    return;
+  }
+  if (toolName === "create") {
+    const r = result;
+    const verb = r.created ? c2.green("created") : c2.dim("overwritten");
+    writeln(`    ${G.ok} ${verb} ${r.path}`);
+    renderDiff(r.diff);
+    return;
+  }
+  if (toolName === "replace" || toolName === "insert") {
+    const r = result;
+    const verb = toolName === "insert" ? "inserted" : r.deleted ? "deleted" : "replaced";
+    writeln(`    ${G.ok} ${c2.dim(verb)} ${r.path}`);
+    renderDiff(r.diff);
+    return;
+  }
+  if (toolName === "shell") {
+    const r = result;
+    const badge = r.timedOut ? c2.yellow("timeout") : r.success ? c2.green(`\u2714 ${r.exitCode}`) : c2.red(`\u2716 ${r.exitCode}`);
+    writeln(`    ${badge}`);
+    const outLines = r.stdout ? r.stdout.split(`
+`) : [];
+    const errLines = r.stderr ? r.stderr.split(`
+`) : [];
+    for (const line of outLines.slice(0, 20)) {
+      writeln(`    ${c2.dim("\u2502")} ${line}`);
+    }
+    if (outLines.length > 20)
+      writeln(`    ${c2.dim(`\u2502 \u2026 +${outLines.length - 20} lines`)}`);
+    for (const line of errLines.slice(0, 8)) {
+      if (line.trim())
+        writeln(`    ${c2.red("\u2502")} ${c2.dim(line)}`);
+    }
+    if (errLines.length > 8)
+      writeln(`    ${c2.red(`\u2502 \u2026 +${errLines.length - 8} lines`)}`);
+    return;
+  }
+  if (toolName === "subagent") {
+    const r = result;
+    if (r.activity?.length) {
+      renderSubagentActivity(r.activity, "    ", 1);
+    }
+    if (r.result) {
+      const lines = r.result.split(`
+`);
+      const preview = lines.slice(0, 8);
+      for (const line of preview)
+        writeln(`    ${c2.dim("\u2502")} ${line}`);
+      if (lines.length > 8)
+        writeln(`    ${c2.dim(`\u2502 \u2026 +${lines.length - 8} lines`)}`);
+    }
+    if (r.inputTokens || r.outputTokens) {
+      writeln(`    ${c2.dim(`\u2191${r.inputTokens ?? 0} \u2193${r.outputTokens ?? 0}`)}`);
+    }
+    return;
+  }
+  if (toolName.startsWith("mcp_")) {
+    const content = Array.isArray(result) ? result : [result];
+    for (const block of content.slice(0, 5)) {
+      if (block?.type === "text" && block.text) {
+        const lines = block.text.split(`
+`).slice(0, 6);
+        for (const l of lines)
+          writeln(`    ${c2.dim("\u2502")} ${l}`);
+      }
+    }
+    return;
+  }
+  const text = JSON.stringify(result);
+  writeln(`    ${c2.dim(text.length > 120 ? `${text.slice(0, 117)}\u2026` : text)}`);
+}
+function renderDiff(diff) {
+  if (!diff || diff === "(no changes)")
+    return;
+  for (const line of diff.split(`
+`)) {
+    if (line.startsWith("+++") || line.startsWith("---")) {
+      writeln(`    ${c2.dim(line)}`);
+    } else if (line.startsWith("+")) {
+      writeln(`    ${c2.green(line)}`);
+    } else if (line.startsWith("-")) {
+      writeln(`    ${c2.red(line)}`);
+    } else if (line.startsWith("@@")) {
+      writeln(`    ${c2.cyan(line)}`);
+    } else {
+      writeln(`    ${c2.dim(line)}`);
+    }
+  }
+}
+async function renderTurn(events, spinner) {
+  let inText = false;
+  let rawBuffer = "";
+  let inFence = false;
+  let printQueue = "";
+  let printPos = 0;
+  let tickerHandle = null;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let contextTokens = 0;
+  let newMessages = [];
+  function enqueuePrint(ansi) {
+    printQueue += ansi;
+    if (tickerHandle === null) {
+      scheduleTick();
+    }
+  }
+  function tick() {
+    tickerHandle = null;
+    if (printPos < printQueue.length) {
+      process.stdout.write(printQueue[printPos]);
+      printPos++;
+      scheduleTick();
+    } else {
+      printQueue = "";
+      printPos = 0;
+    }
+  }
+  function scheduleTick() {
+    tickerHandle = setTimeout(tick, 8);
+  }
+  function drainQueue() {
+    if (tickerHandle !== null) {
+      clearTimeout(tickerHandle);
+      tickerHandle = null;
+    }
+    if (printPos < printQueue.length) {
+      process.stdout.write(printQueue.slice(printPos));
+    }
+    printQueue = "";
+    printPos = 0;
+  }
+  function renderAndTrim(end) {
+    const chunk = rawBuffer.slice(0, end);
+    const rendered = renderChunk(chunk, inFence);
+    inFence = rendered.inFence;
+    enqueuePrint(rendered.output);
+    rawBuffer = rawBuffer.slice(end);
+  }
+  function flushChunks() {
+    let boundary = rawBuffer.indexOf(`
+
+`);
+    if (boundary !== -1) {
+      renderAndTrim(boundary + 2);
+      flushChunks();
+      return;
+    }
+    boundary = rawBuffer.lastIndexOf(`
+`);
+    if (boundary !== -1) {
+      renderAndTrim(boundary + 1);
+    }
+  }
+  function flushAll() {
+    if (rawBuffer) {
+      renderAndTrim(rawBuffer.length);
+    }
+    drainQueue();
+  }
+  for await (const event of events) {
+    switch (event.type) {
+      case "text-delta": {
+        if (!inText) {
+          spinner.stop();
+          process.stdout.write(`${G.reply} `);
+          inText = true;
+        }
+        rawBuffer += event.delta;
+        flushChunks();
+        break;
+      }
+      case "tool-call-start": {
+        if (inText) {
+          flushAll();
+          writeln();
+          inText = false;
+        }
+        spinner.stop();
+        renderToolCall(event.toolName, event.args);
+        spinner.start(event.toolName);
+        break;
+      }
+      case "tool-result": {
+        spinner.stop();
+        renderToolResult(event.toolName, event.result, event.isError);
+        spinner.start("thinking");
+        break;
+      }
+      case "turn-complete": {
+        if (inText) {
+          flushAll();
+          writeln();
+          inText = false;
+        }
+        spinner.stop();
+        inputTokens = event.inputTokens;
+        outputTokens = event.outputTokens;
+        contextTokens = event.contextTokens;
+        newMessages = event.messages;
+        break;
+      }
+      case "turn-error": {
+        if (inText) {
+          flushAll();
+          writeln();
+          inText = false;
+        }
+        spinner.stop();
+        const isAbort = event.error.name === "AbortError" || event.error.name === "Error" && event.error.message.toLowerCase().includes("abort");
+        if (isAbort) {
+          writeln(`${G.warn} ${c2.dim("interrupted")}`);
+        } else {
+          const msg = event.error.message.split(`
+`)[0] ?? event.error.message;
+          writeln(`${G.err} ${c2.red(msg)}`);
+        }
+        break;
+      }
+    }
+  }
+  return { inputTokens, outputTokens, contextTokens, newMessages };
+}
+function renderStatusBar(opts) {
+  const cols = process.stdout.columns ?? 80;
+  const left = [c2.cyan(opts.model)];
+  if (opts.provider && opts.provider !== "zen")
+    left.push(c2.dim(opts.provider));
+  left.push(c2.dim(opts.sessionId.slice(0, 8)));
+  if (opts.ralphMode)
+    left.push(c2.magenta("\u21BB ralph"));
+  const right = [];
+  if (opts.inputTokens > 0 || opts.outputTokens > 0) {
+    right.push(c2.dim(`\u2191${fmtTokens(opts.inputTokens)} \u2193${fmtTokens(opts.outputTokens)}`));
+  }
+  if (opts.contextTokens > 0) {
+    const ctxRaw = fmtTokens(opts.contextTokens);
+    if (opts.contextWindow !== null) {
+      const pct = Math.round(opts.contextTokens / opts.contextWindow * 100);
+      const ctxMax = fmtTokens(opts.contextWindow);
+      const pctStr = `${pct}%`;
+      const colored = pct >= 90 ? c2.red(pctStr) : pct >= 75 ? c2.yellow(pctStr) : c2.dim(pctStr);
+      right.push(c2.dim(`ctx ${ctxRaw}/${ctxMax} `) + colored);
+    } else {
+      right.push(c2.dim(`ctx ${ctxRaw}`));
+    }
+  }
+  if (opts.gitBranch)
+    right.push(c2.dim(`\u2387 ${opts.gitBranch}`));
+  const cwdDisplay = opts.cwd;
+  const middle = c2.dim(cwdDisplay);
+  const sep = c2.dim("  ");
+  const full = [...left, middle, ...right.reverse()].join(sep);
+  const visible = stripAnsi(full);
+  const out = visible.length > cols ? truncateAnsi(full, cols - 1) : full;
+  process.stdout.write(`${out}
+`);
+}
+function renderBanner(model, cwd) {
+  writeln();
+  writeln(`  ${c2.cyan("mc")}  ${c2.dim(`mini-coder \xB7 v${PACKAGE_VERSION}`)}`);
+  writeln(`  ${c2.dim(model)}  ${c2.dim("\xB7")}  ${c2.dim(cwd)}`);
+  writeln(`  ${c2.dim("/help for commands  \xB7  ctrl+d to exit")}`);
+  writeln();
+}
+function renderError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  writeln(`${G.err} ${c2.red(msg)}`);
+}
+function renderInfo(msg) {
+  writeln(`${G.info} ${c2.dim(msg)}`);
+}
+function fmtTokens(n) {
+  if (n >= 1000)
+    return `${(n / 1000).toFixed(1)}k`;
+  return String(n);
+}
+function commonPrefix(paths) {
+  const first = paths[0];
+  if (!first)
+    return "";
+  const parts = first.split("/");
+  let prefix = "";
+  for (let i = 0;i < parts.length - 1; i++) {
+    const candidate = `${parts.slice(0, i + 1).join("/")}/`;
+    if (paths.every((p) => p.startsWith(candidate)))
+      prefix = candidate;
+    else
+      break;
+  }
+  return prefix;
+}
+var ANSI_ESCAPE = "\x1B";
+function stripAnsi(s) {
+  if (!s.includes(ANSI_ESCAPE))
+    return s;
+  return s.split(ANSI_ESCAPE).map((chunk, idx) => idx === 0 ? chunk : chunk.replace(/^\[[0-9;]*m/, "")).join("");
+}
+function truncateAnsi(s, maxLen) {
+  const plain = stripAnsi(s);
+  if (plain.length <= maxLen)
+    return s;
+  let visible = 0;
+  let i = 0;
+  while (i < s.length && visible < maxLen - 1) {
+    if (s[i] === "\x1B") {
+      while (i < s.length && s[i] !== "m")
+        i++;
+    } else {
+      visible++;
+    }
+    i++;
+  }
+  return s.slice(0, i) + c2.dim("\u2026");
+}
+var PREFIX = {
+  user: G.prompt,
+  assistant: G.reply,
+  tool: G.mcp,
+  error: G.err,
+  info: G.info,
+  success: G.ok
+};
+
+// src/cli/commands.ts
+async function handleModel(ctx, args) {
+  if (args) {
+    let modelId = args;
+    if (!args.includes("/")) {
+      const models2 = await fetchAvailableModels();
+      const match = models2.find((m) => m.id.split("/").slice(1).join("/") === args || m.id === args);
+      if (match) {
+        modelId = match.id;
+      } else {
+        writeln(`${PREFIX.error} unknown model ${c3.cyan(args)}  ${c3.dim("\u2014 run /models for the full list")}`);
+        return;
+      }
+    }
+    ctx.setModel(modelId);
+    writeln(`${PREFIX.success} model \u2192 ${c3.cyan(modelId)}`);
+    return;
+  }
+  writeln(`${c3.dim("  fetching models\u2026")}`);
+  const models = await fetchAvailableModels();
+  process.stdout.write("\x1B[1A\r\x1B[2K");
+  if (models.length === 0) {
+    writeln(`${PREFIX.error} No models found. Check your API keys or Ollama connection.`);
+    writeln(c3.dim("  Set OPENCODE_API_KEY for Zen, or start Ollama for local models."));
+    return;
+  }
+  const byProvider = new Map;
+  for (const m of models) {
+    const existing = byProvider.get(m.provider);
+    if (existing) {
+      existing.push(m);
+    } else {
+      byProvider.set(m.provider, [m]);
+    }
+  }
+  writeln();
+  for (const [provider, list] of byProvider) {
+    writeln(c3.bold(`  ${provider}`));
+    for (const m of list) {
+      const isCurrent = ctx.currentModel === m.id;
+      const freeTag = m.free ? c3.green(" free") : "";
+      const ctxTag = m.context ? c3.dim(` ${Math.round(m.context / 1000)}k`) : "";
+      const cur = isCurrent ? c3.cyan(" \u25C0") : "";
+      writeln(`    ${c3.dim("\xB7")} ${m.displayName}${freeTag}${ctxTag}${cur}`);
+      writeln(`      ${c3.dim(m.id)}`);
+    }
+  }
+  writeln();
+  writeln(c3.dim("  /model <id>  to switch  \xB7  e.g. /model zen/claude-sonnet-4-6"));
+}
+function handlePlan(ctx) {
+  ctx.setPlanMode(!ctx.planMode);
+  if (ctx.planMode) {
+    if (ctx.ralphMode)
+      ctx.setRalphMode(false);
+    writeln(`${PREFIX.info} ${c3.yellow("plan mode")} ${c3.dim("\u2014 read-only tools + MCP, no writes or shell")}`);
+  } else {
+    writeln(`${PREFIX.info} ${c3.dim("plan mode off")}`);
+  }
+}
+function handleRalph(ctx) {
+  ctx.setRalphMode(!ctx.ralphMode);
+  if (ctx.ralphMode) {
+    if (ctx.planMode)
+      ctx.setPlanMode(false);
+    writeln(`${PREFIX.info} ${c3.magenta("ralph mode")} ${c3.dim("\u2014 loops until done, fresh context each iteration")}`);
+  } else {
+    writeln(`${PREFIX.info} ${c3.dim("ralph mode off")}`);
+  }
+}
+async function handleUndo(ctx) {
+  const ok = await ctx.undoLastTurn();
+  if (ok) {
+    writeln(`${PREFIX.success} ${c3.dim("last turn undone \u2014 history and files restored")}`);
+  } else {
+    writeln(`${PREFIX.info} ${c3.dim("nothing to undo")}`);
+  }
+}
+async function handleMcp(ctx, args) {
+  const parts = args.trim().split(/\s+/);
+  const sub = parts[0] ?? "list";
+  switch (sub) {
+    case "list": {
+      const servers = listMcpServers();
+      if (servers.length === 0) {
+        writeln(c3.dim("  no MCP servers configured"));
+        writeln(c3.dim("  /mcp add <name> http <url>  \xB7  /mcp add <name> stdio <cmd> [args...]"));
+        return;
+      }
+      writeln();
+      for (const s of servers) {
+        const detail = s.url ? c3.dim(`  ${s.url}`) : s.command ? c3.dim(`  ${s.command}`) : "";
+        writeln(`  ${c3.yellow("\u2699")} ${c3.bold(s.name)}  ${c3.dim(s.transport)}${detail}`);
+      }
+      return;
+    }
+    case "add": {
+      const [, name, transport, ...rest] = parts;
+      if (!name || !transport || rest.length === 0) {
+        writeln(c3.red("  usage: /mcp add <name> http <url>"));
+        writeln(c3.red("         /mcp add <name> stdio <cmd> [args...]"));
+        return;
+      }
+      if (transport === "http") {
+        const url = rest[0];
+        if (!url) {
+          writeln(c3.red("  usage: /mcp add <name> http <url>"));
+          return;
+        }
+        upsertMcpServer({
+          name,
+          transport,
+          url,
+          command: null,
+          args: null,
+          env: null
+        });
+      } else if (transport === "stdio") {
+        const [command, ...cmdArgs] = rest;
+        if (!command) {
+          writeln(c3.red("  usage: /mcp add <name> stdio <cmd> [args...]"));
+          return;
+        }
+        upsertMcpServer({
+          name,
+          transport,
+          url: null,
+          command,
+          args: cmdArgs.length ? JSON.stringify(cmdArgs) : null,
+          env: null
+        });
+      } else {
+        writeln(c3.red(`  unknown transport: ${transport}  (use http or stdio)`));
+        return;
+      }
+      try {
+        await ctx.connectMcpServer(name);
+        writeln(`${PREFIX.success} mcp server ${c3.cyan(name)} added and connected`);
+      } catch (e) {
+        writeln(`${PREFIX.success} mcp server ${c3.cyan(name)} saved  ${c3.dim(`(connection failed: ${String(e)})`)}`);
+      }
+      return;
+    }
+    case "remove":
+    case "rm": {
+      const [, name] = parts;
+      if (!name) {
+        writeln(c3.red("  usage: /mcp remove <name>"));
+        return;
+      }
+      deleteMcpServer(name);
+      writeln(`${PREFIX.success} mcp server ${c3.cyan(name)} removed`);
+      return;
+    }
+    default:
+      writeln(c3.red(`  unknown: /mcp ${sub}`));
+      writeln(c3.dim("  subcommands: list \xB7 add \xB7 remove"));
+  }
+}
+var REVIEW_PROMPT = (cwd, focus) => `You are a code reviewer. Review recent changes and provide actionable feedback.
+
+Working directory: ${cwd}
+${focus ? `Focus: ${focus}` : ""}
+
+## What to review
+- No args: \`git diff\` (unstaged) + \`git diff --cached\` (staged) + \`git status --short\` (untracked)
+- Commit hash: \`git show <hash>\`
+- Branch: \`git diff <branch>...HEAD\`
+- PR number/URL: \`gh pr view\` + \`gh pr diff\`
+
+## How to review
+After getting the diff, read the full files changed \u2014 diffs alone miss context.
+Check for AGENTS.md or CONVENTIONS.md for project conventions.
+
+## What to flag (priority order)
+1. **Bugs** \u2014 logic errors, missing edge cases, unhandled errors, race conditions, security issues. Be certain before flagging; investigate first.
+2. **Structure** \u2014 wrong abstraction, established patterns ignored, excessive nesting.
+3. **Performance** \u2014 only if obviously problematic (O(n\xB2) on unbounded data, N+1, blocking hot paths).
+4. **Style** \u2014 only clear violations of project conventions. Don't be a zealot.
+
+Only review the changed code, not pre-existing code.
+
+## Output
+- Be direct and specific: quote code, cite file and line number.
+- State the scenario/input that triggers a bug \u2014 severity depends on this.
+- No flattery, no filler. Matter-of-fact tone.
+- End with a short **Summary** of the most important items.
+`;
+async function handleReview(ctx, args) {
+  const focus = args.trim();
+  writeln(`${PREFIX.info} ${c3.cyan("review")} ${c3.dim("\u2014 spawning review subagent\u2026")}`);
+  writeln();
+  try {
+    const output = await ctx.runSubagent(REVIEW_PROMPT(ctx.cwd, focus));
+    if (output.activity.length) {
+      renderSubagentActivity(output.activity, "  ", 1);
+      writeln();
+    }
+    write(renderMarkdown(output.result));
+    writeln();
+    return {
+      type: "inject-user-message",
+      text: `Code review output:
+
+${output.result}
+
+<system-message>Review the findings and summarize them to the user.</system-message>`
+    };
+  } catch (e) {
+    writeln(`${PREFIX.error} review failed: ${String(e)}`);
+    return { type: "handled" };
+  }
+}
+function handleNew(ctx) {
+  ctx.startNewSession();
+  writeln(`${PREFIX.success} ${c3.dim("new session started \u2014 context cleared")}`);
+}
+function handleHelp() {
+  writeln();
+  const cmds = [
+    ["/model [id]", "list or switch models (fetches live list)"],
+    ["/undo", "remove the last turn from conversation history"],
+    ["/plan", "toggle plan mode (read-only tools + MCP)"],
+    [
+      "/ralph",
+      "toggle ralph mode (autonomous loop, fresh context each iteration)"
+    ],
+    ["/review [focus]", "run a structured code review on recent changes"],
+    ["/mcp list", "list MCP servers"],
+    ["/mcp add <n> <t> [u]", "add an MCP server"],
+    ["/mcp remove <name>", "remove an MCP server"],
+    ["/new", "start a new session with clean context"],
+    ["/help", "this message"],
+    ["/exit", "quit"]
+  ];
+  for (const [cmd, desc] of cmds) {
+    writeln(`  ${c3.cyan(cmd.padEnd(26))} ${c3.dim(desc)}`);
+  }
+  writeln();
+  writeln(`  ${c3.green("@file".padEnd(26))} ${c3.dim("inject file contents into prompt (Tab to complete)")}`);
+  writeln(`  ${c3.green("!cmd".padEnd(26))} ${c3.dim("run shell command, output added as context")}`);
+  writeln();
+  writeln(`  ${c3.dim("ctrl+c")}  cancel  ${c3.dim("\xB7")}  ${c3.dim("ctrl+d")}  exit  ${c3.dim("\xB7")}  ${c3.dim("ctrl+r")}  history search  ${c3.dim("\xB7")}  ${c3.dim("\u2191\u2193")}  history`);
+  writeln();
+}
+async function handleCommand(command, args, ctx) {
+  switch (command.toLowerCase()) {
+    case "model":
+    case "models":
+      await handleModel(ctx, args);
+      return { type: "handled" };
+    case "undo":
+      await handleUndo(ctx);
+      return { type: "handled" };
+    case "plan":
+      handlePlan(ctx);
+      return { type: "handled" };
+    case "ralph":
+      handleRalph(ctx);
+      return { type: "handled" };
+    case "mcp":
+      await handleMcp(ctx, args);
+      return { type: "handled" };
+    case "new":
+      handleNew(ctx);
+      return { type: "handled" };
+    case "review":
+      return await handleReview(ctx, args);
+    case "help":
+    case "?":
+      handleHelp();
+      return { type: "handled" };
+    case "exit":
+    case "quit":
+    case "q":
+      return { type: "exit" };
+    default:
+      writeln(`${PREFIX.error} unknown: /${command}  ${c3.dim("\u2014 /help for commands")}`);
+      return { type: "unknown", command };
+  }
+}
+
+// src/cli/image-types.ts
+var IMAGE_EXTENSIONS = new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "bmp",
+  "tiff",
+  "tif",
+  "avif",
+  "heic"
+]);
+function isImageFilename(s) {
+  const dotIdx = s.lastIndexOf(".");
+  if (dotIdx === -1 || dotIdx === 0)
+    return false;
+  const ext = s.slice(dotIdx + 1).toLowerCase();
+  return IMAGE_EXTENSIONS.has(ext);
+}
+async function loadImageFile(filePath) {
+  try {
+    const file = Bun.file(filePath);
+    if (!await file.exists())
+      return null;
+    const buf = await file.arrayBuffer();
+    const b64 = Buffer.from(buf).toString("base64");
+    const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+    const mediaType = file.type || `image/${ext === "jpg" ? "jpeg" : ext}` || "image/png";
+    return { data: b64, mediaType };
+  } catch {
+    return null;
+  }
+}
+
+// src/cli/input.ts
+import { join as join2, relative } from "path";
+import * as c4 from "yoctocolors";
+var ESC = "\x1B";
+var CSI = `${ESC}[`;
+var CLEAR_LINE = `\r${CSI}2K`;
+var CURSOR_LEFT = `${CSI}D`;
+var CURSOR_RIGHT = `${CSI}C`;
+var CURSOR_UP = `${CSI}A`;
+var CURSOR_DOWN = `${CSI}B`;
+var SAVE_CURSOR = `${CSI}s`;
+var RESTORE_CURSOR = `${CSI}u`;
+var BPASTE_ENABLE = `${ESC}[?2004h`;
+var BPASTE_DISABLE = `${ESC}[?2004l`;
+var BPASTE_START = `${ESC}[200~`;
+var BPASTE_END = `${ESC}[201~`;
+var ENTER = "\r";
+var NEWLINE = `
+`;
+var BACKSPACE = "\x7F";
+var CTRL_C = "\x03";
+var CTRL_D = "\x04";
+var CTRL_A = "\x01";
+var CTRL_E = "\x05";
+var CTRL_W = "\x17";
+var CTRL_U = "\x15";
+var CTRL_K = "\v";
+var CTRL_L = "\f";
+var CTRL_R = "\x12";
+var TAB = "\t";
+async function getFileCompletions(prefix, cwd) {
+  const query = prefix.startsWith("@") ? prefix.slice(1) : prefix;
+  const glob = new Bun.Glob(`**/*${query}*`);
+  const results = [];
+  for await (const file of glob.scan({ cwd, onlyFiles: true })) {
+    if (file.includes("node_modules") || file.includes(".git"))
+      continue;
+    results.push(`@${relative(cwd, join2(cwd, file))}`);
+    if (results.length >= 10)
+      break;
+  }
+  return results;
+}
+async function tryExtractImageFromPaste(pasted, cwd) {
+  const trimmed = pasted.trim();
+  if (trimmed.startsWith("data:image/")) {
+    const commaIdx = trimmed.indexOf(",");
+    if (commaIdx !== -1 && trimmed.slice(0, commaIdx).includes(";base64")) {
+      const header = trimmed.slice(0, commaIdx);
+      const b64 = trimmed.slice(commaIdx + 1);
+      const mediaType = header.split(";")[0]?.slice(5) ?? "image/png";
+      return {
+        attachment: { data: b64, mediaType },
+        label: `[image: ${mediaType}]`
+      };
+    }
+  }
+  if (!trimmed.includes(" ") && isImageFilename(trimmed)) {
+    const filePath = trimmed.startsWith("/") ? trimmed : join2(cwd, trimmed);
+    const attachment = await loadImageFile(filePath);
+    if (attachment) {
+      const name = filePath.split("/").pop() ?? trimmed;
+      return { attachment, label: `[image: ${name}]` };
+    }
+  }
+  return null;
+}
+var _stdinReader = null;
+function getStdinReader() {
+  if (!_stdinReader) {
+    const stream = new ReadableStream({
+      start(controller) {
+        process.stdin.on("data", (chunk) => {
+          try {
+            controller.enqueue(new Uint8Array(chunk));
+          } catch {}
+        });
+        process.stdin.once("end", () => {
+          try {
+            controller.close();
+          } catch {}
+          _stdinReader = null;
+        });
+      }
+    });
+    _stdinReader = stream.getReader();
+  }
+  return _stdinReader;
+}
+async function readKey(reader) {
+  const { value, done } = await reader.read();
+  if (done || !value)
+    return "";
+  return new TextDecoder().decode(value);
+}
+var PASTE_SENTINEL = "\x00PASTE\x00";
+var PASTE_SENTINEL_LEN = PASTE_SENTINEL.length;
+function pasteLabel(text) {
+  const lines = text.split(`
+`);
+  const first = lines[0] ?? "";
+  const preview = first.length > 40 ? `${first.slice(0, 40)}\u2026` : first;
+  const extra = lines.length - 1;
+  const more = extra > 0 ? ` +${extra} more line${extra === 1 ? "" : "s"}` : "";
+  return `[pasted: "${preview}"${more}]`;
+}
+var PROMPT = c4.green("\u25B6 ");
+var PROMPT_PLAN = c4.yellow("\u2B22 ");
+var PROMPT_RALPH = c4.magenta("\u21BB ");
+var PROMPT_RAW_LEN = 2;
+async function readline(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const history = getPromptHistory(200);
+  let histIdx = history.length;
+  let buf = "";
+  let cursor = 0;
+  let savedInput = "";
+  let searchMode = false;
+  let searchQuery = "";
+  let pasteBuffer = null;
+  const imageAttachments = [];
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdout.write(BPASTE_ENABLE);
+  const reader = getStdinReader();
+  function renderPrompt() {
+    const cols = process.stdout.columns ?? 80;
+    const visualBuf = (pasteBuffer ? buf.replace(PASTE_SENTINEL, c4.dim(pasteLabel(pasteBuffer))) : buf).replace(/\[image: [^\]]+\]/g, (m) => c4.dim(c4.cyan(m)));
+    const visualCursor = pasteBuffer ? (() => {
+      const sentinelPos = buf.indexOf(PASTE_SENTINEL);
+      if (sentinelPos === -1 || cursor <= sentinelPos)
+        return cursor;
+      return cursor - PASTE_SENTINEL_LEN + pasteLabel(pasteBuffer).length;
+    })() : cursor;
+    const display = visualBuf.length > cols - PROMPT_RAW_LEN - 2 ? `\u2026${visualBuf.slice(-(cols - PROMPT_RAW_LEN - 3))}` : visualBuf;
+    const prompt = opts.planMode ? PROMPT_PLAN : opts.ralphMode ? PROMPT_RALPH : PROMPT;
+    process.stdout.write(`${CLEAR_LINE}${prompt}${display}${CSI}${PROMPT_RAW_LEN + visualCursor + 1}G`);
+  }
+  function renderSearchPrompt() {
+    process.stdout.write(`${CLEAR_LINE}${c4.cyan("search:")} ${searchQuery}\u2588`);
+  }
+  function applyHistory() {
+    if (histIdx < history.length) {
+      buf = history[histIdx] ?? "";
+    } else {
+      buf = savedInput;
+    }
+    cursor = buf.length;
+    renderPrompt();
+  }
+  renderPrompt();
+  try {
+    while (true) {
+      const raw = await readKey(reader);
+      if (!raw)
+        continue;
+      if (searchMode) {
+        if (raw === ESC) {
+          searchMode = false;
+          searchQuery = "";
+          renderPrompt();
+          continue;
+        }
+        if (raw === ENTER || raw === NEWLINE) {
+          searchMode = false;
+          cursor = buf.length;
+          renderPrompt();
+          continue;
+        }
+        if (raw === BACKSPACE) {
+          searchQuery = searchQuery.slice(0, -1);
+        } else if (raw >= " ") {
+          searchQuery += raw;
+        }
+        if (searchQuery) {
+          const found = [...history].reverse().find((h) => h.includes(searchQuery));
+          if (found) {
+            buf = found;
+            cursor = buf.length;
+          }
+        }
+        renderSearchPrompt();
+        continue;
+      }
+      if (raw.includes(BPASTE_START)) {
+        let accumulated = raw.slice(raw.indexOf(BPASTE_START) + BPASTE_START.length);
+        while (!accumulated.includes(BPASTE_END)) {
+          const next = await readKey(reader);
+          if (!next)
+            break;
+          accumulated += next;
+        }
+        const endIdx = accumulated.indexOf(BPASTE_END);
+        const pasted = endIdx !== -1 ? accumulated.slice(0, endIdx) : accumulated;
+        const imageResult = await tryExtractImageFromPaste(pasted, cwd);
+        if (imageResult) {
+          imageAttachments.push(imageResult.attachment);
+          buf = buf.slice(0, cursor) + imageResult.label + buf.slice(cursor);
+          cursor += imageResult.label.length;
+          renderPrompt();
+          continue;
+        }
+        pasteBuffer = pasted;
+        buf = buf.slice(0, cursor) + PASTE_SENTINEL + buf.slice(cursor);
+        cursor += PASTE_SENTINEL_LEN;
+        renderPrompt();
+        continue;
+      }
+      if (raw.startsWith(ESC)) {
+        if (raw === `${CSI}A` || raw === `${ESC}[A`) {
+          if (histIdx === history.length)
+            savedInput = buf;
+          if (histIdx > 0) {
+            histIdx--;
+            applyHistory();
+          }
+          continue;
+        }
+        if (raw === `${CSI}B` || raw === `${ESC}[B`) {
+          if (histIdx < history.length) {
+            histIdx++;
+            applyHistory();
+          }
+          continue;
+        }
+        if (raw === `${CSI}C` || raw === `${ESC}[C`) {
+          if (cursor < buf.length) {
+            cursor++;
+            renderPrompt();
+          }
+          continue;
+        }
+        if (raw === `${CSI}D` || raw === `${ESC}[D`) {
+          if (cursor > 0) {
+            cursor--;
+            renderPrompt();
+          }
+          continue;
+        }
+        if (raw === `${ESC}b` || raw === `${ESC}[1;3D`) {
+          while (cursor > 0 && buf[cursor - 1] === " ")
+            cursor--;
+          while (cursor > 0 && buf[cursor - 1] !== " ")
+            cursor--;
+          renderPrompt();
+          continue;
+        }
+        if (raw === `${ESC}f` || raw === `${ESC}[1;3C`) {
+          while (cursor < buf.length && buf[cursor] === " ")
+            cursor++;
+          while (cursor < buf.length && buf[cursor] !== " ")
+            cursor++;
+          renderPrompt();
+          continue;
+        }
+        if (raw === ESC) {
+          process.stdout.write(`
+`);
+          return { type: "interrupt" };
+        }
+        continue;
+      }
+      if (raw === CTRL_C) {
+        process.stdout.write(`
+`);
+        return { type: "interrupt" };
+      }
+      if (raw === CTRL_D) {
+        process.stdout.write(`
+`);
+        return { type: "eof" };
+      }
+      if (raw === CTRL_A) {
+        cursor = 0;
+        renderPrompt();
+        continue;
+      }
+      if (raw === CTRL_E) {
+        cursor = buf.length;
+        renderPrompt();
+        continue;
+      }
+      if (raw === CTRL_W) {
+        const end = cursor;
+        while (cursor > 0 && buf[cursor - 1] === " ")
+          cursor--;
+        while (cursor > 0 && buf[cursor - 1] !== " ")
+          cursor--;
+        buf = buf.slice(0, cursor) + buf.slice(end);
+        if (pasteBuffer && !buf.includes(PASTE_SENTINEL))
+          pasteBuffer = null;
+        renderPrompt();
+        continue;
+      }
+      if (raw === CTRL_U) {
+        buf = buf.slice(cursor);
+        cursor = 0;
+        if (pasteBuffer && !buf.includes(PASTE_SENTINEL))
+          pasteBuffer = null;
+        renderPrompt();
+        continue;
+      }
+      if (raw === CTRL_K) {
+        buf = buf.slice(0, cursor);
+        if (pasteBuffer && !buf.includes(PASTE_SENTINEL))
+          pasteBuffer = null;
+        renderPrompt();
+        continue;
+      }
+      if (raw === CTRL_L) {
+        process.stdout.write("\x1B[2J\x1B[H");
+        renderPrompt();
+        continue;
+      }
+      if (raw === CTRL_R) {
+        searchMode = true;
+        searchQuery = "";
+        renderSearchPrompt();
+        continue;
+      }
+      if (raw === BACKSPACE) {
+        if (cursor > 0) {
+          buf = buf.slice(0, cursor - 1) + buf.slice(cursor);
+          cursor--;
+          if (pasteBuffer && !buf.includes(PASTE_SENTINEL))
+            pasteBuffer = null;
+          renderPrompt();
+        }
+        continue;
+      }
+      if (raw === TAB) {
+        const beforeCursor = buf.slice(0, cursor);
+        const atMatch = beforeCursor.match(/@(\S*)$/);
+        if (atMatch) {
+          const completions = await getFileCompletions(atMatch[0], cwd);
+          if (completions.length === 1 && completions[0]) {
+            const replacement = completions[0];
+            buf = buf.slice(0, cursor - (atMatch[0] ?? "").length) + replacement + buf.slice(cursor);
+            cursor = cursor - (atMatch[0] ?? "").length + replacement.length;
+            renderPrompt();
+          } else if (completions.length > 1) {
+            process.stdout.write(`
+`);
+            for (const c5 of completions)
+              process.stdout.write(`  ${c5}
+`);
+            renderPrompt();
+          }
+        }
+        continue;
+      }
+      if (raw === ENTER || raw === NEWLINE) {
+        const expanded = pasteBuffer ? buf.replace(PASTE_SENTINEL, pasteBuffer) : buf;
+        pasteBuffer = null;
+        const text = expanded.trim();
+        process.stdout.write(`
+`);
+        buf = "";
+        cursor = 0;
+        histIdx = history.length + (text ? 1 : 0);
+        if (!text && !imageAttachments.length) {
+          renderPrompt();
+          continue;
+        }
+        const cleanText = imageAttachments.length ? text.replace(/\[image: [^\]]+\]/g, "").trim() : text;
+        addPromptHistory(cleanText);
+        if (cleanText.startsWith("/")) {
+          const spaceIdx = cleanText.indexOf(" ");
+          const command = spaceIdx === -1 ? cleanText.slice(1) : cleanText.slice(1, spaceIdx);
+          const args = spaceIdx === -1 ? "" : cleanText.slice(spaceIdx + 1).trim();
+          return { type: "command", command, args };
+        }
+        if (cleanText.startsWith("!")) {
+          return { type: "shell", command: cleanText.slice(1).trim() };
+        }
+        return {
+          type: "submit",
+          text: cleanText,
+          images: imageAttachments
+        };
+      }
+      if (raw.length > 1) {
+        const pasted = raw.replace(/\r?\n$/, "");
+        const imageResult = await tryExtractImageFromPaste(pasted, cwd);
+        if (imageResult) {
+          imageAttachments.push(imageResult.attachment);
+          buf = buf.slice(0, cursor) + imageResult.label + buf.slice(cursor);
+          cursor += imageResult.label.length;
+          renderPrompt();
+          continue;
+        }
+        pasteBuffer = pasted;
+        buf = buf.slice(0, cursor) + PASTE_SENTINEL + buf.slice(cursor);
+        cursor += PASTE_SENTINEL_LEN;
+        renderPrompt();
+        continue;
+      }
+      if (raw >= " " || raw === "\t") {
+        buf = buf.slice(0, cursor) + raw + buf.slice(cursor);
+        cursor++;
+        renderPrompt();
+      }
+    }
+  } finally {
+    process.stdout.write(BPASTE_DISABLE);
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+  }
+}
+
+// src/llm-api/turn.ts
+import { dynamicTool, jsonSchema, stepCountIs, streamText } from "ai";
+import { z } from "zod";
+var MAX_STEPS = 50;
+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 err instanceof Error ? err : new Error(String(err));
+      }
+    }
+  });
+}
+async function* runTurn(options) {
+  const { model, messages, tools, systemPrompt, signal } = options;
+  const toolSet = {};
+  for (const def of tools) {
+    toolSet[def.name] = toCoreTool(def);
+  }
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let contextTokens = 0;
+  try {
+    const streamOpts = {
+      model,
+      messages,
+      tools: toolSet,
+      stopWhen: stepCountIs(MAX_STEPS),
+      onStepFinish: (step) => {
+        inputTokens += step.usage?.inputTokens ?? 0;
+        outputTokens += step.usage?.outputTokens ?? 0;
+        contextTokens = step.usage?.inputTokens ?? contextTokens;
+      },
+      ...systemPrompt ? { system: systemPrompt } : {},
+      ...signal ? { abortSignal: signal } : {}
+    };
+    const result = streamText(streamOpts);
+    for await (const chunk of result.fullStream) {
+      if (signal?.aborted)
+        break;
+      const c5 = chunk;
+      switch (c5.type) {
+        case "text-delta": {
+          const delta = typeof c5.text === "string" ? c5.text : typeof c5.textDelta === "string" ? c5.textDelta : "";
+          yield {
+            type: "text-delta",
+            delta
+          };
+          break;
+        }
+        case "tool-call": {
+          yield {
+            type: "tool-call-start",
+            toolCallId: String(c5.toolCallId ?? ""),
+            toolName: String(c5.toolName ?? ""),
+            args: c5.input ?? c5.args
+          };
+          break;
+        }
+        case "tool-result": {
+          yield {
+            type: "tool-result",
+            toolCallId: String(c5.toolCallId ?? ""),
+            toolName: String(c5.toolName ?? ""),
+            result: "output" in c5 ? c5.output : ("result" in c5) ? c5.result : undefined,
+            isError: false
+          };
+          break;
+        }
+        case "tool-error": {
+          yield {
+            type: "tool-result",
+            toolCallId: String(c5.toolCallId ?? ""),
+            toolName: String(c5.toolName ?? ""),
+            result: c5.error ?? "Tool execution failed",
+            isError: true
+          };
+          break;
+        }
+        case "error": {
+          const err = c5.error;
+          throw err instanceof Error ? err : new Error(String(err));
+        }
+      }
+    }
+    const finalResponse = await result.response;
+    const newMessages = finalResponse?.messages ?? [];
+    yield {
+      type: "turn-complete",
+      inputTokens,
+      outputTokens,
+      contextTokens,
+      messages: newMessages
+    };
+  } catch (err) {
+    yield {
+      type: "turn-error",
+      error: err instanceof Error ? err : new Error(String(err))
+    };
+  }
+}
+
+// src/mcp/client.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+async function connectMcpServer(config) {
+  const client = new Client({ name: "mini-coder", version: "0.1.0" });
+  if (config.transport === "http") {
+    if (!config.url) {
+      throw new Error(`MCP server "${config.name}" requires a url`);
+    }
+    const url = new URL(config.url);
+    let transport;
+    try {
+      const streamable = new StreamableHTTPClientTransport(url);
+      transport = streamable;
+      await client.connect(transport);
+    } catch {
+      transport = new SSEClientTransport(url);
+      await client.connect(transport);
+    }
+  } else if (config.transport === "stdio") {
+    if (!config.command) {
+      throw new Error(`MCP server "${config.name}" requires a command`);
+    }
+    const stdioParams = config.env ? { command: config.command, args: config.args ?? [], env: config.env } : { command: config.command, args: config.args ?? [] };
+    const transport = new StdioClientTransport(stdioParams);
+    await client.connect(transport);
+  } else {
+    throw new Error(`Unknown MCP transport: ${config.transport}`);
+  }
+  const { tools: mcpTools } = await client.listTools();
+  const tools = mcpTools.map((t) => ({
+    name: `mcp_${config.name}_${t.name}`,
+    description: `[MCP:${config.name}] ${t.description ?? t.name}`,
+    schema: t.inputSchema,
+    execute: async (input) => {
+      const result = await client.callTool({
+        name: t.name,
+        arguments: input
+      });
+      if (result.isError) {
+        const content = result.content;
+        const errText = content.filter((b) => b.type === "text").map((b) => b.text ?? "").join(`
+`);
+        throw new Error(errText || "MCP tool returned an error");
+      }
+      return result.content;
+    }
+  }));
+  return {
+    name: config.name,
+    tools,
+    close: () => client.close()
+  };
+}
+
+// src/tools/snapshot.ts
+import { readFileSync, unlinkSync as unlinkSync2 } from "fs";
+import { join as join3 } from "path";
+async function gitBytes(args, cwd) {
+  try {
+    const proc = Bun.spawn(["git", ...args], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [bytes] = await Promise.all([
+      new Response(proc.stdout).bytes(),
+      new Response(proc.stderr).bytes()
+    ]);
+    const code = await proc.exited;
+    return { bytes, code };
+  } catch {
+    return { bytes: new Uint8Array, code: -1 };
+  }
+}
+async function git(args, cwd) {
+  const { bytes, code } = await gitBytes(args, cwd);
+  return { stdout: new TextDecoder().decode(bytes), code };
+}
+async function getStatusEntries(repoRoot) {
+  const status = await git(["status", "--porcelain", "-z", "-u"], repoRoot);
+  if (status.code !== 0)
+    return null;
+  const raw = status.stdout;
+  if (raw === "")
+    return [];
+  const entries = [];
+  const parts = raw.split("\x00");
+  let i = 0;
+  while (i < parts.length) {
+    const entry = parts[i];
+    i++;
+    if (!entry || entry.length < 4)
+      continue;
+    const xy = entry.slice(0, 2);
+    const filePath = entry.slice(3);
+    const x = xy[0] ?? " ";
+    const y = xy[1] ?? " ";
+    if (x === "R" || x === "C") {
+      const oldPath = parts[i];
+      i++;
+      if (oldPath) {
+        entries.push({ path: oldPath, existsOnDisk: false, isNew: false });
+      }
+      if (filePath) {
+        entries.push({ path: filePath, existsOnDisk: true, isNew: true });
+      }
+      continue;
+    }
+    if (x === "D" || y === "D") {
+      if (filePath)
+        entries.push({ path: filePath, existsOnDisk: false, isNew: false });
+      continue;
+    }
+    if (x === "?" && y === "?") {
+      if (filePath)
+        entries.push({ path: filePath, existsOnDisk: true, isNew: true });
+      continue;
+    }
+    if (filePath)
+      entries.push({ path: filePath, existsOnDisk: true, isNew: false });
+  }
+  const seen = new Set;
+  return entries.filter((e) => {
+    if (seen.has(e.path))
+      return false;
+    seen.add(e.path);
+    return true;
+  });
+}
+async function getRepoRoot(cwd) {
+  const result = await git(["rev-parse", "--show-toplevel"], cwd);
+  if (result.code !== 0)
+    return null;
+  return result.stdout.trim();
+}
+async function takeSnapshot(cwd, sessionId, turnIndex) {
+  try {
+    const repoRoot = await getRepoRoot(cwd);
+    if (repoRoot === null)
+      return false;
+    const entries = await getStatusEntries(repoRoot);
+    if (entries === null)
+      return false;
+    if (entries.length === 0)
+      return false;
+    const files = [];
+    for (const entry of entries) {
+      const absPath = join3(repoRoot, entry.path);
+      if (!entry.existsOnDisk) {
+        const { bytes, code } = await gitBytes(["show", `HEAD:${entry.path}`], repoRoot);
+        if (code === 0) {
+          files.push({
+            path: entry.path,
+            content: bytes,
+            existed: true
+          });
+        }
+        continue;
+      }
+      if (entry.isNew) {
+        try {
+          const content = readFileSync(absPath);
+          files.push({
+            path: entry.path,
+            content: new Uint8Array(content),
+            existed: false
+          });
+        } catch {}
+        continue;
+      }
+      try {
+        const content = readFileSync(absPath);
+        files.push({
+          path: entry.path,
+          content: new Uint8Array(content),
+          existed: true
+        });
+      } catch {}
+    }
+    if (files.length === 0)
+      return false;
+    saveSnapshot(sessionId, turnIndex, files);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function restoreSnapshot(cwd, sessionId, turnIndex) {
+  try {
+    const files = loadSnapshot(sessionId, turnIndex);
+    const repoRoot = await getRepoRoot(cwd);
+    if (files.length === 0)
+      return { restored: false, reason: "not-found" };
+    const root = repoRoot ?? cwd;
+    let anyFailed = false;
+    for (const file of files) {
+      const absPath = join3(root, file.path);
+      if (!file.existed) {
+        try {
+          if (await Bun.file(absPath).exists()) {
+            unlinkSync2(absPath);
+          }
+        } catch {
+          anyFailed = true;
+        }
+        continue;
+      }
+      if (file.content !== null) {
+        try {
+          await Bun.write(absPath, file.content);
+        } catch {
+          anyFailed = true;
+        }
+      }
+    }
+    if (!anyFailed) {
+      deleteSnapshot(sessionId, turnIndex);
+    }
+    return anyFailed ? { restored: false, reason: "error" } : { restored: true };
+  } catch {
+    return { restored: false, reason: "error" };
+  }
+}
+
+// src/session/manager.ts
+import { homedir as homedir3 } from "os";
+import * as c5 from "yoctocolors";
+function newSession(model, cwd) {
+  const id = generateSessionId();
+  createSession({ id, cwd, model });
+  return { id, model, messages: [] };
+}
+function resumeSession(id) {
+  const row = getSession(id);
+  if (!row)
+    return null;
+  const messages = loadMessages(id);
+  return { id: row.id, model: row.model, messages };
+}
+function touchActiveSession(session) {
+  touchSession(session.id, session.model);
+}
+function printSessionList() {
+  const sessions = listSessions(20);
+  if (sessions.length === 0) {
+    writeln(c5.dim("No sessions found."));
+    return;
+  }
+  writeln(`
+${c5.bold("Recent sessions:")}`);
+  for (const s of sessions) {
+    const date = new Date(s.updated_at).toLocaleString();
+    const cwd = s.cwd.startsWith(homedir3()) ? `~${s.cwd.slice(homedir3().length)}` : s.cwd;
+    const title = s.title || c5.dim("(untitled)");
+    writeln(`  ${c5.dim(s.id.padEnd(14))} ${title.padEnd(30)} ${c5.cyan(s.model.split("/").pop() ?? s.model).padEnd(20)} ${c5.dim(cwd)}  ${c5.dim(date)}`);
+  }
+  writeln(`
+${c5.dim("Use")} mc --resume <id> ${c5.dim("to continue a session.")}`);
+}
+function getMostRecentSession() {
+  const sessions = listSessions(1);
+  return sessions[0] ?? null;
+}
+
+// src/tools/create.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname, join as join4, relative as relative2 } from "path";
+import { z as z2 } from "zod";
+
+// src/tools/diff.ts
+function generateDiff(filePath, before, after) {
+  const beforeLines = before === "" ? [] : before.split(`
+`);
+  const afterLines = after === "" ? [] : after.split(`
+`);
+  const diff = computeUnifiedDiff(beforeLines, afterLines);
+  if (diff.length === 0)
+    return "(no changes)";
+  return `--- ${filePath}
++++ ${filePath}
+${diff}`;
+}
+function lcsTable(before, after) {
+  const m = before.length;
+  const n = after.length;
+  const w = n + 1;
+  const dp = new Array((m + 1) * w).fill(0);
+  for (let i = 1;i <= m; i++) {
+    for (let j = 1;j <= n; j++) {
+      if (before[i - 1] === after[j - 1]) {
+        dp[i * w + j] = (dp[(i - 1) * w + (j - 1)] ?? 0) + 1;
+      } else {
+        dp[i * w + j] = Math.max(dp[(i - 1) * w + j] ?? 0, dp[i * w + (j - 1)] ?? 0);
+      }
+    }
+  }
+  return dp;
+}
+function editScript(before, after) {
+  const n = after.length;
+  const w = n + 1;
+  const dp = lcsTable(before, after);
+  const ops = [];
+  let i = before.length;
+  let j = after.length;
+  while (i > 0 || j > 0) {
+    const bLine = before[i - 1] ?? "";
+    const aLine = after[j - 1] ?? "";
+    if (i > 0 && j > 0 && bLine === aLine) {
+      ops.push({ kind: "eq", line: bLine });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || (dp[i * w + (j - 1)] ?? 0) >= (dp[(i - 1) * w + j] ?? 0))) {
+      ops.push({ kind: "ins", line: aLine });
+      j--;
+    } else {
+      ops.push({ kind: "del", line: bLine });
+      i--;
+    }
+  }
+  ops.reverse();
+  return ops;
+}
+function computeUnifiedDiff(before, after) {
+  const CONTEXT = 3;
+  const ops = editScript(before, after);
+  const indexed = [];
+  let bi = 0;
+  let ai = 0;
+  for (const op of ops) {
+    indexed.push({ ...op, bi, ai });
+    if (op.kind === "eq" || op.kind === "del")
+      bi++;
+    if (op.kind === "eq" || op.kind === "ins")
+      ai++;
+  }
+  const changedIdx = [];
+  for (let k = 0;k < indexed.length; k++) {
+    if (indexed[k]?.kind !== "eq")
+      changedIdx.push(k);
+  }
+  if (changedIdx.length === 0)
+    return "";
+  const groups = [];
+  let groupStart = changedIdx[0] ?? 0;
+  let groupEnd = changedIdx[0] ?? 0;
+  for (let k = 1;k < changedIdx.length; k++) {
+    const prev = changedIdx[k - 1] ?? 0;
+    const cur = changedIdx[k] ?? 0;
+    let equalCount = 0;
+    for (let x = prev + 1;x < cur; x++) {
+      if (indexed[x]?.kind === "eq")
+        equalCount++;
+    }
+    if (equalCount > 2 * CONTEXT) {
+      groups.push([groupStart, groupEnd]);
+      groupStart = cur;
+    }
+    groupEnd = cur;
+  }
+  groups.push([groupStart, groupEnd]);
+  const hunks = [];
+  for (const [gStart, gEnd] of groups) {
+    const opStart = Math.max(0, gStart - CONTEXT);
+    const opEnd = Math.min(indexed.length - 1, gEnd + CONTEXT);
+    const lines = [];
+    let beforeCount = 0;
+    let afterCount = 0;
+    for (let x = opStart;x <= opEnd; x++) {
+      const op = indexed[x];
+      if (!op)
+        continue;
+      if (op.kind === "eq") {
+        lines.push(` ${op.line}`);
+        beforeCount++;
+        afterCount++;
+      } else if (op.kind === "del") {
+        lines.push(`-${op.line}`);
+        beforeCount++;
+      } else {
+        lines.push(`+${op.line}`);
+        afterCount++;
+      }
+    }
+    const firstOp = indexed[opStart];
+    const beforeStart = beforeCount === 0 ? 0 : (firstOp?.bi ?? 0) + 1;
+    const afterStart = afterCount === 0 ? 0 : (firstOp?.ai ?? 0) + 1;
+    hunks.push(`@@ -${beforeStart},${beforeCount} +${afterStart},${afterCount} @@
+${lines.join(`
+`)}`);
+  }
+  return hunks.join(`
+`);
+}
+
+// src/tools/create.ts
+var CreateSchema = z2.object({
+  path: z2.string().describe("File path to write (absolute or relative to cwd)"),
+  content: z2.string().describe("Full content to write to the file")
+});
+var createTool = {
+  name: "create",
+  description: "Create a new file or fully overwrite an existing file with the given content. " + "Use this only for new files. " + "For targeted line edits on existing files, **use `replace` or `insert` instead**.",
+  schema: CreateSchema,
+  execute: async (input) => {
+    const cwd = input.cwd ?? process.cwd();
+    const filePath = input.path.startsWith("/") ? input.path : join4(cwd, input.path);
+    const relPath = relative2(cwd, filePath);
+    const dir = dirname(filePath);
+    if (!existsSync2(dir))
+      mkdirSync2(dir, { recursive: true });
+    const file = Bun.file(filePath);
+    const created = !await file.exists();
+    const before = created ? "" : await file.text();
+    await Bun.write(filePath, input.content);
+    const diff = generateDiff(relPath, before, input.content);
+    return { path: relPath, diff, created };
+  }
+};
+
+// src/tools/glob.ts
+import { join as join5, relative as relative3 } from "path";
+import { z as z3 } from "zod";
+var GlobSchema = z3.object({
+  pattern: z3.string().describe("Glob pattern to match files against, e.g. '**/*.ts'"),
+  ignore: z3.array(z3.string()).optional().describe("Glob patterns to exclude")
+});
+var MAX_RESULTS = 500;
+var globTool = {
+  name: "glob",
+  description: "Find files matching a glob pattern. Returns relative paths sorted by modification time. " + "Use this to discover files before reading them.",
+  schema: GlobSchema,
+  execute: async (input) => {
+    const cwd = input.cwd ?? process.cwd();
+    const defaultIgnore = [
+      "node_modules/**",
+      ".git/**",
+      "dist/**",
+      "*.db",
+      "*.db-shm",
+      "*.db-wal"
+    ];
+    const ignorePatterns = [...defaultIgnore, ...input.ignore ?? []];
+    const glob = new Bun.Glob(input.pattern);
+    const matches = [];
+    for await (const file of glob.scan({ cwd, onlyFiles: true })) {
+      const ignored = ignorePatterns.some((pat) => {
+        const ig = new Bun.Glob(pat);
+        return ig.match(file);
+      });
+      if (ignored)
+        continue;
+      try {
+        const fullPath = join5(cwd, file);
+        const stat = await Bun.file(fullPath).stat?.() ?? null;
+        matches.push({ path: file, mtime: stat?.mtime?.getTime() ?? 0 });
+      } catch {
+        matches.push({ path: file, mtime: 0 });
+      }
+      if (matches.length >= MAX_RESULTS + 1)
+        break;
+    }
+    const truncated = matches.length > MAX_RESULTS;
+    if (truncated)
+      matches.pop();
+    matches.sort((a, b) => b.mtime - a.mtime);
+    const files = matches.map((m) => relative3(cwd, join5(cwd, m.path)));
+    return { files, count: files.length, truncated };
+  }
+};
+
+// src/tools/grep.ts
+import { join as join6 } from "path";
+import { z as z4 } from "zod";
+
+// src/tools/hashline.ts
+var FNV_OFFSET_BASIS = 2166136261;
+var FNV_PRIME = 16777619;
+var HASH_SCAN_RANGE = 10;
+function hashLine(content) {
+  let hash = FNV_OFFSET_BASIS;
+  for (let i = 0;i < content.length; i++) {
+    hash ^= content.charCodeAt(i);
+    hash = hash * FNV_PRIME >>> 0;
+  }
+  const twoHex = (hash & 255).toString(16).padStart(2, "0");
+  return twoHex;
+}
+function formatHashLine(lineNum, content) {
+  return `${lineNum}:${hashLine(content)}| ${content}`;
+}
+function findLineByHash(lines, hash, hintLine) {
+  const normalized = hash.toLowerCase();
+  const hintIdx = hintLine - 1;
+  const foundMatches = [];
+  const matches = (idx) => {
+    const line = lines[idx] ?? "";
+    return hashLine(line) === normalized;
+  };
+  if (hintIdx >= 0 && hintIdx < lines.length) {
+    if (matches(hintIdx))
+      return hintIdx + 1;
+  }
+  for (let offset = 1;offset <= HASH_SCAN_RANGE; offset++) {
+    const lower = hintIdx - offset;
+    if (lower >= 0 && lower < lines.length && matches(lower)) {
+      foundMatches.push(lower + 1);
+    }
+    const higher = hintIdx + offset;
+    if (higher >= 0 && higher < lines.length && matches(higher)) {
+      foundMatches.push(higher + 1);
+    }
+  }
+  if (foundMatches.length === 1)
+    return foundMatches[0] ?? null;
+  return null;
+}
+
+// src/tools/grep.ts
+var GrepSchema = z4.object({
+  pattern: z4.string().describe("Regular expression to search for"),
+  include: z4.string().optional().describe("Glob pattern to filter files, e.g. '*.ts' or '*.{ts,tsx}'"),
+  contextLines: z4.number().int().min(0).max(10).optional().default(2).describe("Lines of context to include around each match"),
+  caseSensitive: z4.boolean().optional().default(true),
+  maxResults: z4.number().int().min(1).max(200).optional().default(50)
+});
+var DEFAULT_IGNORE = [
+  "node_modules",
+  ".git",
+  "dist",
+  "*.db",
+  "*.db-shm",
+  "*.db-wal",
+  "bun.lock"
+];
+var grepTool = {
+  name: "grep",
+  description: "Search for a regex pattern across files. Returns file paths, line numbers, and context. " + "Use this to find code patterns, function definitions, or specific text.",
+  schema: GrepSchema,
+  execute: async (input) => {
+    const cwd = input.cwd ?? process.cwd();
+    const flags = input.caseSensitive ? "" : "i";
+    const regex = new RegExp(input.pattern, flags);
+    const maxResults = input.maxResults ?? 50;
+    const contextLines = input.contextLines ?? 2;
+    const include = input.include ?? "**/*";
+    const fileGlob = new Bun.Glob(include);
+    const ignoreGlob = DEFAULT_IGNORE.map((p) => new Bun.Glob(p));
+    const allMatches = [];
+    let truncated = false;
+    outer:
+      for await (const relPath of fileGlob.scan({
+        cwd,
+        onlyFiles: true
+      })) {
+        if (ignoreGlob.some((g) => g.match(relPath) || g.match(relPath.split("/")[0] ?? ""))) {
+          continue;
+        }
+        const fullPath = join6(cwd, relPath);
+        let text;
+        try {
+          text = await Bun.file(fullPath).text();
+        } catch {
+          continue;
+        }
+        if (text.includes("\x00"))
+          continue;
+        const lines = text.split(`
+`);
+        for (let i = 0;i < lines.length; i++) {
+          const line = lines[i] ?? "";
+          const match = regex.exec(line);
+          if (!match)
+            continue;
+          const ctxStart = Math.max(0, i - contextLines);
+          const ctxEnd = Math.min(lines.length - 1, i + contextLines);
+          const context = [];
+          for (let c6 = ctxStart;c6 <= ctxEnd; c6++) {
+            context.push({
+              line: c6 + 1,
+              text: formatHashLine(c6 + 1, lines[c6] ?? ""),
+              isMatch: c6 === i
+            });
+          }
+          allMatches.push({
+            file: relPath,
+            line: i + 1,
+            column: match.index + 1,
+            text: formatHashLine(i + 1, line),
+            context
+          });
+          if (allMatches.length >= maxResults + 1) {
+            truncated = true;
+            break outer;
+          }
+        }
+      }
+    if (truncated)
+      allMatches.pop();
+    return {
+      matches: allMatches,
+      totalMatches: allMatches.length,
+      truncated
+    };
+  }
+};
+
+// src/tools/hooks.ts
+import { constants, accessSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join7 } from "path";
+function isExecutable(filePath) {
+  try {
+    accessSync(filePath, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findHook(toolName, cwd) {
+  const scriptName = `post-${toolName}`;
+  const candidates = [
+    join7(cwd, ".agents", "hooks", scriptName),
+    join7(homedir4(), ".agents", "hooks", scriptName)
+  ];
+  for (const p of candidates) {
+    if (isExecutable(p))
+      return p;
+  }
+  return null;
+}
+function createHookCache(toolNames, cwd) {
+  const cache = new Map;
+  for (const name of toolNames) {
+    cache.set(name, findHook(name, cwd));
+  }
+  return (toolName) => cache.get(toolName) ?? null;
+}
+async function runHook(scriptPath, env, cwd) {
+  try {
+    const proc = Bun.spawn(["bash", scriptPath], {
+      cwd,
+      env: { ...process.env, ...env },
+      stdout: "ignore",
+      stderr: "ignore"
+    });
+    const code = await proc.exited;
+    return code === 0;
+  } catch {
+    return false;
+  }
+}
+function hookEnvForCreate(result, cwd) {
+  return {
+    TOOL: "create",
+    FILEPATH: result.path,
+    DIFF: result.diff,
+    CREATED: String(result.created),
+    CWD: cwd
+  };
+}
+function hookEnvForReplace(result, cwd) {
+  return {
+    TOOL: "replace",
+    FILEPATH: result.path,
+    DIFF: result.diff,
+    DELETED: String(result.deleted),
+    CWD: cwd
+  };
+}
+function hookEnvForInsert(result, cwd) {
+  return {
+    TOOL: "insert",
+    FILEPATH: result.path,
+    DIFF: result.diff,
+    CWD: cwd
+  };
+}
+function hookEnvForShell(result, input, cwd) {
+  return {
+    TOOL: "shell",
+    COMMAND: input.command,
+    EXIT_CODE: String(result.exitCode),
+    TIMED_OUT: String(result.timedOut),
+    STDOUT: result.stdout,
+    STDERR: result.stderr,
+    CWD: cwd
+  };
+}
+function hookEnvForGlob(input, cwd) {
+  return {
+    TOOL: "glob",
+    PATTERN: input.pattern,
+    CWD: cwd
+  };
+}
+function hookEnvForGrep(input, cwd) {
+  return {
+    TOOL: "grep",
+    PATTERN: input.pattern,
+    CWD: cwd
+  };
+}
+function hookEnvForRead(input, cwd) {
+  return {
+    TOOL: "read",
+    FILEPATH: input.path,
+    CWD: cwd
+  };
+}
+
+// src/tools/insert.ts
+import { join as join8, relative as relative4 } from "path";
+import { z as z5 } from "zod";
+var InsertSchema = z5.object({
+  path: z5.string().describe("File path to edit (absolute or relative to cwd)"),
+  anchor: z5.string().describe('Anchor line from a prior read/grep, e.g. "11:a3"'),
+  position: z5.enum(["before", "after"]).describe('Insert the content "before" or "after" the anchor line'),
+  content: z5.string().describe("Text to insert")
+});
+var HASH_NOT_FOUND_ERROR = "Hash not found. Re-read the file to get current anchors.";
+var insertTool = {
+  name: "insert",
+  description: "Insert new lines before or after an anchor line in an existing file. " + "The anchor line itself is not modified. " + 'Anchors come from the `read` or `grep` tools (format: "line:hash", e.g. "11:a3"). ' + "To replace or delete lines use `replace`. To create a file use `create`.",
+  schema: InsertSchema,
+  execute: async (input) => {
+    const cwd = input.cwd ?? process.cwd();
+    const filePath = input.path.startsWith("/") ? input.path : join8(cwd, input.path);
+    const relPath = relative4(cwd, filePath);
+    const file = Bun.file(filePath);
+    if (!await file.exists()) {
+      throw new Error(`File not found: "${relPath}". To create a new file use the \`create\` tool.`);
+    }
+    const parsed = parseAnchor(input.anchor);
+    const original = await file.text();
+    const lines = original.split(`
+`);
+    const anchorLine = findLineByHash(lines, parsed.hash, parsed.line);
+    if (!anchorLine)
+      throw new Error(HASH_NOT_FOUND_ERROR);
+    const insertAt = input.position === "before" ? anchorLine - 1 : anchorLine;
+    const insertLines = input.content.split(`
+`);
+    const updatedLines = [
+      ...lines.slice(0, insertAt),
+      ...insertLines,
+      ...lines.slice(insertAt)
+    ];
+    const updated = updatedLines.join(`
+`);
+    await Bun.write(filePath, updated);
+    const diff = generateDiff(relPath, original, updated);
+    return { path: relPath, diff };
+  }
+};
+function parseAnchor(value) {
+  const match = /^\s*(\d+):([0-9a-fA-F]{2})\s*$/.exec(value);
+  if (!match) {
+    throw new Error(`Invalid anchor. Expected format: "line:hh" (e.g. "11:a3").`);
+  }
+  const line = Number(match[1]);
+  if (!Number.isInteger(line) || line < 1) {
+    throw new Error("Invalid anchor line number.");
+  }
+  const hash = match[2];
+  if (!hash) {
+    throw new Error(`Invalid anchor. Expected format: "line:hh" (e.g. "11:a3").`);
+  }
+  return { line, hash: hash.toLowerCase() };
+}
+
+// src/tools/read.ts
+import { join as join9, relative as relative5 } from "path";
+import { z as z6 } from "zod";
+var ReadSchema = z6.object({
+  path: z6.string().describe("File path to read (absolute or relative to cwd)"),
+  line: z6.number().int().min(1).optional().describe("1-indexed starting line (default: 1)"),
+  count: z6.number().int().min(1).max(500).optional().describe("Lines to read (default: 500, max: 500)")
+});
+var MAX_COUNT = 500;
+var MAX_BYTES = 1e6;
+var readTool = {
+  name: "read",
+  description: "Read a file's contents. `line` sets the starting line (1-indexed, default 1). " + "`count` sets how many lines to read (default 500, max 500). " + "Check `truncated` and `totalLines` in the result to detect when more content exists; " + "paginate by incrementing `line`.",
+  schema: ReadSchema,
+  execute: async (input) => {
+    const cwd = input.cwd ?? process.cwd();
+    const filePath = input.path.startsWith("/") ? input.path : join9(cwd, input.path);
+    const file = Bun.file(filePath);
+    const exists = await file.exists();
+    if (!exists) {
+      throw new Error(`File not found: ${input.path}`);
+    }
+    const size = file.size;
+    if (size > MAX_BYTES * 5) {
+      throw new Error(`File too large (${Math.round(size / 1024)}KB). Use grep to search within it.`);
+    }
+    const raw = await file.text();
+    const allLines = raw.split(`
+`);
+    const totalLines = allLines.length;
+    const startLine = input.line ?? 1;
+    const count = Math.min(input.count ?? MAX_COUNT, MAX_COUNT);
+    const clampedStart = Math.max(1, Math.min(startLine, totalLines));
+    const endLine = Math.min(totalLines, clampedStart + count - 1);
+    const truncated = endLine < totalLines;
+    const selectedLines = allLines.slice(clampedStart - 1, endLine);
+    const content = selectedLines.map((line, i) => formatHashLine(clampedStart + i, line)).join(`
+`);
+    return {
+      path: relative5(cwd, filePath),
+      content,
+      totalLines,
+      line: clampedStart,
+      truncated
+    };
+  }
+};
+
+// src/tools/replace.ts
+import { join as join10, relative as relative6 } from "path";
+import { z as z7 } from "zod";
+var ReplaceSchema = z7.object({
+  path: z7.string().describe("File path to edit (absolute or relative to cwd)"),
+  startAnchor: z7.string().describe('Start anchor from a prior read/grep, e.g. "11:a3"'),
+  endAnchor: z7.string().optional().describe('End anchor (inclusive), e.g. "33:0e". Omit to target only the startAnchor line.'),
+  newContent: z7.string().optional().describe("Replacement text. Omit or pass empty string to delete the range.")
+});
+var HASH_NOT_FOUND_ERROR2 = "Hash not found. Re-read the file to get current anchors.";
+var replaceTool = {
+  name: "replace",
+  description: "Replace or delete a range of lines in an existing file using hashline anchors. " + 'Anchors come from the `read` or `grep` tools (format: "line:hash", e.g. "11:a3"). ' + "Provide startAnchor alone to target a single line, or add endAnchor for a range. " + "Set newContent to the replacement text, or omit it to delete the range. " + "To create a file use `create`. To insert without replacing any lines use `insert`.",
+  schema: ReplaceSchema,
+  execute: async (input) => {
+    const cwd = input.cwd ?? process.cwd();
+    const filePath = input.path.startsWith("/") ? input.path : join10(cwd, input.path);
+    const relPath = relative6(cwd, filePath);
+    const file = Bun.file(filePath);
+    if (!await file.exists()) {
+      throw new Error(`File not found: "${relPath}". To create a new file use the \`create\` tool.`);
+    }
+    const start = parseAnchor2(input.startAnchor, "startAnchor");
+    const end = input.endAnchor ? parseAnchor2(input.endAnchor, "endAnchor") : null;
+    if (end && end.line < start.line) {
+      throw new Error("endAnchor line number must be >= startAnchor line number.");
+    }
+    const original = await file.text();
+    const lines = original.split(`
+`);
+    const startLine = findLineByHash(lines, start.hash, start.line);
+    if (!startLine)
+      throw new Error(HASH_NOT_FOUND_ERROR2);
+    let endLine = startLine;
+    if (end) {
+      const resolvedEnd = findLineByHash(lines, end.hash, end.line);
+      if (!resolvedEnd)
+        throw new Error(HASH_NOT_FOUND_ERROR2);
+      endLine = resolvedEnd;
+    }
+    if (endLine < startLine) {
+      throw new Error("endAnchor resolves before startAnchor.");
+    }
+    const replacement = input.newContent === undefined || input.newContent === "" ? [] : input.newContent.split(`
+`);
+    const updatedLines = [
+      ...lines.slice(0, startLine - 1),
+      ...replacement,
+      ...lines.slice(endLine)
+    ];
+    const updated = updatedLines.join(`
+`);
+    await Bun.write(filePath, updated);
+    const diff = generateDiff(relPath, original, updated);
+    return { path: relPath, diff, deleted: replacement.length === 0 };
+  }
+};
+function parseAnchor2(value, name) {
+  const match = /^\s*(\d+):([0-9a-fA-F]{2})\s*$/.exec(value);
+  if (!match) {
+    throw new Error(`Invalid ${name}. Expected format: "line:hh" (e.g. "11:a3").`);
+  }
+  const line = Number(match[1]);
+  if (!Number.isInteger(line) || line < 1) {
+    throw new Error(`Invalid ${name} line number.`);
+  }
+  const hash = match[2];
+  if (!hash) {
+    throw new Error(`Invalid ${name}. Expected format: "line:hh" (e.g. "11:a3").`);
+  }
+  return { line, hash: hash.toLowerCase() };
+}
+
+// src/tools/shell.ts
+import { z as z8 } from "zod";
+var ShellSchema = z8.object({
+  command: z8.string().describe("Shell command to execute"),
+  timeout: z8.number().int().min(1000).max(300000).optional().default(30000).describe("Timeout in milliseconds (default: 30s, max: 5min)"),
+  env: z8.record(z8.string(), z8.string()).optional().describe("Additional environment variables to set")
+});
+var MAX_OUTPUT_BYTES = 1e4;
+var shellTool = {
+  name: "shell",
+  description: "Execute a shell command. Returns stdout, stderr, and exit code. " + "Use this for running tests, builds, git commands, and other CLI operations. " + "Prefer non-interactive commands. Avoid commands that run indefinitely.",
+  schema: ShellSchema,
+  execute: async (input) => {
+    const cwd = input.cwd ?? process.cwd();
+    const timeout = input.timeout ?? 30000;
+    const env = Object.assign({}, process.env, input.env ?? {});
+    let timedOut = false;
+    const proc = Bun.spawn(["bash", "-c", input.command], {
+      cwd,
+      env,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        proc.kill("SIGTERM");
+        setTimeout(() => {
+          try {
+            proc.kill("SIGKILL");
+          } catch {}
+        }, 2000);
+      } catch {}
+    }, timeout);
+    async function collectStream(stream) {
+      const reader = stream.getReader();
+      const chunks = [];
+      let totalBytes = 0;
+      let truncated = false;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        if (value) {
+          if (totalBytes + value.length > MAX_OUTPUT_BYTES) {
+            chunks.push(value.slice(0, MAX_OUTPUT_BYTES - totalBytes));
+            truncated = true;
+            reader.cancel().catch(() => {});
+            break;
+          }
+          chunks.push(value);
+          totalBytes += value.length;
+        }
+      }
+      const text = Buffer.concat(chunks).toString("utf-8");
+      return truncated ? `${text}
+[output truncated]` : text;
+    }
+    let stdout = "";
+    let stderr = "";
+    let exitCode = 1;
+    try {
+      [stdout, stderr] = await Promise.all([
+        collectStream(proc.stdout),
+        collectStream(proc.stderr)
+      ]);
+      exitCode = await proc.exited;
+    } finally {
+      clearTimeout(timer);
+      restoreTerminal();
+    }
+    return {
+      stdout: stdout.trimEnd(),
+      stderr: stderr.trimEnd(),
+      exitCode,
+      success: exitCode === 0,
+      timedOut
+    };
+  }
+};
+
+// src/tools/subagent.ts
+import { z as z9 } from "zod";
+var SubagentInput = z9.object({
+  prompt: z9.string().describe("The task or question to give the subagent")
+});
+function createSubagentTool(runSubagent) {
+  return {
+    name: "subagent",
+    description: "Spawn a sub-agent to handle a focused subtask. " + "Use this for parallel exploration, specialised analysis, or tasks that benefit from " + "a fresh context window. The subagent has access to all the same tools.",
+    schema: SubagentInput,
+    execute: async (input) => {
+      return runSubagent(input.prompt);
+    }
+  };
+}
+
+// src/agent/tools.ts
+function withCwdDefault(tool, cwd) {
+  const originalExecute = tool.execute;
+  return {
+    ...tool,
+    execute: async (input) => {
+      const withDefault = {
+        cwd,
+        ...typeof input === "object" && input ? input : {}
+      };
+      return originalExecute(withDefault);
+    }
+  };
+}
+function withHooks(tool, lookupHook, cwd, buildEnv, onHook) {
+  const originalExecute = tool.execute;
+  return {
+    ...tool,
+    execute: async (input) => {
+      const result = await originalExecute(input);
+      const hookScript = lookupHook(tool.name);
+      if (hookScript) {
+        const env = buildEnv(result, input);
+        const success = await runHook(hookScript, env, cwd);
+        onHook(tool.name, hookScript, success);
+      }
+      return result;
+    }
+  };
+}
+var MAX_SUBAGENT_DEPTH = 3;
+var HOOKABLE_TOOLS = [
+  "glob",
+  "grep",
+  "read",
+  "create",
+  "replace",
+  "insert",
+  "shell"
+];
+function buildToolSet(opts) {
+  const { cwd, onHook } = opts;
+  const depth = opts.depth ?? 0;
+  const lookupHook = createHookCache(HOOKABLE_TOOLS, cwd);
+  return [
+    withHooks(withCwdDefault(globTool, cwd), lookupHook, cwd, (_, input) => hookEnvForGlob(input, cwd), onHook),
+    withHooks(withCwdDefault(grepTool, cwd), lookupHook, cwd, (_, input) => hookEnvForGrep(input, cwd), onHook),
+    withHooks(withCwdDefault(readTool, cwd), lookupHook, cwd, (_, input) => hookEnvForRead(input, cwd), onHook),
+    withHooks(withCwdDefault(createTool, cwd), lookupHook, cwd, (result) => hookEnvForCreate(result, cwd), onHook),
+    withHooks(withCwdDefault(replaceTool, cwd), lookupHook, cwd, (result) => hookEnvForReplace(result, cwd), onHook),
+    withHooks(withCwdDefault(insertTool, cwd), lookupHook, cwd, (result) => hookEnvForInsert(result, cwd), onHook),
+    withHooks(withCwdDefault(shellTool, cwd), lookupHook, cwd, (result, input) => hookEnvForShell(result, input, cwd), onHook),
+    createSubagentTool(async (prompt) => {
+      if (depth >= MAX_SUBAGENT_DEPTH) {
+        throw new Error(`Subagent depth limit reached (max ${MAX_SUBAGENT_DEPTH}). ` + `Cannot spawn another subagent from depth ${depth}.`);
+      }
+      return opts.runSubagent(prompt, depth + 1);
+    })
+  ];
+}
+function buildReadOnlyToolSet(opts) {
+  const { cwd } = opts;
+  return [
+    withCwdDefault(globTool, cwd),
+    withCwdDefault(grepTool, cwd),
+    withCwdDefault(readTool, cwd)
+  ];
+}
+
+// src/agent/agent.ts
+async function getGitBranch(cwd) {
+  try {
+    const proc = Bun.spawn(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const out = await new Response(proc.stdout).text();
+    const code = await proc.exited;
+    if (code !== 0)
+      return null;
+    return out.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function loadContextFile(cwd) {
+  const candidates = [
+    join11(cwd, "AGENTS.md"),
+    join11(cwd, "CLAUDE.md"),
+    join11(getConfigDir(), "AGENTS.md")
+  ];
+  for (const p of candidates) {
+    if (existsSync3(p)) {
+      try {
+        return readFileSync2(p, "utf-8");
+      } catch {}
+    }
+  }
+  return null;
+}
+function buildSystemPrompt(cwd) {
+  const contextFile = loadContextFile(cwd);
+  const cwdDisplay = cwd.startsWith(homedir5()) ? `~${cwd.slice(homedir5().length)}` : cwd;
+  const now = new Date().toLocaleString(undefined, { hour12: false });
+  let prompt = `You are mini-coder, a small and fast CLI coding agent.
+You have access to tools to read files, search code, make edits, run shell commands, and spawn subagents.
+
+Current working directory: ${cwdDisplay}
+Current date/time: ${now}
+
+Guidelines:
+- Be concise and precise. Avoid unnecessary preamble.
+- Prefer small, targeted edits over large rewrites.
+- Always read a file before editing it.
+- Use glob to discover files, grep to find patterns, read to inspect contents.
+- Use shell for tests, builds, and git operations.
+- When in doubt, ask the user before making destructive changes.`;
+  if (contextFile) {
+    prompt += `
+
+# Project context
+
+${contextFile}`;
+  }
+  return prompt;
+}
+async function runShellPassthrough(command, cwd) {
+  const proc = Bun.spawn(["bash", "-c", command], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  try {
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    await proc.exited;
+    const out = [stdout, stderr].filter(Boolean).join(`
+`).trim();
+    if (out)
+      writeln(c6.dim(out));
+    return out;
+  } finally {
+    restoreTerminal();
+  }
+}
+async function runAgent(opts) {
+  const cwd = opts.cwd;
+  let currentModel = opts.model;
+  let session;
+  if (opts.sessionId) {
+    const resumed = resumeSession(opts.sessionId);
+    if (!resumed) {
+      renderError(`Session "${opts.sessionId}" not found.`);
+      process.exit(1);
+    }
+    session = resumed;
+    currentModel = session.model;
+    deleteAllSnapshots(session.id);
+    renderInfo(`Resumed session ${session.id} (${c6.cyan(currentModel)})`);
+  } else {
+    session = newSession(currentModel, cwd);
+  }
+  let turnIndex = getMaxTurnIndex(session.id) + 1;
+  const coreHistory = [...session.messages];
+  const runSubagent = async (prompt, depth = 0) => {
+    const subMessages = [{ role: "user", content: prompt }];
+    const subTools = buildToolSet({
+      cwd,
+      depth,
+      runSubagent,
+      onHook: renderHook
+    });
+    const subLlm = resolveModel(currentModel);
+    const systemPrompt = buildSystemPrompt(cwd);
+    let result = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    const activity = [];
+    const pendingCalls = new Map;
+    const events = runTurn({
+      model: subLlm,
+      messages: subMessages,
+      tools: subTools,
+      systemPrompt
+    });
+    for await (const event of events) {
+      if (event.type === "text-delta")
+        result += event.delta;
+      if (event.type === "tool-call-start") {
+        pendingCalls.set(event.toolCallId, {
+          toolName: event.toolName,
+          args: event.args
+        });
+      }
+      if (event.type === "tool-result") {
+        const pending = pendingCalls.get(event.toolCallId);
+        if (pending) {
+          pendingCalls.delete(event.toolCallId);
+          activity.push({
+            toolName: pending.toolName,
+            args: pending.args,
+            result: event.result,
+            isError: event.isError
+          });
+        }
+      }
+      if (event.type === "turn-complete") {
+        inputTokens = event.inputTokens;
+        outputTokens = event.outputTokens;
+      }
+    }
+    return { result, inputTokens, outputTokens, activity };
+  };
+  const tools = buildToolSet({
+    cwd,
+    depth: 0,
+    runSubagent,
+    onHook: renderHook
+  });
+  const mcpTools = [];
+  async function connectAndAddMcp(name) {
+    const rows = listMcpServers();
+    const row = rows.find((r) => r.name === name);
+    if (!row)
+      throw new Error(`MCP server "${name}" not found in DB`);
+    const cfg = {
+      name: row.name,
+      transport: row.transport,
+      ...row.url ? { url: row.url } : {},
+      ...row.command ? { command: row.command } : {},
+      ...row.args ? { args: JSON.parse(row.args) } : {},
+      ...row.env ? { env: JSON.parse(row.env) } : {}
+    };
+    const client = await connectMcpServer(cfg);
+    tools.push(...client.tools);
+    mcpTools.push(...client.tools);
+  }
+  for (const row of listMcpServers()) {
+    try {
+      await connectAndAddMcp(row.name);
+      renderInfo(`MCP: connected ${c6.cyan(row.name)}`);
+    } catch (e) {
+      renderError(`MCP: failed to connect ${row.name}: ${String(e)}`);
+    }
+  }
+  let planMode = false;
+  let ralphMode = false;
+  const cmdCtx = {
+    get currentModel() {
+      return currentModel;
+    },
+    setModel: (m) => {
+      currentModel = m;
+      session.model = m;
+      setPreferredModel(m);
+    },
+    get planMode() {
+      return planMode;
+    },
+    get ralphMode() {
+      return ralphMode;
+    },
+    setRalphMode: (v) => {
+      ralphMode = v;
+    },
+    setPlanMode: (v) => {
+      planMode = v;
+    },
+    cwd,
+    runSubagent: (prompt) => runSubagent(prompt),
+    undoLastTurn: async () => {
+      if (session.messages.length === 0)
+        return false;
+      let lastUserIdx = -1;
+      for (let i = session.messages.length - 1;i >= 0; i--) {
+        if (session.messages[i]?.role === "user") {
+          lastUserIdx = i;
+          break;
+        }
+      }
+      if (lastUserIdx === -1)
+        return false;
+      session.messages.splice(lastUserIdx);
+      let coreLastUserIdx = -1;
+      for (let i = coreHistory.length - 1;i >= 0; i--) {
+        if (coreHistory[i]?.role === "user") {
+          coreLastUserIdx = i;
+          break;
+        }
+      }
+      if (coreLastUserIdx !== -1)
+        coreHistory.splice(coreLastUserIdx);
+      const deleted = deleteLastTurn(session.id);
+      const poppedTurn = snapshotStack.pop() ?? null;
+      if (turnIndex > 0)
+        turnIndex--;
+      if (poppedTurn !== null) {
+        const restoreResult = await restoreSnapshot(cwd, session.id, poppedTurn);
+        if (restoreResult.restored === false && restoreResult.reason === "error") {
+          renderError("snapshot restore failed \u2014 some files may not have been reverted");
+        }
+      }
+      return deleted;
+    },
+    connectMcpServer: connectAndAddMcp,
+    startNewSession: () => {
+      deleteAllSnapshots(session.id);
+      session = newSession(currentModel, cwd);
+      coreHistory.length = 0;
+      turnIndex = 1;
+      totalIn = 0;
+      totalOut = 0;
+      lastContextTokens = 0;
+      snapshotStack.length = 0;
+    }
+  };
+  const spinner = new Spinner;
+  let totalIn = 0;
+  let totalOut = 0;
+  let lastContextTokens = 0;
+  const snapshotStack = [];
+  if (opts.initialPrompt) {
+    await processUserInput(opts.initialPrompt);
+  }
+  while (true) {
+    await renderStatusBarForSession();
+    let input;
+    try {
+      input = await readline({ cwd, planMode, ralphMode });
+    } catch {
+      break;
+    }
+    switch (input.type) {
+      case "eof":
+        writeln(c6.dim("Goodbye."));
+        return;
+      case "interrupt":
+        continue;
+      case "command": {
+        const result = await handleCommand(input.command, input.args, cmdCtx);
+        if (result.type === "exit") {
+          writeln(c6.dim("Goodbye."));
+          return;
+        }
+        if (result.type === "inject-user-message") {
+          await processUserInput(result.text);
+        }
+        continue;
+      }
+      case "shell": {
+        const out = await runShellPassthrough(input.command, cwd);
+        if (out) {
+          const thisTurn = turnIndex++;
+          const msg = {
+            role: "user",
+            content: `Shell output of \`${input.command}\`:
+\`\`\`
+${out}
+\`\`\``
+          };
+          session.messages.push(msg);
+          saveMessages(session.id, [msg], thisTurn);
+          coreHistory.push(msg);
+        }
+        continue;
+      }
+      case "submit": {
+        const RALPH_MAX_ITERATIONS = 20;
+        let ralphIteration = 1;
+        let lastText = await processUserInput(input.text, input.images);
+        if (ralphMode) {
+          const goal = input.text;
+          const goalImages = input.images;
+          while (ralphMode) {
+            if (hasRalphSignal(lastText)) {
+              ralphMode = false;
+              writeln(`${PREFIX.info} ${c6.dim("ralph mode off")}`);
+              break;
+            }
+            if (ralphIteration >= RALPH_MAX_ITERATIONS) {
+              writeln(`${PREFIX.info} ${c6.yellow("ralph")} ${c6.dim("\u2014 max iterations reached, stopping")}`);
+              ralphMode = false;
+              break;
+            }
+            ralphIteration++;
+            cmdCtx.startNewSession();
+            lastText = await processUserInput(goal, goalImages);
+          }
+        }
+        continue;
+      }
+    }
+  }
+  async function processUserInput(text, pastedImages = []) {
+    const abortController = new AbortController;
+    let wasAborted = false;
+    const onSigInt = () => {
+      wasAborted = true;
+      abortController.abort();
+      process.removeListener("SIGINT", onSigInt);
+    };
+    process.on("SIGINT", onSigInt);
+    const { text: resolvedText, images: refImages } = await resolveFileRefs(text, cwd);
+    const allImages = [...pastedImages, ...refImages];
+    const thisTurn = turnIndex++;
+    const snapped = await takeSnapshot(cwd, session.id, thisTurn);
+    if (wasAborted) {
+      process.removeListener("SIGINT", onSigInt);
+      if (snapped)
+        deleteSnapshot(session.id, thisTurn);
+      turnIndex--;
+      return "";
+    }
+    const coreContent = planMode ? `${resolvedText}
+
+<system-message>PLAN MODE ACTIVE: Help the user gather context for the plan -- READ ONLY</system-message>` : ralphMode ? `${resolvedText}
+
+<system-message>RALPH MODE: You are in an autonomous loop. When the task is fully complete (all tests pass, no outstanding issues), output exactly \`/ralph\` as your final message to exit the loop. Otherwise, keep working.</system-message>` : resolvedText;
+    const userMsg = allImages.length > 0 ? {
+      role: "user",
+      content: [
+        { type: "text", text: coreContent },
+        ...allImages.map((img) => ({
+          type: "image",
+          image: img.data,
+          mediaType: img.mediaType
+        }))
+      ]
+    } : { role: "user", content: coreContent };
+    session.messages.push(userMsg);
+    saveMessages(session.id, [userMsg], thisTurn);
+    coreHistory.push(userMsg);
+    const llm = resolveModel(currentModel);
+    const systemPrompt = buildSystemPrompt(cwd);
+    let lastAssistantText = "";
+    let turnRolledBack = false;
+    const rollbackTurn = () => {
+      if (turnRolledBack)
+        return;
+      turnRolledBack = true;
+      coreHistory.pop();
+      session.messages.pop();
+      deleteLastTurn(session.id, thisTurn);
+      if (snapped)
+        deleteSnapshot(session.id, thisTurn);
+      snapshotStack.pop();
+      turnIndex--;
+    };
+    try {
+      snapshotStack.push(snapped ? thisTurn : null);
+      spinner.start("thinking");
+      const events = runTurn({
+        model: llm,
+        messages: coreHistory,
+        tools: planMode ? [...buildReadOnlyToolSet({ cwd }), ...mcpTools] : tools,
+        systemPrompt,
+        signal: abortController.signal
+      });
+      const { inputTokens, outputTokens, contextTokens, newMessages } = await renderTurn(events, spinner);
+      if (newMessages.length > 0) {
+        coreHistory.push(...newMessages);
+        session.messages.push(...newMessages);
+        saveMessages(session.id, newMessages, thisTurn);
+      } else {
+        rollbackTurn();
+      }
+      lastAssistantText = extractAssistantText(newMessages);
+      totalIn += inputTokens;
+      totalOut += outputTokens;
+      lastContextTokens = contextTokens;
+      touchActiveSession(session);
+    } catch (err) {
+      rollbackTurn();
+      throw err;
+    } finally {
+      process.removeListener("SIGINT", onSigInt);
+      if (wasAborted)
+        ralphMode = false;
+    }
+    return lastAssistantText;
+  }
+  async function renderStatusBarForSession() {
+    const branch = await getGitBranch(cwd);
+    const provider = currentModel.split("/")[0] ?? "";
+    const modelShort = currentModel.split("/").slice(1).join("/");
+    const cwdDisplay = cwd.startsWith(homedir5()) ? `~${cwd.slice(homedir5().length)}` : cwd;
+    renderStatusBar({
+      model: modelShort,
+      provider,
+      cwd: cwdDisplay,
+      gitBranch: branch,
+      sessionId: session.id,
+      inputTokens: totalIn,
+      outputTokens: totalOut,
+      contextTokens: lastContextTokens,
+      contextWindow: getContextWindow(currentModel),
+      ralphMode
+    });
+  }
+}
+function extractAssistantText(newMessages) {
+  const parts = [];
+  for (const msg of newMessages) {
+    if (msg.role !== "assistant")
+      continue;
+    const content = msg.content;
+    if (typeof content === "string") {
+      parts.push(content);
+    } else if (Array.isArray(content)) {
+      for (const part of content) {
+        if (part?.type === "text" && part.text)
+          parts.push(part.text);
+      }
+    }
+  }
+  return parts.join(`
+`);
+}
+function hasRalphSignal(text) {
+  return /\/ralph\b/.test(text);
+}
+async function resolveFileRefs(text, cwd) {
+  const atPattern = /@([\w./\-_]+)/g;
+  let result = text;
+  const matches = [...text.matchAll(atPattern)];
+  const images = [];
+  for (const match of matches.reverse()) {
+    const ref = match[1];
+    if (!ref)
+      continue;
+    const filePath = ref.startsWith("/") ? ref : join11(cwd, ref);
+    if (isImageFilename(ref)) {
+      const attachment = await loadImageFile(filePath);
+      if (attachment) {
+        images.unshift(attachment);
+        result = result.slice(0, match.index) + result.slice((match.index ?? 0) + match[0].length);
+        continue;
+      }
+    }
+    try {
+      const content = await Bun.file(filePath).text();
+      const lines = content.split(`
+`);
+      const preview = lines.length > 200 ? `${lines.slice(0, 200).join(`
+`)}
+[truncated]` : content;
+      const replacement = `\`${ref}\`:
+\`\`\`
+${preview}
+\`\`\``;
+      result = result.slice(0, match.index) + replacement + result.slice((match.index ?? 0) + match[0].length);
+    } catch {}
+  }
+  return { text: result, images };
+}
+
+// src/index.ts
+registerTerminalCleanup();
+function parseArgs(argv) {
+  const args = {
+    model: null,
+    sessionId: null,
+    listSessions: false,
+    resumeLast: false,
+    prompt: null,
+    cwd: process.cwd(),
+    help: false
+  };
+  const positional = [];
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i] ?? "";
+    switch (arg) {
+      case "--model":
+      case "-m":
+        args.model = argv[++i] ?? null;
+        break;
+      case "--resume":
+      case "-r":
+        args.sessionId = argv[++i] ?? null;
+        break;
+      case "--continue":
+      case "-c":
+        args.resumeLast = true;
+        break;
+      case "--list":
+      case "-l":
+        args.listSessions = true;
+        break;
+      case "--cwd":
+        args.cwd = argv[++i] ?? process.cwd();
+        break;
+      case "--help":
+      case "-h":
+        args.help = true;
+        break;
+      default:
+        if (!arg.startsWith("-"))
+          positional.push(arg);
+    }
+  }
+  if (positional.length > 0) {
+    args.prompt = positional.join(" ");
+  }
+  return args;
+}
+function printHelp() {
+  writeln(`${c7.bold("mini-coder")} \u2014 a small, fast CLI coding agent
+`);
+  writeln(`${c7.bold("Usage:")}  mc [options] [prompt]
+`);
+  writeln(`${c7.bold("Options:")}`);
+  const opts = [
+    ["-m, --model <id>", "Model to use (e.g. zen/claude-sonnet-4-6)"],
+    ["-c, --continue", "Continue the most recent session"],
+    ["-r, --resume <id>", "Resume a specific session by ID"],
+    ["-l, --list", "List recent sessions"],
+    ["--cwd <path>", "Set working directory (default: current dir)"],
+    ["-h, --help", "Show this help"]
+  ];
+  for (const [flag, desc] of opts) {
+    writeln(`  ${c7.cyan((flag ?? "").padEnd(22))} ${c7.dim(desc ?? "")}`);
+  }
+  writeln(`
+${c7.bold("Provider env vars:")}`);
+  const envs = [
+    ["OPENCODE_API_KEY", "OpenCode Zen (recommended)"],
+    ["ANTHROPIC_API_KEY", "Anthropic direct"],
+    ["OPENAI_API_KEY", "OpenAI direct"],
+    ["GOOGLE_API_KEY", "Google Gemini direct"],
+    ["OLLAMA_BASE_URL", "Ollama base URL (default: http://localhost:11434)"]
+  ];
+  for (const [env, desc] of envs) {
+    writeln(`  ${c7.yellow((env ?? "").padEnd(22))} ${c7.dim(desc ?? "")}`);
+  }
+  writeln(`
+${c7.bold("Examples:")}`);
+  writeln(`  mc                           ${c7.dim("# interactive session")}`);
+  writeln(`  mc "explain this codebase"   ${c7.dim("# one-shot prompt then interactive")}`);
+  writeln(`  mc -c                        ${c7.dim("# continue last session")}`);
+  writeln(`  mc -m ollama/llama3.2        ${c7.dim("# use local Ollama model")}`);
+  writeln(`  mc -l                        ${c7.dim("# list sessions")}`);
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const args = parseArgs(argv);
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+  if (args.listSessions) {
+    printSessionList();
+    process.exit(0);
+  }
+  let sessionId;
+  if (args.resumeLast) {
+    const last = getMostRecentSession();
+    if (last) {
+      sessionId = last.id;
+    } else {
+      writeln(c7.dim("No previous session found, starting fresh."));
+    }
+  } else if (args.sessionId) {
+    sessionId = args.sessionId;
+  }
+  const model = args.model ?? getPreferredModel() ?? autoDiscoverModel();
+  if (!args.prompt) {
+    renderBanner(model, args.cwd);
+  }
+  try {
+    const agentOpts = { model, cwd: args.cwd };
+    if (sessionId)
+      agentOpts.sessionId = sessionId;
+    if (args.prompt)
+      agentOpts.initialPrompt = args.prompt;
+    await runAgent(agentOpts);
+  } catch (err) {
+    renderError(err);
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});