mini-coder 0.0.13 → 0.0.15

package/dist/mc.js

@@ -349,17 +349,6 @@ function renderMarkdown(text) {
   }).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/tool-render.ts
 import { homedir as homedir2 } from "os";
@@ -433,7 +422,7 @@ function toolCallLine(name, args) {
   if (name === "shell") {
     const cmd = String(a.command ?? "");
     const shortCmd = cmd.length > 72 ? `${cmd.slice(0, 69)}\u2026` : cmd;
-    return `${G.run} ${c3.dim("$")} ${shortCmd}`;
+    return `${G.run} ${shortCmd}`;
   }
   if (name === "subagent") {
     const prompt = String(a.prompt ?? "");
@@ -474,19 +463,25 @@ function renderDiff(diff) {
     }
   }
 }
+function formatErrorBadge(result) {
+  const msg = typeof result === "string" ? result : result instanceof Error ? result.message : JSON.stringify(result);
+  const oneLiner = msg.split(`
+`)[0] ?? msg;
+  return `${G.err} ${c3.red(oneLiner)}`;
+}
+function formatShellBadge(r) {
+  return r.timedOut ? c3.yellow("timeout") : r.success ? c3.green(`\u2714 ${r.exitCode}`) : c3.red(`\u2716 ${r.exitCode}`);
+}
 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} ${c3.red(oneLiner)}`);
+    writeln(`${indent}${formatErrorBadge(result)}`);
     return;
   }
   if (toolName === "glob") {
-    const r = result;
-    if (Array.isArray(r?.files)) {
-      const n = r.files.length;
-      writeln(`${indent}${G.info} ${c3.dim(n === 0 ? "no matches" : `${n} file${n === 1 ? "" : "s"}${r.truncated ? " (capped)" : ""}`)}`);
+    const res = result;
+    if (Array.isArray(res?.files)) {
+      const n = res.files.length;
+      writeln(`${indent}${G.info} ${c3.dim(n === 0 ? "no matches" : `${n} file${n === 1 ? "" : "s"}${res.truncated ? " (capped)" : ""}`)}`);
       return;
     }
   }
@@ -517,7 +512,7 @@ function renderToolResultInline(toolName, result, isError, indent) {
   }
   if (toolName === "shell") {
     const r = result;
-    const badge = r.timedOut ? c3.yellow("timeout") : r.success ? c3.green(`\u2714 ${r.exitCode}`) : c3.red(`\u2716 ${r.exitCode}`);
+    const badge = formatShellBadge(r);
     writeln(`${indent}${badge}`);
     return;
   }
@@ -556,10 +551,7 @@ function renderToolResultInline(toolName, result, 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} ${c3.red(oneLiner)}`);
+    writeln(`    ${formatErrorBadge(result)}`);
     return;
   }
   if (toolName === "glob") {
@@ -635,7 +627,7 @@ function renderToolResult(toolName, result, isError) {
   }
   if (toolName === "shell") {
     const r = result;
-    const badge = r.timedOut ? c3.yellow("timeout") : r.success ? c3.green(`\u2714 ${r.exitCode}`) : c3.red(`\u2716 ${r.exitCode}`);
+    const badge = formatShellBadge(r);
     writeln(`    ${badge}`);
     const outLines = r.stdout ? r.stdout.split(`
 `) : [];
@@ -716,15 +708,27 @@ function renderToolResult(toolName, result, isError) {
   const text = JSON.stringify(result);
   writeln(`    ${c3.dim(text.length > 120 ? `${text.slice(0, 117)}\u2026` : text)}`);
 }
+function stripAnsiSgr(text) {
+  const esc = String.fromCharCode(27);
+  return text.replace(new RegExp(`${esc}\\[[0-9;]*m`, "g"), "");
+}
+function normalizeParentLaneLabel(parentLabel) {
+  const plain = stripAnsiSgr(parentLabel);
+  const match = plain.match(/\[([^\]]+)\]/);
+  const inner = (match?.[1] ?? plain).trim();
+  const lanePath = (inner.split("\xB7")[0] ?? inner).trim();
+  return lanePath || inner;
+}
 function formatSubagentLabel(laneId, parentLabel) {
-  const numStr = parentLabel ? `${parentLabel.replace(/[\[\]]/g, "")}.${laneId}` : `${laneId}`;
+  const parent = parentLabel ? normalizeParentLaneLabel(parentLabel) : "";
+  const numStr = parent ? `${parent}.${laneId}` : `${laneId}`;
   return c3.dim(c3.cyan(`[${numStr}]`));
 }
 var laneBuffers = new Map;
 function renderSubagentEvent(event, opts) {
-  const { laneId, parentLabel, activeLanes } = opts;
+  const { laneId, parentLabel, hasWorktree, activeLanes } = opts;
   const labelStr = formatSubagentLabel(laneId, parentLabel);
-  const prefix = activeLanes.size > 1 ? `${labelStr} ` : "";
+  const prefix = activeLanes.size > 1 || hasWorktree ? `${labelStr} ` : "";
   if (event.type === "text-delta") {
     const buf = (laneBuffers.get(laneId) ?? "") + event.delta;
     const lines = buf.split(`
@@ -766,82 +770,46 @@ 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);
+  function renderAndWrite(raw, endWithNewline) {
+    const rendered = renderLine(raw, inFence);
     inFence = rendered.inFence;
-    enqueuePrint(rendered.output);
-    rawBuffer = rawBuffer.slice(end);
+    write(rendered.output);
+    if (endWithNewline) {
+      write(`
+`);
+    }
   }
-  function flushChunks() {
+  function flushCompleteLines() {
     let boundary = rawBuffer.indexOf(`
-
 `);
-    if (boundary !== -1) {
-      renderAndTrim(boundary + 2);
-      flushChunks();
-      return;
-    }
-    boundary = rawBuffer.lastIndexOf(`
+    while (boundary !== -1) {
+      renderAndWrite(rawBuffer.slice(0, boundary), true);
+      rawBuffer = rawBuffer.slice(boundary + 1);
+      boundary = rawBuffer.indexOf(`
 `);
-    if (boundary !== -1) {
-      renderAndTrim(boundary + 1);
     }
   }
   function flushAll() {
-    if (rawBuffer) {
-      renderAndTrim(rawBuffer.length);
+    if (!rawBuffer) {
+      return;
     }
-    drainQueue();
+    renderAndWrite(rawBuffer, false);
+    rawBuffer = "";
   }
   for await (const event of events) {
     switch (event.type) {
       case "text-delta": {
         if (!inText) {
           spinner.stop();
-          process.stdout.write(`${G.reply} `);
+          write(`${G.reply} `);
           inText = true;
         }
         rawBuffer += event.delta;
-        flushChunks();
+        flushCompleteLines();
         break;
       }
       case "tool-call-start": {
@@ -940,7 +908,7 @@ function renderStatusBar(opts) {
     left.push(c5.magenta("\u21BB ralph"));
   const right = [];
   if (opts.inputTokens > 0 || opts.outputTokens > 0) {
-    right.push(c5.dim(`\u2191${fmtTokens(opts.inputTokens)} \u2193${fmtTokens(opts.outputTokens)}`));
+    right.push(c5.dim(`\u2191 ${fmtTokens(opts.inputTokens)} \u2193 ${fmtTokens(opts.outputTokens)}`));
   }
   if (opts.contextTokens > 0) {
     const ctxRaw = fmtTokens(opts.contextTokens);
@@ -978,7 +946,7 @@ function renderError(err, context = "render") {
 
 // src/cli/output.ts
 var HOME2 = homedir3();
-var PACKAGE_VERSION = "0.0.12";
+var PACKAGE_VERSION = "0.0.15";
 function tildePath(p) {
   return p.startsWith(HOME2) ? `~${p.slice(HOME2.length)}` : p;
 }
@@ -1024,7 +992,7 @@ function renderBanner(model, cwd) {
   writeln();
   writeln(`  ${c7.cyan("mc")}  ${c7.dim(`mini-coder \xB7 v${PACKAGE_VERSION}`)}`);
   writeln(`  ${c7.dim(model)}  ${c7.dim("\xB7")}  ${c7.dim(cwd)}`);
-  writeln(`  ${c7.dim("/help for commands  \xB7  ctrl+d to exit")}`);
+  writeln(`  ${c7.dim("/help for commands  \xB7  esc cancel  \xB7  ctrl+c/ctrl+d exit")}`);
   writeln();
 }
 function renderInfo(msg) {
@@ -1068,6 +1036,8 @@ function parseFrontmatter(raw) {
       meta.description = val;
     if (key === "model")
       meta.model = val;
+    if (key === "execution")
+      meta.execution = val;
   }
   return { meta, body: (m[2] ?? "").trim() };
 }
@@ -1207,6 +1177,745 @@ function logApiEvent(event, data) {
   writer2.flush();
 }
 
+// src/session/db/connection.ts
+import { Database } from "bun:sqlite";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, unlinkSync } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join4 } from "path";
+function getConfigDir() {
+  return join4(homedir6(), ".config", "mini-coder");
+}
+function getDbPath() {
+  const dir = getConfigDir();
+  if (!existsSync2(dir))
+    mkdirSync3(dir, { recursive: true });
+  return join4(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 model_capabilities (
+    canonical_model_id TEXT PRIMARY KEY,
+    context_window     INTEGER,
+    reasoning          INTEGER NOT NULL,
+    source_provider    TEXT,
+    raw_json           TEXT,
+    updated_at         INTEGER NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS provider_models (
+    provider           TEXT NOT NULL,
+    provider_model_id  TEXT NOT NULL,
+    display_name       TEXT NOT NULL,
+    canonical_model_id TEXT,
+    context_window     INTEGER,
+    free               INTEGER,
+    updated_at         INTEGER NOT NULL,
+    PRIMARY KEY (provider, provider_model_id)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_provider_models_provider
+    ON provider_models(provider);
+
+  CREATE INDEX IF NOT EXISTS idx_provider_models_canonical
+    ON provider_models(canonical_model_id);
+
+  CREATE TABLE IF NOT EXISTS model_info_state (
+    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 (existsSync2(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;
+}
+
+// src/session/db/model-info-repo.ts
+function listModelCapabilities() {
+  return getDb().query("SELECT canonical_model_id, context_window, reasoning, source_provider, raw_json, updated_at FROM model_capabilities").all();
+}
+function replaceModelCapabilities(rows) {
+  const db = getDb();
+  const insertStmt = db.prepare(`INSERT INTO model_capabilities (
+			canonical_model_id,
+			context_window,
+			reasoning,
+			source_provider,
+			raw_json,
+			updated_at
+		) VALUES (?, ?, ?, ?, ?, ?)`);
+  const run = db.transaction(() => {
+    db.run("DELETE FROM model_capabilities");
+    for (const row of rows) {
+      insertStmt.run(row.canonical_model_id, row.context_window, row.reasoning, row.source_provider, row.raw_json, row.updated_at);
+    }
+  });
+  run();
+}
+function listProviderModels() {
+  return getDb().query("SELECT provider, provider_model_id, display_name, canonical_model_id, context_window, free, updated_at FROM provider_models ORDER BY provider ASC, display_name ASC").all();
+}
+function replaceProviderModels(provider, rows) {
+  const db = getDb();
+  const insertStmt = db.prepare(`INSERT INTO provider_models (
+			provider,
+			provider_model_id,
+			display_name,
+			canonical_model_id,
+			context_window,
+			free,
+			updated_at
+		) VALUES (?, ?, ?, ?, ?, ?, ?)
+		ON CONFLICT(provider, provider_model_id) DO UPDATE SET
+			display_name = excluded.display_name,
+			canonical_model_id = excluded.canonical_model_id,
+			context_window = excluded.context_window,
+			free = excluded.free,
+			updated_at = excluded.updated_at`);
+  const run = db.transaction(() => {
+    db.run("DELETE FROM provider_models WHERE provider = ?", [provider]);
+    for (const row of rows) {
+      insertStmt.run(provider, row.provider_model_id, row.display_name, row.canonical_model_id, row.context_window, row.free, row.updated_at);
+    }
+  });
+  run();
+}
+function setModelInfoState(key, value) {
+  getDb().run(`INSERT INTO model_info_state (key, value) VALUES (?, ?)
+		 ON CONFLICT(key) DO UPDATE SET value = excluded.value`, [key, value]);
+}
+function listModelInfoState() {
+  return getDb().query("SELECT key, value FROM model_info_state").all();
+}
+
+// src/llm-api/model-info.ts
+var ZEN_BASE = "https://opencode.ai/zen/v1";
+var OPENAI_BASE = "https://api.openai.com";
+var ANTHROPIC_BASE = "https://api.anthropic.com";
+var GOOGLE_BASE = "https://generativelanguage.googleapis.com/v1beta";
+var MODELS_DEV_URL = "https://models.dev/api.json";
+var MODELS_DEV_SYNC_KEY = "last_models_dev_sync_at";
+var PROVIDER_SYNC_KEY_PREFIX = "last_provider_sync_at:";
+var MODEL_INFO_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+var runtimeCache = emptyRuntimeCache();
+var loaded = false;
+var refreshInFlight = null;
+function emptyRuntimeCache() {
+  return {
+    capabilitiesByCanonical: new Map,
+    providerModelsByKey: new Map,
+    providerModelUniqIndex: new Map,
+    matchIndex: {
+      exact: new Map,
+      alias: new Map
+    },
+    state: new Map
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseModelStringLoose(modelString) {
+  const slash = modelString.indexOf("/");
+  if (slash === -1) {
+    return { provider: null, modelId: modelString };
+  }
+  const provider = modelString.slice(0, slash).trim().toLowerCase();
+  const modelId = modelString.slice(slash + 1);
+  return { provider: provider || null, modelId };
+}
+function providerModelKey(provider, modelId) {
+  return `${provider}/${modelId}`;
+}
+function basename2(value) {
+  const idx = value.lastIndexOf("/");
+  return idx === -1 ? value : value.slice(idx + 1);
+}
+function normalizeModelId(modelId) {
+  let out = modelId.trim().toLowerCase();
+  while (out.startsWith("models/")) {
+    out = out.slice("models/".length);
+  }
+  return out;
+}
+function parseContextWindow(model) {
+  const limit = model.limit;
+  if (!isRecord(limit))
+    return null;
+  const context = limit.context;
+  if (typeof context !== "number" || !Number.isFinite(context))
+    return null;
+  return Math.max(0, Math.trunc(context));
+}
+function parseModelsDevCapabilities(payload, updatedAt) {
+  if (!isRecord(payload))
+    return [];
+  const merged = new Map;
+  for (const [provider, providerValue] of Object.entries(payload)) {
+    if (!isRecord(providerValue))
+      continue;
+    const models = providerValue.models;
+    if (!isRecord(models))
+      continue;
+    for (const [modelKey, modelValue] of Object.entries(models)) {
+      if (!isRecord(modelValue))
+        continue;
+      const explicitId = typeof modelValue.id === "string" && modelValue.id.trim().length > 0 ? modelValue.id : modelKey;
+      const canonicalModelId = normalizeModelId(explicitId);
+      if (!canonicalModelId)
+        continue;
+      const contextWindow = parseContextWindow(modelValue);
+      const reasoning = modelValue.reasoning === true;
+      const rawJson = JSON.stringify(modelValue);
+      const prev = merged.get(canonicalModelId);
+      if (!prev) {
+        merged.set(canonicalModelId, {
+          canonicalModelId,
+          contextWindow,
+          reasoning,
+          sourceProvider: provider,
+          rawJson
+        });
+        continue;
+      }
+      merged.set(canonicalModelId, {
+        canonicalModelId,
+        contextWindow: prev.contextWindow ?? contextWindow,
+        reasoning: prev.reasoning || reasoning,
+        sourceProvider: prev.sourceProvider,
+        rawJson: prev.rawJson ?? rawJson
+      });
+    }
+  }
+  return Array.from(merged.values()).map((entry) => ({
+    canonical_model_id: entry.canonicalModelId,
+    context_window: entry.contextWindow,
+    reasoning: entry.reasoning ? 1 : 0,
+    source_provider: entry.sourceProvider,
+    raw_json: entry.rawJson,
+    updated_at: updatedAt
+  }));
+}
+function buildModelMatchIndex(canonicalModelIds) {
+  const exact = new Map;
+  const aliasCandidates = new Map;
+  for (const rawCanonical of canonicalModelIds) {
+    const canonical = normalizeModelId(rawCanonical);
+    if (!canonical)
+      continue;
+    exact.set(canonical, canonical);
+    const short = basename2(canonical);
+    if (!short)
+      continue;
+    let set = aliasCandidates.get(short);
+    if (!set) {
+      set = new Set;
+      aliasCandidates.set(short, set);
+    }
+    set.add(canonical);
+  }
+  const alias = new Map;
+  for (const [short, candidates] of aliasCandidates) {
+    if (candidates.size === 1) {
+      for (const value of candidates) {
+        alias.set(short, value);
+      }
+    } else {
+      alias.set(short, null);
+    }
+  }
+  return { exact, alias };
+}
+function matchCanonicalModelId(providerModelId, index) {
+  const normalized = normalizeModelId(providerModelId);
+  if (!normalized)
+    return null;
+  const exactMatch = index.exact.get(normalized);
+  if (exactMatch)
+    return exactMatch;
+  const short = basename2(normalized);
+  if (!short)
+    return null;
+  const alias = index.alias.get(short);
+  return alias ?? null;
+}
+function isStaleTimestamp(timestamp, now = Date.now(), ttlMs = MODEL_INFO_TTL_MS) {
+  if (timestamp === null)
+    return true;
+  return now - timestamp > ttlMs;
+}
+function buildRuntimeCache(capabilityRows, providerRows, stateRows) {
+  const capabilitiesByCanonical = new Map;
+  for (const row of capabilityRows) {
+    const canonical = normalizeModelId(row.canonical_model_id);
+    if (!canonical)
+      continue;
+    capabilitiesByCanonical.set(canonical, {
+      canonicalModelId: canonical,
+      contextWindow: row.context_window,
+      reasoning: row.reasoning === 1,
+      sourceProvider: row.source_provider
+    });
+  }
+  const providerModelsByKey = new Map;
+  const providerModelUniqIndex = new Map;
+  for (const row of providerRows) {
+    const provider = row.provider.trim().toLowerCase();
+    const providerModelId = normalizeModelId(row.provider_model_id);
+    if (!provider || !providerModelId)
+      continue;
+    const key = providerModelKey(provider, providerModelId);
+    providerModelsByKey.set(key, {
+      provider,
+      providerModelId,
+      displayName: row.display_name,
+      canonicalModelId: row.canonical_model_id ? normalizeModelId(row.canonical_model_id) : null,
+      contextWindow: row.context_window,
+      free: row.free === 1
+    });
+    const prev = providerModelUniqIndex.get(providerModelId);
+    if (prev === undefined) {
+      providerModelUniqIndex.set(providerModelId, key);
+    } else if (prev !== key) {
+      providerModelUniqIndex.set(providerModelId, null);
+    }
+  }
+  const matchIndex = buildModelMatchIndex(capabilitiesByCanonical.keys());
+  const state = new Map;
+  for (const row of stateRows) {
+    state.set(row.key, row.value);
+  }
+  return {
+    capabilitiesByCanonical,
+    providerModelsByKey,
+    providerModelUniqIndex,
+    matchIndex,
+    state
+  };
+}
+function loadCacheFromDb() {
+  runtimeCache = buildRuntimeCache(listModelCapabilities(), listProviderModels(), listModelInfoState());
+  loaded = true;
+}
+function ensureLoaded() {
+  if (!loaded)
+    loadCacheFromDb();
+}
+function initModelInfoCache() {
+  loadCacheFromDb();
+}
+function parseStateInt(key) {
+  const raw = runtimeCache.state.get(key);
+  if (!raw)
+    return null;
+  const value = Number.parseInt(raw, 10);
+  if (!Number.isFinite(value))
+    return null;
+  return value;
+}
+function getRemoteProvidersFromEnv(env) {
+  const providers = [];
+  if (env.OPENCODE_API_KEY)
+    providers.push("zen");
+  if (env.OPENAI_API_KEY)
+    providers.push("openai");
+  if (env.ANTHROPIC_API_KEY)
+    providers.push("anthropic");
+  if (env.GOOGLE_API_KEY ?? env.GEMINI_API_KEY)
+    providers.push("google");
+  return providers;
+}
+function getProvidersToRefreshFromEnv(env) {
+  return [...getRemoteProvidersFromEnv(env), "ollama"];
+}
+function getVisibleProvidersForSnapshotFromEnv(env) {
+  return new Set(getProvidersToRefreshFromEnv(env));
+}
+function getConfiguredProvidersForSync() {
+  return getProvidersToRefreshFromEnv(process.env);
+}
+function getProvidersRequiredForFreshness() {
+  return getRemoteProvidersFromEnv(process.env);
+}
+function getProviderSyncKey(provider) {
+  return `${PROVIDER_SYNC_KEY_PREFIX}${provider}`;
+}
+function isModelInfoStale(now = Date.now()) {
+  ensureLoaded();
+  if (isStaleTimestamp(parseStateInt(MODELS_DEV_SYNC_KEY), now))
+    return true;
+  for (const provider of getProvidersRequiredForFreshness()) {
+    const providerSync = parseStateInt(getProviderSyncKey(provider));
+    if (isStaleTimestamp(providerSync, now))
+      return true;
+  }
+  return false;
+}
+function getLastSyncAt() {
+  let latest = parseStateInt(MODELS_DEV_SYNC_KEY);
+  for (const provider of getProvidersRequiredForFreshness()) {
+    const value = parseStateInt(getProviderSyncKey(provider));
+    if (value !== null && (latest === null || value > latest))
+      latest = value;
+  }
+  return latest;
+}
+async function fetchJson(url, init, timeoutMs) {
+  try {
+    const response = await fetch(url, {
+      ...init,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!response.ok)
+      return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function fetchModelsDevPayload() {
+  return fetchJson(MODELS_DEV_URL, {}, 1e4);
+}
+async function fetchZenModels() {
+  const key = process.env.OPENCODE_API_KEY;
+  if (!key)
+    return null;
+  const payload = await fetchJson(`${ZEN_BASE}/models`, { headers: { Authorization: `Bearer ${key}` } }, 8000);
+  return processModelsList(payload, "data", "id", (item, modelId) => {
+    const contextWindow = typeof item.context_window === "number" && Number.isFinite(item.context_window) ? Math.max(0, Math.trunc(item.context_window)) : null;
+    return {
+      providerModelId: modelId,
+      displayName: item.id,
+      contextWindow,
+      free: item.id.endsWith("-free") || item.id === "gpt-5-nano" || item.id === "big-pickle"
+    };
+  });
+}
+function processModelsList(payload, arrayKey, idKey, mapper) {
+  if (!isRecord(payload) || !Array.isArray(payload[arrayKey]))
+    return null;
+  const out = [];
+  for (const item of payload[arrayKey]) {
+    if (!isRecord(item) || typeof item[idKey] !== "string")
+      continue;
+    const modelId = normalizeModelId(item[idKey]);
+    if (!modelId)
+      continue;
+    const mapped = mapper(item, modelId);
+    if (mapped)
+      out.push(mapped);
+  }
+  return out;
+}
+async function fetchOpenAIModels() {
+  const key = process.env.OPENAI_API_KEY;
+  if (!key)
+    return null;
+  const payload = await fetchJson(`${OPENAI_BASE}/v1/models`, { headers: { Authorization: `Bearer ${key}` } }, 6000);
+  return processModelsList(payload, "data", "id", (item, modelId) => ({
+    providerModelId: modelId,
+    displayName: item.id,
+    contextWindow: null,
+    free: false
+  }));
+}
+async function fetchAnthropicModels() {
+  const key = process.env.ANTHROPIC_API_KEY;
+  if (!key)
+    return null;
+  const payload = await fetchJson(`${ANTHROPIC_BASE}/v1/models`, {
+    headers: {
+      "x-api-key": key,
+      "anthropic-version": "2023-06-01"
+    }
+  }, 6000);
+  return processModelsList(payload, "data", "id", (item, modelId) => {
+    const displayName = typeof item.display_name === "string" && item.display_name.trim().length > 0 ? item.display_name : item.id;
+    return {
+      providerModelId: modelId,
+      displayName,
+      contextWindow: null,
+      free: false
+    };
+  });
+}
+async function fetchGoogleModels() {
+  const key = process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
+  if (!key)
+    return null;
+  const payload = await fetchJson(`${GOOGLE_BASE}/models?key=${encodeURIComponent(key)}`, {}, 6000);
+  return processModelsList(payload, "models", "name", (item, modelId) => {
+    const displayName = typeof item.displayName === "string" && item.displayName.trim().length > 0 ? item.displayName : modelId;
+    const contextWindow = typeof item.inputTokenLimit === "number" && Number.isFinite(item.inputTokenLimit) ? Math.max(0, Math.trunc(item.inputTokenLimit)) : null;
+    return {
+      providerModelId: modelId,
+      displayName,
+      contextWindow,
+      free: false
+    };
+  });
+}
+async function fetchOllamaModels() {
+  const base = process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
+  const payload = await fetchJson(`${base}/api/tags`, {}, 3000);
+  return processModelsList(payload, "models", "name", (item, modelId) => {
+    const details = item.details;
+    let sizeSuffix = "";
+    if (isRecord(details) && typeof details.parameter_size === "string") {
+      sizeSuffix = ` (${details.parameter_size})`;
+    }
+    return {
+      providerModelId: modelId,
+      displayName: `${item.name}${sizeSuffix}`,
+      contextWindow: null,
+      free: false
+    };
+  });
+}
+async function fetchProviderCandidates(provider) {
+  switch (provider) {
+    case "zen":
+      return fetchZenModels();
+    case "openai":
+      return fetchOpenAIModels();
+    case "anthropic":
+      return fetchAnthropicModels();
+    case "google":
+      return fetchGoogleModels();
+    case "ollama":
+      return fetchOllamaModels();
+    default:
+      return null;
+  }
+}
+function providerRowsFromCandidates(candidates, matchIndex, updatedAt) {
+  return candidates.map((candidate) => ({
+    provider_model_id: candidate.providerModelId,
+    display_name: candidate.displayName,
+    canonical_model_id: matchCanonicalModelId(candidate.providerModelId, matchIndex),
+    context_window: candidate.contextWindow,
+    free: candidate.free ? 1 : 0,
+    updated_at: updatedAt
+  }));
+}
+async function refreshModelInfoInternal() {
+  ensureLoaded();
+  const now = Date.now();
+  const providers = getConfiguredProvidersForSync();
+  const providerResults = await Promise.all(providers.map(async (provider) => ({
+    provider,
+    candidates: await fetchProviderCandidates(provider)
+  })));
+  const modelsDevPayload = await fetchModelsDevPayload();
+  let matchIndex = runtimeCache.matchIndex;
+  if (modelsDevPayload !== null) {
+    const capabilityRows = parseModelsDevCapabilities(modelsDevPayload, now);
+    if (capabilityRows.length > 0) {
+      replaceModelCapabilities(capabilityRows);
+      setModelInfoState(MODELS_DEV_SYNC_KEY, String(now));
+      matchIndex = buildModelMatchIndex(capabilityRows.map((row) => row.canonical_model_id));
+    }
+  }
+  for (const result of providerResults) {
+    if (result.candidates === null)
+      continue;
+    const rows = providerRowsFromCandidates(result.candidates, matchIndex, now);
+    replaceProviderModels(result.provider, rows);
+    setModelInfoState(getProviderSyncKey(result.provider), String(now));
+  }
+  loadCacheFromDb();
+}
+function refreshModelInfoInBackground(opts) {
+  ensureLoaded();
+  const force = opts?.force ?? false;
+  if (!force && !isModelInfoStale())
+    return Promise.resolve();
+  if (refreshInFlight)
+    return refreshInFlight;
+  refreshInFlight = refreshModelInfoInternal().finally(() => {
+    refreshInFlight = null;
+  });
+  return refreshInFlight;
+}
+function isModelInfoRefreshing() {
+  return refreshInFlight !== null;
+}
+function resolveFromProviderRow(row, cache) {
+  if (row.canonicalModelId) {
+    const capability = cache.capabilitiesByCanonical.get(row.canonicalModelId);
+    if (capability) {
+      return {
+        canonicalModelId: capability.canonicalModelId,
+        contextWindow: capability.contextWindow,
+        reasoning: capability.reasoning
+      };
+    }
+  }
+  return {
+    canonicalModelId: row.canonicalModelId,
+    contextWindow: row.contextWindow,
+    reasoning: false
+  };
+}
+function resolveModelInfoInCache(modelString, cache) {
+  const parsed = parseModelStringLoose(modelString);
+  const normalizedModelId = normalizeModelId(parsed.modelId);
+  if (!normalizedModelId)
+    return null;
+  if (parsed.provider) {
+    const providerRow = cache.providerModelsByKey.get(providerModelKey(parsed.provider, normalizedModelId));
+    if (providerRow)
+      return resolveFromProviderRow(providerRow, cache);
+  }
+  const canonical = matchCanonicalModelId(normalizedModelId, cache.matchIndex);
+  if (canonical) {
+    const capability = cache.capabilitiesByCanonical.get(canonical);
+    if (capability) {
+      return {
+        canonicalModelId: capability.canonicalModelId,
+        contextWindow: capability.contextWindow,
+        reasoning: capability.reasoning
+      };
+    }
+  }
+  if (!parsed.provider) {
+    const uniqueProviderKey = cache.providerModelUniqIndex.get(normalizedModelId);
+    if (uniqueProviderKey) {
+      const providerRow = cache.providerModelsByKey.get(uniqueProviderKey);
+      if (providerRow)
+        return resolveFromProviderRow(providerRow, cache);
+    }
+  }
+  return null;
+}
+function resolveModelInfo(modelString) {
+  ensureLoaded();
+  return resolveModelInfoInCache(modelString, runtimeCache);
+}
+function getContextWindow(modelString) {
+  return resolveModelInfo(modelString)?.contextWindow ?? null;
+}
+function supportsThinking(modelString) {
+  return resolveModelInfo(modelString)?.reasoning ?? false;
+}
+function readLiveModelsFromCache() {
+  const models = [];
+  const visibleProviders = getVisibleProvidersForSnapshotFromEnv(process.env);
+  for (const row of runtimeCache.providerModelsByKey.values()) {
+    if (!visibleProviders.has(row.provider))
+      continue;
+    const info = resolveFromProviderRow(row, runtimeCache);
+    models.push({
+      id: `${row.provider}/${row.providerModelId}`,
+      displayName: row.displayName,
+      provider: row.provider,
+      context: info.contextWindow ?? undefined,
+      free: row.free ? true : undefined
+    });
+  }
+  models.sort((a, b) => a.provider.localeCompare(b.provider) || a.id.localeCompare(b.id));
+  return models;
+}
+async function fetchAvailableModelsSnapshot() {
+  ensureLoaded();
+  if (isModelInfoStale() && !isModelInfoRefreshing()) {
+    if (runtimeCache.providerModelsByKey.size === 0) {
+      await refreshModelInfoInBackground({ force: true });
+    } else {
+      refreshModelInfoInBackground();
+    }
+  }
+  return {
+    models: readLiveModelsFromCache(),
+    stale: isModelInfoStale(),
+    refreshing: isModelInfoRefreshing(),
+    lastSyncAt: getLastSyncAt()
+  };
+}
+
 // src/llm-api/providers.ts
 function getFetchWithLogging() {
   const customFetch = async (input, init) => {
@@ -1233,7 +1942,7 @@ function getFetchWithLogging() {
   };
   return customFetch;
 }
-var ZEN_BASE = "https://opencode.ai/zen/v1";
+var ZEN_BASE2 = "https://opencode.ai/zen/v1";
 function zenEndpointFor(modelId) {
   if (modelId.startsWith("claude-"))
     return zenAnthropic()(modelId);
@@ -1258,7 +1967,7 @@ function zenAnthropic() {
     _zenAnthropic = createAnthropic({
       fetch: getFetchWithLogging(),
       apiKey: getZenApiKey(),
-      baseURL: ZEN_BASE
+      baseURL: ZEN_BASE2
     });
   }
   return _zenAnthropic;
@@ -1268,7 +1977,7 @@ function zenOpenAI() {
     _zenOpenAI = createOpenAI({
       fetch: getFetchWithLogging(),
       apiKey: getZenApiKey(),
-      baseURL: ZEN_BASE
+      baseURL: ZEN_BASE2
     });
   }
   return _zenOpenAI;
@@ -1278,7 +1987,7 @@ function zenGoogle() {
     _zenGoogle = createGoogleGenerativeAI({
       fetch: getFetchWithLogging(),
       apiKey: getZenApiKey(),
-      baseURL: ZEN_BASE
+      baseURL: ZEN_BASE2
     });
   }
   return _zenGoogle;
@@ -1289,7 +1998,7 @@ function zenCompat() {
       fetch: getFetchWithLogging(),
       name: "zen-compat",
       apiKey: getZenApiKey(),
-      baseURL: ZEN_BASE
+      baseURL: ZEN_BASE2
     });
   }
   return _zenCompat;
@@ -1339,31 +2048,8 @@ function parseModelString(modelString) {
     modelId: modelString.slice(slashIdx + 1)
   };
 }
-var CONTEXT_WINDOW_TABLE = [
-  [/^claude-/, 200000],
-  [/^gemini-/, 1e6],
-  [/^gpt-5/, 128000],
-  [/^gpt-4/, 128000],
-  [/^kimi-k2/, 262000],
-  [/^minimax-m2/, 196000],
-  [/^glm-/, 128000],
-  [/^qwen3-/, 131000]
-];
-var REASONING_MODELS = [
-  /^claude-3-5-sonnet/,
-  /^claude-3-7/,
-  /^claude-sonnet-4/,
-  /^claude-opus-4/,
-  /^o1/,
-  /^o3/,
-  /^o4/,
-  /^gpt-5/,
-  /^gemini-2\.5/,
-  /^gemini-3/
-];
-function supportsThinking(modelString) {
-  const { modelId } = parseModelString(modelString);
-  return REASONING_MODELS.some((p) => p.test(modelId));
+function supportsThinking2(modelString) {
+  return supportsThinking(modelString);
 }
 var ANTHROPIC_BUDGET = {
   low: 4096,
@@ -1378,7 +2064,7 @@ function clampEffort(effort, max) {
   return ORDER[Math.min(i, m)];
 }
 function getThinkingProviderOptions(modelString, effort) {
-  if (!supportsThinking(modelString))
+  if (!supportsThinking2(modelString))
     return null;
   const { provider, modelId } = parseModelString(modelString);
   if (provider === "anthropic" || provider === "zen" && modelId.startsWith("claude-")) {
@@ -1430,13 +2116,8 @@ function getThinkingProviderOptions(modelString, effort) {
   }
   return null;
 }
-function getContextWindow(modelString) {
-  const { modelId } = parseModelString(modelString);
-  for (const [pattern, tokens] of CONTEXT_WINDOW_TABLE) {
-    if (pattern.test(modelId))
-      return tokens;
-  }
-  return null;
+function getContextWindow2(modelString) {
+  return getContextWindow(modelString);
 }
 function resolveModel(modelString) {
   const slashIdx = modelString.indexOf("/");
@@ -1478,54 +2159,8 @@ function autoDiscoverModel() {
     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];
+  return fetchAvailableModelsSnapshot();
 }
 
 // src/mcp/client.ts
@@ -1584,110 +2219,6 @@ async function connectMcpServer(config) {
     close: () => client.close()
   };
 }
-
-// src/session/db/connection.ts
-import { Database } from "bun:sqlite";
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, unlinkSync } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join4 } from "path";
-function getConfigDir() {
-  return join4(homedir6(), ".config", "mini-coder");
-}
-function getDbPath() {
-  const dir = getConfigDir();
-  if (!existsSync2(dir))
-    mkdirSync3(dir, { recursive: true });
-  return join4(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 (existsSync2(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;
-}
 // src/session/db/session-repo.ts
 function createSession(opts) {
   const db = getDb();
@@ -1848,29 +2379,24 @@ function deleteSnapshot(sessionId, turnIndex) {
 function deleteAllSnapshots(sessionId) {
   getDb().run("DELETE FROM snapshots WHERE session_id = ?", [sessionId]);
 }
+// src/agent/subagent-runner.ts
+import { tmpdir as tmpdir2 } from "os";
+import { join as join10 } from "path";
+
 // 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, claimWarning) {
+function toCoreTool(def) {
   const schema = isZodSchema(def.schema) ? def.schema : jsonSchema(def.schema);
   return dynamicTool({
     description: def.description,
     inputSchema: schema,
     execute: async (input) => {
       try {
-        const result = await def.execute(input);
-        if (claimWarning()) {
-          const warning = `
-
-<system-message>You have reached the maximum number of tool calls. ` + "No more tools will be available after this result. " + "Respond with a status update and list what still needs to be done.</system-message>";
-          const str = typeof result === "string" ? result : JSON.stringify(result);
-          return str + warning;
-        }
-        return result;
+        return await def.execute(input);
       } catch (err) {
         throw err instanceof Error ? err : new Error(String(err));
       }
@@ -1892,16 +2418,9 @@ async function* runTurn(options) {
     thinkingEffort
   } = options;
   let stepCount = 0;
-  let warningClaimed = false;
-  function claimWarning() {
-    if (stepCount !== MAX_STEPS - 2 || warningClaimed)
-      return false;
-    warningClaimed = true;
-    return true;
-  }
   const toolSet = {};
   for (const def of tools) {
-    toolSet[def.name] = toCoreTool(def, claimWarning);
+    toolSet[def.name] = toCoreTool(def);
   }
   let inputTokens = 0;
   let outputTokens = 0;
@@ -1936,7 +2455,6 @@ async function* runTurn(options) {
         outputTokens += step.usage?.outputTokens ?? 0;
         contextTokens = step.usage?.inputTokens ?? contextTokens;
         stepCount++;
-        warningClaimed = false;
       },
       prepareStep: ({ stepNumber }) => {
         if (stepNumber >= MAX_STEPS - 1) {
@@ -1992,7 +2510,7 @@ async function* runTurn(options) {
           };
           break;
         }
-        case "tool-error": {
+        case "tool-error":
           yield {
             type: "tool-result",
             toolCallId: String(c9.toolCallId ?? ""),
@@ -2001,15 +2519,13 @@ async function* runTurn(options) {
             isError: true
           };
           break;
-        }
         case "error": {
           const err = c9.error;
           throw err instanceof Error ? err : new Error(String(err));
         }
       }
     }
-    const finalResponse = await result.response;
-    const newMessages = finalResponse?.messages ?? [];
+    const newMessages = (await result.response)?.messages ?? [];
     logApiEvent("turn complete", {
       newMessagesCount: newMessages.length,
       inputTokens,
@@ -2031,17 +2547,205 @@ async function* runTurn(options) {
   }
 }
 
+// src/tools/worktree.ts
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync as existsSync3,
+  lstatSync,
+  mkdirSync as mkdirSync4,
+  mkdtempSync,
+  readlinkSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import { dirname, join as join5 } from "path";
+async function runGit(cwd, args) {
+  try {
+    const proc = Bun.spawn(["git", ...args], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    return { stdout, stderr, exitCode };
+  } catch {
+    return { stdout: "", stderr: "failed to execute git", exitCode: -1 };
+  }
+}
+function gitError(action, detail) {
+  return new Error(`${action}: ${detail || "unknown git error"}`);
+}
+function splitNonEmptyLines(text) {
+  return text.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+async function listUnmergedFiles(cwd) {
+  const conflictResult = await runGit(cwd, [
+    "diff",
+    "--name-only",
+    "--diff-filter=U"
+  ]);
+  if (conflictResult.exitCode !== 0)
+    return [];
+  return splitNonEmptyLines(conflictResult.stdout);
+}
+async function hasMergeInProgress(cwd) {
+  const mergeHead = await runGit(cwd, [
+    "rev-parse",
+    "-q",
+    "--verify",
+    "MERGE_HEAD"
+  ]);
+  return mergeHead.exitCode === 0;
+}
+async function isGitRepo(cwd) {
+  const result = await runGit(cwd, ["rev-parse", "--git-dir"]);
+  return result.exitCode === 0;
+}
+function splitNullSeparated(text) {
+  return text.split("\x00").filter((value) => value.length > 0);
+}
+async function getRepoRoot(cwd) {
+  const result = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
+  if (result.exitCode !== 0) {
+    throw gitError("Failed to resolve repository root", (result.stderr || result.stdout).trim());
+  }
+  return result.stdout.trim();
+}
+async function applyPatch(cwd, patch, args) {
+  if (patch.trim().length === 0)
+    return;
+  const tempDir = mkdtempSync(join5(tmpdir(), "mc-worktree-patch-"));
+  const patchPath = join5(tempDir, "changes.patch");
+  try {
+    writeFileSync(patchPath, patch);
+    const result = await runGit(cwd, ["apply", ...args, patchPath]);
+    if (result.exitCode !== 0) {
+      throw gitError("Failed to apply dirty-state patch to worktree", (result.stderr || result.stdout).trim());
+    }
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+function copyUntrackedPath(source, destination) {
+  const stat = lstatSync(source);
+  mkdirSync4(dirname(destination), { recursive: true });
+  if (stat.isSymbolicLink()) {
+    rmSync(destination, { recursive: true, force: true });
+    symlinkSync(readlinkSync(source), destination);
+    return;
+  }
+  copyFileSync(source, destination);
+  chmodSync(destination, stat.mode);
+}
+function copyFileIfMissing(source, destination) {
+  if (!existsSync3(source) || existsSync3(destination))
+    return;
+  mkdirSync4(dirname(destination), { recursive: true });
+  copyFileSync(source, destination);
+}
+function linkDirectoryIfMissing(source, destination) {
+  if (!existsSync3(source) || existsSync3(destination))
+    return;
+  mkdirSync4(dirname(destination), { recursive: true });
+  symlinkSync(source, destination, process.platform === "win32" ? "junction" : "dir");
+}
+async function initializeWorktree(mainCwd, worktreeCwd) {
+  const [mainRoot, worktreeRoot] = await Promise.all([
+    getRepoRoot(mainCwd),
+    getRepoRoot(worktreeCwd)
+  ]);
+  if (!existsSync3(join5(mainRoot, "package.json")))
+    return;
+  for (const lockfile of ["bun.lock", "bun.lockb"]) {
+    copyFileIfMissing(join5(mainRoot, lockfile), join5(worktreeRoot, lockfile));
+  }
+  linkDirectoryIfMissing(join5(mainRoot, "node_modules"), join5(worktreeRoot, "node_modules"));
+}
+async function syncDirtyStateToWorktree(mainCwd, worktreeCwd) {
+  const [staged, unstaged, untracked, mainRoot, worktreeRoot] = await Promise.all([
+    runGit(mainCwd, ["diff", "--binary", "--cached"]),
+    runGit(mainCwd, ["diff", "--binary"]),
+    runGit(mainCwd, ["ls-files", "--others", "--exclude-standard", "-z"]),
+    getRepoRoot(mainCwd),
+    getRepoRoot(worktreeCwd)
+  ]);
+  if (staged.exitCode !== 0) {
+    throw gitError("Failed to read staged changes", (staged.stderr || staged.stdout).trim());
+  }
+  if (unstaged.exitCode !== 0) {
+    throw gitError("Failed to read unstaged changes", (unstaged.stderr || unstaged.stdout).trim());
+  }
+  if (untracked.exitCode !== 0) {
+    throw gitError("Failed to list untracked files", (untracked.stderr || untracked.stdout).trim());
+  }
+  await applyPatch(worktreeRoot, staged.stdout, ["--index"]);
+  await applyPatch(worktreeRoot, unstaged.stdout, []);
+  for (const relPath of splitNullSeparated(untracked.stdout)) {
+    copyUntrackedPath(join5(mainRoot, relPath), join5(worktreeRoot, relPath));
+  }
+}
+async function createWorktree(mainCwd, branch, path) {
+  const result = await runGit(mainCwd, ["worktree", "add", path, "-b", branch]);
+  if (result.exitCode !== 0) {
+    throw gitError(`Failed to create worktree for branch "${branch}"`, (result.stderr || result.stdout).trim());
+  }
+  return path;
+}
+
+class MergeInProgressError extends Error {
+  conflictFiles;
+  constructor(branch, conflictFiles) {
+    super(`Cannot merge branch "${branch}" because another merge is already in progress. Resolve it first before merging this branch.`);
+    this.name = "MergeInProgressError";
+    this.conflictFiles = conflictFiles;
+  }
+}
+async function mergeWorktree(mainCwd, branch) {
+  if (await hasMergeInProgress(mainCwd)) {
+    const conflictFiles2 = await listUnmergedFiles(mainCwd);
+    throw new MergeInProgressError(branch, conflictFiles2);
+  }
+  const merge = await runGit(mainCwd, ["merge", "--no-ff", branch]);
+  if (merge.exitCode === 0)
+    return { success: true };
+  const conflictFiles = await listUnmergedFiles(mainCwd);
+  if (conflictFiles.length > 0) {
+    return { success: false, conflictFiles };
+  }
+  throw gitError(`Failed to merge branch "${branch}"`, (merge.stderr || merge.stdout).trim());
+}
+async function removeWorktree(mainCwd, path) {
+  const result = await runGit(mainCwd, ["worktree", "remove", "--force", path]);
+  if (result.exitCode !== 0) {
+    throw gitError(`Failed to remove worktree "${path}"`, (result.stderr || result.stdout).trim());
+  }
+}
+async function cleanupBranch(mainCwd, branch) {
+  const result = await runGit(mainCwd, ["branch", "-D", branch]);
+  if (result.exitCode !== 0) {
+    throw gitError(`Failed to delete branch "${branch}"`, (result.stderr || result.stdout).trim());
+  }
+}
+
 // src/agent/system-prompt.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { join as join6 } from "path";
 function loadContextFile(cwd) {
   const candidates = [
-    join5(cwd, "AGENTS.md"),
-    join5(cwd, "CLAUDE.md"),
-    join5(getConfigDir(), "AGENTS.md")
+    join6(cwd, "AGENTS.md"),
+    join6(cwd, "CLAUDE.md"),
+    join6(getConfigDir(), "AGENTS.md")
   ];
   for (const p of candidates) {
-    if (existsSync3(p)) {
+    if (existsSync4(p)) {
       try {
         return readFileSync2(p, "utf-8");
       } catch {}
@@ -2075,9 +2779,8 @@ 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.
-- Use subagents for parallel execution and handling large subtasks to protect your context limit.`;
+- Use subagents for all tasks that require a lot of context, like searching code, the web or using shell commands that produce a lot of output.
+- Keep your context clean and focused on the user request, use subagents to achieve this.`;
   if (modelString && isCodexModel(modelString)) {
     prompt += CODEX_AUTONOMY;
   }
@@ -2092,73 +2795,108 @@ ${contextFile}`;
 }
 
 // src/tools/exa.ts
-import { z as z2 } from "zod";
-var ExaSearchSchema = z2.object({
-  query: z2.string().describe("The search query")
+import { z } from "zod";
+var ExaSearchSchema = z.object({
+  query: z.string().describe("The search query")
 });
+async function fetchExa(endpoint, body) {
+  const apiKey = process.env.EXA_API_KEY;
+  if (!apiKey) {
+    throw new Error("EXA_API_KEY is not set.");
+  }
+  const response = await fetch(`https://api.exa.ai/${endpoint}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const errorBody = await response.text();
+    throw new Error(`Exa API error: ${response.status} ${response.statusText} - ${errorBody}`);
+  }
+  return await response.json();
+}
 var webSearchTool = {
   name: "webSearch",
   description: "Search the web for a query using Exa.",
   schema: ExaSearchSchema,
   execute: async (input) => {
-    const apiKey = process.env.EXA_API_KEY;
-    if (!apiKey) {
-      throw new Error("EXA_API_KEY is not set.");
-    }
-    const response = await fetch("https://api.exa.ai/search", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": apiKey
-      },
-      body: JSON.stringify({
-        query: input.query,
-        type: "auto",
-        numResults: 10,
-        contents: { text: { maxCharacters: 4000 } }
-      })
+    return fetchExa("search", {
+      query: input.query,
+      type: "auto",
+      numResults: 10,
+      contents: { text: { maxCharacters: 4000 } }
     });
-    if (!response.ok) {
-      const errorBody = await response.text();
-      throw new Error(`Exa API error: ${response.status} ${response.statusText} - ${errorBody}`);
-    }
-    return await response.json();
   }
 };
-var ExaContentSchema = z2.object({
-  urls: z2.array(z2.string()).max(3).describe("Array of URLs to retrieve content for (max 3)")
+var ExaContentSchema = z.object({
+  urls: z.array(z.string()).max(3).describe("Array of URLs to retrieve content for (max 3)")
 });
 var webContentTool = {
   name: "webContent",
   description: "Get the full content of specific URLs using Exa.",
   schema: ExaContentSchema,
   execute: async (input) => {
-    const apiKey = process.env.EXA_API_KEY;
-    if (!apiKey) {
-      throw new Error("EXA_API_KEY is not set.");
-    }
-    const response = await fetch("https://api.exa.ai/contents", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": apiKey
-      },
-      body: JSON.stringify({
-        urls: input.urls,
-        text: { maxCharacters: 1e4 }
-      })
+    return fetchExa("contents", {
+      urls: input.urls,
+      text: { maxCharacters: 1e4 }
     });
-    if (!response.ok) {
-      const errorBody = await response.text();
-      throw new Error(`Exa API error: ${response.status} ${response.statusText} - ${errorBody}`);
-    }
-    return await response.json();
   }
 };
 
+// src/tools/subagent.ts
+import { z as z2 } from "zod";
+var SubagentInput = z2.object({
+  prompt: z2.string().describe("The task or question to give the subagent"),
+  agentName: z2.string().optional().describe("Name of a custom agent to use (from .agents/agents/). Omit to use a generic subagent.")
+});
+function formatConflictFiles(conflictFiles) {
+  if (conflictFiles.length === 0)
+    return "  - (unknown)";
+  return conflictFiles.map((file) => `  - ${file}`).join(`
+`);
+}
+function getSubagentMergeError(output) {
+  if (output.mergeConflict) {
+    const files = formatConflictFiles(output.mergeConflict.conflictFiles);
+    return `\u26A0 Merge conflict: subagent branch "${output.mergeConflict.branch}" has been merged into your working tree
+but has conflicts in these files:
+${files}
+
+Resolve the conflicts (remove <<<<, ====, >>>> markers), stage the files with
+\`git add <file>\`, then run \`git merge --continue\` to complete the merge.`;
+  }
+  if (output.mergeBlocked) {
+    const files = formatConflictFiles(output.mergeBlocked.conflictFiles);
+    return `\u26A0 Merge deferred: subagent branch "${output.mergeBlocked.branch}" was not merged because another merge is already in progress.
+Current unresolved files:
+${files}
+
+Resolve the current merge first (remove <<<<, ====, >>>> markers), stage files with
+\`git add <file>\`, run \`git merge --continue\`, then merge the deferred branch with
+\`git merge --no-ff ${output.mergeBlocked.branch}\`.`;
+  }
+  return null;
+}
+function createSubagentTool(runSubagent, availableAgents, parentLabel) {
+  const agentSection = availableAgents.size > 0 ? `
+
+When the user's message contains @<agent-name>, delegate to that agent by setting agentName to the exact agent name. Available custom agents: ${[...availableAgents.entries()].map(([name, cfg]) => `"${name}" (${cfg.description})`).join(", ")}.` : "";
+  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. ${agentSection}`,
+    schema: SubagentInput,
+    execute: async (input) => {
+      return runSubagent(input.prompt, input.agentName, parentLabel);
+    }
+  };
+}
+
 // src/tools/create.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync4 } from "fs";
-import { dirname, join as join6, relative } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname2 } from "path";
 import { z as z3 } from "zod";
 
 // src/tools/diff.ts
@@ -2287,6 +3025,39 @@ ${lines.join(`
 `);
 }
 
+// src/tools/shared.ts
+import { join as join7, relative } from "path";
+function resolvePath(cwdInput, pathInput) {
+  const cwd = cwdInput ?? process.cwd();
+  const filePath = pathInput.startsWith("/") ? pathInput : join7(cwd, pathInput);
+  const relPath = relative(cwd, filePath);
+  return { cwd, filePath, relPath };
+}
+async function resolveExistingFile(cwdInput, pathInput) {
+  const { cwd, filePath, relPath } = resolvePath(cwdInput, pathInput);
+  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.`);
+  }
+  return { file, filePath, relPath, cwd };
+}
+function parseAnchor(value, name = "anchor") {
+  const normalized = value.trim().endsWith("|") ? value.trim().slice(0, -1) : value;
+  const match = /^\s*(\d+):([0-9a-fA-F]{2})\s*$/.exec(normalized);
+  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/create.ts
 var CreateSchema = z3.object({
   path: z3.string().describe("File path to write (absolute or relative to cwd)"),
@@ -2297,12 +3068,10 @@ var createTool = {
   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 : join6(cwd, input.path);
-    const relPath = relative(cwd, filePath);
-    const dir = dirname(filePath);
-    if (!existsSync4(dir))
-      mkdirSync4(dir, { recursive: true });
+    const { filePath, relPath } = resolvePath(input.cwd, input.path);
+    const dir = dirname2(filePath);
+    if (!existsSync5(dir))
+      mkdirSync5(dir, { recursive: true });
     const file = Bun.file(filePath);
     const created = !await file.exists();
     const before = created ? "" : await file.text();
@@ -2313,21 +3082,51 @@ var createTool = {
 };
 
 // src/tools/glob.ts
-import { join as join8, relative as relative2 } from "path";
+import { resolve as resolve2 } from "path";
 import { z as z4 } from "zod";
 
 // src/tools/ignore.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import ignore from "ignore";
 async function loadGitignore(cwd) {
   try {
-    const gitignore = await Bun.file(join7(cwd, ".gitignore")).text();
+    const gitignore = await Bun.file(join8(cwd, ".gitignore")).text();
     return ignore().add(gitignore);
   } catch {
     return null;
   }
 }
 
+// src/tools/scan-path.ts
+import { relative as relative2, resolve, sep } from "path";
+var LEADING_PARENT_SEGMENTS = /^(?:\.\.\/)+/;
+function getScannedPathInfo(cwd, scanPath) {
+  const cwdAbsolute = resolve(cwd);
+  const absolute = resolve(cwdAbsolute, scanPath);
+  const relativePath = relative2(cwdAbsolute, absolute).replaceAll("\\", "/");
+  const inCwd = absolute === cwdAbsolute || absolute.startsWith(cwdAbsolute === sep ? sep : `${cwdAbsolute}${sep}`);
+  const ignoreTargets = getIgnoreTargets(relativePath, inCwd);
+  return {
+    absolute,
+    relativePath,
+    ignoreTargets,
+    inCwd
+  };
+}
+function getIgnoreTargets(path, inCwd) {
+  if (inCwd)
+    return [path];
+  const normalized = path.replace(LEADING_PARENT_SEGMENTS, "");
+  const segments = normalized.split("/").filter(Boolean);
+  if (segments.length === 0)
+    return [normalized];
+  const targets = new Set([normalized]);
+  for (let i = 1;i < segments.length; i++) {
+    targets.add(segments.slice(i).join("/"));
+  }
+  return [...targets];
+}
+
 // src/tools/glob.ts
 var GlobSchema = z4.object({
   pattern: z4.string().describe("Glob pattern to match files against, e.g. '**/*.ts'"),
@@ -2347,18 +3146,22 @@ var globTool = {
     const glob = new Bun.Glob(input.pattern);
     const matches = [];
     for await (const file of glob.scan({ cwd, onlyFiles: true, dot: true })) {
-      if (ig?.ignores(file))
+      const { relativePath, ignoreTargets } = getScannedPathInfo(cwd, file);
+      const firstSegment = relativePath.split("/")[0] ?? "";
+      if (ignoreTargets.some((path) => ig?.ignores(path)))
         continue;
-      const firstSegment = file.split("/")[0] ?? "";
-      const ignored = ignoreGlobs.some((g) => g.match(file) || g.match(firstSegment));
+      const ignored = ignoreTargets.some((candidate) => ignoreGlobs.some((g) => g.match(candidate) || g.match(firstSegment)));
       if (ignored)
         continue;
       try {
-        const fullPath = join8(cwd, file);
+        const fullPath = resolve2(cwd, relativePath);
         const stat = await Bun.file(fullPath).stat?.() ?? null;
-        matches.push({ path: file, mtime: stat?.mtime?.getTime() ?? 0 });
+        matches.push({
+          path: relativePath,
+          mtime: stat?.mtime?.getTime() ?? 0
+        });
       } catch {
-        matches.push({ path: file, mtime: 0 });
+        matches.push({ path: relativePath, mtime: 0 });
       }
       if (matches.length >= MAX_RESULTS + 1)
         break;
@@ -2367,13 +3170,12 @@ var globTool = {
     if (truncated)
       matches.pop();
     matches.sort((a, b) => b.mtime - a.mtime);
-    const files = matches.map((m) => relative2(cwd, join8(cwd, m.path)));
+    const files = matches.map((m) => m.path);
     return { files, count: files.length, truncated };
   }
 };
 
 // src/tools/grep.ts
-import { join as join9 } from "path";
 import { z as z5 } from "zod";
 
 // src/tools/hashline.ts
@@ -2428,9 +3230,9 @@ var GrepSchema = z5.object({
   maxResults: z5.number().int().min(1).max(200).optional().default(50)
 });
 var DEFAULT_IGNORE = [
-  "node_modules",
-  ".git",
-  "dist",
+  "node_modules/**",
+  ".git/**",
+  "dist/**",
   "*.db",
   "*.db-shm",
   "*.db-wal",
@@ -2453,18 +3255,19 @@ var grepTool = {
     let truncated = false;
     const ig = await loadGitignore(cwd);
     outer:
-      for await (const relPath of fileGlob.scan({
+      for await (const fromPath of fileGlob.scan({
         cwd,
         onlyFiles: true,
         dot: true
       })) {
-        if (ig?.ignores(relPath))
+        const { absolute, relativePath, ignoreTargets } = getScannedPathInfo(cwd, fromPath);
+        const firstSegment = relativePath.split("/")[0] ?? "";
+        if (ignoreTargets.some((path) => ig?.ignores(path)))
           continue;
-        const firstSegment = relPath.split("/")[0] ?? "";
-        if (ignoreGlob.some((g) => g.match(relPath) || g.match(firstSegment))) {
+        if (ignoreTargets.some((candidate) => ignoreGlob.some((g) => g.match(candidate) || g.match(firstSegment)))) {
           continue;
         }
-        const fullPath = join9(cwd, relPath);
+        const fullPath = absolute;
         let text;
         try {
           text = await Bun.file(fullPath).text();
@@ -2491,7 +3294,7 @@ var grepTool = {
             });
           }
           allMatches.push({
-            file: relPath,
+            file: relativePath,
             line: i + 1,
             column: match.index + 1,
             text: formatHashLine(i + 1, line),
@@ -2516,7 +3319,7 @@ var grepTool = {
 // src/tools/hooks.ts
 import { constants, accessSync } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join10 } from "path";
+import { join as join9 } from "path";
 function isExecutable(filePath) {
   try {
     accessSync(filePath, constants.X_OK);
@@ -2528,8 +3331,8 @@ function isExecutable(filePath) {
 function findHook(toolName, cwd) {
   const scriptName = `post-${toolName}`;
   const candidates = [
-    join10(cwd, ".agents", "hooks", scriptName),
-    join10(homedir7(), ".agents", "hooks", scriptName)
+    join9(cwd, ".agents", "hooks", scriptName),
+    join9(homedir7(), ".agents", "hooks", scriptName)
   ];
   for (const p of candidates) {
     if (isExecutable(p))
@@ -2618,7 +3421,6 @@ function hookEnvForRead(input, cwd) {
 }
 
 // src/tools/insert.ts
-import { join as join11, relative as relative3 } from "path";
 import { z as z6 } from "zod";
 var InsertSchema = z6.object({
   path: z6.string().describe("File path to edit (absolute or relative to cwd)"),
@@ -2632,13 +3434,7 @@ var insertTool = {
   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 : join11(cwd, input.path);
-    const relPath = relative3(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 { file, filePath, relPath } = await resolveExistingFile(input.cwd, input.path);
     const parsed = parseAnchor(input.anchor);
     const original = await file.text();
     const lines = original.split(`
@@ -2661,25 +3457,8 @@ var insertTool = {
     return { path: relPath, diff };
   }
 };
-function parseAnchor(value) {
-  const normalized = value.trim().endsWith("|") ? value.trim().slice(0, -1) : value;
-  const match = /^\s*(\d+):([0-9a-fA-F]{2})\s*$/.exec(normalized);
-  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 join12, relative as relative4 } from "path";
 import { z as z7 } from "zod";
 var ReadSchema = z7.object({
   path: z7.string().describe("File path to read (absolute or relative to cwd)"),
@@ -2693,8 +3472,7 @@ var readTool = {
   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 : join12(cwd, input.path);
+    const { filePath, relPath } = resolvePath(input.cwd, input.path);
     const file = Bun.file(filePath);
     const exists = await file.exists();
     if (!exists) {
@@ -2717,7 +3495,7 @@ var readTool = {
     const content = selectedLines.map((line, i) => formatHashLine(clampedStart + i, line)).join(`
 `);
     return {
-      path: relative4(cwd, filePath),
+      path: relPath,
       content,
       totalLines,
       line: clampedStart,
@@ -2727,7 +3505,6 @@ var readTool = {
 };
 
 // src/tools/replace.ts
-import { join as join13, relative as relative5 } from "path";
 import { z as z8 } from "zod";
 var ReplaceSchema = z8.object({
   path: z8.string().describe("File path to edit (absolute or relative to cwd)"),
@@ -2741,15 +3518,9 @@ var replaceTool = {
   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 : join13(cwd, input.path);
-    const relPath = relative5(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;
+    const { file, filePath, relPath } = await resolveExistingFile(input.cwd, input.path);
+    const start = parseAnchor(input.startAnchor, "startAnchor");
+    const end = input.endAnchor ? parseAnchor(input.endAnchor, "endAnchor") : null;
     if (end && end.line < start.line) {
       throw new Error("endAnchor line number must be >= startAnchor line number.");
     }
@@ -2783,22 +3554,6 @@ var replaceTool = {
     return { path: relPath, diff, deleted: replacement.length === 0 };
   }
 };
-function parseAnchor2(value, name) {
-  const normalized = value.trim().endsWith("|") ? value.trim().slice(0, -1) : value;
-  const match = /^\s*(\d+):([0-9a-fA-F]{2})\s*$/.exec(normalized);
-  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 z9 } from "zod";
@@ -2896,26 +3651,6 @@ var shellTool = {
   }
 };
 
-// src/tools/subagent.ts
-import { z as z10 } from "zod";
-var SubagentInput = z10.object({
-  prompt: z10.string().describe("The task or question to give the subagent"),
-  agentName: z10.string().optional().describe("Name of a custom agent to use (from .agents/agents/). Omit to use a generic subagent.")
-});
-function createSubagentTool(runSubagent, availableAgents, parentLabel) {
-  const agentSection = availableAgents.size > 0 ? `
-
-When the user's message contains @<agent-name>, delegate to that agent by setting agentName to the exact agent name. Available custom agents: ${[...availableAgents.entries()].map(([name, cfg]) => `"${name}" (${cfg.description})`).join(", ")}.` : "";
-  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. ${agentSection}`,
-    schema: SubagentInput,
-    execute: async (input) => {
-      return runSubagent(input.prompt, input.agentName, parentLabel);
-    }
-  };
-}
-
 // src/agent/tools.ts
 function withCwdDefault(tool, cwd) {
   const originalExecute = tool.execute;
@@ -2972,7 +3707,11 @@ function buildToolSet(opts) {
       if (depth >= MAX_SUBAGENT_DEPTH) {
         throw new Error(`Subagent depth limit reached (max ${MAX_SUBAGENT_DEPTH}). ` + `Cannot spawn another subagent from depth ${depth}.`);
       }
-      return opts.runSubagent(prompt, depth + 1, agentName, undefined, opts.parentLabel);
+      const output = await opts.runSubagent(prompt, depth + 1, agentName, undefined, opts.parentLabel);
+      const mergeError = getSubagentMergeError(output);
+      if (mergeError)
+        throw new Error(mergeError);
+      return output;
     }, opts.availableAgents, opts.parentLabel)
   ];
   if (process.env.EXA_API_KEY) {
@@ -2994,67 +3733,150 @@ function buildReadOnlyToolSet(opts) {
 }
 
 // src/agent/subagent-runner.ts
+function makeWorktreeBranch(laneId) {
+  return `mc-sub-${laneId}`;
+}
+function makeWorktreePath(laneId) {
+  return join10(tmpdir2(), `mc-wt-${laneId}`);
+}
 function createSubagentRunner(cwd, reporter, getCurrentModel, getThinkingEffort) {
-  let nextLaneId = 1;
   const activeLanes = new Set;
+  const worktreesEnabledPromise = isGitRepo(cwd);
+  let mergeLock = Promise.resolve();
+  const withMergeLock = (fn) => {
+    const task = mergeLock.then(fn, fn);
+    mergeLock = task.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return task;
+  };
   const runSubagent = async (prompt, depth = 0, agentName, modelOverride, parentLabel) => {
-    const currentModel = getCurrentModel();
-    const allAgents = loadAgents(cwd);
-    const agentConfig = agentName ? allAgents.get(agentName) : undefined;
-    if (agentName && !agentConfig) {
-      throw new Error(`Unknown agent "${agentName}". Available agents: ${[...allAgents.keys()].join(", ") || "(none)"}`);
-    }
-    const model = modelOverride ?? agentConfig?.model ?? currentModel;
-    const systemPrompt = agentConfig?.systemPrompt ?? buildSystemPrompt(cwd, model);
-    const subMessages = [{ role: "user", content: prompt }];
-    const laneId = nextLaneId++;
+    const laneId = crypto.randomUUID().split("-")[0];
     activeLanes.add(laneId);
-    const laneLabel = formatSubagentLabel(laneId, parentLabel);
-    const subTools = buildToolSet({
-      cwd,
-      depth,
-      runSubagent,
-      onHook: (tool, path, ok) => reporter.renderHook(tool, path, ok),
-      availableAgents: allAgents,
-      parentLabel: laneLabel
-    }).filter((tool) => tool.name !== "subagent");
-    const subLlm = resolveModel(model);
-    let result = "";
-    let inputTokens = 0;
-    let outputTokens = 0;
-    const effort = getThinkingEffort();
-    const events = runTurn({
-      model: subLlm,
-      modelString: model,
-      messages: subMessages,
-      tools: subTools,
-      systemPrompt,
-      ...effort ? { thinkingEffort: effort } : {}
-    });
-    for await (const event of events) {
-      reporter.stopSpinner();
-      reporter.renderSubagentEvent(event, {
-        laneId,
-        ...parentLabel ? { parentLabel } : {},
-        activeLanes
+    let subagentCwd = cwd;
+    let worktreeBranch;
+    let worktreePath;
+    let preserveBranchOnFailure = false;
+    try {
+      const worktreesEnabled = await worktreesEnabledPromise;
+      if (worktreesEnabled) {
+        const nextBranch = makeWorktreeBranch(laneId);
+        const nextPath = makeWorktreePath(laneId);
+        await createWorktree(cwd, nextBranch, nextPath);
+        worktreeBranch = nextBranch;
+        worktreePath = nextPath;
+        await syncDirtyStateToWorktree(cwd, nextPath);
+        await initializeWorktree(cwd, nextPath);
+        subagentCwd = nextPath;
+      }
+      const currentModel = getCurrentModel();
+      const allAgents = loadAgents(subagentCwd);
+      const agentConfig = agentName ? allAgents.get(agentName) : undefined;
+      if (agentName && !agentConfig) {
+        throw new Error(`Unknown agent "${agentName}". Available agents: ${[...allAgents.keys()].join(", ") || "(none)"}`);
+      }
+      const model = modelOverride ?? agentConfig?.model ?? currentModel;
+      const systemPrompt = agentConfig?.systemPrompt ?? buildSystemPrompt(subagentCwd, model);
+      const subMessages = [{ role: "user", content: prompt }];
+      const laneLabel = formatSubagentLabel(laneId, parentLabel);
+      const subTools = buildToolSet({
+        cwd: subagentCwd,
+        depth,
+        runSubagent,
+        onHook: (tool, path2, ok) => reporter.renderHook(tool, path2, ok),
+        availableAgents: allAgents,
+        parentLabel: laneLabel
+      }).filter((tool) => tool.name !== "subagent");
+      const subLlm = resolveModel(model);
+      let result = "";
+      let inputTokens = 0;
+      let outputTokens = 0;
+      const effort = getThinkingEffort();
+      const events = runTurn({
+        model: subLlm,
+        modelString: model,
+        messages: subMessages,
+        tools: subTools,
+        systemPrompt,
+        ...effort ? { thinkingEffort: effort } : {}
       });
-      reporter.startSpinner("thinking");
-      if (event.type === "text-delta")
-        result += event.delta;
-      if (event.type === "turn-complete") {
-        inputTokens = event.inputTokens;
-        outputTokens = event.outputTokens;
+      for await (const event of events) {
+        reporter.stopSpinner();
+        reporter.renderSubagentEvent(event, {
+          laneId,
+          ...parentLabel ? { parentLabel } : {},
+          hasWorktree: !!worktreeBranch,
+          activeLanes
+        });
+        reporter.startSpinner("thinking");
+        if (event.type === "text-delta")
+          result += event.delta;
+        if (event.type === "turn-complete") {
+          inputTokens = event.inputTokens;
+          outputTokens = event.outputTokens;
+        }
+      }
+      const baseOutput = { result, inputTokens, outputTokens };
+      const branch = worktreeBranch;
+      const path = worktreePath;
+      if (!branch || !path)
+        return baseOutput;
+      preserveBranchOnFailure = true;
+      return await withMergeLock(async () => {
+        try {
+          const mergeResult = await mergeWorktree(cwd, branch);
+          await removeWorktree(cwd, path);
+          if (mergeResult.success) {
+            await cleanupBranch(cwd, branch);
+            return baseOutput;
+          }
+          return {
+            ...baseOutput,
+            mergeConflict: {
+              branch,
+              conflictFiles: mergeResult.conflictFiles
+            }
+          };
+        } catch (error) {
+          if (error instanceof MergeInProgressError) {
+            await removeWorktree(cwd, path);
+            return {
+              ...baseOutput,
+              mergeBlocked: {
+                branch,
+                conflictFiles: error.conflictFiles
+              }
+            };
+          }
+          throw error;
+        }
+      });
+    } catch (error) {
+      if (worktreeBranch && worktreePath) {
+        const branch = worktreeBranch;
+        const path = worktreePath;
+        try {
+          await withMergeLock(async () => {
+            await removeWorktree(cwd, path);
+            if (!preserveBranchOnFailure) {
+              await cleanupBranch(cwd, branch);
+            }
+          });
+        } catch {}
       }
+      throw error;
+    } finally {
+      activeLanes.delete(laneId);
     }
-    activeLanes.delete(laneId);
-    return { result, inputTokens, outputTokens };
   };
   return runSubagent;
 }
 
 // src/tools/snapshot.ts
 import { readFileSync as readFileSync3, unlinkSync as unlinkSync2 } from "fs";
-import { join as join14 } from "path";
+import { join as join11 } from "path";
 async function gitBytes(args, cwd) {
   try {
     const proc = Bun.spawn(["git", ...args], {
@@ -3127,7 +3949,7 @@ async function getStatusEntries(repoRoot) {
     return true;
   });
 }
-async function getRepoRoot(cwd) {
+async function getRepoRoot2(cwd) {
   const result = await git(["rev-parse", "--show-toplevel"], cwd);
   if (result.code !== 0)
     return null;
@@ -3135,7 +3957,7 @@ async function getRepoRoot(cwd) {
 }
 async function takeSnapshot(cwd, sessionId, turnIndex) {
   try {
-    const repoRoot = await getRepoRoot(cwd);
+    const repoRoot = await getRepoRoot2(cwd);
     if (repoRoot === null)
       return false;
     const entries = await getStatusEntries(repoRoot);
@@ -3145,7 +3967,7 @@ async function takeSnapshot(cwd, sessionId, turnIndex) {
       return false;
     const files = [];
     for (const entry of entries) {
-      const absPath = join14(repoRoot, entry.path);
+      const absPath = join11(repoRoot, entry.path);
       if (!entry.existsOnDisk) {
         const { bytes, code } = await gitBytes(["show", `HEAD:${entry.path}`], repoRoot);
         if (code === 0) {
@@ -3188,13 +4010,13 @@ async function takeSnapshot(cwd, sessionId, turnIndex) {
 async function restoreSnapshot(cwd, sessionId, turnIndex) {
   try {
     const files = loadSnapshot(sessionId, turnIndex);
-    const repoRoot = await getRepoRoot(cwd);
+    const repoRoot = await getRepoRoot2(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 = join14(root, file.path);
+      const absPath = join11(root, file.path);
       if (!file.existed) {
         try {
           if (await Bun.file(absPath).exists()) {
@@ -3261,7 +4083,7 @@ async function undoLastTurn(ctx) {
 }
 
 // src/agent/agent-helpers.ts
-import { join as join15 } from "path";
+import { join as join12 } from "path";
 import * as c9 from "yoctocolors";
 
 // src/cli/image-types.ts
@@ -3360,7 +4182,7 @@ ${skill.content}
       result = result.slice(0, match.index) + replacement + result.slice((match.index ?? 0) + match[0].length);
       continue;
     }
-    const filePath = ref.startsWith("/") ? ref : join15(cwd, ref);
+    const filePath = ref.startsWith("/") ? ref : join12(cwd, ref);
     if (isImageFilename(ref)) {
       const attachment = await loadImageFile(filePath);
       if (attachment) {
@@ -3441,7 +4263,8 @@ function loadCustomCommands(cwd) {
       description: meta.description ?? name,
       ...meta.model ? { model: meta.model } : {},
       template: body,
-      source
+      source,
+      execution: meta.execution === "inline" ? "inline" : "subagent"
     })
   });
 }
@@ -3485,6 +4308,11 @@ async function expandTemplate(template, args, cwd) {
 }
 
 // src/cli/commands.ts
+function assertSubagentMerged(output) {
+  const mergeError = getSubagentMergeError(output);
+  if (mergeError)
+    throw new Error(mergeError);
+}
 async function handleModel(ctx, args) {
   const parts = args.trim().split(/\s+/).filter(Boolean);
   if (parts.length > 0) {
@@ -3504,8 +4332,8 @@ async function handleModel(ctx, args) {
     const idArg = parts[0] ?? "";
     let modelId = idArg;
     if (!idArg.includes("/")) {
-      const models2 = await fetchAvailableModels();
-      const match = models2.find((m) => m.id.split("/").slice(1).join("/") === idArg || m.id === idArg);
+      const snapshot2 = await fetchAvailableModels();
+      const match = snapshot2.models.find((m) => m.id.split("/").slice(1).join("/") === idArg || m.id === idArg);
       if (match) {
         modelId = match.id;
       } else {
@@ -3533,13 +4361,19 @@ async function handleModel(ctx, args) {
     return;
   }
   writeln(`${c10.dim("  fetching models\u2026")}`);
-  const models = await fetchAvailableModels();
+  const snapshot = await fetchAvailableModels();
+  const models = snapshot.models;
   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(c10.dim("  Set OPENCODE_API_KEY for Zen, or start Ollama for local models."));
     return;
   }
+  if (snapshot.stale) {
+    const lastSync = snapshot.lastSyncAt ? new Date(snapshot.lastSyncAt).toLocaleString() : "never";
+    const refreshTag = snapshot.refreshing ? " (refreshing in background)" : "";
+    writeln(c10.dim(`  model metadata is stale (last sync: ${lastSync})${refreshTag}`));
+  }
   const byProvider = new Map;
   for (const m of models) {
     const existing = byProvider.get(m.provider);
@@ -3696,6 +4530,7 @@ async function handleReview(ctx, args) {
   writeln();
   try {
     const output = await ctx.runSubagent(REVIEW_PROMPT(ctx.cwd, focus));
+    assertSubagentMerged(output);
     write(renderMarkdown(output.result));
     writeln();
     return {
@@ -3722,8 +4557,12 @@ async function handleCustomCommand(cmd, args, ctx) {
   const src = c10.dim(`[${srcPath}]`);
   writeln(`${PREFIX.info} ${label} ${src}`);
   writeln();
+  if (cmd.execution === "inline") {
+    return { type: "inject-user-message", text: prompt };
+  }
   try {
     const output = await ctx.runSubagent(prompt, cmd.model);
+    assertSubagentMerged(output);
     write(renderMarkdown(output.result));
     writeln();
     return {
@@ -3792,7 +4631,7 @@ function handleHelp(ctx, custom) {
   writeln(`  ${c10.green("@file".padEnd(26))} ${c10.dim("inject file contents into prompt (Tab to complete)")}`);
   writeln(`  ${c10.green("!cmd".padEnd(26))} ${c10.dim("run shell command, output added as context")}`);
   writeln();
-  writeln(`  ${c10.dim("ctrl+c")}  cancel  ${c10.dim("\xB7")}  ${c10.dim("ctrl+d")}  exit  ${c10.dim("\xB7")}  ${c10.dim("ctrl+r")}  history search  ${c10.dim("\xB7")}  ${c10.dim("\u2191\u2193")}  history`);
+  writeln(`  ${c10.dim("esc")}  cancel response  ${c10.dim("\xB7")}  ${c10.dim("ctrl+c")}  exit  ${c10.dim("\xB7")}  ${c10.dim("ctrl+d")}  exit  ${c10.dim("\xB7")}  ${c10.dim("ctrl+r")}  history search  ${c10.dim("\xB7")}  ${c10.dim("\u2191\u2193")}  history`);
   writeln();
 }
 async function handleCommand(command, args, ctx) {
@@ -3839,7 +4678,7 @@ async function handleCommand(command, args, ctx) {
 }
 
 // src/cli/input.ts
-import { join as join16, relative as relative6 } from "path";
+import { join as join13, relative as relative3 } from "path";
 import * as c11 from "yoctocolors";
 var ESC = "\x1B";
 var CSI = `${ESC}[`;
@@ -3868,6 +4707,8 @@ var CTRL_K = "\v";
 var CTRL_L = "\f";
 var CTRL_R = "\x12";
 var TAB = "\t";
+var ESC_BYTE = 27;
+var CTRL_C_BYTE = 3;
 async function getAtCompletions(prefix, cwd) {
   const query = prefix.startsWith("@") ? prefix.slice(1) : prefix;
   const results = [];
@@ -3891,7 +4732,7 @@ async function getAtCompletions(prefix, cwd) {
     for await (const file of glob.scan({ cwd, onlyFiles: true })) {
       if (file.includes("node_modules") || file.includes(".git"))
         continue;
-      results.push(`@${relative6(cwd, join16(cwd, file))}`);
+      results.push(`@${relative3(cwd, join13(cwd, file))}`);
       if (results.length >= MAX)
         break;
     }
@@ -3913,7 +4754,7 @@ async function tryExtractImageFromPaste(pasted, cwd) {
     }
   }
   if (!trimmed.includes(" ") && isImageFilename(trimmed)) {
-    const filePath = trimmed.startsWith("/") ? trimmed : join16(cwd, trimmed);
+    const filePath = trimmed.startsWith("/") ? trimmed : join13(cwd, trimmed);
     const attachment = await loadImageFile(filePath);
     if (attachment) {
       const name = filePath.split("/").pop() ?? trimmed;
@@ -3950,35 +4791,67 @@ async function readKey(reader) {
     return "";
   return new TextDecoder().decode(value);
 }
-function watchForInterrupt(abortController) {
-  if (!process.stdin.isTTY)
+function getTurnControlAction(chunk) {
+  for (const byte of chunk) {
+    if (byte === ESC_BYTE)
+      return "cancel";
+    if (byte === CTRL_C_BYTE)
+      return "quit";
+  }
+  return null;
+}
+function exitOnCtrlC(opts) {
+  if (opts?.printNewline)
+    process.stdout.write(`
+`);
+  if (opts?.disableBracketedPaste)
+    process.stdout.write(BPASTE_DISABLE);
+  terminal.setInterruptHandler(null);
+  terminal.setRawMode(false);
+  process.stdin.pause();
+  terminal.restoreTerminal();
+  process.exit(130);
+}
+function watchForCancel(abortController) {
+  if (!terminal.isTTY)
     return () => {};
-  const onInterrupt = () => {
+  const onCancel = () => {
     cleanup();
     abortController.abort();
   };
   const onData = (chunk) => {
-    for (const byte of chunk) {
-      if (byte === 3) {
-        onInterrupt();
-        return;
-      }
+    const action = getTurnControlAction(chunk);
+    if (action === "cancel") {
+      onCancel();
+      return;
+    }
+    if (action === "quit") {
+      cleanup();
+      exitOnCtrlC({ printNewline: true });
     }
   };
   const cleanup = () => {
     process.stdin.removeListener("data", onData);
     terminal.setInterruptHandler(null);
-    process.stdin.setRawMode(false);
+    terminal.setRawMode(false);
     process.stdin.pause();
   };
-  terminal.setInterruptHandler(onInterrupt);
-  process.stdin.setRawMode(true);
+  terminal.setInterruptHandler(onCancel);
+  terminal.setRawMode(true);
   process.stdin.resume();
   process.stdin.on("data", onData);
   return cleanup;
 }
-var PASTE_SENTINEL = "\x00PASTE\x00";
-var PASTE_SENTINEL_LEN = PASTE_SENTINEL.length;
+var PASTE_TOKEN_START = 57344;
+var PASTE_TOKEN_END = 63743;
+function createPasteToken(buf, pasteTokens) {
+  for (let code = PASTE_TOKEN_START;code <= PASTE_TOKEN_END; code++) {
+    const token = String.fromCharCode(code);
+    if (!buf.includes(token) && !pasteTokens.has(token))
+      return token;
+  }
+  throw new Error("Too many pasted chunks in a single prompt");
+}
 function pasteLabel(text) {
   const lines = text.split(`
 `);
@@ -3988,6 +4861,58 @@ function pasteLabel(text) {
   const more = extra > 0 ? ` +${extra} more line${extra === 1 ? "" : "s"}` : "";
   return `[pasted: "${preview}"${more}]`;
 }
+function processInputBuffer(buf, pasteTokens, replacer) {
+  let out = "";
+  for (let i = 0;i < buf.length; i++) {
+    const ch = buf[i] ?? "";
+    out += replacer(ch, pasteTokens.get(ch));
+  }
+  return out;
+}
+function renderInputBuffer(buf, pasteTokens) {
+  return processInputBuffer(buf, pasteTokens, (ch, pasted) => pasted ? pasteLabel(pasted) : ch);
+}
+function expandInputBuffer(buf, pasteTokens) {
+  return processInputBuffer(buf, pasteTokens, (ch, pasted) => pasted ?? ch);
+}
+function pruneInputPasteTokens(pasteTokens, ...buffers) {
+  const referenced = buffers.join("");
+  const next = new Map;
+  for (const [token, text] of pasteTokens) {
+    if (referenced.includes(token))
+      next.set(token, text);
+  }
+  return next;
+}
+function getVisualCursor(buf, cursor, pasteTokens) {
+  let visual = 0;
+  for (let i = 0;i < Math.min(cursor, buf.length); i++) {
+    const ch = buf[i] ?? "";
+    const pasted = pasteTokens.get(ch);
+    visual += pasted ? pasteLabel(pasted).length : 1;
+  }
+  return visual;
+}
+function buildPromptDisplay(text, cursor, maxLen) {
+  const clampedCursor = Math.max(0, Math.min(cursor, text.length));
+  if (maxLen <= 0)
+    return { display: "", cursor: 0 };
+  if (text.length <= maxLen)
+    return { display: text, cursor: clampedCursor };
+  let start = Math.max(0, clampedCursor - maxLen);
+  const end = Math.min(text.length, start + maxLen);
+  if (end - start < maxLen)
+    start = Math.max(0, end - maxLen);
+  let display = text.slice(start, end);
+  if (start > 0 && display.length > 0)
+    display = `\u2026${display.slice(1)}`;
+  if (end < text.length && display.length > 0)
+    display = `${display.slice(0, -1)}\u2026`;
+  return {
+    display,
+    cursor: Math.min(clampedCursor - start, display.length)
+  };
+}
 var PROMPT = c11.green("\u25B6 ");
 var PROMPT_PLAN = c11.yellow("\u2B22 ");
 var PROMPT_RALPH = c11.magenta("\u21BB ");
@@ -4001,24 +4926,44 @@ async function readline(opts) {
   let savedInput = "";
   let searchMode = false;
   let searchQuery = "";
-  let pasteBuffer = null;
+  const pasteTokens = new Map;
   const imageAttachments = [];
-  process.stdin.setRawMode(true);
+  function prunePasteTokens() {
+    const next = pruneInputPasteTokens(pasteTokens, buf, savedInput);
+    pasteTokens.clear();
+    for (const [token, text] of next)
+      pasteTokens.set(token, text);
+  }
+  function insertText(text) {
+    buf = buf.slice(0, cursor) + text + buf.slice(cursor);
+    cursor += text.length;
+  }
+  function deleteWordBackward() {
+    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);
+    prunePasteTokens();
+    renderPrompt();
+  }
+  function insertPasteToken(text) {
+    const token = createPasteToken(buf, pasteTokens);
+    pasteTokens.set(token, text);
+    insertText(token);
+  }
+  terminal.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, c11.dim(pasteLabel(pasteBuffer))) : buf).replace(/\[image: [^\]]+\]/g, (m) => c11.dim(c11.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 visualBuf = renderInputBuffer(buf, pasteTokens);
+    const visualCursor = getVisualCursor(buf, cursor, pasteTokens);
+    const { display, cursor: displayCursor } = buildPromptDisplay(visualBuf, visualCursor, Math.max(1, cols - PROMPT_RAW_LEN - 2));
     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`);
+    process.stdout.write(`${CLEAR_LINE}${prompt}${display}${CSI}${PROMPT_RAW_LEN + displayCursor + 1}G`);
   }
   function renderSearchPrompt() {
     process.stdout.write(`${CLEAR_LINE}${c11.cyan("search:")} ${searchQuery}\u2588`);
@@ -4030,6 +4975,7 @@ async function readline(opts) {
       buf = savedInput;
     }
     cursor = buf.length;
+    prunePasteTokens();
     renderPrompt();
   }
   renderPrompt();
@@ -4079,14 +5025,11 @@ async function readline(opts) {
         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;
+          insertText(imageResult.label);
           renderPrompt();
           continue;
         }
-        pasteBuffer = pasted;
-        buf = buf.slice(0, cursor) + PASTE_SENTINEL + buf.slice(cursor);
-        cursor += PASTE_SENTINEL_LEN;
+        insertPasteToken(pasted);
         renderPrompt();
         continue;
       }
@@ -4138,15 +5081,7 @@ async function readline(opts) {
           continue;
         }
         if (raw === `${ESC}${BACKSPACE}`) {
-          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();
+          deleteWordBackward();
           continue;
         }
         if (raw === ESC) {
@@ -4157,9 +5092,7 @@ async function readline(opts) {
         continue;
       }
       if (raw === CTRL_C) {
-        process.stdout.write(`
-`);
-        return { type: "interrupt" };
+        exitOnCtrlC({ printNewline: true, disableBracketedPaste: true });
       }
       if (raw === CTRL_D) {
         process.stdout.write(`
@@ -4177,29 +5110,19 @@ async function readline(opts) {
         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();
+        deleteWordBackward();
         continue;
       }
       if (raw === CTRL_U) {
         buf = buf.slice(cursor);
         cursor = 0;
-        if (pasteBuffer && !buf.includes(PASTE_SENTINEL))
-          pasteBuffer = null;
+        prunePasteTokens();
         renderPrompt();
         continue;
       }
       if (raw === CTRL_K) {
         buf = buf.slice(0, cursor);
-        if (pasteBuffer && !buf.includes(PASTE_SENTINEL))
-          pasteBuffer = null;
+        prunePasteTokens();
         renderPrompt();
         continue;
       }
@@ -4218,8 +5141,7 @@ async function readline(opts) {
         if (cursor > 0) {
           buf = buf.slice(0, cursor - 1) + buf.slice(cursor);
           cursor--;
-          if (pasteBuffer && !buf.includes(PASTE_SENTINEL))
-            pasteBuffer = null;
+          prunePasteTokens();
           renderPrompt();
         }
         continue;
@@ -4246,8 +5168,8 @@ async function readline(opts) {
         continue;
       }
       if (raw === ENTER || raw === NEWLINE) {
-        const expanded = pasteBuffer ? buf.replace(PASTE_SENTINEL, pasteBuffer) : buf;
-        pasteBuffer = null;
+        const expanded = expandInputBuffer(buf, pasteTokens);
+        pasteTokens.clear();
         const text = expanded.trim();
         process.stdout.write(`
 `);
@@ -4276,30 +5198,31 @@ async function readline(opts) {
         };
       }
       if (raw.length > 1) {
-        const pasted = raw.replace(/\r?\n$/, "");
-        const imageResult = await tryExtractImageFromPaste(pasted, cwd);
+        const chunk = raw.replace(/\r?\n$/, "");
+        const imageResult = await tryExtractImageFromPaste(chunk, cwd);
         if (imageResult) {
           imageAttachments.push(imageResult.attachment);
-          buf = buf.slice(0, cursor) + imageResult.label + buf.slice(cursor);
-          cursor += imageResult.label.length;
+          insertText(imageResult.label);
           renderPrompt();
           continue;
         }
-        pasteBuffer = pasted;
-        buf = buf.slice(0, cursor) + PASTE_SENTINEL + buf.slice(cursor);
-        cursor += PASTE_SENTINEL_LEN;
+        if (chunk.includes(`
+`) || chunk.includes("\r")) {
+          insertPasteToken(chunk);
+        } else {
+          insertText(chunk);
+        }
         renderPrompt();
         continue;
       }
       if (raw >= " " || raw === "\t") {
-        buf = buf.slice(0, cursor) + raw + buf.slice(cursor);
-        cursor++;
+        insertText(raw);
         renderPrompt();
       }
     }
   } finally {
     process.stdout.write(BPASTE_DISABLE);
-    process.stdin.setRawMode(false);
+    terminal.setRawMode(false);
     process.stdin.pause();
   }
 }
@@ -4483,7 +5406,7 @@ class SessionRunner {
     abortController.signal.addEventListener("abort", () => {
       wasAborted = true;
     });
-    const stopWatcher = watchForInterrupt(abortController);
+    const stopWatcher = watchForCancel(abortController);
     const { text: resolvedText, images: refImages } = await resolveFileRefs(text, this.cwd);
     const allImages = [...pastedImages, ...refImages];
     const thisTurn = this.turnIndex++;
@@ -4682,7 +5605,7 @@ async function runAgent(opts) {
       inputTokens: runner.totalIn,
       outputTokens: runner.totalOut,
       contextTokens: runner.lastContextTokens,
-      contextWindow: getContextWindow(runner.currentModel) ?? 0,
+      contextWindow: getContextWindow2(runner.currentModel) ?? 0,
       ralphMode: runner.ralphMode,
       thinkingEffort: runner.currentThinkingEffort
     });
@@ -4746,6 +5669,8 @@ class CliReporter {
 registerTerminalCleanup();
 initErrorLog();
 initApiLog();
+initModelInfoCache();
+refreshModelInfoInBackground().catch(() => {});
 function parseArgs(argv) {
   const args = {
     model: null,