mini-coder 0.0.12 → 0.0.14

package/dist/mc.js

@@ -716,15 +716,32 @@ function renderToolResult(toolName, result, isError) {
   const text = JSON.stringify(result);
   writeln(`    ${c3.dim(text.length > 120 ? `${text.slice(0, 117)}\u2026` : text)}`);
 }
-function formatSubagentLabel(laneId, parentLabel) {
-  const numStr = parentLabel ? `${parentLabel.replace(/[\[\]]/g, "")}.${laneId}` : `${laneId}`;
-  return c3.dim(c3.cyan(`[${numStr}]`));
+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 shortWorktreeBranch(branch) {
+  const match = branch.match(/^(mc-sub-\d+)-\d+$/);
+  return match?.[1] ?? branch;
+}
+function formatSubagentLabel(laneId, parentLabel, worktreeBranch) {
+  const parent = parentLabel ? normalizeParentLaneLabel(parentLabel) : "";
+  const numStr = parent ? `${parent}.${laneId}` : `${laneId}`;
+  const branchHint = worktreeBranch ? `\xB7${shortWorktreeBranch(worktreeBranch)}` : "";
+  return c3.dim(c3.cyan(`[${numStr}${branchHint}]`));
 }
 var laneBuffers = new Map;
 function renderSubagentEvent(event, opts) {
-  const { laneId, parentLabel, activeLanes } = opts;
-  const labelStr = formatSubagentLabel(laneId, parentLabel);
-  const prefix = activeLanes.size > 1 ? `${labelStr} ` : "";
+  const { laneId, parentLabel, worktreeBranch, activeLanes } = opts;
+  const labelStr = formatSubagentLabel(laneId, parentLabel, worktreeBranch);
+  const prefix = activeLanes.size > 1 || worktreeBranch ? `${labelStr} ` : "";
   if (event.type === "text-delta") {
     const buf = (laneBuffers.get(laneId) ?? "") + event.delta;
     const lines = buf.split(`
@@ -978,7 +995,7 @@ function renderError(err, context = "render") {
 
 // src/cli/output.ts
 var HOME2 = homedir3();
-var PACKAGE_VERSION = "0.0.12";
+var PACKAGE_VERSION = "0.0.14";
 function tildePath(p) {
   return p.startsWith(HOME2) ? `~${p.slice(HOME2.length)}` : p;
 }
@@ -1068,6 +1085,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 +1226,779 @@ 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);
+  if (!isRecord(payload))
+    return null;
+  const data = payload.data;
+  if (!Array.isArray(data))
+    return null;
+  const out = [];
+  for (const item of data) {
+    if (!isRecord(item) || typeof item.id !== "string")
+      continue;
+    const modelId = normalizeModelId(item.id);
+    if (!modelId)
+      continue;
+    const contextWindow = typeof item.context_window === "number" && Number.isFinite(item.context_window) ? Math.max(0, Math.trunc(item.context_window)) : null;
+    out.push({
+      providerModelId: modelId,
+      displayName: item.id,
+      contextWindow,
+      free: item.id.endsWith("-free") || item.id === "gpt-5-nano" || item.id === "big-pickle"
+    });
+  }
+  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);
+  if (!isRecord(payload) || !Array.isArray(payload.data))
+    return null;
+  const out = [];
+  for (const item of payload.data) {
+    if (!isRecord(item) || typeof item.id !== "string")
+      continue;
+    const modelId = normalizeModelId(item.id);
+    if (!modelId)
+      continue;
+    out.push({
+      providerModelId: modelId,
+      displayName: item.id,
+      contextWindow: null,
+      free: false
+    });
+  }
+  return out;
+}
+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);
+  if (!isRecord(payload) || !Array.isArray(payload.data))
+    return null;
+  const out = [];
+  for (const item of payload.data) {
+    if (!isRecord(item) || typeof item.id !== "string")
+      continue;
+    const modelId = normalizeModelId(item.id);
+    if (!modelId)
+      continue;
+    const displayName = typeof item.display_name === "string" && item.display_name.trim().length > 0 ? item.display_name : item.id;
+    out.push({
+      providerModelId: modelId,
+      displayName,
+      contextWindow: null,
+      free: false
+    });
+  }
+  return out;
+}
+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);
+  if (!isRecord(payload) || !Array.isArray(payload.models))
+    return null;
+  const out = [];
+  for (const item of payload.models) {
+    if (!isRecord(item) || typeof item.name !== "string")
+      continue;
+    const modelId = normalizeModelId(item.name);
+    if (!modelId)
+      continue;
+    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;
+    out.push({
+      providerModelId: modelId,
+      displayName,
+      contextWindow,
+      free: false
+    });
+  }
+  return out;
+}
+async function fetchOllamaModels() {
+  const base = process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
+  const payload = await fetchJson(`${base}/api/tags`, {}, 3000);
+  if (!isRecord(payload) || !Array.isArray(payload.models))
+    return null;
+  const out = [];
+  for (const item of payload.models) {
+    if (!isRecord(item) || typeof item.name !== "string")
+      continue;
+    const modelId = normalizeModelId(item.name);
+    if (!modelId)
+      continue;
+    const details = item.details;
+    let sizeSuffix = "";
+    if (isRecord(details) && typeof details.parameter_size === "string") {
+      sizeSuffix = ` (${details.parameter_size})`;
+    }
+    out.push({
+      providerModelId: modelId,
+      displayName: `${item.name}${sizeSuffix}`,
+      contextWindow: null,
+      free: false
+    });
+  }
+  return out;
+}
+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 +2025,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 +2050,7 @@ function zenAnthropic() {
     _zenAnthropic = createAnthropic({
       fetch: getFetchWithLogging(),
       apiKey: getZenApiKey(),
-      baseURL: ZEN_BASE
+      baseURL: ZEN_BASE2
     });
   }
   return _zenAnthropic;
@@ -1268,7 +2060,7 @@ function zenOpenAI() {
     _zenOpenAI = createOpenAI({
       fetch: getFetchWithLogging(),
       apiKey: getZenApiKey(),
-      baseURL: ZEN_BASE
+      baseURL: ZEN_BASE2
     });
   }
   return _zenOpenAI;
@@ -1278,7 +2070,7 @@ function zenGoogle() {
     _zenGoogle = createGoogleGenerativeAI({
       fetch: getFetchWithLogging(),
       apiKey: getZenApiKey(),
-      baseURL: ZEN_BASE
+      baseURL: ZEN_BASE2
     });
   }
   return _zenGoogle;
@@ -1289,7 +2081,7 @@ function zenCompat() {
       fetch: getFetchWithLogging(),
       name: "zen-compat",
       apiKey: getZenApiKey(),
-      baseURL: ZEN_BASE
+      baseURL: ZEN_BASE2
     });
   }
   return _zenCompat;
@@ -1339,31 +2131,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 +2147,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 +2199,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("/");
@@ -1464,229 +2228,79 @@ function resolveModel(modelString) {
       return ollamaProvider(modelId);
     }
     default:
-      throw new Error(`Unknown provider "${provider}". Supported: zen, anthropic, openai, google, ollama`);
-  }
-}
-function autoDiscoverModel() {
-  if (process.env.OPENCODE_API_KEY)
-    return "zen/claude-sonnet-4-6";
-  if (process.env.ANTHROPIC_API_KEY)
-    return "anthropic/claude-sonnet-4-5-20250929";
-  if (process.env.OPENAI_API_KEY)
-    return "openai/gpt-4o";
-  if (process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY)
-    return "google/gemini-2.0-flash";
-  return "ollama/llama3.2";
-}
-async function fetchZenModels() {
-  const key = process.env.OPENCODE_API_KEY;
-  if (!key)
-    return [];
-  try {
-    const res = await fetch(`${ZEN_BASE}/models`, {
-      headers: { Authorization: `Bearer ${key}` },
-      signal: AbortSignal.timeout(8000)
-    });
-    if (!res.ok)
-      return [];
-    const json = await res.json();
-    const models = json.data ?? [];
-    return models.map((m) => ({
-      id: `zen/${m.id}`,
-      displayName: m.id,
-      provider: "zen",
-      context: m.context_window,
-      free: m.id.endsWith("-free") || m.id === "gpt-5-nano" || m.id === "big-pickle"
-    }));
-  } catch {
-    return [];
-  }
-}
-async function fetchOllamaModels() {
-  const base = process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
-  try {
-    const res = await fetch(`${base}/api/tags`, {
-      signal: AbortSignal.timeout(3000)
-    });
-    if (!res.ok)
-      return [];
-    const json = await res.json();
-    return (json.models ?? []).map((m) => ({
-      id: `ollama/${m.name}`,
-      displayName: m.name + (m.details?.parameter_size ? ` (${m.details.parameter_size})` : ""),
-      provider: "ollama"
-    }));
-  } catch {
-    return [];
-  }
-}
-async function fetchAvailableModels() {
-  const [zen, ollama] = await Promise.all([
-    fetchZenModels(),
-    fetchOllamaModels()
-  ]);
-  return [...zen, ...ollama];
-}
-
-// src/mcp/client.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-async function connectMcpServer(config) {
-  const client = new Client({ name: "mini-coder", version: "0.1.0" });
-  if (config.transport === "http") {
-    if (!config.url) {
-      throw new Error(`MCP server "${config.name}" requires a url`);
-    }
-    const url = new URL(config.url);
-    let transport;
-    try {
-      const streamable = new StreamableHTTPClientTransport(url);
-      transport = streamable;
-      await client.connect(transport);
-    } catch {
-      transport = new SSEClientTransport(url);
-      await client.connect(transport);
-    }
-  } else if (config.transport === "stdio") {
-    if (!config.command) {
-      throw new Error(`MCP server "${config.name}" requires a command`);
-    }
-    const stdioParams = config.env ? { command: config.command, args: config.args ?? [], env: config.env } : { command: config.command, args: config.args ?? [] };
-    const transport = new StdioClientTransport(stdioParams);
-    await client.connect(transport);
-  } else {
-    throw new Error(`Unknown MCP transport: ${config.transport}`);
-  }
-  const { tools: mcpTools } = await client.listTools();
-  const tools = mcpTools.map((t) => ({
-    name: `mcp_${config.name}_${t.name}`,
-    description: `[MCP:${config.name}] ${t.description ?? t.name}`,
-    schema: t.inputSchema,
-    execute: async (input) => {
-      const result = await client.callTool({
-        name: t.name,
-        arguments: input
-      });
-      if (result.isError) {
-        const content = result.content;
-        const errText = content.filter((b) => b.type === "text").map((b) => b.text ?? "").join(`
-`);
-        throw new Error(errText || "MCP tool returned an error");
-      }
-      return result.content;
-    }
-  }));
-  return {
-    name: config.name,
-    tools,
-    close: () => client.close()
-  };
-}
-
-// src/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
-  );
+      throw new Error(`Unknown provider "${provider}". Supported: zen, anthropic, openai, google, ollama`);
+  }
+}
+function autoDiscoverModel() {
+  if (process.env.OPENCODE_API_KEY)
+    return "zen/claude-sonnet-4-6";
+  if (process.env.ANTHROPIC_API_KEY)
+    return "anthropic/claude-sonnet-4-5-20250929";
+  if (process.env.OPENAI_API_KEY)
+    return "openai/gpt-4o";
+  if (process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY)
+    return "google/gemini-2.0-flash";
+  return "ollama/llama3.2";
+}
+async function fetchAvailableModels() {
+  return fetchAvailableModelsSnapshot();
+}
 
-  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);
+// src/mcp/client.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+async function connectMcpServer(config) {
+  const client = new Client({ name: "mini-coder", version: "0.1.0" });
+  if (config.transport === "http") {
+    if (!config.url) {
+      throw new Error(`MCP server "${config.name}" requires a url`);
     }
-    _db = db;
+    const url = new URL(config.url);
+    let transport;
+    try {
+      const streamable = new StreamableHTTPClientTransport(url);
+      transport = streamable;
+      await client.connect(transport);
+    } catch {
+      transport = new SSEClientTransport(url);
+      await client.connect(transport);
+    }
+  } else if (config.transport === "stdio") {
+    if (!config.command) {
+      throw new Error(`MCP server "${config.name}" requires a command`);
+    }
+    const stdioParams = config.env ? { command: config.command, args: config.args ?? [], env: config.env } : { command: config.command, args: config.args ?? [] };
+    const transport = new StdioClientTransport(stdioParams);
+    await client.connect(transport);
+  } else {
+    throw new Error(`Unknown MCP transport: ${config.transport}`);
   }
-  return _db;
+  const { tools: mcpTools } = await client.listTools();
+  const tools = mcpTools.map((t) => ({
+    name: `mcp_${config.name}_${t.name}`,
+    description: `[MCP:${config.name}] ${t.description ?? t.name}`,
+    schema: t.inputSchema,
+    execute: async (input) => {
+      const result = await client.callTool({
+        name: t.name,
+        arguments: input
+      });
+      if (result.isError) {
+        const content = result.content;
+        const errText = content.filter((b) => b.type === "text").map((b) => b.text ?? "").join(`
+`);
+        throw new Error(errText || "MCP tool returned an error");
+      }
+      return result.content;
+    }
+  }));
+  return {
+    name: config.name,
+    tools,
+    close: () => client.close()
+  };
 }
 // src/session/db/session-repo.ts
 function createSession(opts) {
@@ -1848,6 +2462,10 @@ 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 join15 } from "path";
+
 // src/llm-api/turn.ts
 import { dynamicTool, jsonSchema, stepCountIs, streamText } from "ai";
 import { z } from "zod";
@@ -2031,17 +2649,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 +2881,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;
   }
@@ -2156,10 +2961,58 @@ var webContentTool = {
   }
 };
 
-// src/tools/create.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync4 } from "fs";
-import { dirname, join as join6, relative } from "path";
+// src/tools/subagent.ts
 import { z as z3 } from "zod";
+var SubagentInput = z3.object({
+  prompt: z3.string().describe("The task or question to give the subagent"),
+  agentName: z3.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 existsSync5, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname2, join as join7, relative } from "path";
+import { z as z4 } from "zod";
 
 // src/tools/diff.ts
 function generateDiff(filePath, before, after) {
@@ -2288,9 +3141,9 @@ ${lines.join(`
 }
 
 // src/tools/create.ts
-var CreateSchema = z3.object({
-  path: z3.string().describe("File path to write (absolute or relative to cwd)"),
-  content: z3.string().describe("Full content to write to the file")
+var CreateSchema = z4.object({
+  path: z4.string().describe("File path to write (absolute or relative to cwd)"),
+  content: z4.string().describe("Full content to write to the file")
 });
 var createTool = {
   name: "create",
@@ -2298,11 +3151,11 @@ var createTool = {
   schema: CreateSchema,
   execute: async (input) => {
     const cwd = input.cwd ?? process.cwd();
-    const filePath = input.path.startsWith("/") ? input.path : join6(cwd, input.path);
+    const filePath = input.path.startsWith("/") ? input.path : join7(cwd, input.path);
     const relPath = relative(cwd, filePath);
-    const dir = dirname(filePath);
-    if (!existsSync4(dir))
-      mkdirSync4(dir, { recursive: true });
+    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,15 +3166,15 @@ var createTool = {
 };
 
 // src/tools/glob.ts
-import { join as join8, relative as relative2 } from "path";
-import { z as z4 } from "zod";
+import { join as join9, relative as relative2 } from "path";
+import { z as z5 } 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;
@@ -2329,9 +3182,9 @@ async function loadGitignore(cwd) {
 }
 
 // src/tools/glob.ts
-var GlobSchema = z4.object({
-  pattern: z4.string().describe("Glob pattern to match files against, e.g. '**/*.ts'"),
-  ignore: z4.array(z4.string()).optional().describe("Glob patterns to exclude")
+var GlobSchema = z5.object({
+  pattern: z5.string().describe("Glob pattern to match files against, e.g. '**/*.ts'"),
+  ignore: z5.array(z5.string()).optional().describe("Glob patterns to exclude")
 });
 var MAX_RESULTS = 500;
 var globTool = {
@@ -2354,7 +3207,7 @@ var globTool = {
       if (ignored)
         continue;
       try {
-        const fullPath = join8(cwd, file);
+        const fullPath = join9(cwd, file);
         const stat = await Bun.file(fullPath).stat?.() ?? null;
         matches.push({ path: file, mtime: stat?.mtime?.getTime() ?? 0 });
       } catch {
@@ -2367,14 +3220,14 @@ 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) => relative2(cwd, join9(cwd, m.path)));
     return { files, count: files.length, truncated };
   }
 };
 
 // src/tools/grep.ts
-import { join as join9 } from "path";
-import { z as z5 } from "zod";
+import { join as join10 } from "path";
+import { z as z6 } from "zod";
 
 // src/tools/hashline.ts
 var FNV_OFFSET_BASIS = 2166136261;
@@ -2420,12 +3273,12 @@ function findLineByHash(lines, hash, hintLine) {
 }
 
 // src/tools/grep.ts
-var GrepSchema = z5.object({
-  pattern: z5.string().describe("Regular expression to search for"),
-  include: z5.string().optional().describe("Glob pattern to filter files, e.g. '*.ts' or '*.{ts,tsx}'"),
-  contextLines: z5.number().int().min(0).max(10).optional().default(2).describe("Lines of context to include around each match"),
-  caseSensitive: z5.boolean().optional().default(true),
-  maxResults: z5.number().int().min(1).max(200).optional().default(50)
+var GrepSchema = z6.object({
+  pattern: z6.string().describe("Regular expression to search for"),
+  include: z6.string().optional().describe("Glob pattern to filter files, e.g. '*.ts' or '*.{ts,tsx}'"),
+  contextLines: z6.number().int().min(0).max(10).optional().default(2).describe("Lines of context to include around each match"),
+  caseSensitive: z6.boolean().optional().default(true),
+  maxResults: z6.number().int().min(1).max(200).optional().default(50)
 });
 var DEFAULT_IGNORE = [
   "node_modules",
@@ -2464,7 +3317,7 @@ var grepTool = {
         if (ignoreGlob.some((g) => g.match(relPath) || g.match(firstSegment))) {
           continue;
         }
-        const fullPath = join9(cwd, relPath);
+        const fullPath = join10(cwd, relPath);
         let text;
         try {
           text = await Bun.file(fullPath).text();
@@ -2516,7 +3369,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 join11 } from "path";
 function isExecutable(filePath) {
   try {
     accessSync(filePath, constants.X_OK);
@@ -2528,8 +3381,8 @@ function isExecutable(filePath) {
 function findHook(toolName, cwd) {
   const scriptName = `post-${toolName}`;
   const candidates = [
-    join10(cwd, ".agents", "hooks", scriptName),
-    join10(homedir7(), ".agents", "hooks", scriptName)
+    join11(cwd, ".agents", "hooks", scriptName),
+    join11(homedir7(), ".agents", "hooks", scriptName)
   ];
   for (const p of candidates) {
     if (isExecutable(p))
@@ -2618,13 +3471,13 @@ 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)"),
-  anchor: z6.string().describe('Anchor line from a prior read/grep, e.g. "11:a3"'),
-  position: z6.enum(["before", "after"]).describe('Insert the content "before" or "after" the anchor line'),
-  content: z6.string().describe("Text to insert")
+import { join as join12, relative as relative3 } from "path";
+import { z as z7 } from "zod";
+var InsertSchema = z7.object({
+  path: z7.string().describe("File path to edit (absolute or relative to cwd)"),
+  anchor: z7.string().describe('Anchor line from a prior read/grep, e.g. "11:a3"'),
+  position: z7.enum(["before", "after"]).describe('Insert the content "before" or "after" the anchor line'),
+  content: z7.string().describe("Text to insert")
 });
 var HASH_NOT_FOUND_ERROR = "Hash not found. Re-read the file to get current anchors.";
 var insertTool = {
@@ -2633,7 +3486,7 @@ var insertTool = {
   schema: InsertSchema,
   execute: async (input) => {
     const cwd = input.cwd ?? process.cwd();
-    const filePath = input.path.startsWith("/") ? input.path : join11(cwd, input.path);
+    const filePath = input.path.startsWith("/") ? input.path : join12(cwd, input.path);
     const relPath = relative3(cwd, filePath);
     const file = Bun.file(filePath);
     if (!await file.exists()) {
@@ -2679,12 +3532,12 @@ function parseAnchor(value) {
 }
 
 // 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)"),
-  line: z7.number().int().min(1).optional().describe("1-indexed starting line (default: 1)"),
-  count: z7.number().int().min(1).max(500).optional().describe("Lines to read (default: 500, max: 500)")
+import { join as join13, relative as relative4 } from "path";
+import { z as z8 } from "zod";
+var ReadSchema = z8.object({
+  path: z8.string().describe("File path to read (absolute or relative to cwd)"),
+  line: z8.number().int().min(1).optional().describe("1-indexed starting line (default: 1)"),
+  count: z8.number().int().min(1).max(500).optional().describe("Lines to read (default: 500, max: 500)")
 });
 var MAX_COUNT = 500;
 var MAX_BYTES = 1e6;
@@ -2694,7 +3547,7 @@ var readTool = {
   schema: ReadSchema,
   execute: async (input) => {
     const cwd = input.cwd ?? process.cwd();
-    const filePath = input.path.startsWith("/") ? input.path : join12(cwd, input.path);
+    const filePath = input.path.startsWith("/") ? input.path : join13(cwd, input.path);
     const file = Bun.file(filePath);
     const exists = await file.exists();
     if (!exists) {
@@ -2727,13 +3580,13 @@ 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)"),
-  startAnchor: z8.string().describe('Start anchor from a prior read/grep, e.g. "11:a3"'),
-  endAnchor: z8.string().optional().describe('End anchor (inclusive), e.g. "33:0e". Omit to target only the startAnchor line.'),
-  newContent: z8.string().optional().describe("Replacement text. Omit or pass empty string to delete the range.")
+import { join as join14, relative as relative5 } from "path";
+import { z as z9 } from "zod";
+var ReplaceSchema = z9.object({
+  path: z9.string().describe("File path to edit (absolute or relative to cwd)"),
+  startAnchor: z9.string().describe('Start anchor from a prior read/grep, e.g. "11:a3"'),
+  endAnchor: z9.string().optional().describe('End anchor (inclusive), e.g. "33:0e". Omit to target only the startAnchor line.'),
+  newContent: z9.string().optional().describe("Replacement text. Omit or pass empty string to delete the range.")
 });
 var HASH_NOT_FOUND_ERROR2 = "Hash not found. Re-read the file to get current anchors.";
 var replaceTool = {
@@ -2742,7 +3595,7 @@ var replaceTool = {
   schema: ReplaceSchema,
   execute: async (input) => {
     const cwd = input.cwd ?? process.cwd();
-    const filePath = input.path.startsWith("/") ? input.path : join13(cwd, input.path);
+    const filePath = input.path.startsWith("/") ? input.path : join14(cwd, input.path);
     const relPath = relative5(cwd, filePath);
     const file = Bun.file(filePath);
     if (!await file.exists()) {
@@ -2801,11 +3654,11 @@ function parseAnchor2(value, name) {
 }
 
 // src/tools/shell.ts
-import { z as z9 } from "zod";
-var ShellSchema = z9.object({
-  command: z9.string().describe("Shell command to execute"),
-  timeout: z9.number().int().min(1000).max(300000).optional().default(30000).describe("Timeout in milliseconds (default: 30s, max: 5min)"),
-  env: z9.record(z9.string(), z9.string()).optional().describe("Additional environment variables to set")
+import { z as z10 } from "zod";
+var ShellSchema = z10.object({
+  command: z10.string().describe("Shell command to execute"),
+  timeout: z10.number().int().min(1000).max(300000).optional().default(30000).describe("Timeout in milliseconds (default: 30s, max: 5min)"),
+  env: z10.record(z10.string(), z10.string()).optional().describe("Additional environment variables to set")
 });
 var MAX_OUTPUT_BYTES = 1e4;
 var shellTool = {
@@ -2896,26 +3749,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 +3805,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 +3831,152 @@ function buildReadOnlyToolSet(opts) {
 }
 
 // src/agent/subagent-runner.ts
+function makeWorktreeBranch(laneId) {
+  return `mc-sub-${laneId}-${Date.now()}`;
+}
+function makeWorktreePath(laneId) {
+  const suffix = crypto.randomUUID().replace(/-/g, "").slice(0, 10);
+  return join15(tmpdir2(), `mc-wt-${laneId}-${suffix}`);
+}
 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++;
     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 } : {},
+          ...worktreeBranch ? { 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 join16 } from "path";
 async function gitBytes(args, cwd) {
   try {
     const proc = Bun.spawn(["git", ...args], {
@@ -3127,7 +4049,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 +4057,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 +4067,7 @@ async function takeSnapshot(cwd, sessionId, turnIndex) {
       return false;
     const files = [];
     for (const entry of entries) {
-      const absPath = join14(repoRoot, entry.path);
+      const absPath = join16(repoRoot, entry.path);
       if (!entry.existsOnDisk) {
         const { bytes, code } = await gitBytes(["show", `HEAD:${entry.path}`], repoRoot);
         if (code === 0) {
@@ -3188,13 +4110,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 = join16(root, file.path);
       if (!file.existed) {
         try {
           if (await Bun.file(absPath).exists()) {
@@ -3261,7 +4183,7 @@ async function undoLastTurn(ctx) {
 }
 
 // src/agent/agent-helpers.ts
-import { join as join15 } from "path";
+import { join as join17 } from "path";
 import * as c9 from "yoctocolors";
 
 // src/cli/image-types.ts
@@ -3360,7 +4282,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 : join17(cwd, ref);
     if (isImageFilename(ref)) {
       const attachment = await loadImageFile(filePath);
       if (attachment) {
@@ -3441,7 +4363,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 +4408,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 +4432,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 +4461,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 +4630,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 +4657,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 {
@@ -3839,7 +4778,7 @@ async function handleCommand(command, args, ctx) {
 }
 
 // src/cli/input.ts
-import { join as join16, relative as relative6 } from "path";
+import { join as join18, relative as relative6 } from "path";
 import * as c11 from "yoctocolors";
 var ESC = "\x1B";
 var CSI = `${ESC}[`;
@@ -3891,7 +4830,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(`@${relative6(cwd, join18(cwd, file))}`);
       if (results.length >= MAX)
         break;
     }
@@ -3913,7 +4852,7 @@ async function tryExtractImageFromPaste(pasted, cwd) {
     }
   }
   if (!trimmed.includes(" ") && isImageFilename(trimmed)) {
-    const filePath = trimmed.startsWith("/") ? trimmed : join16(cwd, trimmed);
+    const filePath = trimmed.startsWith("/") ? trimmed : join18(cwd, trimmed);
     const attachment = await loadImageFile(filePath);
     if (attachment) {
       const name = filePath.split("/").pop() ?? trimmed;
@@ -4682,7 +5621,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 +5685,8 @@ class CliReporter {
 registerTerminalCleanup();
 initErrorLog();
 initApiLog();
+initModelInfoCache();
+refreshModelInfoInBackground().catch(() => {});
 function parseArgs(argv) {
   const args = {
     model: null,