turbollm 1.9.0 → 1.9.2

package/dist/cli.js

@@ -5,7 +5,7 @@ import {
   engineModelAlias,
   engineRejectsAudioModel,
   evaluateVariant
-} from "./chunk-U4OPDHSX.js";
+} from "./chunk-5MCP2ZAJ.js";
 
 // src/util/hide-console-windows.ts
 import { ChildProcess } from "child_process";
@@ -23,9 +23,9 @@ function hideChildConsoleWindows() {
 
 // src/cli.ts
 import { spawn as spawn8 } from "child_process";
-import { openSync as openSync3, readFileSync as readFileSync15 } from "fs";
+import { openSync as openSync3, readFileSync as readFileSync16 } from "fs";
 import { serve } from "@hono/node-server";
-import { dirname as dirname12, join as join32 } from "path";
+import { dirname as dirname12, join as join33 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/config.ts
@@ -124,7 +124,7 @@ function defaultConfig() {
     customAgents: [],
     builtinAgentOverrides: {},
     build: { toolchainDirs: [] },
-    code: { agentsMdProjectCandidates: ["AGENTS.md", "agents.md", "CLAUDE.md"], agentsMdGlobalCandidates: ["agents.md", "AGENTS.md", "CLAUDE.md"] },
+    code: { agentsMdProjectCandidates: ["AGENTS.md", "agents.md", "CLAUDE.md"], agentsMdGlobalCandidates: ["agents.md", "AGENTS.md", "CLAUDE.md"], defaultAgent: "turbollm" },
     cloudDeploy: { runpodTemplateId: "" }
   };
 }
@@ -368,9 +368,12 @@ function normalize(c) {
     const filtered = Array.isArray(v) ? v.filter((p) => typeof p === "string" && p.trim() !== "").map((p) => p.trim()) : [];
     return filtered.length > 0 ? filtered : fallback;
   };
+  const ALLOWED_AGENTS = /* @__PURE__ */ new Set(["turbollm", "pi", "claude", "opencode"]);
   c.code = {
     agentsMdProjectCandidates: cleanCandidates(cc.agentsMdProjectCandidates, ["AGENTS.md", "agents.md", "CLAUDE.md"]),
-    agentsMdGlobalCandidates: cleanCandidates(cc.agentsMdGlobalCandidates, ["agents.md", "AGENTS.md", "CLAUDE.md"])
+    agentsMdGlobalCandidates: cleanCandidates(cc.agentsMdGlobalCandidates, ["agents.md", "AGENTS.md", "CLAUDE.md"]),
+    // Unrecognized/absent → 'turbollm' (the built-in chat UI), never a silently-broken terminal launch.
+    defaultAgent: ALLOWED_AGENTS.has(cc.defaultAgent) ? cc.defaultAgent : "turbollm"
   };
   const cd = c.cloudDeploy ?? {};
   c.cloudDeploy = { runpodTemplateId: typeof cd.runpodTemplateId === "string" ? cd.runpodTemplateId.trim() : "" };
@@ -577,6 +580,9 @@ function availableBackends(tag = LLAMA_BUILD) {
     ];
     return a === "arm64" ? list.filter((b) => b.id === "vulkan" || b.id === "cpu") : list;
   }
+  if (plat() === "android") {
+    return [];
+  }
   throw new Error(`unsupported platform: ${plat()}/${process.arch}`);
 }
 function recommendBackendId(vendor, hasGpu, tag = LLAMA_BUILD) {
@@ -674,8 +680,8 @@ async function downloadFile(url, dest, onProgress, signal) {
   const total = Number(res.headers.get("content-length") ?? 0);
   let got = 0;
   let lastPct = -1;
-  const body6 = Readable.fromWeb(res.body);
-  body6.on("data", (chunk) => {
+  const body7 = Readable.fromWeb(res.body);
+  body7.on("data", (chunk) => {
     got += chunk.length;
     if (total && onProgress) {
       const pct = got / total;
@@ -685,7 +691,7 @@ async function downloadFile(url, dest, onProgress, signal) {
       }
     }
   });
-  await pipeline(body6, createWriteStream(dest), { signal });
+  await pipeline(body7, createWriteStream(dest), { signal });
 }
 async function extractArchive(archive, destDir) {
   if (process.platform === "win32") {
@@ -2213,9 +2219,9 @@ var ProbeError = class extends Error {
 var RE_VERSION = /^\s*version:\s*(.+?)\s*$/im;
 var RE_FLAG = /--[a-z0-9][a-z0-9-]+/g;
 var KNOWN_KV = ["f16", "q8_0", "q4_0", "q4_1", "q5_0", "q5_1", "q8_1"];
-function isTimeout(err6) {
-  if (!err6) return false;
-  const e = err6;
+function isTimeout(err7) {
+  if (!err7) return false;
+  const e = err7;
   return e.killed === true && (e.signal === "SIGTERM" || e.signal != null);
 }
 function runCaptured(bin, arg) {
@@ -3679,15 +3685,15 @@ function getSysInfo() {
   if (cached) return cached;
   cached = {
     os: `${process.platform}/${process.arch}`,
-    cpu: os.cpus()[0]?.model?.trim() ?? "",
-    cores: os.cpus().length || 1,
+    cpu: getCpuModel(),
+    cores: getCpuCoreCount(),
     ramMB: Math.round(os.totalmem() / 1e6),
     gpus: detectGpus()
   };
   return cached;
 }
 function primaryVendor(info = getSysInfo()) {
-  const rank = { nvidia: 4, amd: 3, apple: 3, intel: 2, unknown: 1 };
+  const rank = { nvidia: 4, amd: 3, apple: 3, intel: 2, arm: 2, qualcomm: 2, unknown: 1 };
   let best = "unknown";
   for (const g of info.gpus) if (rank[g.vendor] > rank[best]) best = g.vendor;
   return best;
@@ -3698,6 +3704,8 @@ function classifyVendor(name) {
   if (/amd|radeon|\brx\b|instinct|vega|firepro/.test(n)) return "amd";
   if (/intel|arc|iris|\buhd\b|\bhd graphics\b/.test(n)) return "intel";
   if (/apple/.test(n)) return "apple";
+  if (/mali|immortalis/.test(n)) return "arm";
+  if (/adreno/.test(n)) return "qualcomm";
   return "unknown";
 }
 function isIntegratedGpuName(name) {
@@ -3705,7 +3713,10 @@ function isIntegratedGpuName(name) {
   if (/iris|uhd graphics|hd graphics/.test(n)) return true;
   if (/\barc\b/.test(n) && !/\b(?:pro\s+)?[ab]\d{2,4}\b/.test(n)) return true;
   if (/radeon.*graphics/.test(n) && !/\b(rx|pro|instinct|vega\s*\d|firepro)\b/.test(n)) return true;
+  if (/radeon\s*(?:[6-9]\d{2}|\d{4})\s*[ms]\b/.test(n) && !/\b(rx|pro|instinct|vega\s*\d|firepro)\b/.test(n)) return true;
   if (/intel/.test(n) && /graphics/.test(n) && !/\barc\b/.test(n)) return true;
+  if (/mali|immortalis/.test(n)) return true;
+  if (/adreno/.test(n)) return true;
   return false;
 }
 function detectGpus() {
@@ -3729,7 +3740,7 @@ function detectGpus() {
       const out = execFileSync2("system_profiler", ["SPDisplaysDataType"], { timeout: 8e3 }).toString();
       const m = out.match(/Chipset Model:\s*(.+)/);
       if (m && /Apple/.test(out)) {
-        return [{ name: m[1].trim(), vramMb: Math.round(os.totalmem() / 1e6 * 0.65), vendor: "apple" }];
+        return [{ name: m[1].trim(), vramMb: Math.round(os.totalmem() / 1e6 * 0.65), vendor: "apple", unified: true }];
       }
     } catch {
     }
@@ -3756,8 +3767,9 @@ function enumWindowsGpus() {
     const [name, ram] = line.split("|");
     const nm = (name ?? "").trim();
     const bytes = parseInt((ram ?? "").trim(), 10) || 0;
-    const vramMb = isIntegratedGpuName(nm) ? Math.round(os.totalmem() / 1e6 * 0.5) : bytes > 0 ? Math.round(bytes / 1e6) : 0;
-    return { name: nm, vramMb, vendor: classifyVendor(nm) };
+    const integrated = isIntegratedGpuName(nm);
+    const vramMb = integrated ? Math.round(os.totalmem() / 1e6 * 0.5) : bytes > 0 ? Math.round(bytes / 1e6) : 0;
+    return { name: nm, vramMb, vendor: classifyVendor(nm), ...integrated ? { unified: true } : {} };
   }).filter((g) => g.name && g.vendor !== "unknown");
   const registryVram = readWindowsVramRegistry();
   return wmiGpus.map((g) => {
@@ -3826,28 +3838,181 @@ function parseRocmSmi(memJson, nameJson = "") {
   return gpus;
 }
 function enumLinuxGpus() {
-  const out = execFileSync2("sh", ["-c", "lspci -mm 2>/dev/null | grep -iE 'VGA|3D|Display'"], {
-    timeout: 8e3
-  }).toString();
-  return out.trim().split("\n").filter(Boolean).map((line) => {
-    const vendor = classifyVendor(line);
-    const slot = line.trim().split(/\s+/)[0] ?? "";
-    const name = line.replace(/"/g, "").trim().slice(0, 80);
-    const sysfsVramMb = linuxVramMb(slot);
-    const vramMb = sysfsVramMb > 0 ? sysfsVramMb : isIntegratedGpuName(name) ? Math.round(os.totalmem() / 1e6 * 0.5) : 0;
-    return { name, vramMb, vendor };
-  }).filter((g) => g.vendor !== "unknown");
-}
-function linuxVramMb(pciSlot) {
-  if (!pciSlot) return 0;
+  try {
+    const out = execFileSync2("sh", ["-c", "lspci -mm 2>/dev/null | grep -iE 'VGA|3D|Display'"], {
+      timeout: 8e3
+    }).toString();
+    if (out.trim()) {
+      const gpus = out.trim().split("\n").filter(Boolean).map((line) => linuxGpuFromLspci(line, linuxAmdgpuMem, linuxAmdIsApu, os.totalmem(), console.log)).filter((g) => g !== null && g.vendor !== "unknown");
+      if (gpus.length) return gpus;
+    }
+  } catch {
+  }
+  return enumVulkanGpus();
+}
+function enumVulkanGpus() {
+  try {
+    const isAndroid = process.platform === "android";
+    const env = isAndroid ? {
+      ...process.env,
+      LD_LIBRARY_PATH: `/system/lib64:${process.env.LD_LIBRARY_PATH ?? ""}`,
+      LD_PRELOAD: "/system/lib64/liblzma.so"
+    } : process.env;
+    const out = execFileSync2("vulkaninfo", ["--summary"], { timeout: 8e3, env }).toString();
+    const gpus = [];
+    const lines = out.split("\n");
+    let inDevice = false;
+    let deviceName = "";
+    let deviceType = "";
+    for (const line of lines) {
+      if (/^GPU\d+:/.test(line.trim())) {
+        if (deviceName) gpus.push(makeVulkanGpu(deviceName, deviceType));
+        inDevice = true;
+        deviceName = "";
+        deviceType = "";
+        continue;
+      }
+      if (inDevice) {
+        const m1 = line.match(/deviceName\s*=\s*(.+)/i);
+        if (m1) deviceName = m1[1].trim();
+        const m2 = line.match(/deviceType\s*=\s*(.+)/i);
+        if (m2) deviceType = m2[1].trim();
+      }
+    }
+    if (deviceName) gpus.push(makeVulkanGpu(deviceName, deviceType));
+    return gpus;
+  } catch {
+    return [];
+  }
+}
+function makeVulkanGpu(name, deviceType) {
+  const vendor = classifyVendor(name);
+  const integrated = /INTEGRATED_GPU/i.test(deviceType) || isIntegratedGpuName(name);
+  const vramMb = integrated ? Math.round(os.totalmem() / 1e6 * 0.5) : 0;
+  return { name, vramMb, vendor, ...integrated ? { unified: true } : {} };
+}
+function parseLspciMm(line) {
+  const slot = line.trim().split(/\s+/)[0] ?? "";
+  const fields = (line.match(/"[^"]*"/g) ?? []).map((f) => f.slice(1, -1).trim());
+  if (!slot || slot.includes('"') || fields.length < 3) return null;
+  return { slot, deviceClass: fields[0], vendor: fields[1], device: fields[2] };
+}
+function linuxGpuFromLspci(line, readMem, isApu, totalRamBytes, log = () => {
+}) {
+  const entry = parseLspciMm(line);
+  const slot = entry?.slot ?? (line.trim().split(/\s+/)[0] ?? "");
+  if (!slot) return null;
+  const label = entry ? `${entry.vendor} ${entry.device}` : line;
+  const device = entry ? /^device\s+[0-9a-f]{4}$/i.test(entry.device) ? `${entry.vendor} ${entry.device}` : entry.device : "";
+  const name = entry ? device.slice(0, 80) : line.replace(/"/g, "").trim().slice(0, 80);
+  const vendor = classifyVendor(label);
+  const mem = readMem(slot);
+  let vramMb = mem.vramMb;
+  let unified = false;
+  if (mem.vramMb > 0 && vendor === "amd" && mem.gttMb > 0 && isApu(slot, label)) {
+    vramMb = amdApuVramMb(mem.vramMb, mem.gttMb, totalRamBytes);
+    unified = true;
+    log(`[sysinfo] amdgpu APU at ${slot}: vram=${mem.vramMb}MB + gtt=${mem.gttMb}MB \u2192 ${vramMb}MB usable`);
+  } else if (vramMb === 0 && isIntegratedGpuName(label)) {
+    vramMb = Math.round(totalRamBytes / 1e6 * 0.5);
+    unified = true;
+  }
+  return { name, vramMb, vendor, ...unified ? { unified: true } : {} };
+}
+function linuxAmdgpuMem(pciSlot) {
+  if (!pciSlot) return { vramMb: 0, gttMb: 0 };
   for (const dev of [`/sys/bus/pci/devices/0000:${pciSlot}`, `/sys/bus/pci/devices/${pciSlot}`]) {
+    const vram = readSysfsBytes(dev, "mem_info_vram_total");
+    if (vram > 0) return { vramMb: Math.round(vram / 1e6), gttMb: Math.round(readSysfsBytes(dev, "mem_info_gtt_total") / 1e6) };
+  }
+  return { vramMb: 0, gttMb: 0 };
+}
+function readSysfsBytes(dir, attr) {
+  try {
+    const bytes = parseInt(fs.readFileSync(`${dir}/${attr}`, "utf8").trim(), 10);
+    return Number.isFinite(bytes) && bytes > 0 ? bytes : 0;
+  } catch {
+    return 0;
+  }
+}
+function amdApuVramMb(vramMb, gttMb, totalRamBytes) {
+  const cap = Math.round(totalRamBytes / 1e6 * 0.9);
+  return Math.max(vramMb, Math.min(vramMb + gttMb, cap));
+}
+function parseKfdNodes(propsTexts) {
+  const nodes = [];
+  for (const text of propsTexts) {
+    const prop = (key) => {
+      const m = new RegExp(`^${key}\\s+(\\d+)\\s*$`, "m").exec(text);
+      return m ? parseInt(m[1], 10) : 0;
+    };
+    if (prop("simd_count") <= 0) continue;
+    nodes.push({ domain: prop("domain"), locationId: prop("location_id"), fused: prop("cpu_cores_count") > 0 });
+  }
+  return nodes;
+}
+function pciSlotToKfdIds(slot) {
+  const m = /^(?:([0-9a-f]{1,4}):)?([0-9a-f]{1,2}):([0-9a-f]{1,2})\.([0-7])$/i.exec(slot.trim());
+  if (!m) return null;
+  return {
+    domain: m[1] === void 0 ? 0 : parseInt(m[1], 16),
+    locationId: parseInt(m[2], 16) << 8 | (parseInt(m[3], 16) & 31) << 3 | parseInt(m[4], 10)
+  };
+}
+function linuxAmdIsApu(pciSlot, label) {
+  if (kfdReportsFusedNode(pciSlot)) return true;
+  return isIntegratedGpuName(label);
+}
+function kfdReportsFusedNode(pciSlot) {
+  const ids = pciSlotToKfdIds(pciSlot);
+  if (!ids) return false;
+  return readKfdNodes().some((n) => n.domain === ids.domain && n.locationId === ids.locationId && n.fused);
+}
+function readKfdNodes() {
+  const base2 = "/sys/class/kfd/kfd/topology/nodes";
+  try {
+    const texts = [];
+    for (const entry of fs.readdirSync(base2)) {
+      try {
+        texts.push(fs.readFileSync(`${base2}/${entry}/properties`, "utf8"));
+      } catch {
+      }
+    }
+    return parseKfdNodes(texts);
+  } catch {
+    return [];
+  }
+}
+function getCpuModel() {
+  const model = os.cpus()[0]?.model?.trim();
+  if (model && model.length > 0) return model;
+  if (process.platform === "linux" || process.platform === "android") {
+    try {
+      const cpuinfo = fs.readFileSync("/proc/cpuinfo", "utf8");
+      const m = cpuinfo.match(/Hardware\s*:\s*(.+)/) || cpuinfo.match(/model name\s*:\s*(.+)/);
+      if (m) return m[1].trim();
+    } catch {
+    }
+  }
+  return model ?? "";
+}
+function getCpuCoreCount() {
+  const cpus = os.cpus();
+  if (cpus.length > 1) return cpus.length;
+  try {
+    const n = parseInt(execFileSync2("nproc", { timeout: 2e3 }).toString().trim(), 10);
+    if (n > 0) return n;
+  } catch {
+  }
+  if (process.platform === "linux" || process.platform === "android") {
     try {
-      const bytes = parseInt(fs.readFileSync(`${dev}/mem_info_vram_total`, "utf8").trim(), 10);
-      if (Number.isFinite(bytes) && bytes > 0) return Math.round(bytes / 1e6);
+      const cpuinfo = fs.readFileSync("/proc/cpuinfo", "utf8");
+      const matches = cpuinfo.match(/processor\s*:/g);
+      if (matches && matches.length > 0) return matches.length;
     } catch {
     }
   }
-  return 0;
+  return cpus.length || 1;
 }
 
 // src/engines/update-apply.ts
@@ -5193,6 +5358,7 @@ function rowToAgentRun(r) {
     completion: r.completion ?? void 0,
     repoRoot: r.repo_root ?? void 0,
     repoBranch: r.repo_branch ?? void 0,
+    codeAgent: r.code_agent ?? void 0,
     useWorktree: r.use_worktree === null ? void 0 : r.use_worktree === 1,
     worktreeBranch: r.worktree_branch ?? void 0,
     worktreeBase: r.worktree_base ?? void 0,
@@ -5203,7 +5369,8 @@ function rowToAgentRun(r) {
     compactionTokensBefore: r.compaction_tokens_before ?? void 0,
     clearedUpToMessageId: r.cleared_upto_message_id ?? void 0,
     revertedFromMessageId: r.reverted_from_message_id ?? void 0,
-    titleAutoSynced: r.title_auto_synced === 1
+    titleAutoSynced: r.title_auto_synced === 1,
+    terminalLaunchedOnce: r.terminal_launched_once === 1
   };
 }
 function rowToMsg(r) {
@@ -5489,6 +5656,29 @@ var ConversationStore = class {
         PRAGMA user_version = 34;
       `);
     }
+    if (v < 35) {
+      if (!this.hasColumn("agent_runs", "code_agent")) this.db.exec(`ALTER TABLE agent_runs ADD COLUMN code_agent TEXT;`);
+      this.db.exec(`PRAGMA user_version = 35;`);
+    }
+    if (v < 36) {
+      if (!this.hasColumn("api_usage", "code_session_id")) this.db.exec(`ALTER TABLE api_usage ADD COLUMN code_session_id TEXT;`);
+      if (!this.hasColumn("api_usage", "duration_ms")) this.db.exec(`ALTER TABLE api_usage ADD COLUMN duration_ms INTEGER;`);
+      this.db.exec(`CREATE INDEX IF NOT EXISTS idx_api_usage_code_session ON api_usage(code_session_id, created_at);`);
+      this.db.exec(`PRAGMA user_version = 36;`);
+    }
+    if (v < 37) {
+      if (!this.hasColumn("agent_runs", "terminal_launched_once")) this.db.exec(`ALTER TABLE agent_runs ADD COLUMN terminal_launched_once INTEGER NOT NULL DEFAULT 0;`);
+      this.db.exec(`PRAGMA user_version = 37;`);
+    }
+    if (v < 38) {
+      this.db.exec(`UPDATE agent_runs SET terminal_launched_once = 0;`);
+      this.db.exec(`PRAGMA user_version = 38;`);
+    }
+    if (v < 39) {
+      if (!this.hasColumn("api_usage", "prompt_tps")) this.db.exec(`ALTER TABLE api_usage ADD COLUMN prompt_tps REAL;`);
+      if (!this.hasColumn("api_usage", "gen_tps")) this.db.exec(`ALTER TABLE api_usage ADD COLUMN gen_tps REAL;`);
+      this.db.exec(`PRAGMA user_version = 39;`);
+    }
   }
   listConversations(q, kind = "all") {
     if (q) {
@@ -5853,20 +6043,46 @@ var ConversationStore = class {
   }
   /** Insert one completed gateway request (GitHub #71) — called from the two gateway entry
    *  points (gateway.ts) right where in-app chat already records into `messages`. Fully
-   *  additive/fail-safe: callers wrap this the same way `recordCompletion` is wrapped. */
+   *  additive/fail-safe: callers wrap this the same way `recordCompletion` is wrapped.
+   *  `codeSessionId`/`durationMs` (ADR-284) are only populated for a terminal-agent session's
+   *  own token-identified traffic — undefined for every other gateway client, same as before. */
   recordApiUsage(rec) {
+    const rate = (v) => v != null && Number.isFinite(v) && v > 0 ? v : null;
     this.db.prepare(`
-      INSERT INTO api_usage (id, created_at, source, model_key, prompt_tokens, gen_tokens)
-      VALUES ($id, $createdAt, $source, $modelKey, $promptTokens, $genTokens)
+      INSERT INTO api_usage (id, created_at, source, model_key, prompt_tokens, gen_tokens, code_session_id, duration_ms, prompt_tps, gen_tps)
+      VALUES ($id, $createdAt, $source, $modelKey, $promptTokens, $genTokens, $codeSessionId, $durationMs, $promptTps, $genTps)
     `).run({
       $id: randomUUID3(),
       $createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       $source: rec.source,
       $modelKey: rec.modelKey,
       $promptTokens: Math.max(0, Math.floor(rec.promptTokens) || 0),
-      $genTokens: Math.max(0, Math.floor(rec.genTokens) || 0)
+      $genTokens: Math.max(0, Math.floor(rec.genTokens) || 0),
+      $codeSessionId: rec.codeSessionId ?? null,
+      $durationMs: rec.durationMs != null && Number.isFinite(rec.durationMs) ? Math.max(0, Math.floor(rec.durationMs)) : null,
+      $promptTps: rate(rec.promptTps),
+      $genTps: rate(rec.genTps)
     });
   }
+  /** Most recent completed gateway request attributed to a terminal-agent Code session
+   *  (ADR-284) — powers TerminalToolbar.tsx's composer-parity stats row the same way
+   *  `lastRealStats` already does for a 'turbollm' chat session's last turn. null when the
+   *  session has made no gateway requests yet (fresh session, or a non-terminal-agent one). */
+  getLastApiUsageForSession(codeSessionId) {
+    const row = this.db.prepare(`
+      SELECT prompt_tokens, gen_tokens, duration_ms, prompt_tps, gen_tps FROM api_usage
+      WHERE code_session_id = $codeSessionId
+      ORDER BY created_at DESC LIMIT 1
+    `).get({ $codeSessionId: codeSessionId });
+    if (!row) return null;
+    const seconds = row.duration_ms != null && row.duration_ms > 0 ? row.duration_ms / 1e3 : null;
+    return {
+      promptTokens: row.prompt_tokens,
+      genTokens: row.gen_tokens,
+      promptTps: row.prompt_tps ?? (seconds ? row.prompt_tokens / seconds : null),
+      genTps: row.gen_tps ?? (seconds ? row.gen_tokens / seconds : null)
+    };
+  }
   /** Gateway (external-client) token usage — see `ApiUsageStats`'s doc comment for why this
    *  is a separate bucket from `tokenUsageStats`. Same local-day range scoping as the chat
    *  stats above, but no streak/session concepts (a gateway request isn't a chat turn). */
@@ -6115,7 +6331,7 @@ var ConversationStore = class {
     const id = randomUUID3();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const agentId = params.agentId ?? null;
-    this.db.prepare(`INSERT INTO agent_runs (id,conv_id,title,status,allowed_tools,agent_id,repo_root,repo_branch,use_worktree,worktree_branch,worktree_base,lines_added,lines_removed,created_at,updated_at) VALUES ($id,$cid,$title,'queued',$at,$aid,$rr,$rb,$uw,$wb,$wbase,$la,$lr,$now,$now)`).run({
+    this.db.prepare(`INSERT INTO agent_runs (id,conv_id,title,status,allowed_tools,agent_id,repo_root,repo_branch,use_worktree,worktree_branch,worktree_base,lines_added,lines_removed,code_agent,created_at,updated_at) VALUES ($id,$cid,$title,'queued',$at,$aid,$rr,$rb,$uw,$wb,$wbase,$la,$lr,$ca,$now,$now)`).run({
       $id: id,
       $cid: params.convId,
       $title: params.title,
@@ -6130,6 +6346,7 @@ var ConversationStore = class {
       // sidebar shows +0/-0 rather than a blank; a background 'agent' run leaves them NULL.
       $la: params.repoRoot !== void 0 ? 0 : null,
       $lr: params.repoRoot !== void 0 ? 0 : null,
+      $ca: params.codeAgent ?? null,
       $now: now
     });
     return this.getAgentRun(id);
@@ -6189,6 +6406,10 @@ var ConversationStore = class {
       sets.push("title_auto_synced = $tas");
       params.$tas = patch.titleAutoSynced ? 1 : 0;
     }
+    if (patch.terminalLaunchedOnce !== void 0) {
+      sets.push("terminal_launched_once = $tlo");
+      params.$tlo = patch.terminalLaunchedOnce ? 1 : 0;
+    }
     return this.db.prepare(`UPDATE agent_runs SET ${sets.join(", ")} WHERE id = $id`).run(params).changes > 0;
   }
   // ── Code session lifecycle (archive/delete/clear) ───────────────────────────
@@ -7020,8 +7241,8 @@ var DownloadManager = class {
       const verifyHash = hash !== null && startAt === 0;
       let lastTick = Date.now();
       let lastBytes = startAt;
-      const body6 = Readable2.fromWeb(res.body);
-      body6.on("data", (chunk) => {
+      const body7 = Readable2.fromWeb(res.body);
+      body7.on("data", (chunk) => {
         rec.received += chunk.length;
         if (verifyHash) hash.update(chunk);
         const now = Date.now();
@@ -7033,7 +7254,7 @@ var DownloadManager = class {
         }
       });
       const out = createWriteStream3(part, startAt > 0 ? { flags: "a" } : { flags: "w" });
-      await pipeline2(body6, out, { signal: ac.signal });
+      await pipeline2(body7, out, { signal: ac.signal });
       if (rec.total > 0 && rec.received !== rec.total) {
         rmSync9(part, { force: true });
         throw new DownloadError("size_mismatch", "Download corrupt \u2014 size did not match. Removed the partial file.");
@@ -7551,8 +7772,8 @@ var BenchRunner = class {
       };
     } else {
       const memoryBound = results.length > 0 && results.every((r) => r.outcome === "oom");
-      const err6 = this.cancelled ? void 0 : memoryBound ? `This model doesn't fit on your GPU at ${baseProfile.ctx.toLocaleString()} context \u2014 even with maximum CPU offload it ran out of VRAM. Lower the context length and try again.` : "No candidate completed successfully.";
-      this.state = { running: false, modelKey, done: true, error: err6, candidates: results };
+      const err7 = this.cancelled ? void 0 : memoryBound ? `This model doesn't fit on your GPU at ${baseProfile.ctx.toLocaleString()} context \u2014 even with maximum CPU offload it ran out of VRAM. Lower the context length and try again.` : "No candidate completed successfully.";
+      this.state = { running: false, modelKey, done: true, error: err7, candidates: results };
     }
   }
   /** Dense models: pin `ngl` by VRAM probing (Phase 1), then run the full bench once (Phase 2).
@@ -8320,8 +8541,8 @@ function readNvidiaVramMb() {
         "nvidia-smi",
         ["--query-gpu=memory.used", "--format=csv,noheader,nounits"],
         { timeout: 8e3, windowsHide: true },
-        (err6, stdout) => {
-          if (err6 || !stdout) return resolve5(null);
+        (err7, stdout) => {
+          if (err7 || !stdout) return resolve5(null);
           const total = stdout.trim().split("\n").map((l) => parseInt(l.trim(), 10)).filter((n) => Number.isFinite(n)).reduce((a, b) => a + b, 0);
           resolve5(total > 0 ? total : null);
         }
@@ -8349,8 +8570,8 @@ function parseRocmVramUsed(memJson) {
 function readRocmVramMb() {
   return new Promise((resolve5) => {
     try {
-      execFile10("rocm-smi", ["--showmeminfo", "vram", "--json"], { timeout: 8e3, windowsHide: true }, (err6, stdout) => {
-        resolve5(err6 || !stdout ? null : parseRocmVramUsed(stdout));
+      execFile10("rocm-smi", ["--showmeminfo", "vram", "--json"], { timeout: 8e3, windowsHide: true }, (err7, stdout) => {
+        resolve5(err7 || !stdout ? null : parseRocmVramUsed(stdout));
       });
     } catch {
       resolve5(null);
@@ -8428,6 +8649,28 @@ var ModelRouter = class {
       }
       this.extraSlots.delete(entry.key);
     }
+    return this.withSwapLock(() => this.doLoad(entry));
+  }
+  /** Acquire the SAME swap-serialization queue `route()` uses, then run `fn` exclusively with
+   *  respect to any other swap (manual or auto). `route()` itself is just this wrapping
+   *  `doLoad()` — exposed publicly so a MANUAL model switch (routes.ts's `/api/v1/engine/start`,
+   *  which loads the primary manager directly, entirely outside this router) can coordinate too.
+   *
+   *  Why this was missing mattered in practice: the lower-level `Manager.runExclusive` static
+   *  gate already stops two loads from physically racing (no double-spawn), but it only
+   *  serialises EXECUTION order — it doesn't stop a router-triggered auto-swap (e.g. a
+   *  terminal-agent session's own gateway traffic) from independently deciding, mid-manual-
+   *  switch, "the primary is occupied, evict it and load MY model" (`evictChatLru()` picks
+   *  the primary as LRU whenever it's the only occupied slot, `'starting'`/`'stopping'`
+   *  included per ADR-285's `isOccupied()` fix). That decision would then queue behind the
+   *  manual switch at the `Manager` gate and win once it finally ran — so the model that ends
+   *  up loaded silently isn't the one the user just picked in the UI, which reads exactly like
+   *  "my switch reverted" even though nothing crashed or errored. Wrapping the manual switch in
+   *  this same queue means a concurrent auto-swap request now waits for the manual switch to
+   *  fully settle before it even re-checks "is the model I want already running" — so it either
+   *  fast-path no-ops (the manual switch happened to satisfy it) or proceeds cleanly AFTER,
+   *  never mid-flight. */
+  async withSwapLock(fn) {
     let unlock;
     const prev = this.swapChain;
     this.swapChain = new Promise((r) => {
@@ -8435,11 +8678,18 @@ var ModelRouter = class {
     });
     try {
       await prev;
-      return await this.doLoad(entry);
+      return await fn();
     } finally {
       unlock();
     }
   }
+  /** A manual switch (routes.ts) always loads directly into the PRIMARY manager, never an
+   *  extra pool slot — so unlike `doLoad()`'s own bookkeeping, only `primaryLastUsed` needs
+   *  updating on success. Without this, a manual switch left the router's own LRU timestamp
+   *  stale, which could bias `evictChatLru()`'s choice on a later auto-swap. */
+  markPrimaryLoaded() {
+    this.primaryLastUsed = Date.now();
+  }
   /** Every model key currently loaded (or loading) across the WHOLE pool — the primary
    *  manager plus every alive extra slot (F-033). "Alive" = running OR starting, matching
    *  the delete-guard's notion of "loaded" (routes.ts), so a model loaded via gateway
@@ -8513,32 +8763,45 @@ var ModelRouter = class {
     });
     return { target };
   }
-  /** Count of alive chat (non-embedding) slots. Embedding models don't consume
+  /** A slot counts as occupied while 'stopping' too, not just 'running'/'starting' —
+   *  a manual swap (routes.ts's /api/v1/engine/start, going straight to the primary
+   *  Manager, outside this router entirely) passes the primary through 'stopping' on
+   *  its way to the new model. A concurrent gateway request landing in that window
+   *  (e.g. a terminal-agent CLI's own request, racing a founder's manual model switch
+   *  in the UI) used to read the narrower running/starting-only check as "no slot is
+   *  occupied" and spin up a whole SECOND, independently-tracked Manager/llama-server
+   *  process — invisible to the primary manager's own status() and never cleaned up,
+   *  since nothing outside the router's own extraSlots map ever stops it. Found live:
+   *  a founder-reported "it loaded 2 models" during a manual switch while a terminal
+   *  session was open, confirmed via two concurrent llama-server.exe processes on
+   *  8081/8082 where only 8081 was known to /api/v1/status.  */
+  isOccupied(state) {
+    return state === "running" || state === "starting" || state === "stopping";
+  }
+  /** Count of occupied chat (non-embedding) slots. Embedding models don't consume
    *  a keepN slot so chat models and embedding models can coexist independently. */
   chatSlotCount() {
-    const isAlive2 = (s) => s === "running" || s === "starting";
     const ms = this.manager.status();
-    const primaryAlive = isAlive2(ms.state);
+    const primaryAlive = this.isOccupied(ms.state);
     const primaryEmbed = primaryAlive && !!ms.model && (this.scanner.get(ms.model.key)?.embedding ?? false);
     const extraChat = [...this.extraSlots.values()].filter(
-      (s) => isAlive2(s.manager.status().state) && !(this.scanner.get(s.modelKey)?.embedding ?? false)
+      (s) => this.isOccupied(s.manager.status().state) && !(this.scanner.get(s.modelKey)?.embedding ?? false)
     ).length;
     return (primaryAlive && !primaryEmbed ? 1 : 0) + extraChat;
   }
-  /** Evict the least-recently-used chat (non-embedding) slot. Embedding slots are
-   *  skipped; if every alive slot is an embedding model the true LRU is used as
-   *  a fallback so we never deadlock. */
+  /** Evict the least-recently-used occupied chat (non-embedding) slot. Embedding
+   *  slots are skipped; if every occupied slot is an embedding model the true LRU is
+   *  used as a fallback so we never deadlock. */
   evictChatLru() {
-    const isAlive2 = (s) => s === "running" || s === "starting";
     const ms = this.manager.status();
-    const primaryAlive = isAlive2(ms.state);
+    const primaryAlive = this.isOccupied(ms.state);
     const primaryEmbed = primaryAlive && !!ms.model && (this.scanner.get(ms.model.key)?.embedding ?? false);
     let lruManager = this.manager;
     let lruTime = primaryAlive && !primaryEmbed ? this.primaryLastUsed : Infinity;
     let lruKey = null;
     for (const slot of this.extraSlots.values()) {
       const slotEmbed = this.scanner.get(slot.modelKey)?.embedding ?? false;
-      if (isAlive2(slot.manager.status().state) && !slotEmbed && slot.lastUsedMs < lruTime) {
+      if (this.isOccupied(slot.manager.status().state) && !slotEmbed && slot.lastUsedMs < lruTime) {
         lruTime = slot.lastUsedMs;
         lruManager = slot.manager;
         lruKey = slot.modelKey;
@@ -8549,7 +8812,7 @@ var ModelRouter = class {
       lruManager = this.manager;
       lruKey = null;
       for (const slot of this.extraSlots.values()) {
-        if (isAlive2(slot.manager.status().state) && slot.lastUsedMs < lruTime) {
+        if (this.isOccupied(slot.manager.status().state) && slot.lastUsedMs < lruTime) {
           lruTime = slot.lastUsedMs;
           lruManager = slot.manager;
           lruKey = slot.modelKey;
@@ -9987,12 +10250,12 @@ var GenerationGate = class {
           clearTimeout(timer);
           resolvePromise(release);
         },
-        giveUp: (err6) => {
+        giveUp: (err7) => {
           if (settled) return;
           settled = true;
           signal?.removeEventListener("abort", onAbort);
           clearTimeout(timer);
-          rejectPromise(err6);
+          rejectPromise(err7);
         }
       };
       const removeFromQueue = () => {
@@ -10096,11 +10359,21 @@ import { readFile, writeFile, mkdir } from "fs/promises";
 import { join as join20, dirname as dirname8 } from "path";
 var AUTH_TOKEN = "turbollm-local";
 var SUPPORTED = {
-  claude: { bin: "claude", label: "Claude Code", install: "npm install -g @anthropic-ai/claude-code" },
+  claude: {
+    bin: "claude",
+    label: "Claude Code",
+    install: "npm install -g @anthropic-ai/claude-code",
+    // Measured against the real CLI: both mismatches exit 1 during startup, before any TUI
+    // paints or any model call is made.
+    //   --session-id <existing> -> "Error: Session ID <uuid> is already in use."
+    //   --resume     <unknown>  -> "No conversation found with session ID: <uuid>"
+    sessionFlags: { register: "--session-id", resume: "--resume" }
+  },
   opencode: { bin: "opencode", label: "opencode", install: "npm install -g opencode-ai", prepareConfig: prepareOpencode },
   kilo: { bin: "kilo", label: "Kilo Code", install: "npm install -g @kilocode/cli", prepareConfig: prepareKilo },
   openclaw: { bin: "openclaw", label: "openclaw", install: "npm install -g openclaw@latest", prepareConfig: prepareOpenclaw },
-  hermes: { bin: "hermes", label: "Hermes Agent", install: "npm install -g hermes-agent", prepareConfig: prepareHermes }
+  hermes: { bin: "hermes", label: "Hermes Agent", install: "npm install -g hermes-agent", prepareConfig: prepareHermes },
+  pi: { bin: "pi", label: "pi", install: "npm install -g @earendil-works/pi-coding-agent", prepareConfig: preparePi }
 };
 async function fetchStatus(base2, _fetch = fetch) {
   try {
@@ -10289,6 +10562,39 @@ async function prepareOpenclaw(base2, apiKey, modelKey, modelName, fs2 = realFs)
   await fs2.writeFile(path, JSON.stringify(cfg2, null, 2) + "\n");
   return { ok: true };
 }
+async function preparePi(base2, apiKey, modelKey, modelName, fs2 = realFs) {
+  const modelsPath = join20(fs2.home, ".pi", "agent", "models.json");
+  const modelsRead = await readConfigObject(fs2, modelsPath);
+  if ("corrupt" in modelsRead) return corruptConfigError(modelsPath, "pi");
+  const modelsCfg = modelsRead.obj;
+  const providers = asObject(modelsCfg.providers);
+  if (!providers) return corruptConfigError(modelsPath, "pi");
+  if (modelsRead.lenient) {
+    if (!providerAlreadyPointsHere(providers.turbollm, base2)) return commentedConfigError(modelsPath, "pi");
+  } else {
+    providers.turbollm = {
+      baseUrl: `${base2}/v1`,
+      api: "openai-completions",
+      apiKey,
+      models: [{ id: modelKey, name: modelName }]
+    };
+    modelsCfg.providers = providers;
+    await fs2.mkdir(dirname8(modelsPath));
+    await fs2.writeFile(modelsPath, JSON.stringify(modelsCfg, null, 2) + "\n");
+  }
+  const settingsPath = join20(fs2.home, ".pi", "agent", "settings.json");
+  const settingsRead = await readConfigObject(fs2, settingsPath);
+  if ("corrupt" in settingsRead) return corruptConfigError(settingsPath, "pi");
+  const settingsCfg = settingsRead.obj;
+  if (settingsRead.lenient) {
+    return settingsCfg.defaultProvider === "turbollm" && settingsCfg.defaultModel === modelKey ? { ok: true } : commentedConfigError(settingsPath, "pi");
+  }
+  settingsCfg.defaultProvider = "turbollm";
+  settingsCfg.defaultModel = modelKey;
+  await fs2.mkdir(dirname8(settingsPath));
+  await fs2.writeFile(settingsPath, JSON.stringify(settingsCfg, null, 2) + "\n");
+  return { ok: true };
+}
 var realRunCommand = (bin, args) => new Promise((resolve5) => {
   const child = spawn4(bin, args, { stdio: "ignore" });
   child.on("error", () => resolve5(false));
@@ -10333,7 +10639,7 @@ async function loadAndWait(base2, modelKey, timeoutMs = 18e4, _fetch = fetch) {
   }
   return false;
 }
-async function launchCli(target, port2, passthrough, _spawn = spawn4, modelKey, _fetch = fetch) {
+async function launchCli(target, port2, passthrough, _spawn = spawn4, modelKey, _fetch = fetch, authToken) {
   const spec = SUPPORTED[target];
   if (!target || !spec) {
     const list = Object.keys(SUPPORTED).join(", ");
@@ -10429,18 +10735,19 @@ Open ${base2} \u2192 Models \u2192 Load a model, then run this again.
       process.stderr.write(prep.message + "\n");
       return 1;
     }
-    const child2 = _spawn(spec.bin, passthrough, {
+    return await spawnWithSessionRecovery(spec, passthrough, {
       stdio: "inherit",
       shell: process.platform === "win32",
       env: process.env
-    });
-    return await waitForChild(child2, spec);
+    }, _spawn);
   }
   const env = {
     ...process.env,
     ANTHROPIC_BASE_URL: base2,
-    // No auth is enforced on the local gateway; the CLI just needs a non-empty token.
-    ANTHROPIC_AUTH_TOKEN: AUTH_TOKEN,
+    // No auth is enforced on the local gateway; the CLI just needs a non-empty token. A
+    // session-scoped token (embedded terminal launches) takes priority over the shared static
+    // one so the gateway can attribute this session's requests correctly (session-auth.ts).
+    ANTHROPIC_AUTH_TOKEN: authToken ?? AUTH_TOKEN,
     // Local LLMs are 30–120 s per response — raise Claude Code's request timeout so it
     // doesn't abort mid-generation. 300 s (5 min) covers even the slowest local model.
     // Zero retries: retrying a slow local model cold-starts it again and makes things worse.
@@ -10457,15 +10764,40 @@ Open ${base2} \u2192 Models \u2192 Load a model, then run this again.
     // populates the /model picker with the local library (gateway synthesises the entries).
     CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1"
   };
-  const child = _spawn(spec.bin, passthrough, {
+  return await spawnWithSessionRecovery(spec, passthrough, {
     stdio: "inherit",
     // On Windows the CLI is usually a `.cmd`/`.ps1` shim; a shell resolves it via PATHEXT.
     shell: process.platform === "win32",
     env
-  });
-  return await waitForChild(child, spec);
+  }, _spawn);
+}
+function swapSessionFlag(args, flags) {
+  const i = args.findIndex((a) => a === flags.resume || a === flags.register);
+  if (i === -1) return null;
+  const out = [...args];
+  out[i] = out[i] === flags.resume ? flags.register : flags.resume;
+  return out;
+}
+var SESSION_MISMATCH_WINDOW_MS = 3e4;
+async function spawnWithSessionRecovery(spec, args, opts, _spawn) {
+  const flags = spec.sessionFlags;
+  const retryArgs = flags ? swapSessionFlag(args, flags) : null;
+  if (!flags || !retryArgs) return await waitForChild(_spawn(spec.bin, args, opts), spec);
+  const startedAt2 = Date.now();
+  const first = await waitForChildExit(_spawn(spec.bin, args, opts), spec);
+  const diedDuringStartup = Date.now() - startedAt2 < SESSION_MISMATCH_WINDOW_MS;
+  if (first.code === 0 || first.signal || !diedDuringStartup) return first.code;
+  process.stdout.write(
+    retryArgs.includes(flags.register) ? `\u25B8 That ${spec.label} session is gone \u2014 starting a fresh one.
+` : `\u25B8 That ${spec.label} session already exists \u2014 resuming it.
+`
+  );
+  return await waitForChild(_spawn(spec.bin, retryArgs, opts), spec);
+}
+async function waitForChild(child, spec) {
+  return (await waitForChildExit(child, spec)).code;
 }
-function waitForChild(child, spec) {
+function waitForChildExit(child, spec) {
   return new Promise((resolve5) => {
     child.on("error", (e) => {
       if (e.code === "ENOENT") {
@@ -10479,9 +10811,9 @@ Install it:  ${spec.install}
         process.stderr.write(`Failed to launch ${spec.label}: ${e.message}
 `);
       }
-      resolve5(127);
+      resolve5({ code: 127, signal: null });
     });
-    child.on("exit", (code, signal) => resolve5(code ?? (signal ? 1 : 0)));
+    child.on("exit", (code, signal) => resolve5({ code: code ?? (signal ? 1 : 0), signal: signal ?? null }));
   });
 }
 
@@ -10538,8 +10870,8 @@ var defaultHooks = {
     try {
       const res = await fetch(`http://127.0.0.1:${port2}/api/v1/status`, { signal: AbortSignal.timeout(2e3) });
       if (!res.ok) return false;
-      const body6 = await res.json();
-      return typeof body6 === "object" && body6 !== null && "version" in body6 && "engine" in body6;
+      const body7 = await res.json();
+      return typeof body7 === "object" && body7 !== null && "version" in body7 && "engine" in body7;
     } catch {
       return false;
     }
@@ -10742,16 +11074,16 @@ function runMcpServer(baseUrl, version2) {
 // src/server.ts
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import { existsSync as existsSync24, readFileSync as readFileSync13, statSync as statSync6 } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync14, statSync as statSync6 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname11, join as join29, normalize as normalize2 } from "path";
+import { dirname as dirname11, join as join30, normalize as normalize2 } from "path";
 import { Agent, setGlobalDispatcher } from "undici";
 
 // src/api/routes.ts
 import { streamSSE as streamSSE2 } from "hono/streaming";
-import { existsSync as existsSync22, mkdirSync as mkdirSync13, readFileSync as readFileSync10, readdirSync as readdirSync8, realpathSync, rmSync as rmSync12, statSync as statSync5, writeFileSync as writeFileSync11 } from "fs";
-import { execFileSync as execFileSync5 } from "child_process";
-import { basename as basename3, dirname as dirname9, join as join25, resolve } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync11, readdirSync as readdirSync9, realpathSync, rmSync as rmSync13, statSync as statSync5, writeFileSync as writeFileSync12 } from "fs";
+import { execFileSync as execFileSync6 } from "child_process";
+import { basename as basename3, dirname as dirname9, join as join26, resolve } from "path";
 
 // src/comfyui/gate-template.ts
 var GATE_VERSION = 2;
@@ -12688,6 +13020,12 @@ function isLocalRequest(c, d) {
   if (!d.store.snapshot().daemon.lanBind) return true;
   return isLoopback(c) === true;
 }
+function isLocalUpgrade(remoteAddress, headers, d) {
+  const tunneled = !!d.tunnel?.active() && !!(headers["cf-ray"] || headers["cf-connecting-ip"]);
+  if (tunneled) return false;
+  if (!d.store.snapshot().daemon.lanBind) return true;
+  return !!remoteAddress && LOOPBACK.has(remoteAddress);
+}
 function bypassesAuth(opts) {
   const { lanBind, requireApiKey, tunneled, loopback, exempt } = opts;
   if (!lanBind && !tunneled) return true;
@@ -12703,8 +13041,7 @@ function isLocalOrAuthenticated(c, d) {
   if (isLoopback(c) === true && !tunneled) return true;
   return daemon.requireApiKey === true;
 }
-function verifyPresentedKey(c, d) {
-  const key = presentedKey(c);
+function verifyKeyValue(key, d) {
   if (!key) return false;
   const hash = hashKey(key);
   const cfg2 = d.store.snapshot();
@@ -12719,6 +13056,9 @@ function verifyPresentedKey(c, d) {
   }
   return true;
 }
+function verifyPresentedKey(c, d) {
+  return verifyKeyValue(presentedKey(c), d);
+}
 function lanAuth(d) {
   return async (c, next) => {
     const daemon = d.store.snapshot().daemon;
@@ -12758,6 +13098,730 @@ function enabledFeatures() {
   return KNOWN_FEATURES.filter((f) => requested.has(f));
 }
 
+// src/terminal/terminal-routes.ts
+import { createRequire as createRequire2 } from "module";
+
+// src/code/session-auth.ts
+import { randomBytes as randomBytes2 } from "crypto";
+var SessionAuthRegistry = class {
+  sessionToToken = /* @__PURE__ */ new Map();
+  tokenToSession = /* @__PURE__ */ new Map();
+  sessionThinkingBudget = /* @__PURE__ */ new Map();
+  /** Mint a token for a Code session — idempotent: returns the SAME token on every call for a
+   *  given session (a reconnect/remount must never invalidate the CLI's already-running auth). */
+  mint(codeSessionId) {
+    const existing = this.sessionToToken.get(codeSessionId);
+    if (existing) return existing;
+    const token = `tllm-cs-${randomBytes2(24).toString("hex")}`;
+    this.sessionToToken.set(codeSessionId, token);
+    this.tokenToSession.set(token, codeSessionId);
+    return token;
+  }
+  /** The Code session a presented token belongs to, or null for an unrecognized/expired token. */
+  resolve(token) {
+    return this.tokenToSession.get(token) ?? null;
+  }
+  /** Drop a session's token (terminal killed/exited) — safe to call even if none was ever
+   *  minted. Deliberately does NOT clear the session's stored thinking budget: a model-relaunch
+   *  (revoke + mint again under the same codeSessionId) should keep whatever the user had the
+   *  slider set to, not silently reset it. */
+  revoke(codeSessionId) {
+    const token = this.sessionToToken.get(codeSessionId);
+    if (token) this.tokenToSession.delete(token);
+    this.sessionToToken.delete(codeSessionId);
+  }
+  /** Set (or clear, with `null`) the live thinking-budget override for a session — takes effect
+   *  on the session's NEXT gateway request, no CLI restart involved (gateway.ts injects it into
+   *  the outbound request server-side). Keyed by codeSessionId, not by token, so it can be set
+   *  before a terminal/token even exists yet (composer mounts before the terminal connects). */
+  setThinkingBudget(codeSessionId, tokens) {
+    if (tokens === null) this.sessionThinkingBudget.delete(codeSessionId);
+    else this.sessionThinkingBudget.set(codeSessionId, tokens);
+  }
+  /** The thinking-budget override for whichever session `token` belongs to, or null when the
+   *  token is unrecognized or no override has been set. */
+  getThinkingBudgetForToken(token) {
+    const sessionId = this.tokenToSession.get(token);
+    if (!sessionId) return null;
+    return this.sessionThinkingBudget.get(sessionId) ?? null;
+  }
+};
+var sessionAuth = new SessionAuthRegistry();
+
+// src/terminal/agent-modes.ts
+var CLAUDE_MODE_PREFERENCE = {
+  auto: ["auto", "acceptEdits"],
+  plan: ["plan"],
+  ask: ["manual", "default"]
+};
+var CODE_MODES = /* @__PURE__ */ new Set(["auto", "plan", "ask"]);
+function parsePermissionModeChoices(helpText) {
+  const m = helpText.match(/--permission-mode[\s\S]{0,400}?\(choices:([^)]*)\)/);
+  if (!m) return [];
+  return m[1].split(",").map((s) => s.trim().replace(/^["']|["']$/g, "").trim()).filter((s) => /^[A-Za-z]+$/.test(s));
+}
+function resolveClaudePermissionMode(mode, choices) {
+  if (!CODE_MODES.has(mode)) return null;
+  const prefs = CLAUDE_MODE_PREFERENCE[mode];
+  if (choices.length === 0) return prefs[prefs.length - 1];
+  return prefs.find((p) => choices.includes(p)) ?? null;
+}
+var realHelpRunner = async () => {
+  const { spawn: spawn9 } = await import("child_process");
+  return await new Promise((resolve5) => {
+    let out = "";
+    let settled = false;
+    const done = (v) => {
+      if (!settled) {
+        settled = true;
+        resolve5(v);
+      }
+    };
+    try {
+      const child = spawn9("claude", ["--help"], {
+        shell: process.platform === "win32",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      const timer = setTimeout(() => {
+        try {
+          child.kill();
+        } catch {
+        }
+        ;
+        done("");
+      }, 5e3);
+      child.stdout?.on("data", (b) => {
+        out += b.toString("utf8");
+      });
+      child.on("error", () => {
+        clearTimeout(timer);
+        done("");
+      });
+      child.on("close", () => {
+        clearTimeout(timer);
+        done(out);
+      });
+    } catch {
+      done("");
+    }
+  });
+};
+var cachedChoices = null;
+async function claudePermissionModeChoices(run = realHelpRunner) {
+  if (!cachedChoices) cachedChoices = run().then(parsePermissionModeChoices).catch(() => []);
+  return await cachedChoices;
+}
+
+// src/terminal/terminal-manager.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync10, readdirSync as readdirSync7, rmSync as rmSync11, writeFileSync as writeFileSync11 } from "fs";
+import { join as join23 } from "path";
+
+// src/terminal/pty-session.ts
+import { EventEmitter } from "events";
+import { createRequire } from "module";
+import { execFileSync as execFileSync4 } from "child_process";
+var require2 = createRequire(import.meta.url);
+var cachedWindowsShell = null;
+function resolveWindowsShell() {
+  if (cachedWindowsShell) return cachedWindowsShell;
+  try {
+    execFileSync4("where", ["pwsh.exe"], { stdio: "ignore" });
+    cachedWindowsShell = "pwsh.exe";
+  } catch {
+    cachedWindowsShell = "powershell.exe";
+  }
+  return cachedWindowsShell;
+}
+var SCROLLBACK_CAP = 512 * 1024;
+var PTYSession = class _PTYSession {
+  pty = null;
+  emitter = new EventEmitter();
+  exited = false;
+  exitCode = null;
+  processId = null;
+  // Every byte the PTY has ever written, capped — replayed to a NEWLY connecting WebSocket
+  // client (terminal-manager.ts's registerWsListener) so a reconnect (tab reload, WS drop,
+  // navigating away and back) shows the terminal's actual current state instead of a blank
+  // screen until the next byte happens to arrive. xterm.js replaying the same escape
+  // sequences that produced the original screen reconstructs it correctly, the same way
+  // `tmux attach`/`screen -r` catch a reconnecting client up.
+  scrollback = "";
+  /** Spawn a new PTY session. When `launchCommand` is given, the shell runs it as its
+   *  own startup command (never typed into stdin — see the module header comment). */
+  static spawn(cwd, rows = 24, cols = 80, launchCommand) {
+    const s = new _PTYSession();
+    s.doSpawn(cwd, rows, cols, launchCommand);
+    return s;
+  }
+  doSpawn(cwd, rows, cols, launchCommand) {
+    const ptyModule = require2("node-pty");
+    const win32 = process.platform === "win32";
+    const shell = win32 ? resolveWindowsShell() : "bash";
+    const args = launchCommand ? win32 ? ["-NoExit", "-Command", launchCommand] : ["-lc", `${launchCommand}; exec bash`] : [];
+    this.pty = ptyModule.spawn(shell, args, {
+      name: "xterm-256color",
+      cols,
+      rows,
+      cwd,
+      env: {
+        ...process.env,
+        TERM: "xterm-256color",
+        COLORTERM: "truecolor"
+      }
+    });
+    const termPty = this.pty;
+    this.processId = termPty.pid;
+    termPty.onData((data) => {
+      this.scrollback += data;
+      if (this.scrollback.length > SCROLLBACK_CAP) {
+        this.scrollback = this.scrollback.slice(this.scrollback.length - SCROLLBACK_CAP);
+      }
+      this.emitter.emit("data", data);
+    });
+    termPty.onExit(({ exitCode, signal }) => {
+      this.exited = true;
+      this.exitCode = exitCode ?? signal ?? 1;
+      this.emitter.emit("exit", { exitCode: this.exitCode, signal });
+    });
+  }
+  // ── public API ──────────────────────────────────────────────────────
+  /** Write raw bytes to the PTY's stdin. */
+  write(data) {
+    if (this.exited || !this.pty) return;
+    this.pty.write(data);
+  }
+  /** Resize the PTY (cols, rows). */
+  resize(cols, rows) {
+    if (!this.pty) return;
+    try {
+      this.pty.resize(cols, rows);
+    } catch {
+    }
+  }
+  /** Kill the PTY and all child processes. */
+  kill() {
+    if (!this.pty || this.exited) return;
+    try {
+      this.pty.kill();
+    } catch {
+    }
+    this.exited = true;
+  }
+  isExited() {
+    return this.exited;
+  }
+  getExitCode() {
+    return this.exitCode;
+  }
+  getPid() {
+    return this.processId;
+  }
+  /** Everything written so far (capped, oldest trimmed) — replay this to a newly-attached
+   *  client before it starts receiving live `onData` output. */
+  getScrollback() {
+    return this.scrollback;
+  }
+  onData(cb) {
+    this.emitter.on("data", cb);
+  }
+  onExit(cb) {
+    this.emitter.on("exit", cb);
+  }
+  /** Remove all listeners and kill the PTY. */
+  dispose() {
+    this.kill();
+    this.emitter.removeAllListeners();
+  }
+};
+
+// src/terminal/terminal-manager.ts
+function terminalPidDir(dataDir) {
+  return join23(dataDir, "run");
+}
+function terminalPidFile(dataDir, pid) {
+  return join23(terminalPidDir(dataDir), `terminal-${pid}.pid`);
+}
+function writeTerminalPid(dataDir, pid) {
+  try {
+    mkdirSync12(terminalPidDir(dataDir), { recursive: true });
+    writeFileSync11(terminalPidFile(dataDir, pid), JSON.stringify({ pid, owner: process.pid }));
+  } catch {
+  }
+}
+function clearTerminalPid(dataDir, pid) {
+  try {
+    rmSync11(terminalPidFile(dataDir, pid), { force: true });
+  } catch {
+  }
+}
+function pidAlive2(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function readTerminalPidFiles(dataDir) {
+  const dir = terminalPidDir(dataDir);
+  let names;
+  try {
+    names = readdirSync7(dir).filter((n) => /^terminal-\d+\.pid$/.test(n));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    const file = join23(dir, name);
+    try {
+      const { pid, owner } = JSON.parse(readFileSync10(file, "utf8"));
+      if (typeof pid === "number" && pid > 0) out.push({ pid, owner: typeof owner === "number" ? owner : 0, file });
+      else rmSync11(file, { force: true });
+    } catch {
+      try {
+        rmSync11(file, { force: true });
+      } catch {
+      }
+    }
+  }
+  return out;
+}
+function reapStaleTerminals(dataDir) {
+  let killed = 0;
+  for (const { pid, owner, file } of readTerminalPidFiles(dataDir)) {
+    if (owner && pidAlive2(owner)) continue;
+    try {
+      if (process.platform === "win32") spawnSync2("taskkill", ["/PID", String(pid), "/F", "/T"]);
+      else process.kill(pid, "SIGKILL");
+      killed++;
+    } catch {
+    }
+    try {
+      rmSync11(file, { force: true });
+    } catch {
+    }
+  }
+  return killed;
+}
+function killTrackedTerminalsSync(dataDir) {
+  for (const { pid, owner, file } of readTerminalPidFiles(dataDir)) {
+    if (owner !== process.pid) continue;
+    try {
+      if (process.platform === "win32") spawnSync2("taskkill", ["/PID", String(pid), "/F", "/T"]);
+      else process.kill(pid, "SIGKILL");
+    } catch {
+    }
+    try {
+      rmSync11(file, { force: true });
+    } catch {
+    }
+  }
+}
+var IDLE_SWEEP_MS = 6e4;
+var TerminalManager = class {
+  /** `dataDir` — the daemon's own data directory (ConfigStore.dir()), for the orphan-safety
+   *  pidfile tracking above. Terminal-manager unit tests never spawn a real PTY (see
+   *  terminal-manager.test.ts's header), so an empty string is a safe default there. */
+  constructor(dataDir = "") {
+    this.dataDir = dataDir;
+    setInterval(() => this.cleanupIdle(), IDLE_SWEEP_MS).unref();
+  }
+  dataDir;
+  sessions = /* @__PURE__ */ new Map();
+  infoMap = /* @__PURE__ */ new Map();
+  /** When each terminal last had ZERO attached WebSocket listeners — the idle clock. Absent
+   *  entirely while at least one listener is attached (registerWsListener deletes the entry),
+   *  so an actively-viewed terminal is NEVER a cleanupIdle candidate no matter how old it is.
+   *  Seeded at create() too, so a terminal that's created but never actually connected to
+   *  (a client-side failure right after the create() response) still starts its idle clock
+   *  rather than living forever untracked. */
+  idleSince = /* @__PURE__ */ new Map();
+  /**
+   * Create a new terminal session.
+   * @param repoRoot Working directory for the PTY
+   * @param codeSessionId Optional Code session to associate with
+   * @param cols Terminal columns (default 80)
+   * @param rows Terminal rows (default 24)
+   * @param launchCommand Optional command the shell runs at startup (see pty-session.ts) —
+   *   e.g. `turbollm launch claude`, built server-side (terminal-routes.ts), never sent by
+   *   the client. Absent for a plain interactive shell.
+   * @returns The session ID
+   */
+  create(repoRoot, codeSessionId = null, cols = 80, rows = 24, launchCommand) {
+    const id = crypto.randomUUID();
+    const session = PTYSession.spawn(repoRoot, rows, cols, launchCommand);
+    const shellPid = session.getPid();
+    if (shellPid) writeTerminalPid(this.dataDir, shellPid);
+    session.onData((data) => {
+      const ev = this.infoMap.get(id);
+      if (ev) this.broadcast(id, (h) => h.onData?.(data));
+    });
+    session.onExit(() => {
+      this.broadcast(id, (h) => h.onClose?.());
+      this.sessions.delete(id);
+      this.infoMap.delete(id);
+      this.idleSince.delete(id);
+      if (shellPid) clearTerminalPid(this.dataDir, shellPid);
+      if (codeSessionId) sessionAuth.revoke(codeSessionId);
+    });
+    this.sessions.set(id, session);
+    this.infoMap.set(id, {
+      id,
+      codeSessionId,
+      cwd: repoRoot,
+      cols,
+      rows,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.idleSince.set(id, Date.now());
+    return id;
+  }
+  /**
+   * Resize a terminal session.
+   */
+  resize(id, cols, rows) {
+    const session = this.sessions.get(id);
+    if (session) session.resize(cols, rows);
+    const info = this.infoMap.get(id);
+    if (info) {
+      info.cols = cols;
+      info.rows = rows;
+    }
+  }
+  /**
+   * Write data to a terminal's PTY stdin.
+   */
+  write(id, data) {
+    const session = this.sessions.get(id);
+    if (session) session.write(data);
+  }
+  /**
+   * Kill a terminal session.
+   */
+  kill(id) {
+    const session = this.sessions.get(id);
+    if (session) {
+      const shellPid = session.getPid();
+      session.dispose();
+      this.sessions.delete(id);
+      this.infoMap.delete(id);
+      this.idleSince.delete(id);
+      if (shellPid) clearTerminalPid(this.dataDir, shellPid);
+    }
+  }
+  /**
+   * Check if a session exists and is alive.
+   */
+  isActive(id) {
+    const session = this.sessions.get(id);
+    const info = this.infoMap.get(id);
+    return !!session && !!info && !session.isExited();
+  }
+  /**
+   * Get info about a session.
+   */
+  getInfo(id) {
+    return this.infoMap.get(id);
+  }
+  /**
+   * List all session IDs.
+   */
+  listIds() {
+    return Array.from(this.infoMap.keys());
+  }
+  /**
+   * Look up a terminal ID by the Code session ID it was scoped to.
+   * Returns null if no active terminal is associated with that Code session.
+   */
+  findByCodeSessionId(codeSessionId) {
+    for (const [id, info] of this.infoMap) {
+      if (info.codeSessionId === codeSessionId && this.sessions.get(id) && !this.sessions.get(id).isExited()) {
+        return id;
+      }
+    }
+    return null;
+  }
+  /** Record that the agent CLI in this Code session's terminal has exited (see
+   *  TerminalSessionInfo.agentExited). No-op when the session has no live terminal. */
+  markAgentExited(codeSessionId) {
+    const id = this.findByCodeSessionId(codeSessionId);
+    if (!id) return;
+    const info = this.infoMap.get(id);
+    if (info) info.agentExited = true;
+  }
+  /** Whether this terminal's agent CLI has exited, leaving only a bare shell behind. */
+  isAgentExited(terminalId) {
+    return this.infoMap.get(terminalId)?.agentExited === true;
+  }
+  /**
+   * Kill any terminal that's had ZERO attached WebSocket listeners for longer than `maxAgeMs`
+   * (default 5 min) — e.g. every browser tab viewing it was closed/navigated away and nobody
+   * came back. Deliberately NOT based on the terminal's age since creation: switching between
+   * Chat and Code sessions (or between two Code sessions) must never kill a still-open CLI —
+   * only genuine, sustained abandonment does. A terminal with at least one listener currently
+   * attached is never a candidate, no matter how long it's been running.
+   */
+  cleanupIdle(maxAgeMs = 3e5) {
+    const now = Date.now();
+    for (const [id, since] of this.idleSince) {
+      if ((this.listeners.get(id)?.size ?? 0) > 0) continue;
+      if (now - since > maxAgeMs) this.kill(id);
+    }
+  }
+  // ── WebSocket handler registration ─────────────────────────────────
+  // A Code session's terminal can be attached from more than one browser tab at once (the
+  // PTY itself already supports this — see the scrollback replay below, tmux-attach style) —
+  // so each terminal id maps to a SET of handlers, not a single one. A single-handler map
+  // would let a second tab's connect silently steal the first tab's slot, and either tab
+  // closing would silence (or fully unregister) the other.
+  listeners = /* @__PURE__ */ new Map();
+  /** Call `fn` for every handler currently attached to `id`. No-op if none are attached. */
+  broadcast(id, fn) {
+    const handlers = this.listeners.get(id);
+    if (!handlers) return;
+    for (const h of handlers) fn(h);
+  }
+  /**
+   * Register a WebSocket handler for a session. Called when the WebSocket
+   * connects, and removed (via `unregisterWsListener`, passing the SAME handler
+   * reference) when it closes.
+   *
+   * Replays the PTY's buffered scrollback to the handler BEFORE registering it for live
+   * `onData` — otherwise a reconnecting client (tab reload, a dropped WS, navigating away
+   * and back to the session) shows a blank terminal until the next byte happens to arrive,
+   * even though the CLI underneath is still running and has already printed real output.
+   */
+  registerWsListener(id, handler) {
+    const session = this.sessions.get(id);
+    if (session) {
+      const scrollback = session.getScrollback();
+      if (scrollback) handler.onData(scrollback);
+    }
+    let handlers = this.listeners.get(id);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.listeners.set(id, handlers);
+    }
+    handlers.add(handler);
+    this.idleSince.delete(id);
+  }
+  /**
+   * Unregister one WebSocket handler. Called when that WebSocket closes — must pass the
+   * exact handler object given to `registerWsListener`, so a still-open second tab's
+   * handler on the same terminal id is untouched.
+   */
+  unregisterWsListener(id, handler) {
+    const handlers = this.listeners.get(id);
+    if (!handlers) return;
+    handlers.delete(handler);
+    if (handlers.size === 0) {
+      this.listeners.delete(id);
+      if (this.infoMap.has(id)) this.idleSince.set(id, Date.now());
+    }
+  }
+};
+
+// src/terminal/terminal-routes.ts
+async function body2(c) {
+  try {
+    return await c.req.json();
+  } catch {
+    return {};
+  }
+}
+var require3 = createRequire2(import.meta.url);
+var AGENT_SESSION_ID_FLAGS = {
+  claude: { first: "--session-id", resume: "--resume" }
+};
+function buildTerminalLaunchCommand(agent, port2, token, sessionId, launchedOnce, permissionMode) {
+  const flags = AGENT_SESSION_ID_FLAGS[agent];
+  const sessionArg = flags ? ` ${launchedOnce ? flags.resume : flags.first} ${sessionId}` : "";
+  const modeArg = permissionMode ? ` --permission-mode ${permissionMode}` : "";
+  return `turbollm launch ${agent} --port ${port2} --token ${token}${sessionArg}${modeArg}`;
+}
+function err2(c, s, code, msg2) {
+  return c.json({ error: { code, message: msg2 } }, s);
+}
+var terminalManager = null;
+var backendAvailable = null;
+function isTerminalBackendAvailable() {
+  if (backendAvailable === null) {
+    try {
+      require3.resolve("node-pty");
+      backendAvailable = true;
+    } catch {
+      backendAvailable = false;
+    }
+  }
+  return backendAvailable;
+}
+function getManager(_d) {
+  if (!terminalManager) {
+    if (isTerminalBackendAvailable()) {
+      terminalManager = new TerminalManager(_d.store.dir());
+    }
+  }
+  return terminalManager ?? {
+    create: () => {
+      throw new Error("node-pty not available \u2014 install with: npm install node-pty --save");
+    },
+    isActive: () => false,
+    getInfo: () => void 0,
+    listIds: () => [],
+    kill: () => {
+    },
+    registerWsListener: () => {
+    },
+    unregisterWsListener: () => {
+    },
+    cleanupIdle: () => {
+    },
+    findByCodeSessionId: () => null
+  };
+}
+function registerTerminalRoutes(app2, d) {
+  app2.post("/api/v1/code/sessions/:sessionId/terminal", async (c) => {
+    const run = d.db.getAgentRun(c.req.param("sessionId"));
+    if (!run) return err2(c, 404, "not_found", "Session not found.");
+    if (!run.repoRoot) return err2(c, 400, "invalid_input", "Session has no repo root.");
+    const agent = run.codeAgent ?? "turbollm";
+    if (agent === "turbollm") {
+      return err2(c, 400, "invalid_input", "This session uses the built-in chat UI, not a terminal agent.");
+    }
+    const b = await body2(c);
+    const cols = typeof b.cols === "number" && b.cols > 0 ? Math.floor(b.cols) : 80;
+    const rows = typeof b.rows === "number" && b.rows > 0 ? Math.floor(b.rows) : 24;
+    const m = getManager(d);
+    const existing = m.findByCodeSessionId(run.id);
+    if (existing && !m.isAgentExited(existing)) {
+      m.resize(existing, cols, rows);
+      return c.json({ terminalId: existing }, 200);
+    }
+    if (existing) {
+      m.kill(existing);
+    }
+    try {
+      const port2 = d.store.snapshot().daemon.port;
+      const token = sessionAuth.mint(run.id);
+      const mode = d.db.getConversation(run.convId)?.agentMode ?? "auto";
+      const permissionMode = resolveClaudePermissionMode(mode, await claudePermissionModeChoices());
+      const launchCommand = buildTerminalLaunchCommand(
+        agent,
+        port2,
+        token,
+        run.id,
+        !!run.terminalLaunchedOnce,
+        agent === "claude" ? permissionMode : null
+      );
+      const terminalId = m.create(run.repoRoot, run.id, cols, rows, launchCommand);
+      if (!run.terminalLaunchedOnce) d.db.updateAgentRun(run.id, { terminalLaunchedOnce: true });
+      return c.json({ terminalId }, 201);
+    } catch (e) {
+      const msg2 = e instanceof Error ? e.message : "Failed to create terminal session.";
+      console.error("[terminal] create failed for session", run.id, ":", e);
+      if (msg2.includes("node-pty not available")) return err2(c, 501, "not_available", msg2);
+      return err2(c, 500, "create_failed", msg2);
+    }
+  });
+  app2.post("/api/v1/code/sessions/:sessionId/terminal/kill", (c) => {
+    const run = d.db.getAgentRun(c.req.param("sessionId"));
+    if (!run) return err2(c, 404, "not_found", "Session not found.");
+    const m = getManager(d);
+    const terminalId = m.findByCodeSessionId(run.id);
+    if (terminalId) m.kill(terminalId);
+    sessionAuth.revoke(run.id);
+    return c.json({ ok: true }, 200);
+  });
+  app2.post("/api/v1/code/sessions/:sessionId/terminal/agent-exited", (c) => {
+    const run = d.db.getAgentRun(c.req.param("sessionId"));
+    if (!run) return err2(c, 404, "not_found", "Session not found.");
+    getManager(d).markAgentExited(run.id);
+    return c.json({ ok: true }, 200);
+  });
+  app2.get("/api/v1/code/terminals", (c) => {
+    const m = getManager(d);
+    const ids = m.listIds();
+    const sessions = ids.map((id) => m.getInfo(id)).filter(Boolean);
+    return c.json({ terminals: sessions });
+  });
+}
+var WS_OPEN = 1;
+function registerTerminalWs(server2, _d) {
+  const wsLib = require3("ws");
+  const WebSocketServer = wsLib.Server;
+  const wss = new WebSocketServer({ noServer: true });
+  server2.on("upgrade", (request, socket, head) => {
+    const url = new URL(request.url ?? "", "http://localhost");
+    if (url.pathname !== "/api/v1/code/terminal/ws") {
+      socket.destroy();
+      return;
+    }
+    const terminalId = url.searchParams.get("terminalId") ?? "";
+    if (!terminalId) {
+      socket.destroy();
+      return;
+    }
+    const local = isLocalUpgrade(socket.remoteAddress, request.headers, _d);
+    if (!local && !verifyKeyValue(url.searchParams.get("key") ?? "", _d)) {
+      socket.write("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+    const m = getManager(_d);
+    if (!m.isActive(terminalId)) {
+      socket.destroy();
+      return;
+    }
+    wss.handleUpgrade(request, socket, head, (ws) => {
+      wss.emit("connection", ws, request);
+    });
+  });
+  wss.on("connection", (ws, _request) => {
+    const url = new URL(_request.url ?? "", "http://localhost");
+    const terminalId = url.searchParams.get("terminalId") ?? "";
+    const m = getManager(_d);
+    if (!m.isActive(terminalId)) {
+      ws.close(4004, "Terminal session not found or exited");
+      return;
+    }
+    const handler = {
+      onData(data) {
+        if (ws.readyState === WS_OPEN) {
+          ws.send(data);
+        }
+      },
+      onClose() {
+        if (ws.readyState === WS_OPEN) {
+          ws.close(1001, "Terminal exited");
+        }
+      }
+    };
+    m.registerWsListener(terminalId, handler);
+    ws.on("message", (data, isBinary) => {
+      if (isBinary && Buffer.isBuffer(data)) {
+        try {
+          const { cols, rows } = JSON.parse(data.toString("utf-8"));
+          if (typeof cols === "number" && typeof rows === "number" && cols > 0 && rows > 0) {
+            m.resize(terminalId, cols, rows);
+          }
+        } catch {
+        }
+        return;
+      }
+      const input = typeof data === "string" ? data : data.toString("utf-8");
+      m.write(terminalId, input);
+    });
+    ws.on("close", () => {
+      m.unregisterWsListener(terminalId, handler);
+    });
+    ws.on("error", () => {
+      m.unregisterWsListener(terminalId, handler);
+    });
+  });
+}
+
 // src/engines/catalog.ts
 var LLAMA_BACKEND_REQ = {
   cuda: { requires: { gpuVendor: ["nvidia"], backend: "cuda" }, speed: "fast" },
@@ -13177,9 +14241,9 @@ function catalogEngine(id) {
 
 // src/engines/cuda-provision.ts
 import { execFile as execFile11 } from "child_process";
-import { cpSync as cpSync2, existsSync as existsSync20, mkdirSync as mkdirSync12, readdirSync as readdirSync7, rmSync as rmSync11 } from "fs";
+import { cpSync as cpSync2, existsSync as existsSync20, mkdirSync as mkdirSync13, readdirSync as readdirSync8, rmSync as rmSync12 } from "fs";
 import { tmpdir } from "os";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 import { promisify as promisify8 } from "util";
 var execFileP8 = promisify8(execFile11);
 var REDIST_BASE = "https://developer.download.nvidia.com/compute/cuda/redist/";
@@ -13234,9 +14298,9 @@ async function provisionCuda(dataDir, onProgress, signal) {
     phase: "resolving",
     message: `Using CUDA ${version2}${driverMax ? ` (driver supports up to ${driverMax})` : ""}.`
   });
-  const root = join23(dataDir, "cuda", version2);
-  const binDir = join23(root, "bin");
-  if (existsSync20(join23(binDir, "nvcc.exe"))) {
+  const root = join24(dataDir, "cuda", version2);
+  const binDir = join24(root, "bin");
+  if (existsSync20(join24(binDir, "nvcc.exe"))) {
     onProgress({ phase: "assembling", message: `CUDA ${version2} already downloaded \u2014 reusing it.` });
     return { root, binDir, version: version2 };
   }
@@ -13251,38 +14315,38 @@ async function provisionCuda(dataDir, onProgress, signal) {
     const rel = relOf(id);
     if (rel) components.push({ id, url: REDIST_BASE + rel });
   }
-  const work = join23(tmpdir(), `tllm-cuda-${version2}`);
-  rmSync11(work, { recursive: true, force: true });
-  mkdirSync12(work, { recursive: true });
+  const work = join24(tmpdir(), `tllm-cuda-${version2}`);
+  rmSync12(work, { recursive: true, force: true });
+  mkdirSync13(work, { recursive: true });
   const stageRoot = `${root}.partial`;
-  rmSync11(stageRoot, { recursive: true, force: true });
-  mkdirSync12(stageRoot, { recursive: true });
+  rmSync12(stageRoot, { recursive: true, force: true });
+  mkdirSync13(stageRoot, { recursive: true });
   try {
     for (let i = 0; i < components.length; i++) {
       const { id, url } = components[i];
-      const zip = join23(work, `${id}.zip`);
+      const zip = join24(work, `${id}.zip`);
       onProgress({ phase: "downloading", message: `Downloading ${id} (${i + 1}/${components.length})\u2026`, pct: 0 });
       await downloadFile(url, zip, (p) => onProgress({ phase: "downloading", message: `Downloading ${id} (${i + 1}/${components.length})\u2026`, pct: p.pct }), signal);
-      const exDir = join23(work, id);
-      mkdirSync12(exDir, { recursive: true });
+      const exDir = join24(work, id);
+      mkdirSync13(exDir, { recursive: true });
       onProgress({ phase: "extracting", message: `Extracting ${id}\u2026` });
       await extractArchive(zip, exDir);
-      const inner = readdirSync7(exDir).map((n) => join23(exDir, n)).find((p) => existsSync20(join23(p, "include")) || existsSync20(join23(p, "bin")) || existsSync20(join23(p, "lib")));
-      const srcRoot = inner ?? join23(exDir, readdirSync7(exDir)[0] ?? "");
+      const inner = readdirSync8(exDir).map((n) => join24(exDir, n)).find((p) => existsSync20(join24(p, "include")) || existsSync20(join24(p, "bin")) || existsSync20(join24(p, "lib")));
+      const srcRoot = inner ?? join24(exDir, readdirSync8(exDir)[0] ?? "");
       cpSync2(srcRoot, stageRoot, { recursive: true, force: true });
-      rmSync11(zip, { force: true });
+      rmSync12(zip, { force: true });
     }
-    if (!existsSync20(join23(stageRoot, "bin", "nvcc.exe"))) {
+    if (!existsSync20(join24(stageRoot, "bin", "nvcc.exe"))) {
       throw new Error("Assembled CUDA toolkit is missing bin/nvcc.exe \u2014 the component set may have changed.");
     }
-    rmSync11(root, { recursive: true, force: true });
-    mkdirSync12(join23(dataDir, "cuda"), { recursive: true });
+    rmSync12(root, { recursive: true, force: true });
+    mkdirSync13(join24(dataDir, "cuda"), { recursive: true });
     cpSync2(stageRoot, root, { recursive: true, force: true });
     onProgress({ phase: "assembling", message: `CUDA ${version2} ready.` });
     return { root, binDir, version: version2 };
   } finally {
-    rmSync11(work, { recursive: true, force: true });
-    rmSync11(stageRoot, { recursive: true, force: true });
+    rmSync12(work, { recursive: true, force: true });
+    rmSync12(stageRoot, { recursive: true, force: true });
   }
 }
 
@@ -13291,7 +14355,8 @@ function detectHardware(info = getSysInfo()) {
   const arch2 = process.arch === "arm64" ? "arm64" : "x64";
   const gpuVendor = primaryVendor(info);
   const hasGpu = gpuVendor !== "unknown" && info.gpus.length > 0;
-  const ofVendor = info.gpus.filter((g) => g.vendor === gpuVendor);
+  const allOfVendor = info.gpus.filter((g) => g.vendor === gpuVendor);
+  const ofVendor = allOfVendor.some((g) => !g.unified) ? allOfVendor.filter((g) => !g.unified) : allOfVendor;
   const pool = ofVendor.length ? ofVendor : info.gpus;
   const headline = pool.reduce(
     (best, g) => !best || g.vramMb > best.vramMb ? g : best,
@@ -13357,8 +14422,8 @@ function recommendEngines(p, engines) {
 
 // src/artifacts/screenshot.ts
 import { existsSync as existsSync21 } from "fs";
-import { execFileSync as execFileSync4 } from "child_process";
-import { join as join24 } from "path";
+import { execFileSync as execFileSync5 } from "child_process";
+import { join as join25 } from "path";
 function chromeCandidates() {
   const env = process.env.PUPPETEER_EXECUTABLE_PATH || process.env.CHROME_PATH;
   const out = env ? [env] : [];
@@ -13367,10 +14432,10 @@ function chromeCandidates() {
     const pfx86 = process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)";
     const local = process.env["LOCALAPPDATA"] || "";
     for (const base2 of [pf, pfx86, local].filter(Boolean)) {
-      out.push(join24(base2, "Google", "Chrome", "Application", "chrome.exe"));
+      out.push(join25(base2, "Google", "Chrome", "Application", "chrome.exe"));
     }
     for (const base2 of [pfx86, pf].filter(Boolean)) {
-      out.push(join24(base2, "Microsoft", "Edge", "Application", "msedge.exe"));
+      out.push(join25(base2, "Microsoft", "Edge", "Application", "msedge.exe"));
     }
   } else if (process.platform === "darwin") {
     out.push(
@@ -13389,7 +14454,7 @@ function chromeCandidates() {
     );
     for (const name of ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge"]) {
       try {
-        const p = execFileSync4("which", [name], { encoding: "utf-8" }).trim();
+        const p = execFileSync5("which", [name], { encoding: "utf-8" }).trim();
         if (p) out.push(p);
       } catch {
       }
@@ -13452,10 +14517,10 @@ async function screenshotArtifact(html, opts) {
 }
 
 // src/api/routes.ts
-function err2(c, status, code, message) {
+function err3(c, status, code, message) {
   return c.json({ error: { code, message } }, status);
 }
-async function body2(c) {
+async function body3(c) {
   try {
     return await c.req.json();
   } catch {
@@ -13499,6 +14564,10 @@ function registerApi(app2, d) {
       agentTasks: d.agentTasks?.list() ?? [],
       // In-app compile-from-source status (ADR-100): live phase + log tail while a build runs.
       engineBuild: d.build.get(),
+      // Whether this install can spawn a PTY at all (node-pty is an optional native dependency,
+      // so a healthy install may legitimately not have it). The Code agent picker reads this to
+      // decide whether a terminal-only agent is even offerable on this machine.
+      terminalAvailable: isTerminalBackendAvailable(),
       // ComfyUI GPU coordination: lets the UI explain a paused/unloaded engine.
       // Also expose the installed gate node version so the UI can prompt an upgrade.
       comfyui: (() => {
@@ -13508,7 +14577,7 @@ function registerApi(app2, d) {
         let installedVersion = null;
         if (gatePath) {
           try {
-            const src = readFileSync10(join25(gatePath, "__init__.py"), "utf-8");
+            const src = readFileSync11(join26(gatePath, "__init__.py"), "utf-8");
             const m = src.match(/^GATE_VERSION\s*=\s*(\d+)/m);
             if (m) installedVersion = Number(m[1]);
           } catch {
@@ -13527,13 +14596,13 @@ function registerApi(app2, d) {
   });
   app2.get("/api/v1/artifacts/screenshot/available", (c) => c.json({ available: findChrome() !== null }));
   app2.post("/api/v1/artifacts/screenshot", async (c) => {
-    if (!isLocalRequest(c, d)) return err2(c, 403, "forbidden", "Screenshot is local-only.");
-    const { html, width } = await body2(c);
-    if (!html || typeof html !== "string") return err2(c, 400, "bad_request", "html is required");
+    if (!isLocalRequest(c, d)) return err3(c, 403, "forbidden", "Screenshot is local-only.");
+    const { html, width } = await body3(c);
+    if (!html || typeof html !== "string") return err3(c, 400, "bad_request", "html is required");
     const w = Math.max(360, Math.min(Math.round(width || 1e3), 1280));
     const h = Math.max(480, Math.round(w * 800 / 1280));
     const png = await screenshotArtifact(html, { width: w, height: h });
-    if (!png) return err2(c, 503, "no_browser", "No system Chrome/Chromium/Edge found.");
+    if (!png) return err3(c, 503, "no_browser", "No system Chrome/Chromium/Edge found.");
     return new Response(png, { status: 200, headers: { "Content-Type": "image/png", "Cache-Control": "no-store" } });
   });
   app2.get("/api/v1/engines", (c) => {
@@ -13548,7 +14617,7 @@ function registerApi(app2, d) {
     const sys = getSysInfo();
     const vendor = primaryVendor(sys);
     const recommended = recommendBackendId(vendor, sys.gpus.length > 0);
-    const root = join25(d.store.dir(), "engines");
+    const root = join26(d.store.dir(), "engines");
     const active = d.registry.active();
     const regEngines = d.registry.list().engines;
     const backendOf = (p) => p.match(/llama\.cpp-[^/\\]+-(cuda|rocm|sycl|vulkan|metal|cpu)/i)?.[1]?.toLowerCase();
@@ -13569,7 +14638,7 @@ function registerApi(app2, d) {
         engineId: eng?.id ?? ""
       };
     });
-    const mlxVenvPy = join25(root, "mlx", "venv", process.platform === "win32" ? "Scripts/python.exe" : "bin/python");
+    const mlxVenvPy = join26(root, "mlx", "venv", process.platform === "win32" ? "Scripts/python.exe" : "bin/python");
     const mlxInstalledOnDisk = existsSync22(mlxVenvPy);
     const mlxEngine = regEngines.find((e) => e.kind === "mlx");
     const mlx = {
@@ -13582,17 +14651,17 @@ function registerApi(app2, d) {
     return c.json({ vendor, recommended, gpus: sys.gpus, backends, mlx });
   });
   app2.post("/api/v1/engines/backends/install", async (c) => {
-    const b = await body2(c);
+    const b = await body3(c);
     const def = availableBackends().find((x) => x.id === b.backend);
-    if (!def) return err2(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join25(d.store.dir(), "engines");
+    if (!def) return err3(c, 400, "invalid_config_value", "Unknown backend for this platform.");
+    const root = join26(d.store.dir(), "engines");
     const existing = installedBackendBuild(root, def.id);
     if (existing) {
       return c.json({ accepted: false, alreadyInstalled: true, build: existing.tag });
     }
     {
       const busy = engineWorkBusy(d);
-      if (busy) return err2(c, 409, "engine_already_running", busy);
+      if (busy) return err3(c, 409, "engine_already_running", busy);
     }
     const ac = new AbortController();
     provisionAbort = ac;
@@ -13628,27 +14697,27 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/engines/backends/:id/update", async (c) => {
     const def = availableBackends().find((x) => x.id === c.req.param("id"));
-    if (!def) return err2(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join25(d.store.dir(), "engines");
+    if (!def) return err3(c, 400, "invalid_config_value", "Unknown backend for this platform.");
+    const root = join26(d.store.dir(), "engines");
     const oldBin = installedBackendBuild(root, def.id)?.bin ?? null;
-    if (!oldBin) return err2(c, 409, "not_installed", "Backend is not installed \u2014 download it first.");
+    if (!oldBin) return err3(c, 409, "not_installed", "Backend is not installed \u2014 download it first.");
     {
       const busy = engineWorkBusy(d);
-      if (busy) return err2(c, 409, "engine_already_running", busy);
+      if (busy) return err3(c, 409, "engine_already_running", busy);
     }
     let latestTag;
     try {
       latestTag = await latestReleaseTag("ggml-org/llama.cpp", AbortSignal.timeout(15e3));
     } catch {
-      return err2(c, 503, "offline", "Couldn't reach GitHub to check for a newer build. Try again when online.");
+      return err3(c, 503, "offline", "Couldn't reach GitHub to check for a newer build. Try again when online.");
     }
-    if (!latestTag) return err2(c, 503, "offline", "GitHub didn't report a latest build. Try again later.");
+    if (!latestTag) return err3(c, 503, "offline", "GitHub didn't report a latest build. Try again later.");
     const installedTag = tagFromManagedBinPath(oldBin);
     if (installedTag && installedTag === latestTag) {
       return c.json({ accepted: false, alreadyLatest: true, build: latestTag });
     }
     const newDef = backendDefAt(def.id, latestTag);
-    if (!newDef) return err2(c, 500, "internal", "No upstream build of this backend for your platform.");
+    if (!newDef) return err3(c, 500, "internal", "No upstream build of this backend for your platform.");
     const ac = new AbortController();
     provisionAbort = ac;
     void (async () => {
@@ -13673,7 +14742,7 @@ function registerApi(app2, d) {
           }
         }
         if (installedTag && installedTag !== latestTag) {
-          rmSync12(backendDir(root, def.id, installedTag), { recursive: true, force: true });
+          rmSync13(backendDir(root, def.id, installedTag), { recursive: true, force: true });
         }
         d.provision.done();
       } catch (e) {
@@ -13687,10 +14756,10 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/engines/backends/:id/enable", async (c) => {
     const def = availableBackends().find((x) => x.id === c.req.param("id"));
-    if (!def) return err2(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join25(d.store.dir(), "engines");
+    if (!def) return err3(c, 400, "invalid_config_value", "Unknown backend for this platform.");
+    const root = join26(d.store.dir(), "engines");
     const build2 = installedBackendBuild(root, def.id);
-    if (!build2) return err2(c, 409, "not_installed", "Backend is not installed on disk \u2014 download it first.");
+    if (!build2) return err3(c, 409, "not_installed", "Backend is not installed on disk \u2014 download it first.");
     let eng = d.registry.list().engines.find((e) => e.binPath === build2.bin);
     if (!eng) eng = (await d.registry.add(`llama.cpp ${build2.tag} (${def.id})`, build2.bin)).engine;
     d.registry.activate(eng.id);
@@ -13698,8 +14767,8 @@ function registerApi(app2, d) {
   });
   app2.delete("/api/v1/engines/backends/:id", async (c) => {
     const def = availableBackends().find((x) => x.id === c.req.param("id"));
-    if (!def) return err2(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join25(d.store.dir(), "engines");
+    if (!def) return err3(c, 400, "invalid_config_value", "Unknown backend for this platform.");
+    const root = join26(d.store.dir(), "engines");
     const backendDirRe = new RegExp(`[\\\\/]engines[\\\\/]llama\\.cpp-[^\\\\/]+-${def.id}[\\\\/]`);
     const engs = d.registry.list().engines.filter((e) => backendDirRe.test(e.binPath));
     const activeId = d.registry.active()?.id;
@@ -13715,13 +14784,13 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/engines/mlx", (c) => {
     if (process.platform !== "darwin") {
-      return err2(c, 409, "unsupported_platform", "MLX is only available on macOS (Apple Silicon).");
+      return err3(c, 409, "unsupported_platform", "MLX is only available on macOS (Apple Silicon).");
     }
     {
       const busy = engineWorkBusy(d);
-      if (busy) return err2(c, 409, "engine_already_running", busy);
+      if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join25(d.store.dir(), "engines");
+    const root = join26(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
@@ -13738,13 +14807,13 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/engines/rapid-mlx", (c) => {
     if (process.platform !== "darwin") {
-      return err2(c, 409, "unsupported_platform", "Rapid-MLX is only available on macOS (Apple Silicon).");
+      return err3(c, 409, "unsupported_platform", "Rapid-MLX is only available on macOS (Apple Silicon).");
     }
     {
       const busy = engineWorkBusy(d);
-      if (busy) return err2(c, 409, "engine_already_running", busy);
+      if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join25(d.store.dir(), "engines");
+    const root = join26(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
@@ -13761,12 +14830,12 @@ function registerApi(app2, d) {
   });
   app2.get("/api/v1/engines/catalog", (c) => {
     const regEngines = d.registry.list().engines;
-    const enginesRoot = join25(d.store.dir(), "engines");
+    const enginesRoot = join26(d.store.dir(), "engines");
     const items = catalogForPlatform().map((e) => {
       let installed2;
       let enabled;
       if (e.provision === "pip") {
-        const pyPath = join25(
+        const pyPath = join26(
           enginesRoot,
           e.id,
           "venv",
@@ -13775,7 +14844,7 @@ function registerApi(app2, d) {
         installed2 = existsSync22(pyPath);
         enabled = regEngines.some((x) => x.kind === e.kind);
       } else if (e.id === "turboquant") {
-        const tqDir = join25(enginesRoot, "turboquant");
+        const tqDir = join26(enginesRoot, "turboquant");
         installed2 = existsSync22(tqDir);
         enabled = regEngines.some((x) => /[\\/]engines[\\/]turboquant[\\/]/.test(x.binPath));
       } else if (e.id === "koboldcpp") {
@@ -13821,33 +14890,33 @@ function registerApi(app2, d) {
   );
   app2.post("/api/v1/build/run", async (c) => {
     if (!isLocalRequest(c, d))
-      return err2(c, 403, "forbidden", "Building an engine is only available on the machine running TurboLLM.");
+      return err3(c, 403, "forbidden", "Building an engine is only available on the machine running TurboLLM.");
     if (process.platform !== "win32" && process.platform !== "linux" && process.platform !== "darwin")
-      return err2(c, 409, "unsupported_platform", "In-app build is currently Windows, Linux, or macOS only.");
-    const b = await body2(c);
+      return err3(c, 409, "unsupported_platform", "In-app build is currently Windows, Linux, or macOS only.");
+    const b = await body3(c);
     const repoUrl = (b.repoUrl ?? "").trim();
     if (!/^https?:\/\//i.test(repoUrl))
-      return err2(c, 400, "invalid_config_value", "A http(s) repo URL is required.");
+      return err3(c, 400, "invalid_config_value", "A http(s) repo URL is required.");
     const branch = (b.branch ?? "").trim() || void 0;
     if (branch && branch.startsWith("-"))
-      return err2(c, 400, "invalid_config_value", 'Branch name cannot start with "-".');
+      return err3(c, 400, "invalid_config_value", 'Branch name cannot start with "-".');
     const commit = (b.commit ?? "").trim() || void 0;
     if (commit && !/^[0-9a-f]{7,40}$/i.test(commit))
-      return err2(c, 400, "invalid_config_value", "commit must be a hex SHA (7-40 chars).");
+      return err3(c, 400, "invalid_config_value", "commit must be a hex SHA (7-40 chars).");
     const patchUrl = (b.patchUrl ?? "").trim() || void 0;
     const patchSha256 = (b.patchSha256 ?? "").trim() || void 0;
     if (!!patchUrl !== !!patchSha256)
-      return err2(c, 400, "invalid_config_value", "patchUrl and patchSha256 must be provided together \u2014 a patch may only be applied with a pinned checksum.");
+      return err3(c, 400, "invalid_config_value", "patchUrl and patchSha256 must be provided together \u2014 a patch may only be applied with a pinned checksum.");
     if (patchUrl && !/^https?:\/\//i.test(patchUrl))
-      return err2(c, 400, "invalid_config_value", "patchUrl must be an http(s) URL.");
+      return err3(c, 400, "invalid_config_value", "patchUrl must be an http(s) URL.");
     if (patchSha256 && !/^[0-9a-f]{64}$/i.test(patchSha256))
-      return err2(c, 400, "invalid_config_value", "patchSha256 must be a 64-char hex SHA-256.");
+      return err3(c, 400, "invalid_config_value", "patchSha256 must be a 64-char hex SHA-256.");
     const busy = engineWorkBusy(d);
-    if (busy) return err2(c, 409, "engine_already_running", busy);
+    if (busy) return err3(c, 409, "engine_already_running", busy);
     const name = (b.name ?? "").trim() || void 0;
-    const enginesRoot = join25(d.store.dir(), "engines");
+    const enginesRoot = join26(d.store.dir(), "engines");
     const toolchainDirs = d.store.snapshot().build.toolchainDirs;
-    const buildRoot = join25(enginesRoot, "build", buildDirName(repoUrl, branch, commit));
+    const buildRoot = join26(enginesRoot, "build", buildDirName(repoUrl, branch, commit));
     const ac = new AbortController();
     buildAbort = ac;
     d.build.start(name ?? repoUrl);
@@ -13862,7 +14931,7 @@ function registerApi(app2, d) {
           );
         } catch (e) {
           try {
-            rmSync12(buildRoot, { recursive: true, force: true });
+            rmSync13(buildRoot, { recursive: true, force: true });
           } catch {
           }
           if (e?.name === "AbortError") {
@@ -13917,11 +14986,11 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/build/cuda", async (c) => {
     if (!isLocalRequest(c, d))
-      return err2(c, 403, "forbidden", "Downloading CUDA is only available on the machine running TurboLLM.");
+      return err3(c, 403, "forbidden", "Downloading CUDA is only available on the machine running TurboLLM.");
     if (process.platform !== "win32")
-      return err2(c, 409, "unsupported_platform", "Automatic CUDA download is currently Windows x86_64 only.");
+      return err3(c, 409, "unsupported_platform", "Automatic CUDA download is currently Windows x86_64 only.");
     const busy = engineWorkBusy(d);
-    if (busy) return err2(c, 409, "engine_already_running", busy);
+    if (busy) return err3(c, 409, "engine_already_running", busy);
     const dataDir = d.store.dir();
     const ac = new AbortController();
     buildAbort = ac;
@@ -13955,9 +15024,9 @@ function registerApi(app2, d) {
   app2.post("/api/v1/engines/vllm", (c) => {
     {
       const busy = engineWorkBusy(d);
-      if (busy) return err2(c, 409, "engine_already_running", busy);
+      if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join25(d.store.dir(), "engines");
+    const root = join26(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
@@ -13975,9 +15044,9 @@ function registerApi(app2, d) {
   app2.post("/api/v1/engines/sglang", (c) => {
     {
       const busy = engineWorkBusy(d);
-      if (busy) return err2(c, 409, "engine_already_running", busy);
+      if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join25(d.store.dir(), "engines");
+    const root = join26(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
@@ -13994,22 +15063,22 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/engines/turboquant", (c) => {
     const entry = catalogEngine("turboquant");
-    if (!entry?.repo) return err2(c, 500, "internal", "TurboQuant catalog entry is misconfigured.");
+    if (!entry?.repo) return err3(c, 500, "internal", "TurboQuant catalog entry is misconfigured.");
     if (!entry.platforms.includes(process.platform)) {
-      return err2(c, 409, "unsupported_platform", "TurboQuant has no prebuilt binary for this operating system yet.");
+      return err3(c, 409, "unsupported_platform", "TurboQuant has no prebuilt binary for this operating system yet.");
     }
     {
       const busy = engineWorkBusy(d);
-      if (busy) return err2(c, 409, "engine_already_running", busy);
+      if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join25(d.store.dir(), "engines");
+    const root = join26(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
         d.provision.start("turboquant");
         if (upgrade) {
-          const tqDir = join25(root, "turboquant");
-          if (existsSync22(tqDir)) rmSync12(tqDir, { recursive: true, force: true });
+          const tqDir = join26(root, "turboquant");
+          if (existsSync22(tqDir)) rmSync13(tqDir, { recursive: true, force: true });
         }
         const bin = await provisionTurboquant(
           root,
@@ -14029,15 +15098,15 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/engines/koboldcpp", (c) => {
     const entry = catalogEngine("koboldcpp");
-    if (!entry?.repo) return err2(c, 500, "internal", "KoboldCpp catalog entry is misconfigured.");
+    if (!entry?.repo) return err3(c, 500, "internal", "KoboldCpp catalog entry is misconfigured.");
     if (!entry.platforms.includes(process.platform)) {
-      return err2(c, 409, "unsupported_platform", "KoboldCpp has no prebuilt binary for this operating system yet.");
+      return err3(c, 409, "unsupported_platform", "KoboldCpp has no prebuilt binary for this operating system yet.");
     }
     {
       const busy = engineWorkBusy(d);
-      if (busy) return err2(c, 409, "engine_already_running", busy);
+      if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join25(d.store.dir(), "engines");
+    const root = join26(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     const hasNvidia = primaryVendor(getSysInfo()) === "nvidia";
     void (async () => {
@@ -14045,7 +15114,7 @@ function registerApi(app2, d) {
         d.provision.start("koboldcpp");
         if (upgrade) {
           const dir = koboldcppDir(root);
-          if (existsSync22(dir)) rmSync12(dir, { recursive: true, force: true });
+          if (existsSync22(dir)) rmSync13(dir, { recursive: true, force: true });
         }
         const rt = await ensureKoboldcpp(root, hasNvidia, (p) => d.provision.progress(p.phase, p.pct, p.part, p.parts));
         const eng = d.registry.addKoboldcpp(`KoboldCpp (${rt.version})`, rt.binPath, rt.version);
@@ -14060,22 +15129,22 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/engines/llamafile", (c) => {
     const entry = catalogEngine("llamafile");
-    if (!entry?.repo) return err2(c, 500, "internal", "llamafile catalog entry is misconfigured.");
+    if (!entry?.repo) return err3(c, 500, "internal", "llamafile catalog entry is misconfigured.");
     if (!entry.platforms.includes(process.platform)) {
-      return err2(c, 409, "unsupported_platform", "llamafile is not available for this operating system yet.");
+      return err3(c, 409, "unsupported_platform", "llamafile is not available for this operating system yet.");
     }
     {
       const busy = engineWorkBusy(d);
-      if (busy) return err2(c, 409, "engine_already_running", busy);
+      if (busy) return err3(c, 409, "engine_already_running", busy);
     }
-    const root = join25(d.store.dir(), "engines");
+    const root = join26(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
         d.provision.start("llamafile");
         if (upgrade) {
           const dir = llamafileDir(root);
-          if (existsSync22(dir)) rmSync12(dir, { recursive: true, force: true });
+          if (existsSync22(dir)) rmSync13(dir, { recursive: true, force: true });
         }
         const rt = await ensureLlamafile(root, (p) => d.provision.progress(p.phase, p.pct, p.part, p.parts));
         const eng = d.registry.addLlamafile(`llamafile (${rt.version})`, rt.binPath, rt.version);
@@ -14090,9 +15159,9 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/engines", async (c) => {
     if (!isLocalRequest(c, d))
-      return err2(c, 403, "forbidden", "Engines can only be added from the machine running TurboLLM.");
-    const b = await body2(c);
-    if (!b.binPath || !b.binPath.trim()) return err2(c, 400, "invalid_config_value", "binPath is required.");
+      return err3(c, 403, "forbidden", "Engines can only be added from the machine running TurboLLM.");
+    const b = await body3(c);
+    if (!b.binPath || !b.binPath.trim()) return err3(c, 400, "invalid_config_value", "binPath is required.");
     try {
       const { engine, warning } = await d.registry.add(b.name ?? "", b.binPath, {
         sourceRepo: b.sourceRepo,
@@ -14104,17 +15173,17 @@ function registerApi(app2, d) {
       }
       return c.json({ ...engine, warning: warning ?? null }, 201);
     } catch (e) {
-      if (e instanceof NameTakenError) return err2(c, 400, "name_already_taken", e.message);
-      if (e instanceof ProbeError) return err2(c, 400, e.code, e.message);
-      return err2(c, 500, "internal", e.message);
+      if (e instanceof NameTakenError) return err3(c, 400, "name_already_taken", e.message);
+      if (e instanceof ProbeError) return err3(c, 400, e.code, e.message);
+      return err3(c, 500, "internal", e.message);
     }
   });
   app2.post("/api/v1/engines/scan", async (c) => {
     if (!isLocalRequest(c, d))
-      return err2(c, 403, "forbidden", "Engine scanning is only available on the machine running TurboLLM.");
-    const b = await body2(c);
+      return err3(c, 403, "forbidden", "Engine scanning is only available on the machine running TurboLLM.");
+    const b = await body3(c);
     const path = (b.path ?? "").trim();
-    if (!path) return err2(c, 400, "invalid_config_value", "path is required.");
+    if (!path) return err3(c, 400, "invalid_config_value", "path is required.");
     const binPath = resolveServerBinary(path);
     if (!binPath) return c.json({ found: false });
     try {
@@ -14127,12 +15196,12 @@ function registerApi(app2, d) {
         suggestedName: suggestEngineName(binPath, version2)
       });
     } catch (e) {
-      if (e instanceof ProbeError) return err2(c, 400, e.code, e.message);
-      return err2(c, 500, "internal", e.message);
+      if (e instanceof ProbeError) return err3(c, 400, e.code, e.message);
+      return err3(c, 500, "internal", e.message);
     }
   });
   app2.put("/api/v1/engines/:id", async (c) => {
-    const b = await body2(c);
+    const b = await body3(c);
     const id = c.req.param("id");
     try {
       if (b.sourceRepo !== void 0 || b.sourceBranch !== void 0) {
@@ -14156,7 +15225,7 @@ function registerApi(app2, d) {
     const id = c.req.param("id");
     const { activeEngineId } = d.registry.list();
     if (id === activeEngineId && engineBusy(d)) {
-      return err2(c, 409, "engine_in_use", "Stop the engine before removing it.");
+      return err3(c, 409, "engine_in_use", "Stop the engine before removing it.");
     }
     const purge = c.req.query("purge") === "1";
     const recordSource = c.req.query("recordSource") === "1";
@@ -14175,10 +15244,10 @@ function registerApi(app2, d) {
       }
       d.registry.remove(id);
       if (purge && eng) {
-        const enginesRoot = join25(d.store.dir(), "engines");
+        const enginesRoot = join26(d.store.dir(), "engines");
         const purgeDir = engineInstallDir(eng, enginesRoot);
         if (purgeDir && existsSync22(purgeDir)) {
-          rmSync12(purgeDir, { recursive: true, force: true });
+          rmSync13(purgeDir, { recursive: true, force: true });
         }
         d.registry.forgetCustomSource(customSourceKey(eng));
       }
@@ -14188,7 +15257,7 @@ function registerApi(app2, d) {
     }
   });
   app2.post("/api/v1/engines/:id/activate", (c) => {
-    if (engineBusy(d)) return err2(c, 409, "engine_running", "Stop the running engine before switching the active engine.");
+    if (engineBusy(d)) return err3(c, 409, "engine_running", "Stop the running engine before switching the active engine.");
     try {
       d.registry.activate(c.req.param("id"));
       d.manager.clearError();
@@ -14201,7 +15270,7 @@ function registerApi(app2, d) {
     try {
       return c.json(await d.registry.reprobe(c.req.param("id")));
     } catch (e) {
-      if (e instanceof ProbeError) return err2(c, 400, e.code, e.message);
+      if (e instanceof ProbeError) return err3(c, 400, e.code, e.message);
       return regErr(c, e);
     }
   });
@@ -14234,9 +15303,9 @@ function registerApi(app2, d) {
     return c.json(d.appUpdates.get() ?? fallback);
   });
   app2.put("/api/v1/engines/:id/update-policy", async (c) => {
-    const b = await body2(c);
+    const b = await body3(c);
     if (b.policy !== "off" && b.policy !== "notify" && b.policy !== "auto") {
-      return err2(c, 400, "invalid_config_value", "policy must be off, notify, or auto.");
+      return err3(c, 400, "invalid_config_value", "policy must be off, notify, or auto.");
     }
     try {
       return c.json(d.registry.setUpdatePolicy(c.req.param("id"), b.policy));
@@ -14246,7 +15315,7 @@ function registerApi(app2, d) {
   });
   app2.get("/api/v1/fs/browse", (c) => {
     if (!isLocalRequest(c, d))
-      return err2(c, 403, "forbidden", "Browsing the filesystem is only available on the machine running TurboLLM.");
+      return err3(c, 403, "forbidden", "Browsing the filesystem is only available on the machine running TurboLLM.");
     const raw = (c.req.query("path") ?? "").trim();
     if (raw === FS_DRIVES_ROOT && process.platform === "win32") {
       return c.json({ path: FS_DRIVES_ROOT, parent: null, entries: listWindowsDrives() });
@@ -14260,19 +15329,19 @@ function registerApi(app2, d) {
     }
     let entries;
     try {
-      entries = readdirSync8(real, { withFileTypes: true }).filter((d2) => !d2.name.startsWith(".")).map((d2) => {
+      entries = readdirSync9(real, { withFileTypes: true }).filter((d2) => !d2.name.startsWith(".")).map((d2) => {
         let isDir = d2.isDirectory();
         if (d2.isSymbolicLink()) {
           try {
-            isDir = statSync5(join25(real, d2.name)).isDirectory();
+            isDir = statSync5(join26(real, d2.name)).isDirectory();
           } catch {
             isDir = false;
           }
         }
-        return { name: d2.name, path: join25(real, d2.name), isDir };
+        return { name: d2.name, path: join26(real, d2.name), isDir };
       }).sort((a, b) => a.isDir === b.isDir ? a.name.localeCompare(b.name) : a.isDir ? -1 : 1);
     } catch {
-      return err2(c, 400, "fs_read_failed", "Could not read that folder (permission denied or not a directory).");
+      return err3(c, 400, "fs_read_failed", "Could not read that folder (permission denied or not a directory).");
     }
     const parentDir = dirname9(real);
     const parent = parentDir === real ? process.platform === "win32" ? FS_DRIVES_ROOT : null : parentDir;
@@ -14280,14 +15349,14 @@ function registerApi(app2, d) {
   });
   app2.get("/api/v1/fs/git-branch", (c) => {
     if (!isLocalRequest(c, d))
-      return err2(c, 403, "forbidden", "Reading git info is only available on the machine running TurboLLM.");
+      return err3(c, 403, "forbidden", "Reading git info is only available on the machine running TurboLLM.");
     const raw = (c.req.query("path") ?? "").trim();
-    if (!raw) return err2(c, 400, "invalid_input", "path is required.");
+    if (!raw) return err3(c, 400, "invalid_input", "path is required.");
     const cwd = resolve(raw);
     if (!existsSync22(cwd) || !statSync5(cwd).isDirectory()) {
       return c.json({ isRepo: false, branch: "", branches: [] });
     }
-    const git2 = (args) => execFileSync5("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3, windowsHide: true }).trim();
+    const git2 = (args) => execFileSync6("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3, windowsHide: true }).trim();
     try {
       if (git2(["rev-parse", "--is-inside-work-tree"]) !== "true") return c.json({ isRepo: false, branch: "", branches: [] });
       let branch = "";
@@ -14307,10 +15376,10 @@ function registerApi(app2, d) {
     }
   });
   app2.post("/api/v1/engine/start", async (c) => {
-    const b = await body2(c);
+    const b = await body3(c);
     const active = d.registry.active();
-    if (!active) return err2(c, 409, "no_active_engine", "Register and select an engine first.");
-    if (d.comfy?.isBlocked()) return err2(c, 409, "comfyui_busy", "ComfyUI is rendering \u2014 model loading is paused until its queue finishes.");
+    if (!active) return err3(c, 409, "no_active_engine", "Register and select an engine first.");
+    if (d.comfy?.isBlocked()) return err3(c, 409, "comfyui_busy", "ComfyUI is rendering \u2014 model loading is paused until its queue finishes.");
     d.bench.cancel();
     abortAllInFlightChats();
     await d.bench.waitIdle();
@@ -14321,13 +15390,13 @@ function registerApi(app2, d) {
     const entry = key ? d.scanner.get(key) : void 0;
     if (entry) {
       if (entry.incomplete || entry.parseError) {
-        return err2(c, 409, "model_not_loadable", "This model is incomplete or unreadable.");
+        return err3(c, 409, "model_not_loadable", "This model is incomplete or unreadable.");
       }
       if (!engineAcceptsFormat(active.kind, entry.format)) {
-        return err2(c, 409, "engine_model_mismatch", formatMismatchMessage(active.kind, entry.format));
+        return err3(c, 409, "engine_model_mismatch", formatMismatchMessage(active.kind, entry.format));
       }
       if (entry.audio && engineRejectsAudioModel(active.kind)) {
-        return err2(
+        return err3(
           c,
           409,
           "engine_model_mismatch",
@@ -14358,7 +15427,7 @@ function registerApi(app2, d) {
           preferredPort: profile.port
         };
       }
-      void d.manager.load(opts2, { beforeStart: () => d.comfy?.freeComfyUIBeforeLoad() ?? Promise.resolve() }).catch((e) => console.warn(`engine load failed: ${e}`));
+      void d.modelRouter.withSwapLock(() => d.manager.load(opts2, { beforeStart: () => d.comfy?.freeComfyUIBeforeLoad() ?? Promise.resolve() })).then(() => d.modelRouter.markPrimaryLoaded()).catch((e) => console.warn(`engine load failed: ${e}`));
       d.store.update((x) => {
         x.lastLoaded = { modelKey: entry.key, engineId: active.id };
       });
@@ -14372,9 +15441,9 @@ function registerApi(app2, d) {
       extra = cfg2.devModel.extraArgs;
       name = cfg2.devModel.label;
     }
-    if (!modelPath) return err2(c, 409, "no_such_model", "No model specified. Pick one from the Models screen.");
+    if (!modelPath) return err3(c, 409, "no_such_model", "No model specified. Pick one from the Models screen.");
     const opts = { engine: active, model: deriveModel(modelPath, name, extra), modelPath, extraArgs: extra };
-    void d.manager.load(opts, { beforeStart: () => d.comfy?.freeComfyUIBeforeLoad() ?? Promise.resolve() }).catch((e) => console.warn(`engine load failed: ${e}`));
+    void d.modelRouter.withSwapLock(() => d.manager.load(opts, { beforeStart: () => d.comfy?.freeComfyUIBeforeLoad() ?? Promise.resolve() })).then(() => d.modelRouter.markPrimaryLoaded()).catch((e) => console.warn(`engine load failed: ${e}`));
     return c.json({ ok: true }, 202);
   });
   app2.post("/api/v1/engine/stop", (c) => {
@@ -14403,28 +15472,28 @@ function registerApi(app2, d) {
     return c.json({ ok: true });
   });
   app2.post("/api/v1/comfyui/install", async (c) => {
-    const b = await body2(c);
+    const b = await body3(c);
     const raw = (b.path ?? "").trim();
-    if (!raw) return err2(c, 400, "invalid_config_value", "Enter the path to your ComfyUI folder.");
+    if (!raw) return err3(c, 400, "invalid_config_value", "Enter the path to your ComfyUI folder.");
     const root = resolve(raw);
     if (!existsSync22(root) || !statSync5(root).isDirectory()) {
-      return err2(c, 400, "invalid_config_value", "That folder does not exist.");
+      return err3(c, 400, "invalid_config_value", "That folder does not exist.");
     }
     let customNodes;
     if (basename3(root).toLowerCase() === "custom_nodes") customNodes = root;
-    else if (existsSync22(join25(root, "custom_nodes"))) customNodes = join25(root, "custom_nodes");
+    else if (existsSync22(join26(root, "custom_nodes"))) customNodes = join26(root, "custom_nodes");
     else {
-      return err2(c, 400, "invalid_config_value", "No 'custom_nodes' folder here. Point me at your ComfyUI folder or its custom_nodes folder.");
+      return err3(c, 400, "invalid_config_value", "No 'custom_nodes' folder here. Point me at your ComfyUI folder or its custom_nodes folder.");
     }
     const reqUrl = new URL(c.req.url);
     const port2 = reqUrl.port || (reqUrl.protocol === "https:" ? "443" : "80");
     const base2 = `http://127.0.0.1:${port2}`;
-    const gateDir = join25(customNodes, "turbollm_gate");
+    const gateDir = join26(customNodes, "turbollm_gate");
     try {
-      mkdirSync13(gateDir, { recursive: true });
-      writeFileSync11(join25(gateDir, "__init__.py"), gateNodeSource(base2));
+      mkdirSync14(gateDir, { recursive: true });
+      writeFileSync12(join26(gateDir, "__init__.py"), gateNodeSource(base2));
     } catch (e) {
-      return err2(c, 500, "fs_write_failed", `Could not write the gate node: ${e instanceof Error ? e.message : e}`);
+      return err3(c, 500, "fs_write_failed", `Could not write the gate node: ${e instanceof Error ? e.message : e}`);
     }
     d.store.update((x) => {
       x.comfyui.gatePath = gateDir;
@@ -14435,9 +15504,9 @@ function registerApi(app2, d) {
     const dir = d.store.snapshot().comfyui.gatePath;
     if (dir && existsSync22(dir)) {
       try {
-        rmSync12(dir, { recursive: true, force: true });
+        rmSync13(dir, { recursive: true, force: true });
       } catch (e) {
-        return err2(c, 500, "fs_write_failed", `Could not remove the gate node: ${e instanceof Error ? e.message : e}`);
+        return err3(c, 500, "fs_write_failed", `Could not remove the gate node: ${e instanceof Error ? e.message : e}`);
       }
     }
     d.store.update((x) => {
@@ -14447,7 +15516,7 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/daemon/restart", (c) => {
     if (!d.requestRestart) {
-      return err2(c, 501, "not_supported", "Daemon restart is not available in this run mode.");
+      return err3(c, 501, "not_supported", "Daemon restart is not available in this run mode.");
     }
     const restart = d.requestRestart;
     setTimeout(() => restart(), 200).unref();
@@ -14469,7 +15538,7 @@ function registerApi(app2, d) {
       while (!aborted) {
         const path = d.manager.logPath();
         if (path && existsSync22(path)) {
-          const lines = readFileSync10(path, "utf8").split("\n");
+          const lines = readFileSync11(path, "utf8").split("\n");
           for (; sent < lines.length - 1; sent++) {
             await stream.writeSSE({ event: "line", data: JSON.stringify({ line: lines[sent].replace(/\r$/, "") }) });
           }
@@ -14480,10 +15549,10 @@ function registerApi(app2, d) {
     })
   );
   app2.post("/api/v1/bench", async (c) => {
-    const b = await body2(c);
+    const b = await body3(c);
     const key = (b.modelKey ?? "").trim();
-    if (!key) return err2(c, 400, "invalid_config_value", "modelKey is required.");
-    if (d.comfy?.isBlocked()) return err2(c, 409, "comfyui_busy", "ComfyUI is rendering \u2014 benchmarking is paused until its queue finishes.");
+    if (!key) return err3(c, 400, "invalid_config_value", "modelKey is required.");
+    if (d.comfy?.isBlocked()) return err3(c, 409, "comfyui_busy", "ComfyUI is rendering \u2014 benchmarking is paused until its queue finishes.");
     await d.comfy?.freeComfyUIBeforeLoad();
     try {
       d.bench.start(key, b.base && typeof b.base === "object" ? b.base : void 0);
@@ -14498,12 +15567,12 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/bench/save", (c) => {
     const saved = d.bench.saveResult();
-    if (!saved) return err2(c, 409, "no_bench_result", "No auto-tune result to save.");
+    if (!saved) return err3(c, 409, "no_bench_result", "No auto-tune result to save.");
     return c.json({ ok: true });
   });
   app2.get("/api/v1/bench/log", (c) => {
     const log = d.bench.getLog();
-    if (!log) return err2(c, 404, "no_bench_log", "No auto-tune log available.");
+    if (!log) return err3(c, 404, "no_bench_log", "No auto-tune log available.");
     const slug = log.modelKey.replace(/[^a-z0-9]/gi, "-").replace(/-+/g, "-").slice(0, 60);
     c.header("Content-Disposition", `attachment; filename="autotune-${slug}-${log.startedAt.slice(0, 10)}.json"`);
     return c.json(log);
@@ -14520,23 +15589,23 @@ function registerApi(app2, d) {
   app2.delete("/api/v1/models/:key", async (c) => {
     const key = decodeURIComponent(c.req.param("key"));
     const e = d.scanner.get(key);
-    if (!e) return err2(c, 404, "no_such_model", "No model with that key.");
+    if (!e) return err3(c, 404, "no_such_model", "No model with that key.");
     const ms = d.manager.status();
     const loadedKey = ms.state === "running" || ms.state === "starting" ? ms.model?.key : void 0;
     if (loadedKey === e.path || loadedKey === e.key) {
-      return err2(c, 409, "model_loaded", "This model is currently loaded. Eject it before deleting.");
+      return err3(c, 409, "model_loaded", "This model is currently loaded. Eject it before deleting.");
     }
     try {
       const deleted = await d.scanner.delete(key);
       return c.json({ ok: true, deleted });
     } catch (e2) {
-      if (e2 instanceof ScannerError) return err2(c, 404, e2.code, e2.message);
-      return err2(c, 500, "delete_failed", e2.message);
+      if (e2 instanceof ScannerError) return err3(c, 404, e2.code, e2.message);
+      return err3(c, 500, "delete_failed", e2.message);
     }
   });
   app2.get("/api/v1/models/:key", (c) => {
     const e = d.scanner.get(decodeURIComponent(c.req.param("key")));
-    if (!e) return err2(c, 404, "no_such_model", "No model with that key.");
+    if (!e) return err3(c, 404, "no_such_model", "No model with that key.");
     const sys = getSysInfo();
     const snap = d.store.snapshot();
     const engineId = c.req.query("engine") || d.registry.active()?.id || "*";
@@ -14547,24 +15616,24 @@ function registerApi(app2, d) {
   app2.put("/api/v1/models/:key/profile", async (c) => {
     const key = decodeURIComponent(c.req.param("key"));
     const e = d.scanner.get(key);
-    if (!e) return err2(c, 404, "no_such_model", "No model with that key.");
-    const p = await body2(c);
+    if (!e) return err3(c, 404, "no_such_model", "No model with that key.");
+    const p = await body3(c);
     if (!p || typeof p.ctx !== "number" || p.ctx < 256) {
-      return err2(c, 400, "invalid_profile_value", "ctx must be at least 256.");
+      return err3(c, 400, "invalid_profile_value", "ctx must be at least 256.");
     }
     if (p.gpu) {
       const g = p.gpu;
       if (!["layer", "row", "none"].includes(g.splitMode)) {
-        return err2(c, 400, "invalid_profile_value", "gpu.splitMode must be layer, row, or none.");
+        return err3(c, 400, "invalid_profile_value", "gpu.splitMode must be layer, row, or none.");
       }
       if (!Array.isArray(g.tensorSplit) || g.tensorSplit.some((n) => typeof n !== "number" || !(n >= 0))) {
-        return err2(c, 400, "invalid_profile_value", "gpu.tensorSplit must be an array of non-negative numbers.");
+        return err3(c, 400, "invalid_profile_value", "gpu.tensorSplit must be an array of non-negative numbers.");
       }
       if (!Number.isInteger(g.mainGpu) || g.mainGpu < -1) {
-        return err2(c, 400, "invalid_profile_value", "gpu.mainGpu must be an integer \u2265 -1.");
+        return err3(c, 400, "invalid_profile_value", "gpu.mainGpu must be an integer \u2265 -1.");
       }
       if (!Number.isInteger(g.tensorParallelSize) || g.tensorParallelSize < 1) {
-        return err2(c, 400, "invalid_profile_value", "gpu.tensorParallelSize must be an integer \u2265 1.");
+        return err3(c, 400, "invalid_profile_value", "gpu.tensorParallelSize must be an integer \u2265 1.");
       }
     }
     const engineId = c.req.query("engine") || d.registry.active()?.id || "*";
@@ -14584,20 +15653,20 @@ function registerApi(app2, d) {
   app2.get("/api/v1/sysinfo", (c) => c.json(getSysInfo()));
   app2.get("/api/v1/settings", (c) => c.json(settingsPayload(d)));
   app2.patch("/api/v1/settings", async (c) => {
-    const b = await body2(c);
+    const b = await body3(c);
     const updates2 = {};
     if (b.idleTtlMinutes !== void 0) {
       const v = Number(b.idleTtlMinutes);
-      if (!Number.isFinite(v) || v < 0) return err2(c, 400, "invalid_config_value", "idleTtlMinutes must be a non-negative number.");
+      if (!Number.isFinite(v) || v < 0) return err3(c, 400, "invalid_config_value", "idleTtlMinutes must be a non-negative number.");
       updates2.idleTtlMinutes = v;
     }
     if (b.port !== void 0) {
       const v = Number(b.port);
-      if (!Number.isInteger(v) || v < 1024 || v > 65535) return err2(c, 400, "invalid_config_value", "port must be 1024\u201365535.");
+      if (!Number.isInteger(v) || v < 1024 || v > 65535) return err3(c, 400, "invalid_config_value", "port must be 1024\u201365535.");
       updates2.port = v;
     }
     if (b.theme !== void 0) {
-      if (!["system", "light", "dark"].includes(b.theme)) return err2(c, 400, "invalid_config_value", "theme must be system, light, or dark.");
+      if (!["system", "light", "dark"].includes(b.theme)) return err3(c, 400, "invalid_config_value", "theme must be system, light, or dark.");
       updates2.theme = b.theme;
     }
     if (b.autoGenerateTitles !== void 0) updates2.autoGenerateTitles = !!b.autoGenerateTitles;
@@ -14608,7 +15677,7 @@ function registerApi(app2, d) {
       const v = Number(b.vramHeadroomMb);
       const valid = v === VRAM_HEADROOM_SPILL_MB || v >= VRAM_HEADROOM_MIN_MB && v <= VRAM_HEADROOM_MAX_MB;
       if (!Number.isFinite(v) || !valid) {
-        return err2(c, 400, "invalid_config_value", `vramHeadroomMb must be ${VRAM_HEADROOM_SPILL_MB} (allow VRAM spill) or ${VRAM_HEADROOM_MIN_MB}\u2013${VRAM_HEADROOM_MAX_MB}.`);
+        return err3(c, 400, "invalid_config_value", `vramHeadroomMb must be ${VRAM_HEADROOM_SPILL_MB} (allow VRAM spill) or ${VRAM_HEADROOM_MIN_MB}\u2013${VRAM_HEADROOM_MAX_MB}.`);
       }
       vramHeadroomMb = Math.round(v);
     }
@@ -14617,7 +15686,7 @@ function registerApi(app2, d) {
     let telemetryLevel;
     if (b.telemetryLevel !== void 0) {
       if (!["off", "anon", "full"].includes(b.telemetryLevel)) {
-        return err2(c, 400, "invalid_config_value", "telemetryLevel must be off, anon, or full.");
+        return err3(c, 400, "invalid_config_value", "telemetryLevel must be off, anon, or full.");
       }
       telemetryLevel = b.telemetryLevel;
     }
@@ -14626,22 +15695,22 @@ function registerApi(app2, d) {
     if (md) {
       if (md.ctx !== void 0) {
         const v = Number(md.ctx);
-        if (!Number.isFinite(v) || v < 256) return err2(c, 400, "invalid_config_value", "modelDefaults.ctx must be at least 256.");
+        if (!Number.isFinite(v) || v < 256) return err3(c, 400, "invalid_config_value", "modelDefaults.ctx must be at least 256.");
         mdUpdates.ctx = Math.floor(v);
       }
       if (md.ngl !== void 0) {
         const v = Number(md.ngl);
-        if (!Number.isFinite(v) || v < 0 || v > 99) return err2(c, 400, "invalid_config_value", "modelDefaults.ngl must be 0\u201399.");
+        if (!Number.isFinite(v) || v < 0 || v > 99) return err3(c, 400, "invalid_config_value", "modelDefaults.ngl must be 0\u201399.");
         mdUpdates.ngl = Math.floor(v);
       }
       if (md.imageMaxTokens !== void 0) {
         const v = Number(md.imageMaxTokens);
-        if (!Number.isFinite(v) || v < 0) return err2(c, 400, "invalid_config_value", "modelDefaults.imageMaxTokens must be a non-negative number.");
+        if (!Number.isFinite(v) || v < 0) return err3(c, 400, "invalid_config_value", "modelDefaults.imageMaxTokens must be a non-negative number.");
         mdUpdates.imageMaxTokens = Math.floor(v);
       }
       if (md.maxTokens !== void 0) {
         const v = Number(md.maxTokens);
-        if (!Number.isFinite(v) || v < 0) return err2(c, 400, "invalid_config_value", "modelDefaults.maxTokens must be a non-negative number (0 = unlimited).");
+        if (!Number.isFinite(v) || v < 0) return err3(c, 400, "invalid_config_value", "modelDefaults.maxTokens must be a non-negative number (0 = unlimited).");
         mdUpdates.maxTokens = Math.floor(v);
       }
     }
@@ -14651,7 +15720,7 @@ function registerApi(app2, d) {
     if (b.comfyui?.url !== void 0) {
       const u = b.comfyui.url.trim();
       if (u && !/^https?:\/\//i.test(u)) {
-        return err2(c, 400, "invalid_config_value", "comfyui.url must be an http(s):// origin (e.g. http://127.0.0.1:8188).");
+        return err3(c, 400, "invalid_config_value", "comfyui.url must be an http(s):// origin (e.g. http://127.0.0.1:8188).");
       }
       cuUpdates.url = u;
     }
@@ -14659,18 +15728,18 @@ function registerApi(app2, d) {
     if (b.gateway?.autoSwap !== void 0) gwUpdates.autoSwap = !!b.gateway.autoSwap;
     if (b.gateway?.keepN !== void 0) {
       const v = Number(b.gateway.keepN);
-      if (!Number.isInteger(v) || v < 1 || v > 4) return err2(c, 400, "invalid_config_value", "gateway.keepN must be 1\u20134.");
+      if (!Number.isInteger(v) || v < 1 || v > 4) return err3(c, 400, "invalid_config_value", "gateway.keepN must be 1\u20134.");
       gwUpdates.keepN = v;
     }
     let toolchainDirs;
     if (b.build?.toolchainDirs !== void 0) {
       if (!Array.isArray(b.build.toolchainDirs)) {
-        return err2(c, 400, "invalid_config_value", "build.toolchainDirs must be an array of paths.");
+        return err3(c, 400, "invalid_config_value", "build.toolchainDirs must be an array of paths.");
       }
       const dirs = b.build.toolchainDirs.map((p) => String(p).trim()).filter(Boolean);
       for (const dir of dirs) {
         if (!/^([a-zA-Z]:[\\/]|[\\/])/.test(dir)) {
-          return err2(c, 400, "invalid_config_value", `build.toolchainDirs: "${dir}" must be an absolute path.`);
+          return err3(c, 400, "invalid_config_value", `build.toolchainDirs: "${dir}" must be an absolute path.`);
         }
       }
       toolchainDirs = dirs;
@@ -14688,25 +15757,33 @@ function registerApi(app2, d) {
     ]) {
       const raw = b.code?.[key];
       if (raw === void 0) continue;
-      if (!Array.isArray(raw)) return err2(c, 400, "invalid_config_value", `code.${key} must be an array of filenames.`);
+      if (!Array.isArray(raw)) return err3(c, 400, "invalid_config_value", `code.${key} must be an array of filenames.`);
       const list = raw.map((p) => String(p).trim()).filter(Boolean);
-      if (list.length > MAX_AGENTS_MD_CANDIDATES2) return err2(c, 400, "invalid_config_value", `code.${key}: at most ${MAX_AGENTS_MD_CANDIDATES2} candidates.`);
+      if (list.length > MAX_AGENTS_MD_CANDIDATES2) return err3(c, 400, "invalid_config_value", `code.${key}: at most ${MAX_AGENTS_MD_CANDIDATES2} candidates.`);
       for (const entry of list) {
         if (/^([a-zA-Z]:[\\/]|[\\/])/.test(entry)) {
-          return err2(c, 400, "invalid_config_value", `code.${key}: "${entry}" must be a relative filename/path, not absolute.`);
+          return err3(c, 400, "invalid_config_value", `code.${key}: "${entry}" must be a relative filename/path, not absolute.`);
         }
       }
       out(list);
     }
+    let defaultAgent;
+    if (b.code?.defaultAgent !== void 0) {
+      const v = b.code.defaultAgent;
+      if (v !== "turbollm" && v !== "pi" && v !== "claude" && v !== "opencode") {
+        return err3(c, 400, "invalid_config_value", "code.defaultAgent must be one of: turbollm, pi, claude, opencode.");
+      }
+      defaultAgent = v;
+    }
     let toolPolicies;
     if (b.toolPolicies !== void 0) {
       if (typeof b.toolPolicies !== "object" || b.toolPolicies === null || Array.isArray(b.toolPolicies)) {
-        return err2(c, 400, "invalid_config_value", "toolPolicies must be an object mapping tool name to ask, allow, or deny.");
+        return err3(c, 400, "invalid_config_value", "toolPolicies must be an object mapping tool name to ask, allow, or deny.");
       }
       const validated = {};
       for (const [toolName, v] of Object.entries(b.toolPolicies)) {
         if (v !== "ask" && v !== "allow" && v !== "deny") {
-          return err2(c, 400, "invalid_config_value", `toolPolicies.${toolName} must be ask, allow, or deny.`);
+          return err3(c, 400, "invalid_config_value", `toolPolicies.${toolName} must be ask, allow, or deny.`);
         }
         validated[toolName] = v;
       }
@@ -14721,6 +15798,7 @@ function registerApi(app2, d) {
       if (toolchainDirs !== void 0) cfg2.build.toolchainDirs = toolchainDirs;
       if (agentsMdProjectCandidates !== void 0) cfg2.code.agentsMdProjectCandidates = agentsMdProjectCandidates;
       if (agentsMdGlobalCandidates !== void 0) cfg2.code.agentsMdGlobalCandidates = agentsMdGlobalCandidates;
+      if (defaultAgent !== void 0) cfg2.code.defaultAgent = defaultAgent;
       if (toolPolicies !== void 0) cfg2.tools.toolPolicies = toolPolicies;
       if (b.autoAllowAll !== void 0) cfg2.tools.autoAllowAll = !!b.autoAllowAll;
       if (b.autoLoadOnStart !== void 0) cfg2.autoLoadOnStart = !!b.autoLoadOnStart;
@@ -14763,12 +15841,12 @@ function registerApi(app2, d) {
     return c.json({ ...settingsPayload(d), rebind });
   });
   app2.post("/api/v1/mcp/servers", async (c) => {
-    const b = await body2(c);
+    const b = await body3(c);
     const transport = b.transport === "sse" ? "sse" : "stdio";
-    if (!b.name?.trim()) return err2(c, 400, "invalid_config_value", "name is required.");
-    if (transport === "stdio" && !b.command?.trim()) return err2(c, 400, "invalid_config_value", "command is required for stdio transport.");
-    if (transport === "sse" && !b.url?.trim()) return err2(c, 400, "invalid_config_value", "url is required for sse transport.");
-    if (transport === "sse" && !/^https?:\/\//i.test(b.url ?? "")) return err2(c, 400, "invalid_config_value", "url must be an http(s):// address.");
+    if (!b.name?.trim()) return err3(c, 400, "invalid_config_value", "name is required.");
+    if (transport === "stdio" && !b.command?.trim()) return err3(c, 400, "invalid_config_value", "command is required for stdio transport.");
+    if (transport === "sse" && !b.url?.trim()) return err3(c, 400, "invalid_config_value", "url is required for sse transport.");
+    if (transport === "sse" && !/^https?:\/\//i.test(b.url ?? "")) return err3(c, 400, "invalid_config_value", "url must be an http(s):// address.");
     const { randomUUID: randomUUID11 } = await import("crypto");
     const server2 = {
       id: randomUUID11(),
@@ -14779,7 +15857,7 @@ function registerApi(app2, d) {
     };
     const isMemoryServer = server2.transport === "stdio" && (server2.command?.includes("server-memory") || server2.args?.some((a) => a.includes("server-memory")));
     if (isMemoryServer && !server2.env?.MEMORY_FILE_PATH) {
-      server2.env = { ...server2.env, MEMORY_FILE_PATH: join25(homedir4(), ".turbollm", "mcp-memory.jsonl") };
+      server2.env = { ...server2.env, MEMORY_FILE_PATH: join26(homedir4(), ".turbollm", "mcp-memory.jsonl") };
     }
     d.store.update((cfg2) => {
       cfg2.mcp.servers.push(server2);
@@ -14794,11 +15872,11 @@ function registerApi(app2, d) {
   });
   app2.put("/api/v1/mcp/servers/:id", async (c) => {
     const id = c.req.param("id");
-    const b = await body2(c);
+    const b = await body3(c);
     const cfg2 = d.store.snapshot();
-    if (!cfg2.mcp.servers.some((s) => s.id === id)) return err2(c, 404, "not_found", "MCP server not found.");
-    if (b.transport && b.transport !== "stdio" && b.transport !== "sse") return err2(c, 400, "invalid_config_value", "transport must be stdio or sse.");
-    if (b.url && !/^https?:\/\//i.test(b.url)) return err2(c, 400, "invalid_config_value", "url must be an http(s):// address.");
+    if (!cfg2.mcp.servers.some((s) => s.id === id)) return err3(c, 404, "not_found", "MCP server not found.");
+    if (b.transport && b.transport !== "stdio" && b.transport !== "sse") return err3(c, 400, "invalid_config_value", "transport must be stdio or sse.");
+    if (b.url && !/^https?:\/\//i.test(b.url)) return err3(c, 400, "invalid_config_value", "url must be an http(s):// address.");
     d.store.update((c2) => {
       const s = c2.mcp.servers.find((x) => x.id === id);
       if (b.name !== void 0) s.name = b.name.trim();
@@ -14820,7 +15898,7 @@ function registerApi(app2, d) {
   app2.delete("/api/v1/mcp/servers/:id", async (c) => {
     const id = c.req.param("id");
     const cfg2 = d.store.snapshot();
-    if (!cfg2.mcp.servers.some((s) => s.id === id)) return err2(c, 404, "not_found", "MCP server not found.");
+    if (!cfg2.mcp.servers.some((s) => s.id === id)) return err3(c, 404, "not_found", "MCP server not found.");
     d.store.update((c2) => {
       c2.mcp.servers = c2.mcp.servers.filter((s) => s.id !== id);
     });
@@ -14845,10 +15923,10 @@ function registerApi(app2, d) {
   });
   app2.get("/api/v1/modeldirs", (c) => c.json(modelDirsPayload(d)));
   app2.post("/api/v1/modeldirs", async (c) => {
-    const b = await body2(c);
+    const b = await body3(c);
     const dir = (b.dir ?? "").trim();
-    if (!dir || !/^([a-zA-Z]:[\\/]|[\\/])/.test(dir)) return err2(c, 400, "invalid_config_value", "Path must be absolute.");
-    if (!existsSync22(dir)) return err2(c, 400, "invalid_config_value", "That folder does not exist.");
+    if (!dir || !/^([a-zA-Z]:[\\/]|[\\/])/.test(dir)) return err3(c, 400, "invalid_config_value", "Path must be absolute.");
+    if (!existsSync22(dir)) return err3(c, 400, "invalid_config_value", "That folder does not exist.");
     try {
       d.store.update((cfg2) => {
         if (!cfg2.modelDirs.includes(dir)) cfg2.modelDirs.push(dir);
@@ -14860,7 +15938,7 @@ function registerApi(app2, d) {
     return c.json(modelDirsPayload(d), 201);
   });
   app2.delete("/api/v1/modeldirs", async (c) => {
-    const b = await body2(c);
+    const b = await body3(c);
     d.store.update((cfg2) => {
       cfg2.modelDirs = cfg2.modelDirs.filter((x) => x !== b.dir);
       if (cfg2.primaryModelDir === b.dir) cfg2.primaryModelDir = "";
@@ -14869,10 +15947,10 @@ function registerApi(app2, d) {
     return c.json(modelDirsPayload(d));
   });
   app2.post("/api/v1/modeldirs/primary", async (c) => {
-    const b = await body2(c);
+    const b = await body3(c);
     const dir = (b.dir ?? "").trim();
     if (!dir || !d.store.snapshot().modelDirs.includes(dir)) {
-      return err2(c, 400, "invalid_config_value", "Primary folder must be one of your model folders.");
+      return err3(c, 400, "invalid_config_value", "Primary folder must be one of your model folders.");
     }
     d.store.update((cfg2) => {
       cfg2.primaryModelDir = dir;
@@ -14931,7 +16009,7 @@ function registerApi(app2, d) {
     }
   });
   app2.post("/api/v1/hf/token/test", async (c) => {
-    const b = await body2(c);
+    const b = await body3(c);
     try {
       return c.json(await d.hf.testToken(b.token ?? ""));
     } catch (e) {
@@ -14940,7 +16018,7 @@ function registerApi(app2, d) {
   });
   app2.get("/api/v1/downloads", (c) => c.json({ downloads: d.downloads.list() }));
   app2.post("/api/v1/downloads", async (c) => {
-    const b = await body2(c);
+    const b = await body3(c);
     try {
       const recs = await d.downloads.enqueue(b);
       return c.json({ downloads: recs }, 202);
@@ -14950,24 +16028,24 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/downloads/:id/cancel", (c) => {
     const ok = d.downloads.cancel(c.req.param("id"));
-    if (!ok) return err2(c, 404, "no_such_download", "No download with that id.");
+    if (!ok) return err3(c, 404, "no_such_download", "No download with that id.");
     return c.json({ ok: true });
   });
   app2.post("/api/v1/downloads/:id/resume", (c) => {
     const ok = d.downloads.resume(c.req.param("id"));
-    if (!ok) return err2(c, 404, "no_such_download", "No paused or errored download with that id.");
+    if (!ok) return err3(c, 404, "no_such_download", "No paused or errored download with that id.");
     return c.json({ ok: true });
   });
   app2.delete("/api/v1/downloads/:id", (c) => {
     const ok = d.downloads.remove(c.req.param("id"));
-    if (!ok) return err2(c, 404, "no_such_download", "No download with that id.");
+    if (!ok) return err3(c, 404, "no_such_download", "No download with that id.");
     return c.json({ ok: true });
   });
   function keysHostGate(c) {
     return isLocalRequest(c, d) || d.store.snapshot().daemon.requireApiKey;
   }
   app2.get("/api/v1/keys", (c) => {
-    if (!keysHostGate(c)) return err2(c, 403, "forbidden", 'API keys are only visible from this machine until "Require an API key" is turned on.');
+    if (!keysHostGate(c)) return err3(c, 403, "forbidden", 'API keys are only visible from this machine until "Require an API key" is turned on.');
     const keys = d.store.snapshot().apiKeys.map(({ id, name, prefix, createdAt, lastUsedAt }) => ({
       id,
       name,
@@ -14978,10 +16056,10 @@ function registerApi(app2, d) {
     return c.json({ keys });
   });
   app2.post("/api/v1/keys", async (c) => {
-    if (!keysHostGate(c)) return err2(c, 403, "forbidden", 'API keys can only be created from this machine until "Require an API key" is turned on.');
-    const b = await body2(c);
+    if (!keysHostGate(c)) return err3(c, 403, "forbidden", 'API keys can only be created from this machine until "Require an API key" is turned on.');
+    const b = await body3(c);
     const name = (b.name ?? "").trim();
-    if (!name) return err2(c, 400, "invalid_config_value", "name is required.");
+    if (!name) return err3(c, 400, "invalid_config_value", "name is required.");
     const { full, hash, prefix } = generateApiKey();
     const key = {
       id: randomUUID7(),
@@ -14998,7 +16076,7 @@ function registerApi(app2, d) {
     );
   });
   app2.delete("/api/v1/keys/:id", (c) => {
-    if (!keysHostGate(c)) return err2(c, 403, "forbidden", 'API keys can only be revoked from this machine until "Require an API key" is turned on.');
+    if (!keysHostGate(c)) return err3(c, 403, "forbidden", 'API keys can only be revoked from this machine until "Require an API key" is turned on.');
     const id = c.req.param("id");
     d.store.update((cfg2) => {
       cfg2.apiKeys = cfg2.apiKeys.filter((k) => k.id !== id);
@@ -15006,7 +16084,7 @@ function registerApi(app2, d) {
     return c.json({ ok: true });
   });
   app2.get("/api/v1/connect/:cli", (c) => {
-    if (!keysHostGate(c)) return err2(c, 403, "forbidden", 'Connect setup is only available from this machine until "Require an API key" is turned on.');
+    if (!keysHostGate(c)) return err3(c, 403, "forbidden", 'Connect setup is only available from this machine until "Require an API key" is turned on.');
     const cli = c.req.param("cli");
     const cfg2 = d.store.snapshot();
     const { port: port2, lanBind } = cfg2.daemon;
@@ -15179,23 +16257,23 @@ function engineWorkBusy(d) {
 function hfErr(c, e) {
   if (e instanceof HfError) {
     const status = e.code === "hf_unauthorized" ? 401 : e.code === "hf_gated" ? 403 : e.code === "hf_not_found" ? 404 : 503;
-    return err2(c, status, e.code, e.message);
+    return err3(c, status, e.code, e.message);
   }
-  return err2(c, 500, "internal", e.message);
+  return err3(c, 500, "internal", e.message);
 }
 function dlErr(c, e) {
   if (e instanceof DownloadError) {
     const status = e.code === "no_model_dir" ? 409 : e.code === "hf_unauthorized" ? 401 : e.code === "hf_gated" ? 403 : 400;
-    return err2(c, status, e.code, e.message);
+    return err3(c, status, e.code, e.message);
   }
-  return err2(c, 500, "internal", e.message);
+  return err3(c, 500, "internal", e.message);
 }
 function benchError(c, e) {
   if (e instanceof BenchError) {
     const status = e.code === "bench_running" || e.code === "engine_in_use" || e.code === "no_active_engine" ? 409 : e.code === "no_such_model" ? 404 : 400;
-    return err2(c, status, e.code, e.message);
+    return err3(c, status, e.code, e.message);
   }
-  return err2(c, 500, "internal", e.message);
+  return err3(c, 500, "internal", e.message);
 }
 function engineBusy(d) {
   const s = d.manager.status().state;
@@ -15206,9 +16284,9 @@ function isCatalogRepo(repoUrl) {
   return catalogForPlatform().some((e) => sameRepo(repoUrl, e.homepage));
 }
 function regErr(c, e) {
-  if (e instanceof NotFoundError) return err2(c, 404, "engine_not_found", "No engine with that id.");
-  if (e instanceof ValueError) return err2(c, 400, "invalid_config_value", e.message);
-  return err2(c, 500, "internal", e.message);
+  if (e instanceof NotFoundError) return err3(c, 404, "engine_not_found", "No engine with that id.");
+  if (e instanceof ValueError) return err3(c, 400, "invalid_config_value", e.message);
+  return err3(c, 500, "internal", e.message);
 }
 function engineInstallDir(eng, enginesRoot) {
   const norm = enginesRoot.replace(/[\\/]+$/, "");
@@ -15217,19 +16295,19 @@ function engineInstallDir(eng, enginesRoot) {
     return n.startsWith(norm + "/") || n.startsWith(norm + "\\");
   };
   if (eng.kind === "mlx") {
-    const d = join25(enginesRoot, "mlx", "venv");
+    const d = join26(enginesRoot, "mlx", "venv");
     return inside(d) ? d : null;
   }
   if (eng.kind === "rapid-mlx") {
-    const d = join25(enginesRoot, "rapid-mlx", "venv");
+    const d = join26(enginesRoot, "rapid-mlx", "venv");
     return inside(d) ? d : null;
   }
   if (eng.kind === "vllm") {
-    const d = join25(enginesRoot, "vllm", "venv");
+    const d = join26(enginesRoot, "vllm", "venv");
     return inside(d) ? d : null;
   }
   if (/[\\/]engines[\\/]turboquant[\\/]/.test(eng.binPath)) {
-    const d = join25(enginesRoot, "turboquant");
+    const d = join26(enginesRoot, "turboquant");
     return inside(d) ? d : null;
   }
   if (eng.kind === "koboldcpp") {
@@ -15244,7 +16322,7 @@ function engineInstallDir(eng, enginesRoot) {
   if (srcDir) return inside(srcDir) ? srcDir : null;
   const llamaMatch = eng.binPath.replace(/\\/g, "/").match(/\/(llama\.cpp-[^/]+)\//i);
   if (llamaMatch) {
-    const d = join25(enginesRoot, llamaMatch[1]);
+    const d = join26(enginesRoot, llamaMatch[1]);
     return inside(d) ? d : null;
   }
   return null;
@@ -15262,7 +16340,7 @@ function cleanModelName(p) {
 function readTail2(path, n) {
   if (!path || !existsSync22(path)) return [];
   try {
-    const lines = readFileSync10(path, "utf8").replace(/[\r\n]+$/, "").split("\n").map((l) => l.replace(/\r$/, ""));
+    const lines = readFileSync11(path, "utf8").replace(/[\r\n]+$/, "").split("\n").map((l) => l.replace(/\r$/, ""));
     return lines.length > n ? lines.slice(-n) : lines;
   } catch {
     return [];
@@ -15453,10 +16531,10 @@ function buildConnectSnippets(cli, base2, apiKey, modelName, modelKey = modelNam
 
 // src/chat/chat-agent-routes.ts
 import { randomUUID as randomUUID8 } from "crypto";
-function err3(c, status, code, message) {
+function err4(c, status, code, message) {
   return c.json({ error: { code, message } }, status);
 }
-async function body3(c) {
+async function body4(c) {
   try {
     return await c.req.json();
   } catch {
@@ -15471,8 +16549,8 @@ function registerChatAgentRoutes(app2, d) {
   app2.get("/api/v1/chat-agents/builtin-overrides", (c) => c.json(d.store.snapshot().builtinAgentOverrides));
   app2.put("/api/v1/chat-agents/builtin-overrides/:id", async (c) => {
     const id = c.req.param("id");
-    if (!id.trim()) return err3(c, 400, "invalid_config_value", "id is required.");
-    const b = await body3(c);
+    if (!id.trim()) return err4(c, 400, "invalid_config_value", "id is required.");
+    const b = await body4(c);
     const override = {};
     if (b.name !== void 0) override.name = b.name.trim();
     if (b.description !== void 0) override.description = b.description.trim();
@@ -15480,7 +16558,7 @@ function registerChatAgentRoutes(app2, d) {
     if (b.skillIds !== void 0) override.skillIds = sanitizeStringArray(b.skillIds);
     if (b.tools !== void 0) override.tools = sanitizeStringArray(b.tools);
     if (Object.keys(d.store.snapshot().builtinAgentOverrides).length >= AGENT_CAP && !(id in d.store.snapshot().builtinAgentOverrides)) {
-      return err3(c, 400, "too_many_agents", `Override limit reached (${AGENT_CAP}).`);
+      return err4(c, 400, "too_many_agents", `Override limit reached (${AGENT_CAP}).`);
     }
     d.store.update((cfg2) => {
       cfg2.builtinAgentOverrides[id] = override;
@@ -15496,10 +16574,10 @@ function registerChatAgentRoutes(app2, d) {
   });
   app2.get("/api/v1/chat-agents", (c) => c.json(d.store.snapshot().customAgents));
   app2.post("/api/v1/chat-agents", async (c) => {
-    const b = await body3(c);
-    if (!b.name?.trim()) return err3(c, 400, "invalid_config_value", "name is required.");
+    const b = await body4(c);
+    if (!b.name?.trim()) return err4(c, 400, "invalid_config_value", "name is required.");
     if (d.store.snapshot().customAgents.length >= AGENT_CAP) {
-      return err3(c, 400, "too_many_agents", `Agent limit reached (${AGENT_CAP}).`);
+      return err4(c, 400, "too_many_agents", `Agent limit reached (${AGENT_CAP}).`);
     }
     const agent = {
       id: randomUUID8(),
@@ -15517,10 +16595,10 @@ function registerChatAgentRoutes(app2, d) {
   app2.put("/api/v1/chat-agents/:id", async (c) => {
     const id = c.req.param("id");
     if (!d.store.snapshot().customAgents.some((a) => a.id === id)) {
-      return err3(c, 404, "not_found", "Agent not found.");
+      return err4(c, 404, "not_found", "Agent not found.");
     }
-    const b = await body3(c);
-    if (b.name !== void 0 && !b.name.trim()) return err3(c, 400, "invalid_config_value", "name is required.");
+    const b = await body4(c);
+    if (b.name !== void 0 && !b.name.trim()) return err4(c, 400, "invalid_config_value", "name is required.");
     d.store.update((cfg2) => {
       const a = cfg2.customAgents.find((x) => x.id === id);
       if (b.name !== void 0) a.name = b.name.trim();
@@ -15534,7 +16612,7 @@ function registerChatAgentRoutes(app2, d) {
   app2.delete("/api/v1/chat-agents/:id", (c) => {
     const id = c.req.param("id");
     if (!d.store.snapshot().customAgents.some((a) => a.id === id)) {
-      return err3(c, 404, "not_found", "Agent not found.");
+      return err4(c, 404, "not_found", "Agent not found.");
     }
     d.store.update((cfg2) => {
       cfg2.customAgents = cfg2.customAgents.filter((a) => a.id !== id);
@@ -15544,10 +16622,10 @@ function registerChatAgentRoutes(app2, d) {
 }
 
 // src/agents/agent-routes.ts
-function err4(c, status, code, message) {
+function err5(c, status, code, message) {
   return c.json({ error: { code, message } }, status);
 }
-async function body4(c) {
+async function body5(c) {
   try {
     return await c.req.json();
   } catch {
@@ -15559,14 +16637,14 @@ function registerAgentRoutes(app2, d) {
   const SKILL_CAP = 200;
   app2.get("/api/v1/skills", (c) => c.json(skills().list()));
   app2.post("/api/v1/skills", async (c) => {
-    if (!isLocalOrAuthenticated(c, d)) return err4(c, 403, "forbidden", "Skills can only be authored on the machine running TurboLLM.");
-    const b = await body4(c);
-    if (!b.id?.trim() || !/^[a-z0-9-]+$/.test(b.id)) return err4(c, 400, "invalid_config_value", "id must be kebab-case (a-z0-9-).");
-    if (!b.name?.trim()) return err4(c, 400, "invalid_config_value", "name is required.");
-    if (isBuiltinSkill(b.id)) return err4(c, 400, "builtin_skill", "Cannot overwrite a built-in skill.");
-    if (!b.instructions?.trim()) return err4(c, 400, "invalid_config_value", "instructions are required.");
+    if (!isLocalOrAuthenticated(c, d)) return err5(c, 403, "forbidden", "Skills can only be authored on the machine running TurboLLM.");
+    const b = await body5(c);
+    if (!b.id?.trim() || !/^[a-z0-9-]+$/.test(b.id)) return err5(c, 400, "invalid_config_value", "id must be kebab-case (a-z0-9-).");
+    if (!b.name?.trim()) return err5(c, 400, "invalid_config_value", "name is required.");
+    if (isBuiltinSkill(b.id)) return err5(c, 400, "builtin_skill", "Cannot overwrite a built-in skill.");
+    if (!b.instructions?.trim()) return err5(c, 400, "invalid_config_value", "instructions are required.");
     const lib = skills().list();
-    if (!lib.some((s) => s.id === b.id) && lib.length >= SKILL_CAP) return err4(c, 400, "too_many_skills", `Skill limit reached (${SKILL_CAP}).`);
+    if (!lib.some((s) => s.id === b.id) && lib.length >= SKILL_CAP) return err5(c, 400, "too_many_skills", `Skill limit reached (${SKILL_CAP}).`);
     const skill = {
       id: b.id.trim(),
       name: b.name.trim(),
@@ -15578,37 +16656,37 @@ function registerAgentRoutes(app2, d) {
     return c.json(skill, 201);
   });
   app2.delete("/api/v1/skills/:id", (c) => {
-    if (!isLocalOrAuthenticated(c, d)) return err4(c, 403, "forbidden", "Skills can only be modified on the machine running TurboLLM.");
+    if (!isLocalOrAuthenticated(c, d)) return err5(c, 403, "forbidden", "Skills can only be modified on the machine running TurboLLM.");
     const id = c.req.param("id");
-    if (!isValidSkillId(id)) return err4(c, 400, "invalid_config_value", "invalid skill id.");
-    if (isBuiltinSkill(id)) return err4(c, 400, "builtin_skill", "Built-in skills cannot be deleted.");
+    if (!isValidSkillId(id)) return err5(c, 400, "invalid_config_value", "invalid skill id.");
+    if (isBuiltinSkill(id)) return err5(c, 400, "builtin_skill", "Built-in skills cannot be deleted.");
     skills().delete(id);
     return c.json({ ok: true });
   });
   app2.post("/api/v1/skills/import", async (c) => {
-    if (!isLocalOrAuthenticated(c, d)) return err4(c, 403, "forbidden", "Skills can only be authored on the machine running TurboLLM.");
-    const b = await body4(c);
+    if (!isLocalOrAuthenticated(c, d)) return err5(c, 403, "forbidden", "Skills can only be authored on the machine running TurboLLM.");
+    const b = await body5(c);
     const text = b.text?.trim();
-    if (!text) return err4(c, 400, "invalid_input", "text is required.");
+    if (!text) return err5(c, 400, "invalid_input", "text is required.");
     const draft = fromSkillMd("draft", text);
-    if (!draft?.name) return err4(c, 400, "invalid_input", "Could not parse a SKILL.md \u2014 expected YAML frontmatter (name/description/tools) followed by an instructions body.");
+    if (!draft?.name) return err5(c, 400, "invalid_input", "Could not parse a SKILL.md \u2014 expected YAML frontmatter (name/description/tools) followed by an instructions body.");
     const id = toSkillId(draft.name);
-    if (!id) return err4(c, 400, "invalid_input", "Could not derive a valid id from the skill name.");
-    if (isBuiltinSkill(id)) return err4(c, 400, "builtin_skill", "Cannot overwrite a built-in skill.");
+    if (!id) return err5(c, 400, "invalid_input", "Could not derive a valid id from the skill name.");
+    if (isBuiltinSkill(id)) return err5(c, 400, "builtin_skill", "Cannot overwrite a built-in skill.");
     const store2 = skills();
     const lib = store2.list();
-    if (!lib.some((s) => s.id === id) && lib.length >= SKILL_CAP) return err4(c, 400, "too_many_skills", `Skill limit reached (${SKILL_CAP}).`);
+    if (!lib.some((s) => s.id === id) && lib.length >= SKILL_CAP) return err5(c, 400, "too_many_skills", `Skill limit reached (${SKILL_CAP}).`);
     const skill = { id, name: draft.name, description: draft.description, instructions: draft.instructions, tools: draft.tools };
     store2.write(skill);
     return c.json(skill, 201);
   });
   app2.post("/api/v1/skills/learn-folder", async (c) => {
-    if (!isLocalOrAuthenticated(c, d)) return err4(c, 403, "forbidden", "Local host only.");
-    const b = await body4(c);
+    if (!isLocalOrAuthenticated(c, d)) return err5(c, 403, "forbidden", "Local host only.");
+    const b = await body5(c);
     const folder = b.folder?.trim();
-    if (!folder) return err4(c, 400, "invalid_input", "folder is required.");
+    if (!folder) return err5(c, 400, "invalid_input", "folder is required.");
     const store2 = skills();
-    if (store2.userSkills().length >= SKILL_CAP) return err4(c, 400, "skill_cap", `Skill limit reached (${SKILL_CAP}).`);
+    if (store2.userSkills().length >= SKILL_CAP) return err5(c, 400, "skill_cap", `Skill limit reached (${SKILL_CAP}).`);
     const taskId = d.agentTasks?.start("skill_from_folder", "skills", `Learning from ${folder}`);
     void (async () => {
       try {
@@ -15629,7 +16707,7 @@ function registerAgentRoutes(app2, d) {
           return;
         }
         if (taskId) d.agentTasks?.step(taskId, "No skill files found \u2014 distilling from the folder\u2026");
-        const { distillSkillsFromFolder } = await import("./distiller-MRW6VEYO.js");
+        const { distillSkillsFromFolder } = await import("./distiller-6E6IOZ5G.js");
         const distilled = await distillSkillsFromFolder(d, folder, {
           max: Math.max(0, SKILL_CAP - store2.userSkills().length),
           onProgress: (done, total, file) => {
@@ -15663,10 +16741,10 @@ function registerAgentRoutes(app2, d) {
 import { streamSSE as streamSSE3 } from "hono/streaming";
 
 // src/code/code-run-manager.ts
-import { EventEmitter } from "events";
+import { EventEmitter as EventEmitter2 } from "events";
 
 // src/code/code-session.ts
-import { join as join28, resolve as resolve3 } from "path";
+import { join as join29, resolve as resolve3 } from "path";
 import { readFile as readFile2 } from "fs/promises";
 import { Type, Unsafe } from "typebox";
 import {
@@ -15734,11 +16812,11 @@ function waitForChildProcess(child) {
       stderrEnded = true;
       maybeFinalizeAfterExit();
     };
-    const onError = (err6) => {
+    const onError = (err7) => {
       if (settled) return;
       settled = true;
       cleanup();
-      reject(err6);
+      reject(err7);
     };
     const onExit = (code) => {
       exited = true;
@@ -15895,7 +16973,7 @@ Cannot execute bash commands.`);
 
 // src/code/containment.ts
 import { realpathSync as realpathSync2 } from "fs";
-import { resolve as resolve2, dirname as dirname10, basename as basename4, join as join26, sep } from "path";
+import { resolve as resolve2, dirname as dirname10, basename as basename4, join as join27, sep } from "path";
 var isWin = process.platform === "win32";
 function canonicalize(input) {
   if (typeof input !== "string" || input.length === 0) return null;
@@ -15911,7 +16989,7 @@ function canonicalize(input) {
   for (let i = 0; i < 4096; i++) {
     try {
       const real = realpathSync2(cur);
-      const full = tail.length ? join26(real, ...[...tail].reverse()) : real;
+      const full = tail.length ? join27(real, ...[...tail].reverse()) : real;
       return normForCompare(full);
     } catch {
       const parent = dirname10(cur);
@@ -15954,8 +17032,8 @@ function isContainedFromRoot(input, root) {
 }
 
 // src/code/persona.ts
-import { readFileSync as readFileSync11 } from "fs";
-import { join as join27 } from "path";
+import { readFileSync as readFileSync12 } from "fs";
+import { join as join28 } from "path";
 var MAX_SKILL_CATALOG_CHARS = 16e3;
 var MAX_AGENTS_MD_CHARS = 2e4;
 var MAX_AGENTS_MD_CANDIDATES = 8;
@@ -16073,7 +17151,7 @@ function skillCatalogBlock(skills) {
 }
 function readAgentsFile(path) {
   try {
-    const text = readFileSync11(path, "utf8").trim();
+    const text = readFileSync12(path, "utf8").trim();
     if (!text) return null;
     return text.length > MAX_AGENTS_MD_CHARS ? text.slice(0, MAX_AGENTS_MD_CHARS) : text;
   } catch {
@@ -16083,7 +17161,7 @@ function readAgentsFile(path) {
 function resolveAgentsFile(root, candidates) {
   for (const entry of candidates.slice(0, MAX_AGENTS_MD_CANDIDATES)) {
     if (!isContainedFromRoot(entry, root)) continue;
-    const text = readAgentsFile(join27(root, entry));
+    const text = readAgentsFile(join28(root, entry));
     if (text !== null) return { name: entry, text };
   }
   return null;
@@ -16397,6 +17475,7 @@ function resolveEffectiveHistory(d, convId, sessionId) {
 }
 var PI_DEFAULT_RESERVE_TOKENS = 16384;
 var PI_DEFAULT_KEEP_RECENT_TOKENS = 2e4;
+var PI_MAX_OUTPUT_TOKENS = 8192;
 function compactionSettingsFor(contextWindow) {
   const reserveTokens = Math.max(512, Math.min(PI_DEFAULT_RESERVE_TOKENS, Math.round(contextWindow * 0.15)));
   const keepRecentTokens = Math.max(1024, Math.min(PI_DEFAULT_KEEP_RECENT_TOKENS, Math.round(contextWindow * 0.35)));
@@ -16613,7 +17692,7 @@ async function runCodeSession(params) {
     console.warn(`[code-session] history seed for session ${sessionId} produced ${sessionManager.getEntries().length}/${expectedEntries} expected entries \u2014 falling back to a plain-text history prefix on this turn's prompt`);
     task = `${HISTORY_FALLBACK_PREFIX}${renderHistoryFallbackText(summaryText, priorMessages)}${HISTORY_FALLBACK_SUFFIX}${rawTask}`;
   }
-  const agentDir = join28(d.store.dir(), "pi-agent");
+  const agentDir = join29(d.store.dir(), "pi-agent");
   modelRegistry.registerProvider("local", {
     baseUrl: `${target}/v1`,
     apiKey: "agent-key",
@@ -16627,7 +17706,7 @@ async function runCodeSession(params) {
         input: ["text"],
         cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
         contextWindow,
-        maxTokens: 8192,
+        maxTokens: PI_MAX_OUTPUT_TOKENS,
         // qwen-chat-template thinking control matches how TurboLLM drives local chat models.
         compat: { supportsDeveloperRole: false, thinkingFormat: "qwen-chat-template" }
       }
@@ -16672,7 +17751,7 @@ async function runCodeSession(params) {
         input: ["text"],
         cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
         contextWindow,
-        maxTokens: 8192,
+        maxTokens: PI_MAX_OUTPUT_TOKENS,
         compat: { supportsDeveloperRole: false, thinkingFormat: "qwen-chat-template" }
       }]
     });
@@ -16744,7 +17823,7 @@ async function runCodeSession(params) {
         await sink({ event: "tool_call", data });
       });
     };
-    const skillAgentDir = join28(d.store.dir(), "pi-agent");
+    const skillAgentDir = join29(d.store.dir(), "pi-agent");
     const skillResourceLoader = new DefaultResourceLoader({
       cwd: repoRoot,
       agentDir: skillAgentDir,
@@ -16806,7 +17885,7 @@ async function runCodeSession(params) {
         input: ["text"],
         cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
         contextWindow,
-        maxTokens: 8192,
+        maxTokens: PI_MAX_OUTPUT_TOKENS,
         compat: { supportsDeveloperRole: false, thinkingFormat: "qwen-chat-template" }
       }]
     });
@@ -16887,7 +17966,7 @@ async function runCodeSession(params) {
         await sink({ event: "tool_call", data });
       });
     };
-    const subAgentDir = join28(d.store.dir(), "pi-agent");
+    const subAgentDir = join29(d.store.dir(), "pi-agent");
     const subResourceLoader = new DefaultResourceLoader({
       cwd: repoRoot,
       agentDir: subAgentDir,
@@ -17426,7 +18505,7 @@ async function compactCodeSession(params) {
       input: ["text"],
       cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
       contextWindow,
-      maxTokens: 8192,
+      maxTokens: PI_MAX_OUTPUT_TOKENS,
       compat: { supportsDeveloperRole: false, thinkingFormat: "qwen-chat-template" }
     }]
   });
@@ -17445,7 +18524,7 @@ async function compactCodeSession(params) {
       return payload;
     });
   };
-  const compactAgentDir = join28(d.store.dir(), "pi-agent");
+  const compactAgentDir = join29(d.store.dir(), "pi-agent");
   const compactResourceLoader = new DefaultResourceLoader({
     cwd: repoRoot,
     agentDir: compactAgentDir,
@@ -17529,7 +18608,7 @@ async function lookbackPreCompactionHistory(params) {
       input: ["text"],
       cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
       contextWindow,
-      maxTokens: 8192,
+      maxTokens: PI_MAX_OUTPUT_TOKENS,
       compat: { supportsDeveloperRole: false, thinkingFormat: "qwen-chat-template" }
     }]
   });
@@ -17547,7 +18626,7 @@ async function lookbackPreCompactionHistory(params) {
       return payload;
     });
   };
-  const lookbackAgentDir = join28(d.store.dir(), "pi-agent");
+  const lookbackAgentDir = join29(d.store.dir(), "pi-agent");
   const lookbackResourceLoader = new DefaultResourceLoader({
     cwd: repoRoot,
     agentDir: lookbackAgentDir,
@@ -17659,7 +18738,7 @@ var CodeRunManager = class {
   ensure(sessionId, convId, repoRoot) {
     let s = this.sessions.get(sessionId);
     if (!s) {
-      const emitter = new EventEmitter();
+      const emitter = new EventEmitter2();
       emitter.setMaxListeners(0);
       s = { convId, repoRoot, buffer: new RingBuffer(), emitter, queue: [], active: null, replayFloor: 0, todos: [] };
       this.sessions.set(sessionId, s);
@@ -17932,7 +19011,7 @@ var CodeRunManager = class {
    */
   subscribe(sessionId, fromSeq) {
     const s = this.sessions.get(sessionId);
-    if (!s) return subscribeToBuffer(new RingBuffer(), new EventEmitter(), { fromSeq: 0, replayFloor: 0, idleAtStart: true });
+    if (!s) return subscribeToBuffer(new RingBuffer(), new EventEmitter2(), { fromSeq: 0, replayFloor: 0, idleAtStart: true });
     return subscribeToBuffer(s.buffer, s.emitter, {
       fromSeq,
       replayFloor: s.replayFloor,
@@ -17994,7 +19073,7 @@ function subscribeToBuffer(buffer, emitter, opts) {
 }
 
 // src/code/revert.ts
-import { existsSync as existsSync23, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync13, writeFileSync as writeFileSync13 } from "fs";
 import { resolve as resolve4 } from "path";
 import { applyPatch, parsePatch, reversePatch } from "diff";
 function revertFileEdits(messages, repoRoot) {
@@ -18023,7 +19102,7 @@ function revertFileEdits(messages, repoRoot) {
     }
     let content;
     try {
-      content = readFileSync12(absPath, "utf8");
+      content = readFileSync13(absPath, "utf8");
     } catch {
       failed.push(path);
       continue;
@@ -18052,7 +19131,7 @@ function revertFileEdits(messages, repoRoot) {
       continue;
     }
     try {
-      writeFileSync12(absPath, content);
+      writeFileSync13(absPath, content);
       reverted.push(path);
     } catch {
       failed.push(path);
@@ -18070,9 +19149,9 @@ function truncateForExport(text, limit = EXPORT_TRUNCATE_LIMIT) {
 
 \u2026 [truncated \u2014 ${cut.toLocaleString()} more character${cut === 1 ? "" : "s"}] \u2026`;
 }
-function fence(lang, body6) {
+function fence(lang, body7) {
   return `\`\`\`${lang}
-${body6}
+${body7}
 \`\`\``;
 }
 function renderReasoning(reasoning) {
@@ -18152,14 +19231,14 @@ function serializeCodeSessionMarkdown(run, conv, opts = {}) {
     `- **Exported:** ${exportedAt}`
   ].filter((line) => !!line);
   const messages = (conv.messages ?? []).slice().sort((a, b) => a.seq - b.seq);
-  const body6 = messages.length ? messages.map(renderMessage).join("\n\n---\n\n") : "*(no messages in this session yet)*";
+  const body7 = messages.length ? messages.map(renderMessage).join("\n\n---\n\n") : "*(no messages in this session yet)*";
   return `# ${title}
 
 ${meta.join("\n")}
 
 ---
 
-${body6}
+${body7}
 `;
 }
 var MAX_FILENAME_SLUG = 80;
@@ -18342,21 +19421,21 @@ async function runShellCommand(command, repoRoot, sessionLabel, opts) {
   }
 }
 function shellContextText(result) {
-  const body6 = result.output.trim() || "(no output)";
+  const body7 = result.output.trim() || "(no output)";
   const status = result.timedOut ? ` (timed out after ${SHELL_TIMEOUT_SEC}s)` : result.exitCode !== null && result.exitCode !== 0 ? ` (exit code ${result.exitCode})` : "";
   const trunc = result.truncated ? "\n\u2026(output truncated)" : "";
   return `I ran a shell command in the repo${status}:
 
 $ ${result.command}
 
-${body6}${trunc}`;
+${body7}${trunc}`;
 }
 
 // src/code/code-routes.ts
-function err5(c, s, code, msg2) {
+function err6(c, s, code, msg2) {
   return c.json({ error: { code, message: msg2 } }, s);
 }
-async function body5(c) {
+async function body6(c) {
   try {
     return await c.req.json();
   } catch {
@@ -18420,6 +19499,7 @@ function toSidebarRow(run) {
     // filled from CodeRunManager below when available
     createdAt: run.createdAt,
     repoRoot: run.repoRoot ?? "",
+    codeAgent: run.codeAgent ?? "turbollm",
     error: run.error,
     archivedAt: run.archivedAt,
     clearedUpToMessageId: run.clearedUpToMessageId,
@@ -18431,15 +19511,16 @@ function registerCodeRoutes(app2, d) {
   const runs = new CodeRunManager(d);
   runs.reconcileOnStartup();
   app2.post("/api/v1/code/sessions", async (c) => {
-    const b = await body5(c);
+    const b = await body6(c);
     const repoRoot = (b.repoRoot ?? "").trim();
     const task = (b.task ?? "").trim();
     const mode = b.mode ?? "auto";
-    if (!repoRoot) return err5(c, 400, "invalid_input", "repoRoot is required.");
-    if (!task) return err5(c, 400, "invalid_input", "A task description is required.");
-    if (!VALID_MODES.has(mode)) return err5(c, 400, "invalid_input", "mode must be one of: auto, plan, ask.");
+    if (!repoRoot) return err6(c, 400, "invalid_input", "repoRoot is required.");
+    if (!task) return err6(c, 400, "invalid_input", "A task description is required.");
+    if (!VALID_MODES.has(mode)) return err6(c, 400, "invalid_input", "mode must be one of: auto, plan, ask.");
     const conv = db2.createConversation({ kind: "code", modelKey: b.modelKey });
     db2.setConversationMode(conv.id, mode);
+    const codeAgent = d.store.snapshot().code.defaultAgent;
     const run = db2.createAgentRun({
       convId: conv.id,
       title: task.slice(0, 60),
@@ -18450,8 +19531,9 @@ function registerCodeRoutes(app2, d) {
       // captured; NOT acted on in Phase 1 (fast-follow)
       worktreeBranch: b.worktreeBranch,
       // captured; NOT acted on in Phase 1
-      worktreeBase: b.worktreeBase
+      worktreeBase: b.worktreeBase,
       // captured; NOT acted on in Phase 1
+      codeAgent
     });
     db2.addMessage(conv.id, "user", task, { textAttachments: b.contextFiles });
     return c.json({ sessionId: run.id, convId: conv.id }, 201);
@@ -18480,9 +19562,9 @@ function registerCodeRoutes(app2, d) {
   });
   app2.get("/api/v1/code/sessions/:id", (c) => {
     const run = db2.getAgentRun(c.req.param("id"));
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
     const conv = db2.getConversation(run.convId, true);
-    if (!conv) return err5(c, 404, "not_found", "Session conversation not found.");
+    if (!conv) return err6(c, 404, "not_found", "Session conversation not found.");
     return c.json({
       session: { ...toSidebarRow(run), mode: conv.agentMode },
       conversation: conv,
@@ -18512,11 +19594,11 @@ function registerCodeRoutes(app2, d) {
   app2.get("/api/v1/code/sessions/:id/export", (c) => {
     const id = c.req.param("id");
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
     const conv = db2.getConversation(run.convId, true);
-    if (!conv) return err5(c, 404, "not_found", "Session conversation not found.");
+    if (!conv) return err6(c, 404, "not_found", "Session conversation not found.");
     const format = c.req.query("format") === "html" ? "html" : "markdown";
-    if (format === "html") return err5(c, 400, "unsupported_format", "HTML export is not available yet \u2014 use format=markdown.");
+    if (format === "html") return err6(c, 400, "unsupported_format", "HTML export is not available yet \u2014 use format=markdown.");
     const md = serializeCodeSessionMarkdown(run, conv);
     const filename = codeSessionExportFilename(run.title, run.createdAt, "md");
     c.header("Content-Disposition", `attachment; filename="${filename}"`);
@@ -18526,38 +19608,53 @@ function registerCodeRoutes(app2, d) {
   app2.patch("/api/v1/code/sessions/:id/mode", async (c) => {
     const id = c.req.param("id");
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
-    const b = await body5(c);
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    const b = await body6(c);
     const mode = b.mode ?? "";
-    if (!VALID_MODES.has(mode)) return err5(c, 400, "invalid_input", "mode must be one of: auto, plan, ask.");
+    if (!VALID_MODES.has(mode)) return err6(c, 400, "invalid_input", "mode must be one of: auto, plan, ask.");
     db2.setConversationMode(run.convId, mode);
     return c.json({ ok: true, mode });
   });
+  app2.patch("/api/v1/code/sessions/:id/thinking-budget", async (c) => {
+    const id = c.req.param("id");
+    const run = db2.getAgentRun(id);
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    const b = await body6(c);
+    const tokens = typeof b.tokens === "number" && Number.isFinite(b.tokens) ? Math.floor(b.tokens) : -1;
+    sessionAuth.setThinkingBudget(run.id, tokens === -1 ? null : tokens);
+    return c.json({ ok: true, tokens });
+  });
+  app2.get("/api/v1/code/sessions/:id/last-usage", (c) => {
+    const id = c.req.param("id");
+    const run = db2.getAgentRun(id);
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    return c.json({ usage: db2.getLastApiUsageForSession(run.id) });
+  });
   app2.patch("/api/v1/code/sessions/:id/title", async (c) => {
     const id = c.req.param("id");
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
-    const b = await body5(c);
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    const b = await body6(c);
     const title = (b.title ?? "").trim();
-    if (!title) return err5(c, 400, "invalid_input", "title is required.");
+    if (!title) return err6(c, 400, "invalid_input", "title is required.");
     db2.updateAgentRun(id, { title });
     return c.json({ ok: true, title });
   });
   app2.post("/api/v1/code/sessions/:id/archive", async (c) => {
     const id = c.req.param("id");
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
-    const b = await body5(c);
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    const b = await body6(c);
     const archived = b.archived !== false;
-    if (archived && runs.isActive(id)) return err5(c, 409, "run_active", "Stop the current run before archiving this session.");
+    if (archived && runs.isActive(id)) return err6(c, 409, "run_active", "Stop the current run before archiving this session.");
     db2.setAgentRunArchived(id, archived);
     return c.json({ ok: true, archived });
   });
   app2.delete("/api/v1/code/sessions/:id", (c) => {
     const id = c.req.param("id");
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
-    if (runs.isActive(id)) return err5(c, 409, "run_active", "Stop the current run before deleting this session.");
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    if (runs.isActive(id)) return err6(c, 409, "run_active", "Stop the current run before deleting this session.");
     disposeLspClientsForConv(run.convId);
     db2.deleteCodeSession(id);
     return c.json({ ok: true });
@@ -18565,13 +19662,13 @@ function registerCodeRoutes(app2, d) {
   app2.post("/api/v1/code/sessions/:id/compact", async (c) => {
     const id = c.req.param("id");
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
-    if (!run.repoRoot) return err5(c, 400, "invalid_input", "Session has no repo root.");
-    if (runs.isActive(id)) return err5(c, 409, "run_active", "Stop or wait for the current run before compacting.");
-    if (run.clearedUpToMessageId) return err5(c, 409, "session_cleared", "Resume this session before compacting \u2014 compacting a cleared session would lose the hidden history.");
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    if (!run.repoRoot) return err6(c, 400, "invalid_input", "Session has no repo root.");
+    if (runs.isActive(id)) return err6(c, 409, "run_active", "Stop or wait for the current run before compacting.");
+    if (run.clearedUpToMessageId) return err6(c, 409, "session_cleared", "Resume this session before compacting \u2014 compacting a cleared session would lose the hidden history.");
     const ms = d.manager.status();
-    if (ms.state !== "running" || !ms.model) return err5(c, 409, "model_not_loaded", "Load a model first.");
-    const b = await body5(c);
+    if (ms.state !== "running" || !ms.model) return err6(c, 409, "model_not_loaded", "Load a model first.");
+    const b = await body6(c);
     try {
       const result = await compactCodeSession({
         d,
@@ -18583,21 +19680,21 @@ function registerCodeRoutes(app2, d) {
       return c.json({ ok: true, ...result });
     } catch (e) {
       const message = e instanceof Error ? e.message : String(e);
-      if (message === "nothing_to_compact") return err5(c, 400, "nothing_to_compact", "Nothing to compact yet \u2014 history is already short enough.");
-      if (message === "session_cleared") return err5(c, 409, "session_cleared", "Resume this session before compacting \u2014 compacting a cleared session would lose the hidden history.");
-      return err5(c, 500, "compact_failed", message);
+      if (message === "nothing_to_compact") return err6(c, 400, "nothing_to_compact", "Nothing to compact yet \u2014 history is already short enough.");
+      if (message === "session_cleared") return err6(c, 409, "session_cleared", "Resume this session before compacting \u2014 compacting a cleared session would lose the hidden history.");
+      return err6(c, 500, "compact_failed", message);
     }
   });
   app2.post("/api/v1/code/sessions/:id/clear", (c) => {
     const id = c.req.param("id");
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
-    if (runs.isActive(id)) return err5(c, 409, "run_active", "Stop or wait for the current run before clearing.");
-    if (run.revertedFromMessageId) return err5(c, 409, "session_reverted", "Resume this session before clearing \u2014 it currently has a reverted message pending.");
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    if (runs.isActive(id)) return err6(c, 409, "run_active", "Stop or wait for the current run before clearing.");
+    if (run.revertedFromMessageId) return err6(c, 409, "session_reverted", "Resume this session before clearing \u2014 it currently has a reverted message pending.");
     const conv = db2.getConversation(run.convId, true);
     const lastMsg = (conv?.messages ?? []).at(-1);
-    if (!lastMsg) return err5(c, 400, "nothing_to_clear", "Nothing to clear yet.");
-    if (run.clearedUpToMessageId === lastMsg.id) return err5(c, 400, "nothing_to_clear", "Already cleared up to the latest message.");
+    if (!lastMsg) return err6(c, 400, "nothing_to_clear", "Nothing to clear yet.");
+    if (run.clearedUpToMessageId === lastMsg.id) return err6(c, 400, "nothing_to_clear", "Already cleared up to the latest message.");
     db2.deactivateMessagesUpTo(run.convId, lastMsg.id);
     db2.setClearedUpToMessageId(id, lastMsg.id);
     return c.json({ ok: true, clearedUpToMessageId: lastMsg.id });
@@ -18605,36 +19702,36 @@ function registerCodeRoutes(app2, d) {
   app2.post("/api/v1/code/sessions/:id/resume", (c) => {
     const id = c.req.param("id");
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
-    if (runs.isActive(id)) return err5(c, 409, "run_active", "Stop or wait for the current run before resuming.");
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    if (runs.isActive(id)) return err6(c, 409, "run_active", "Stop or wait for the current run before resuming.");
     if (run.revertedFromMessageId) {
       db2.reactivateMessagesFrom(run.convId, run.revertedFromMessageId);
       db2.setRevertedFromMessageId(id, null);
       return c.json({ ok: true });
     }
-    if (!run.clearedUpToMessageId) return err5(c, 400, "not_cleared", "This session has not been cleared.");
+    if (!run.clearedUpToMessageId) return err6(c, 400, "not_cleared", "This session has not been cleared.");
     db2.reactivateMessagesUpTo(run.convId, run.clearedUpToMessageId);
     db2.setClearedUpToMessageId(id, null);
     return c.json({ ok: true });
   });
   app2.post("/api/v1/code/sessions/:id/revert", async (c) => {
     const id = c.req.param("id");
-    const b = await body5(c);
+    const b = await body6(c);
     const messageId = (b.messageId ?? "").trim();
-    if (!messageId) return err5(c, 400, "invalid_input", "messageId is required.");
+    if (!messageId) return err6(c, 400, "invalid_input", "messageId is required.");
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
-    if (!run.repoRoot) return err5(c, 400, "invalid_input", "Session has no repo root.");
-    if (runs.isActive(id)) return err5(c, 409, "run_active", "Stop or wait for the current run before reverting.");
-    if (run.clearedUpToMessageId) return err5(c, 409, "session_cleared", "Resume this session before reverting \u2014 it currently has cleared messages pending.");
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    if (!run.repoRoot) return err6(c, 400, "invalid_input", "Session has no repo root.");
+    if (runs.isActive(id)) return err6(c, 409, "run_active", "Stop or wait for the current run before reverting.");
+    if (run.clearedUpToMessageId) return err6(c, 409, "session_cleared", "Resume this session before reverting \u2014 it currently has cleared messages pending.");
     const conv = db2.getConversation(run.convId, true);
-    if (!conv) return err5(c, 404, "not_found", "Session conversation not found.");
+    if (!conv) return err6(c, 404, "not_found", "Session conversation not found.");
     const messages = conv.messages ?? [];
     const cut = resolveRevertCut(messages, messageId);
     if (!cut.ok) {
-      if (cut.error === "not_found") return err5(c, 404, "not_found", "Message not found.");
-      if (cut.error === "not_a_user_message") return err5(c, 400, "invalid_input", "Can only revert to a user message.");
-      return err5(c, 400, "invalid_input", "This is the first message in the session \u2014 nothing before it to revert to.");
+      if (cut.error === "not_found") return err6(c, 404, "not_found", "Message not found.");
+      if (cut.error === "not_a_user_message") return err6(c, 400, "invalid_input", "Can only revert to a user message.");
+      return err6(c, 400, "invalid_input", "This is the first message in the session \u2014 nothing before it to revert to.");
     }
     let revertedFiles = [];
     let failedFiles = [];
@@ -18650,48 +19747,48 @@ function registerCodeRoutes(app2, d) {
   });
   app2.get("/api/v1/code/sessions/:id/git/status", async (c) => {
     const run = db2.getAgentRun(c.req.param("id"));
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
-    if (!run.repoRoot) return err5(c, 400, "invalid_input", "Session has no repo root.");
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    if (!run.repoRoot) return err6(c, 400, "invalid_input", "Session has no repo root.");
     const status = await getGitStatus(run.repoRoot);
     return c.json({ ok: true, status });
   });
   app2.post("/api/v1/code/sessions/:id/git/commit", async (c) => {
     const id = c.req.param("id");
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
-    if (!run.repoRoot) return err5(c, 400, "invalid_input", "Session has no repo root.");
-    if (runs.isActive(id)) return err5(c, 409, "run_active", "Stop or wait for the current run before committing.");
-    const b = await body5(c);
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    if (!run.repoRoot) return err6(c, 400, "invalid_input", "Session has no repo root.");
+    if (runs.isActive(id)) return err6(c, 409, "run_active", "Stop or wait for the current run before committing.");
+    const b = await body6(c);
     try {
       const result = await commitGitChanges(run.repoRoot, b.message ?? "", b.files);
       return c.json({ ok: true, ...result });
     } catch (e) {
       const message = e instanceof Error ? e.message : "Commit failed.";
-      if (/commit message is required/i.test(message)) return err5(c, 400, "invalid_input", message);
-      if (/not a git repository/i.test(message)) return err5(c, 400, "not_a_git_repo", message);
-      if (/nothing to commit|nothing staged/i.test(message)) return err5(c, 400, "nothing_to_commit", message);
-      if (/outside the repo/i.test(message)) return err5(c, 400, "invalid_input", message);
-      return err5(c, 500, "git_commit_failed", message);
+      if (/commit message is required/i.test(message)) return err6(c, 400, "invalid_input", message);
+      if (/not a git repository/i.test(message)) return err6(c, 400, "not_a_git_repo", message);
+      if (/nothing to commit|nothing staged/i.test(message)) return err6(c, 400, "nothing_to_commit", message);
+      if (/outside the repo/i.test(message)) return err6(c, 400, "invalid_input", message);
+      return err6(c, 500, "git_commit_failed", message);
     }
   });
   app2.post("/api/v1/code/sessions/:id/git/push", async (c) => {
     const id = c.req.param("id");
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
-    if (!run.repoRoot) return err5(c, 400, "invalid_input", "Session has no repo root.");
-    if (runs.isActive(id)) return err5(c, 409, "run_active", "Stop or wait for the current run before pushing.");
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    if (!run.repoRoot) return err6(c, 400, "invalid_input", "Session has no repo root.");
+    if (runs.isActive(id)) return err6(c, 409, "run_active", "Stop or wait for the current run before pushing.");
     const result = await pushGitBranch(run.repoRoot);
     if (!result.ok) {
       const status = result.reason === "diverged" ? 409 : 400;
-      return err5(c, status, result.reason, result.message);
+      return err6(c, status, result.reason, result.message);
     }
     const compareUrl = await getGithubCompareUrl(run.repoRoot, result.branch);
     return c.json({ ok: true, remote: result.remote, branch: result.branch, compareUrl });
   });
   app2.get("/api/v1/code/sessions/:id/git/compare-url", async (c) => {
     const run = db2.getAgentRun(c.req.param("id"));
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
-    if (!run.repoRoot) return err5(c, 400, "invalid_input", "Session has no repo root.");
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    if (!run.repoRoot) return err6(c, 400, "invalid_input", "Session has no repo root.");
     const status = await getGitStatus(run.repoRoot);
     if (!status.isRepo || status.detached || !status.branch) return c.json({ ok: true, compareUrl: null });
     const compareUrl = await getGithubCompareUrl(run.repoRoot, status.branch);
@@ -18700,18 +19797,18 @@ function registerCodeRoutes(app2, d) {
   app2.post("/api/v1/code/sessions/:id/exec", async (c) => {
     const id = c.req.param("id");
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
-    if (!run.repoRoot) return err5(c, 400, "invalid_input", "Session has no repo root.");
-    if (runs.isActive(id)) return err5(c, 409, "run_active", "Stop or wait for the current run before running a command.");
-    const b = await body5(c);
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
+    if (!run.repoRoot) return err6(c, 400, "invalid_input", "Session has no repo root.");
+    if (runs.isActive(id)) return err6(c, 409, "run_active", "Stop or wait for the current run before running a command.");
+    const b = await body6(c);
     const command = (b.command ?? "").trim();
-    if (!command) return err5(c, 400, "invalid_input", "A command is required.");
+    if (!command) return err6(c, 400, "invalid_input", "A command is required.");
     const feedToModel = b.feedToModel !== false;
     let result;
     try {
       result = await runShellCommand(command, run.repoRoot, id);
     } catch (e) {
-      return err5(c, 500, "exec_failed", e instanceof Error ? e.message : "Command failed to run.");
+      return err6(c, 500, "exec_failed", e instanceof Error ? e.message : "Command failed to run.");
     }
     let messageId;
     if (feedToModel) {
@@ -18748,16 +19845,16 @@ function registerCodeRoutes(app2, d) {
   });
   app2.post("/api/v1/code/sessions/:id/messages", async (c) => {
     const id = c.req.param("id");
-    const b = await body5(c);
+    const b = await body6(c);
     const kind = b.kind === "steer" ? "steer" : "followUp";
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
     const conv = db2.getConversation(run.convId, true);
-    if (!conv) return err5(c, 404, "not_found", "Session conversation not found.");
-    if (!run.repoRoot) return err5(c, 400, "invalid_input", "Session has no repo root.");
+    if (!conv) return err6(c, 404, "not_found", "Session conversation not found.");
+    if (!run.repoRoot) return err6(c, 400, "invalid_input", "Session has no repo root.");
     const ms = d.manager.status();
-    if (ms.state !== "running" || !ms.model) return err5(c, 409, "model_not_loaded", "Load a model first.");
-    if (!d.manager.target()) return err5(c, 409, "model_not_loaded", "Engine not running.");
+    if (ms.state !== "running" || !ms.model) return err6(c, 409, "model_not_loaded", "Load a model first.");
+    if (!d.manager.target()) return err6(c, 409, "model_not_loaded", "Engine not running.");
     const newContent = (b.content ?? "").trim();
     let userMsgId;
     let task;
@@ -18766,7 +19863,7 @@ function registerCodeRoutes(app2, d) {
       task = contextFilesBlock(b.contextFiles) + ((b.promptOverride ?? "").trim() || newContent);
     } else {
       const lastUser = (conv.messages ?? []).filter((m) => m.role === "user").at(-1);
-      if (!lastUser) return err5(c, 400, "no_task", "No task to run.");
+      if (!lastUser) return err6(c, 400, "no_task", "No task to run.");
       userMsgId = lastUser.id;
       task = contextFilesBlock(lastUser.textAttachments) + lastUser.content;
     }
@@ -18781,7 +19878,7 @@ function registerCodeRoutes(app2, d) {
   app2.get("/api/v1/code/sessions/:id/stream", (c) => {
     const id = c.req.param("id");
     const run = db2.getAgentRun(id);
-    if (!run) return err5(c, 404, "not_found", "Session not found.");
+    if (!run) return err6(c, 404, "not_found", "Session not found.");
     const fromSeqRaw = Number.parseInt(c.req.query("fromSeq") ?? "", 10);
     const fromSeq = Number.isFinite(fromSeqRaw) && fromSeqRaw >= 0 ? fromSeqRaw : 0;
     return streamSSE3(c, async (stream) => {
@@ -18807,13 +19904,56 @@ import { streamSSE as streamSSE4 } from "hono/streaming";
 
 // src/gateway/anthropic.ts
 import { randomUUID as randomUUID9 } from "crypto";
+var UNSUPPORTED_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+  "format",
+  "pattern",
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf"
+]);
+var SCHEMA_NAME_MAP_KEYS = /* @__PURE__ */ new Set(["properties", "patternProperties", "$defs", "definitions"]);
+function stripUnsupportedSchemaKeywords(schema) {
+  if (Array.isArray(schema)) return schema.map(stripUnsupportedSchemaKeywords);
+  if (schema && typeof schema === "object") {
+    const out = {};
+    for (const [key, value] of Object.entries(schema)) {
+      if (UNSUPPORTED_SCHEMA_KEYWORDS.has(key)) continue;
+      out[key] = SCHEMA_NAME_MAP_KEYS.has(key) ? stripSchemaNameMap(value) : stripUnsupportedSchemaKeywords(value);
+    }
+    return out;
+  }
+  return schema;
+}
+function stripSchemaNameMap(map) {
+  if (!map || typeof map !== "object" || Array.isArray(map)) return stripUnsupportedSchemaKeywords(map);
+  const out = {};
+  for (const [name, sub] of Object.entries(map)) {
+    out[name] = stripUnsupportedSchemaKeywords(sub);
+  }
+  return out;
+}
 function mapToOpenAI(req) {
   const messages = [];
+  const systemParts = [];
   if (req.system) {
     const text = typeof req.system === "string" ? req.system : req.system.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
-    if (text) messages.push({ role: "system", content: text });
+    if (text) systemParts.push(text);
   }
   for (const msg2 of req.messages) {
+    if (msg2.role !== "system") continue;
+    const raw = msg2.content;
+    const text = typeof raw === "string" ? raw : raw.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
+    if (text) systemParts.push(text);
+  }
+  if (systemParts.length > 0) messages.push({ role: "system", content: systemParts.join("\n\n") });
+  for (const msg2 of req.messages) {
+    if (msg2.role === "system") continue;
     const raw = msg2.content;
     if (typeof raw === "string") {
       messages.push({ role: msg2.role, content: raw });
@@ -18840,9 +19980,6 @@ function mapToOpenAI(req) {
         const content = parts.length === 1 && parts[0].type === "text" ? parts[0].text : parts;
         messages.push({ role: "user", content });
       }
-    } else if (msg2.role === "system") {
-      const text = raw.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
-      if (text) messages.push({ role: "system", content: text });
     } else {
       let text = "";
       const toolCalls = [];
@@ -18882,7 +20019,7 @@ function mapToOpenAI(req) {
   if (req.tools?.length) {
     oai.tools = req.tools.map((t) => ({
       type: "function",
-      function: { name: t.name, description: t.description, parameters: t.input_schema }
+      function: { name: t.name, description: t.description, parameters: stripUnsupportedSchemaKeywords(t.input_schema) }
     }));
     const tc = req.tool_choice;
     if (tc)
@@ -18954,6 +20091,8 @@ async function* streamToAnthropic(oaiStream, modelName, msgId, onUsage, onLive)
   let outputTokens = 0;
   let inputTokens = 0;
   let cacheReadTokens = 0;
+  let promptTps = 0;
+  let genTps = 0;
   let liveOut = 0;
   yield sse("message_start", {
     message: {
@@ -18999,6 +20138,8 @@ async function* streamToAnthropic(oaiStream, modelName, msgId, onUsage, onLive)
         const timings = chunk.timings;
         const cacheN = timings?.cache_n ?? timings?.prompt_n_reuse;
         if (cacheN != null) cacheReadTokens = cacheN;
+        if (timings?.prompt_per_second) promptTps = timings.prompt_per_second;
+        if (timings?.predicted_per_second) genTps = timings.predicted_per_second;
         const choices = chunk.choices;
         if (!choices?.length) continue;
         const choice = choices[0];
@@ -19085,7 +20226,12 @@ async function* streamToAnthropic(oaiStream, modelName, msgId, onUsage, onLive)
     yield sse("message_stop", {});
     if (onUsage) {
       try {
-        onUsage({ inputTokens, outputTokens });
+        onUsage({
+          inputTokens,
+          outputTokens,
+          promptTps: promptTps > 0 ? promptTps : void 0,
+          genTps: genTps > 0 ? genTps : void 0
+        });
       } catch {
       }
     }
@@ -19114,6 +20260,10 @@ function cbStop(index) {
 }
 
 // src/gateway/gateway.ts
+function resolveCodeSession(c) {
+  const token = presentedKey(c);
+  return { token, codeSessionId: token ? sessionAuth.resolve(token) : null };
+}
 function clientAbort(c) {
   const ac = new AbortController();
   const sig = c.req.raw.signal;
@@ -19123,6 +20273,25 @@ function clientAbort(c) {
   }
   return ac;
 }
+async function describeEngineError(res) {
+  const raw = await res.text().catch(() => "");
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.error?.message) return { message: parsed.error.message, type: parsed.error.type };
+  } catch {
+  }
+  return { message: raw.slice(0, 2e3) || `Engine returned HTTP ${res.status}.` };
+}
+function anthropicErrorType(status) {
+  if (status === 400) return "invalid_request_error";
+  if (status === 404) return "not_found_error";
+  if (status === 429) return "rate_limit_error";
+  if (status === 503) return "overloaded_error";
+  return "api_error";
+}
+function asClientStatus(status) {
+  return status >= 400 && status <= 599 ? status : 500;
+}
 function registerGateway(app2, d) {
   app2.post("/v1/messages", async (c) => {
     let req;
@@ -19135,6 +20304,13 @@ function registerGateway(app2, d) {
       );
     }
     if (req.model?.startsWith("claude-")) req.model = req.model.slice(7);
+    const { token: anthropicToken, codeSessionId: anthropicCodeSessionId } = resolveCodeSession(c);
+    if (anthropicCodeSessionId) {
+      const override = sessionAuth.getThinkingBudgetForToken(anthropicToken);
+      if (override !== null) {
+        req.thinking = override > 0 ? { type: "enabled", budget_tokens: override } : void 0;
+      }
+    }
     if (!req.max_tokens) {
       return c.json(
         { type: "error", error: { type: "invalid_request_error", message: "max_tokens is required." } },
@@ -19158,6 +20334,7 @@ function registerGateway(app2, d) {
     if (oaiAlias) oaiBody.model = oaiAlias;
     d.manager.generationStart();
     const ac = clientAbort(c);
+    const requestStart = Date.now();
     let res;
     try {
       res = await fetch(`${target}/v1/chat/completions`, {
@@ -19168,17 +20345,26 @@ function registerGateway(app2, d) {
       });
     } catch (e) {
       d.manager.generationEnd();
+      const err7 = e;
+      const isAbort = err7.name === "AbortError" || ac.signal.aborted;
+      const cause = err7.cause instanceof Error ? `: ${err7.cause.message}` : "";
       return c.json(
-        { type: "error", error: { type: "api_error", message: e.message || "Engine error." } },
+        {
+          type: "error",
+          error: {
+            type: "api_error",
+            message: isAbort ? "Client disconnected before the engine responded." : `${err7.message || "Engine unreachable."}${cause}`
+          }
+        },
         500
       );
     }
     if (!res.ok || !res.body) {
       d.manager.generationEnd();
-      const text = await res.text().catch(() => "");
+      const { message, type } = await describeEngineError(res);
       return c.json(
-        { type: "error", error: { type: "api_error", message: text || "Engine error." } },
-        500
+        { type: "error", error: { type: type ?? anthropicErrorType(res.status), message } },
+        asClientStatus(res.status)
       );
     }
     if (req.stream) {
@@ -19189,8 +20375,22 @@ function registerGateway(app2, d) {
         msgId,
         (u) => {
           try {
-            d.manager.recordCompletion({ inputTokens: u.inputTokens, outputTokens: u.outputTokens });
-            d.db.recordApiUsage({ source: "anthropic", modelKey: req.model ?? null, promptTokens: u.inputTokens, genTokens: u.outputTokens });
+            d.manager.recordCompletion({
+              inputTokens: u.inputTokens,
+              outputTokens: u.outputTokens,
+              promptTps: u.promptTps,
+              genTps: u.genTps
+            });
+            d.db.recordApiUsage({
+              source: "anthropic",
+              modelKey: req.model ?? null,
+              promptTokens: u.inputTokens,
+              genTokens: u.outputTokens,
+              codeSessionId: anthropicCodeSessionId,
+              durationMs: Date.now() - requestStart,
+              promptTps: u.promptTps,
+              genTps: u.genTps
+            });
           } catch {
           }
         },
@@ -19217,7 +20417,7 @@ function registerGateway(app2, d) {
     }
     try {
       const oaiRes = await res.json();
-      recordOpenAiUsage(d, oaiRes, "anthropic", req.model ?? null);
+      recordOpenAiUsage(d, oaiRes, "anthropic", req.model ?? null, anthropicCodeSessionId, Date.now() - requestStart);
       return c.json(mapFromOpenAI(oaiRes, modelName));
     } finally {
       d.manager.generationEnd();
@@ -19270,6 +20470,7 @@ function registerGateway(app2, d) {
         parsedBody = null;
       }
     }
+    const { token: chatToken, codeSessionId: chatCodeSessionId } = resolveCodeSession(c);
     const requestedModel = isChat ? parsedBody?.model ?? "" : "";
     const routeResult = await d.modelRouter.route(requestedModel);
     if ("status" in routeResult) {
@@ -19294,6 +20495,13 @@ function registerGateway(app2, d) {
           const alias = engineModelAlias(d.registry.active()?.kind ?? "");
           if (alias) parsedBody.model = alias;
         }
+        if (parsedBody && chatCodeSessionId) {
+          const override = sessionAuth.getThinkingBudgetForToken(chatToken);
+          if (override !== null) {
+            if (override > 0) parsedBody.thinking_budget_tokens = override;
+            else delete parsedBody.thinking_budget_tokens;
+          }
+        }
         if (parsedBody?.stream === true && parsedBody.stream_options === void 0) {
           parsedBody.stream_options = { include_usage: true };
         }
@@ -19304,17 +20512,18 @@ function registerGateway(app2, d) {
         init.duplex = "half";
       }
     }
+    const requestStart = Date.now();
     let res;
     try {
       res = await fetch(upstream, init);
     } catch (e) {
-      const err6 = e;
-      const isAbort = err6.name === "AbortError" || ac.signal.aborted;
-      const cause = err6.cause instanceof Error ? `: ${err6.cause.message}` : "";
+      const err7 = e;
+      const isAbort = err7.name === "AbortError" || ac.signal.aborted;
+      const cause = err7.cause instanceof Error ? `: ${err7.cause.message}` : "";
       return c.json(
         {
           error: {
-            message: isAbort ? "Client disconnected before the engine responded." : `${err6.message || "Engine unreachable."}${cause}`,
+            message: isAbort ? "Client disconnected before the engine responded." : `${err7.message || "Engine unreachable."}${cause}`,
             type: "api_error",
             code: isAbort ? "client_disconnected" : "engine_unreachable"
           }
@@ -19326,7 +20535,7 @@ function registerGateway(app2, d) {
       try {
         const [a, b] = res.body.tee();
         d.manager.generationStart();
-        const drain = parsedBody?.stream === true ? recordOpenAiStreamUsage(d, b, "openai", requestedModel || null) : recordOpenAiJsonUsage(d, b, "openai", requestedModel || null);
+        const drain = parsedBody?.stream === true ? recordOpenAiStreamUsage(d, b, "openai", requestedModel || null, chatCodeSessionId, requestStart) : recordOpenAiJsonUsage(d, b, "openai", requestedModel || null, chatCodeSessionId, requestStart);
         void drain.finally(() => d.manager.generationEnd());
         return new Response(a, { status: res.status, headers: res.headers });
       } catch {
@@ -19336,7 +20545,7 @@ function registerGateway(app2, d) {
     return new Response(res.body, { status: res.status, headers: res.headers });
   });
 }
-function recordOpenAiUsage(d, oai, source, modelKey) {
+function recordOpenAiUsage(d, oai, source, modelKey, codeSessionId = null, durationMs = null) {
   try {
     const usage = oai.usage;
     const timings = oai.timings;
@@ -19346,21 +20555,32 @@ function recordOpenAiUsage(d, oai, source, modelKey) {
       promptTps: timings?.prompt_per_second,
       genTps: timings?.predicted_per_second
     });
-    d.db.recordApiUsage({ source, modelKey, promptTokens: usage?.prompt_tokens ?? 0, genTokens: usage?.completion_tokens ?? 0 });
+    d.db.recordApiUsage({
+      source,
+      modelKey,
+      promptTokens: usage?.prompt_tokens ?? 0,
+      genTokens: usage?.completion_tokens ?? 0,
+      codeSessionId,
+      durationMs,
+      // Already extracted for the engine card two lines up; persisting them is what lets the
+      // stats row report the engine's real rates instead of deriving both from `durationMs`.
+      promptTps: timings?.prompt_per_second,
+      genTps: timings?.predicted_per_second
+    });
   } catch {
   }
 }
-async function recordOpenAiJsonUsage(d, body6, source, modelKey) {
+async function recordOpenAiJsonUsage(d, body7, source, modelKey, codeSessionId = null, startedAt2 = null) {
   try {
-    const text = await new Response(body6).text();
+    const text = await new Response(body7).text();
     const oai = JSON.parse(text);
-    recordOpenAiUsage(d, oai, source, modelKey);
+    recordOpenAiUsage(d, oai, source, modelKey, codeSessionId, startedAt2 != null ? Date.now() - startedAt2 : null);
   } catch {
   }
 }
-async function recordOpenAiStreamUsage(d, body6, source, modelKey) {
+async function recordOpenAiStreamUsage(d, body7, source, modelKey, codeSessionId = null, startedAt2 = null) {
   try {
-    const reader = body6.getReader();
+    const reader = body7.getReader();
     const dec = new TextDecoder();
     let buf = "";
     let promptTokens = 0;
@@ -19404,14 +20624,25 @@ async function recordOpenAiStreamUsage(d, body6, source, modelKey) {
       }
     }
     d.manager.recordCompletion({ inputTokens: promptTokens, outputTokens: completionTokens, promptTps, genTps });
-    d.db.recordApiUsage({ source, modelKey, promptTokens, genTokens: completionTokens });
+    d.db.recordApiUsage({
+      source,
+      modelKey,
+      promptTokens,
+      genTokens: completionTokens,
+      codeSessionId,
+      durationMs: startedAt2 != null ? Date.now() - startedAt2 : null,
+      // Accumulated from the stream's own `timings` above (0 when the engine reported none —
+      // recordApiUsage stores that as null, and the reader falls back to the old derivation).
+      promptTps,
+      genTps
+    });
   } catch {
   }
 }
 
 // src/server.ts
 setGlobalDispatcher(new Agent({ keepAliveMaxTimeout: 6e4, connections: 10 }));
-var WEB_ROOT = join29(dirname11(fileURLToPath(import.meta.url)), "webdist");
+var WEB_ROOT = join30(dirname11(fileURLToPath(import.meta.url)), "webdist");
 function createApp(d) {
   const app2 = new Hono();
   app2.use(
@@ -19442,18 +20673,19 @@ function createApp(d) {
   registerChatAgentRoutes(app2, d);
   registerAgentRoutes(app2, d);
   registerCodeRoutes(app2, d);
+  registerTerminalRoutes(app2, d);
   registerGateway(app2, d);
   app2.get("/*", (c) => {
     const path = decodeURIComponent(new URL(c.req.url).pathname).replace(/^\/+/, "");
     if (path.startsWith("api/") || path.startsWith("v1/")) {
       return c.json({ error: { code: "not_found", message: "Unknown endpoint." } }, 404);
     }
-    let file = normalize2(join29(WEB_ROOT, path || "index.html"));
+    let file = normalize2(join30(WEB_ROOT, path || "index.html"));
     if (!file.startsWith(WEB_ROOT) || !existsSync24(file) || statSync6(file).isDirectory()) {
-      file = join29(WEB_ROOT, "index.html");
+      file = join30(WEB_ROOT, "index.html");
     }
     if (!existsSync24(file)) return c.text("web ui not built \u2014 run `npm run build:web`", 500);
-    return new Response(readFileSync13(file), { status: 200, headers: { "Content-Type": contentType(file) } });
+    return new Response(readFileSync14(file), { status: 200, headers: { "Content-Type": contentType(file) } });
   });
   return app2;
 }
@@ -19478,22 +20710,22 @@ function contentType(file) {
 }
 
 // src/tunnel/manager.ts
-import { execFile as execFile13, spawn as spawn7, spawnSync as spawnSync2 } from "child_process";
-import { mkdirSync as mkdirSync15, readFileSync as readFileSync14, readdirSync as readdirSync9, rmSync as rmSync14, writeFileSync as writeFileSync13 } from "fs";
-import { join as join31 } from "path";
+import { execFile as execFile13, spawn as spawn7, spawnSync as spawnSync3 } from "child_process";
+import { mkdirSync as mkdirSync16, readFileSync as readFileSync15, readdirSync as readdirSync10, rmSync as rmSync15, writeFileSync as writeFileSync14 } from "fs";
+import { join as join32 } from "path";
 
 // src/tunnel/provision.ts
-import { chmodSync as chmodSync3, existsSync as existsSync25, mkdirSync as mkdirSync14, rmSync as rmSync13 } from "fs";
-import { join as join30 } from "path";
+import { chmodSync as chmodSync3, existsSync as existsSync25, mkdirSync as mkdirSync15, rmSync as rmSync14 } from "fs";
+import { join as join31 } from "path";
 var CLOUDFLARED_REPO = "cloudflare/cloudflared";
 function cloudflaredDir(dataDir) {
-  return join30(dataDir, "cloudflared");
+  return join31(dataDir, "cloudflared");
 }
 function cloudflaredBinName(platform = process.platform) {
   return platform === "win32" ? "cloudflared.exe" : "cloudflared";
 }
 function cloudflaredBinPath(dataDir, platform = process.platform) {
-  return join30(cloudflaredDir(dataDir), cloudflaredBinName(platform));
+  return join31(cloudflaredDir(dataDir), cloudflaredBinName(platform));
 }
 function cloudflaredAssetName(platform = process.platform, archStr = process.arch) {
   if (platform === "win32") {
@@ -19522,18 +20754,18 @@ async function ensureCloudflared(dataDir, onProgress, signal) {
   if (existsSync25(binPath)) return { binPath, version: version2 };
   const asset = pickCloudflaredAsset(rel.assets ?? []);
   if (!asset) throw new Error("no_release_asset");
-  mkdirSync14(dir, { recursive: true });
+  mkdirSync15(dir, { recursive: true });
   onProgress?.({ phase: "downloading", pct: 0 });
   if (asset.name.endsWith(".tgz")) {
-    const tmp = join30(dir, asset.name);
+    const tmp = join31(dir, asset.name);
     try {
       await downloadFile(asset.browser_download_url, tmp, onProgress, signal);
       onProgress?.({ phase: "extracting", pct: -1 });
       await extractArchive(tmp, dir);
-      rmSync13(tmp, { force: true });
+      rmSync14(tmp, { force: true });
     } catch (e) {
-      rmSync13(tmp, { force: true });
-      rmSync13(dir, { recursive: true, force: true });
+      rmSync14(tmp, { force: true });
+      rmSync14(dir, { recursive: true, force: true });
       throw e;
     }
     const found = findFile(dir, "cloudflared");
@@ -19569,25 +20801,25 @@ function forceKill2(child) {
   else child.kill("SIGKILL");
 }
 function tunnelPidDir(dataDir) {
-  return join31(dataDir, "run");
+  return join32(dataDir, "run");
 }
 function tunnelPidFile(dataDir, pid) {
-  return join31(tunnelPidDir(dataDir), `tunnel-${pid}.pid`);
+  return join32(tunnelPidDir(dataDir), `tunnel-${pid}.pid`);
 }
 function writeTunnelPid(dataDir, pid) {
   try {
-    mkdirSync15(tunnelPidDir(dataDir), { recursive: true });
-    writeFileSync13(tunnelPidFile(dataDir, pid), JSON.stringify({ pid, owner: process.pid }));
+    mkdirSync16(tunnelPidDir(dataDir), { recursive: true });
+    writeFileSync14(tunnelPidFile(dataDir, pid), JSON.stringify({ pid, owner: process.pid }));
   } catch {
   }
 }
 function clearTunnelPid(dataDir, pid) {
   try {
-    rmSync14(tunnelPidFile(dataDir, pid), { force: true });
+    rmSync15(tunnelPidFile(dataDir, pid), { force: true });
   } catch {
   }
 }
-function pidAlive2(pid) {
+function pidAlive3(pid) {
   if (!pid) return false;
   try {
     process.kill(pid, 0);
@@ -19600,20 +20832,20 @@ function readTunnelPidFiles(dataDir) {
   const dir = tunnelPidDir(dataDir);
   let names;
   try {
-    names = readdirSync9(dir).filter((n) => /^tunnel-\d+\.pid$/.test(n));
+    names = readdirSync10(dir).filter((n) => /^tunnel-\d+\.pid$/.test(n));
   } catch {
     return [];
   }
   const out = [];
   for (const name of names) {
-    const file = join31(dir, name);
+    const file = join32(dir, name);
     try {
-      const { pid, owner } = JSON.parse(readFileSync14(file, "utf8"));
+      const { pid, owner } = JSON.parse(readFileSync15(file, "utf8"));
       if (typeof pid === "number" && pid > 0) out.push({ pid, owner: typeof owner === "number" ? owner : 0, file });
-      else rmSync14(file, { force: true });
+      else rmSync15(file, { force: true });
     } catch {
       try {
-        rmSync14(file, { force: true });
+        rmSync15(file, { force: true });
       } catch {
       }
     }
@@ -19623,15 +20855,15 @@ function readTunnelPidFiles(dataDir) {
 function reapStaleTunnels(dataDir) {
   let killed = 0;
   for (const { pid, owner, file } of readTunnelPidFiles(dataDir)) {
-    if (owner && pidAlive2(owner)) continue;
+    if (owner && pidAlive3(owner)) continue;
     try {
-      if (process.platform === "win32") spawnSync2("taskkill", ["/PID", String(pid), "/F", "/T"]);
+      if (process.platform === "win32") spawnSync3("taskkill", ["/PID", String(pid), "/F", "/T"]);
       else process.kill(pid, "SIGKILL");
       killed++;
     } catch {
     }
     try {
-      rmSync14(file, { force: true });
+      rmSync15(file, { force: true });
     } catch {
     }
   }
@@ -19641,12 +20873,12 @@ function killTrackedTunnelsSync(dataDir) {
   for (const { pid, owner, file } of readTunnelPidFiles(dataDir)) {
     if (owner !== process.pid) continue;
     try {
-      if (process.platform === "win32") spawnSync2("taskkill", ["/PID", String(pid), "/F", "/T"]);
+      if (process.platform === "win32") spawnSync3("taskkill", ["/PID", String(pid), "/F", "/T"]);
       else process.kill(pid, "SIGKILL");
     } catch {
     }
     try {
-      rmSync14(file, { force: true });
+      rmSync15(file, { force: true });
     } catch {
     }
   }
@@ -19739,8 +20971,8 @@ var TunnelManager = class {
 hideChildConsoleWindows();
 var version = "0.1.1";
 try {
-  const pkgPath = join32(dirname12(fileURLToPath2(import.meta.url)), "..", "package.json");
-  version = JSON.parse(readFileSync15(pkgPath, "utf8")).version ?? version;
+  const pkgPath = join33(dirname12(fileURLToPath2(import.meta.url)), "..", "package.json");
+  version = JSON.parse(readFileSync16(pkgPath, "utf8")).version ?? version;
 } catch {
 }
 var [nodeMajor, nodeMinor] = process.versions.node.split(".").map(Number);
@@ -19767,7 +20999,7 @@ function argValue(name, fallback) {
 }
 function configuredDaemonPort(configPath) {
   try {
-    const cfg2 = JSON.parse(readFileSync15(configPath, "utf8"));
+    const cfg2 = JSON.parse(readFileSync16(configPath, "utf8"));
     if (typeof cfg2.daemon?.port === "number" && cfg2.daemon.port > 0) return cfg2.daemon.port;
   } catch {
   }
@@ -19783,10 +21015,21 @@ if (argv[0] === "launch") {
     explicitPort,
     configuredDaemonPort(launchConfigPath)
   );
+  const authToken = argValue("--token", "") || void 0;
   const passthrough = argv.slice(2).filter(
-    (a, i, arr) => a !== "--port" && arr[i - 1] !== "--port" && a !== "--model" && arr[i - 1] !== "--model" && a !== "--config" && arr[i - 1] !== "--config"
+    (a, i, arr) => a !== "--port" && arr[i - 1] !== "--port" && a !== "--model" && arr[i - 1] !== "--model" && a !== "--config" && arr[i - 1] !== "--config" && a !== "--token" && arr[i - 1] !== "--token"
   );
-  const code = await launchCli(target, port2, passthrough, void 0, modelKey);
+  const code = await launchCli(target, port2, passthrough, void 0, modelKey, void 0, authToken);
+  const codeSessionId = argValue("--session-id", "") || argValue("--resume", "");
+  if (codeSessionId) {
+    try {
+      await fetch(`http://127.0.0.1:${port2}/api/v1/code/sessions/${codeSessionId}/terminal/agent-exited`, {
+        method: "POST",
+        signal: AbortSignal.timeout(2e3)
+      });
+    } catch {
+    }
+  }
   process.exit(code);
 }
 if (argv[0] === "mcp-server") {
@@ -19865,13 +21108,18 @@ try {
   if (reapedTunnels > 0) console.log(`reaped ${reapedTunnels} orphaned tunnel process(es) from a previous run`);
 } catch {
 }
+try {
+  const reapedTerminals = reapStaleTerminals(store.dir());
+  if (reapedTerminals > 0) console.log(`reaped ${reapedTerminals} orphaned terminal-agent process(es) from a previous run`);
+} catch {
+}
 var registry = new Registry(store);
 var pruned = registry.pruneDeadManagedBuilds();
 if (pruned > 0) console.log(`pruned ${pruned} dangling engine build(s)`);
 var provision = new ProvisionState();
 var build = new BuildState();
 var updates = new UpdateChecker();
-var enginesDir = join32(store.dir(), "engines");
+var enginesDir = join33(store.dir(), "engines");
 void seedDefaultEngines(registry, enginesDir, provision).then(() => registry.ensureProbed());
 var manager = new Manager(store);
 var scanner = new Scanner(store);
@@ -20015,6 +21263,7 @@ function listen(attempt = 0) {
   server = s;
 }
 listen();
+registerTerminalWs(server, deps);
 deps.rebind = () => {
   const c = store.snapshot();
   const want = c.daemon.lanBind ? "0.0.0.0" : c.daemon.host || "127.0.0.1";
@@ -20044,7 +21293,7 @@ var restarting = false;
 function spawnReplacement() {
   let out = "ignore";
   try {
-    out = openSync3(join32(store.dir(), "restart.log"), "a");
+    out = openSync3(join33(store.dir(), "restart.log"), "a");
   } catch {
     out = "ignore";
   }
@@ -20163,6 +21412,10 @@ process.on("exit", () => {
     killTrackedTunnelsSync(store.dir());
   } catch {
   }
+  try {
+    killTrackedTerminalsSync(store.dir());
+  } catch {
+  }
   try {
     removePidfile(store.dir());
   } catch {