@kernlang/agon 0.1.1 → 0.1.3

package/dist/{chunk-7PMMOQZ7.js → chunk-PFHGKBQT.js}

@@ -1703,7 +1703,7 @@ async function spawnWithTimeout(opts) {
   if (opts.signal?.aborted) {
     return { exitCode: 130, stdout: "", stderr: "Aborted", durationMs: 0, timedOut: false };
   }
-  return new Promise((resolve27) => {
+  return new Promise((resolve28) => {
     const startTime = Date.now();
     let timedOut = false;
     let aborted2 = false;
@@ -1719,7 +1719,7 @@ async function spawnWithTimeout(opts) {
       if (forceKillTimer) clearTimeout(forceKillTimer);
       if (forceFinishTimer) clearTimeout(forceFinishTimer);
       if (opts.signal) opts.signal.removeEventListener("abort", onAbort);
-      resolve27(result);
+      resolve28(result);
     }
     const child = spawn(opts.command, opts.args, {
       cwd: opts.cwd,
@@ -16551,20 +16551,235 @@ ${result}
   return result;
 }
 
+// ../core/src/generated/blocks/codebase-map.ts
+import { readFileSync as readFileSync9, readdirSync as readdirSync7, statSync as statSync7, lstatSync as lstatSync2, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, existsSync as existsSync7, rmSync as rmSync4 } from "fs";
+import { join as join10, relative as relative2 } from "path";
+import { createHash as createHash2 } from "crypto";
+var MAP_IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "dist-tsc", ".next", ".cache", ".turbo", "__pycache__", ".venv", "venv", "coverage", ".kern-gaps", ".agon", ".claude", "worktrees", "build", "out", ".idea", ".vscode"]);
+var MAP_SOURCE_EXT = [".kern", ".ts", ".tsx", ".py", ".js", ".jsx"];
+var MAP_MAX_FILES_WALKED = 6e3;
+var MAP_MAX_FILES_READ = 600;
+var MAP_MAX_FILE_BYTES = 262144;
+var MAP_MEMO = /* @__PURE__ */ new Map();
+var MAP_LOCKFILES = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb"];
+var MAP_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
+function mapSourceExt(path) {
+  const dot = path.lastIndexOf(".");
+  if (dot < 0) return null;
+  const ext = path.slice(dot);
+  return MAP_SOURCE_EXT.includes(ext) ? ext : null;
+}
+function collectSourceFiles(root) {
+  const out = [];
+  const stack = [root];
+  while (stack.length > 0 && out.length < MAP_MAX_FILES_WALKED) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync7(dir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.startsWith(".DS_")) continue;
+      const full = join10(dir, entry);
+      let st;
+      try {
+        st = lstatSync2(full);
+      } catch {
+        continue;
+      }
+      if (st.isSymbolicLink()) continue;
+      if (st.isDirectory()) {
+        if (!MAP_IGNORE_DIRS.has(entry)) stack.push(full);
+        continue;
+      }
+      if (mapSourceExt(entry)) out.push(relative2(root, full));
+      if (out.length >= MAP_MAX_FILES_WALKED) break;
+    }
+  }
+  out.sort();
+  return out;
+}
+function extractSymbols(relPath, content) {
+  const ext = mapSourceExt(relPath);
+  const names = [];
+  const push = (n) => {
+    if (n && !names.includes(n)) names.push(n);
+  };
+  if (ext === ".kern") {
+    const re = /\b(?:fn|service|union|interface|const|screen|machine|event|type)\s+name=([A-Za-z0-9_$]+)/g;
+    let m;
+    while ((m = re.exec(content)) !== null) push(m[1]);
+  } else if (ext === ".py") {
+    const re = /^\s*(?:async\s+)?(?:def|class)\s+([A-Za-z0-9_]+)/gm;
+    let m;
+    while ((m = re.exec(content)) !== null) push(m[1]);
+  } else {
+    const re = /^\s*export\s+(?:default\s+)?(?:async\s+)?(?:function|const|let|var|class|interface|type|enum)\s+([A-Za-z0-9_$]+)/gm;
+    let m;
+    while ((m = re.exec(content)) !== null) push(m[1]);
+  }
+  return names.slice(0, 12);
+}
+function topLevelGroup(relPath) {
+  const parts = relPath.split("/");
+  if (parts[0] === "packages" && parts.length > 1) return `packages/${parts[1]}`;
+  if (parts.length > 1) return parts[0];
+  return "(root)";
+}
+function mapCacheDir() {
+  return agonPath("cache", "codebase-map");
+}
+function mapCacheKey(cwd) {
+  return createHash2("sha1").update(cwd).digest("hex").slice(0, 16);
+}
+function mapCacheFile(cwd) {
+  return join10(mapCacheDir(), `${mapCacheKey(cwd)}.json`);
+}
+function mapCacheSignature(cwd) {
+  let head = "nogit";
+  try {
+    head = headSha(cwd);
+  } catch {
+  }
+  let lockMtime = "0";
+  for (const lf of MAP_LOCKFILES) {
+    try {
+      lockMtime = String(Math.round(statSync7(join10(cwd, lf)).mtimeMs));
+      break;
+    } catch {
+    }
+  }
+  return `${head}:${lockMtime}`;
+}
+function readMapDiskCache(cwd, sig) {
+  try {
+    const path = mapCacheFile(cwd);
+    if (!existsSync7(path)) return null;
+    const raw = JSON.parse(readFileSync9(path, "utf-8"));
+    if (raw.sig !== sig) return null;
+    if (typeof raw.builtAt === "number" && Date.now() - raw.builtAt > MAP_CACHE_TTL_MS) return null;
+    return typeof raw.brief === "string" ? raw.brief : null;
+  } catch {
+    return null;
+  }
+}
+function writeMapDiskCache(cwd, sig, brief) {
+  try {
+    mkdirSync7(mapCacheDir(), { recursive: true });
+    writeFileSync7(mapCacheFile(cwd), JSON.stringify({ sig, brief, builtAt: Date.now() }));
+  } catch {
+  }
+}
+function composeBrief(cwd, cap) {
+  const files = collectSourceFiles(cwd);
+  if (files.length === 0) return "";
+  const generatedCount = files.filter((f) => f.includes("/generated/")).length;
+  const kernCount = files.filter((f) => f.endsWith(".kern")).length;
+  const groups = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const g = topLevelGroup(f);
+    const arr = groups.get(g) ?? [];
+    arr.push(f);
+    groups.set(g, arr);
+  }
+  let filesRead = 0;
+  const lines = [];
+  let totalLen = 0;
+  const addLine = (s) => {
+    lines.push(s);
+    totalLen += s.length + 1;
+  };
+  addLine("## CODEBASE BRIEF (where things live \u2014 prefer this over searching)");
+  if (kernCount > 0 && generatedCount > 0) {
+    addLine(`KERN project: ${kernCount} .kern sources compile to generated/ TS mirrors \u2014 EDIT THE .kern, not generated/.`);
+  }
+  const groupNames = Array.from(groups.keys()).sort();
+  const perGroupBudget = Math.min(cap, Math.max(300, Math.floor(cap / Math.max(1, groupNames.length))));
+  for (const g of groupNames) {
+    if (totalLen > cap) break;
+    const groupFiles = (groups.get(g) ?? []).filter((f) => !f.includes("/generated/"));
+    if (groupFiles.length === 0) continue;
+    groupFiles.sort((a, b) => {
+      const ak = a.endsWith(".kern") ? 0 : 1;
+      const bk = b.endsWith(".kern") ? 0 : 1;
+      if (ak !== bk) return ak - bk;
+      return a < b ? -1 : a > b ? 1 : 0;
+    });
+    const groupStart = totalLen;
+    addLine(`
+### ${g} (${groupFiles.length} files)`);
+    let shown = 0;
+    for (const f of groupFiles.slice(0, 12)) {
+      if (totalLen > cap) break;
+      if (shown > 0 && totalLen - groupStart > perGroupBudget) break;
+      let syms = [];
+      if (filesRead < MAP_MAX_FILES_READ) {
+        try {
+          const st = statSync7(join10(cwd, f));
+          if (st.size <= MAP_MAX_FILE_BYTES) {
+            syms = extractSymbols(f, readFileSync9(join10(cwd, f), "utf-8"));
+            filesRead++;
+          }
+        } catch {
+        }
+      }
+      addLine(syms.length > 0 ? `- ${f}: ${syms.join(", ")}` : `- ${f}`);
+      shown++;
+    }
+    const extra = groupFiles.length - shown;
+    if (extra > 0) addLine(`  (+${extra} more files in ${g})`);
+  }
+  let brief = lines.join("\n");
+  if (brief.length > cap) brief = brief.slice(0, cap) + "\n... (brief truncated)";
+  return brief;
+}
+function buildCodebaseMap(cwd, maxChars) {
+  if (maxChars !== void 0) return composeBrief(cwd, Math.max(1, maxChars));
+  const sig = mapCacheSignature(cwd);
+  const cached2 = MAP_MEMO.get(cwd);
+  if (cached2 !== void 0 && cached2.sig === sig) return cached2.brief;
+  const fromDisk = readMapDiskCache(cwd, sig);
+  if (fromDisk !== null) {
+    MAP_MEMO.set(cwd, { sig, brief: fromDisk });
+    return fromDisk;
+  }
+  const brief = composeBrief(cwd, 3500);
+  writeMapDiskCache(cwd, sig, brief);
+  MAP_MEMO.set(cwd, { sig, brief });
+  return brief;
+}
+function clearCodebaseMapCache(cwd) {
+  if (cwd) {
+    MAP_MEMO.delete(cwd);
+    try {
+      rmSync4(mapCacheFile(cwd), { force: true });
+    } catch {
+    }
+  } else {
+    MAP_MEMO.clear();
+    try {
+      rmSync4(mapCacheDir(), { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
 // ../core/src/generated/blocks/workspace.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, renameSync as renameSync6 } from "fs";
-import { join as join10, resolve as resolve5, basename as basename2 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, renameSync as renameSync6 } from "fs";
+import { join as join11, resolve as resolve5, basename as basename2 } from "path";
 import { homedir as homedir4 } from "os";
 function getWorkspacesPath() {
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve5(override) : join10(homedir4(), ".agon");
-  return join10(home, "workspaces.json");
+  const home = override ? resolve5(override) : join11(homedir4(), ".agon");
+  return join11(home, "workspaces.json");
 }
 function loadState() {
   const WORKSPACES_PATH = getWorkspacesPath();
   ensureAgonHome();
   try {
-    return JSON.parse(readFileSync9(WORKSPACES_PATH, "utf-8"));
+    return JSON.parse(readFileSync10(WORKSPACES_PATH, "utf-8"));
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.warn(`[agon] workspace state corrupted, resetting to defaults: ${err instanceof Error ? err.message : String(err)}`);
@@ -16575,7 +16790,7 @@ function loadState() {
 function saveState(state) {
   const WORKSPACES_PATH = getWorkspacesPath();
   const tmpPath = WORKSPACES_PATH + ".tmp";
-  writeFileSync7(tmpPath, JSON.stringify(state, null, 2) + "\n");
+  writeFileSync8(tmpPath, JSON.stringify(state, null, 2) + "\n");
   renameSync6(tmpPath, WORKSPACES_PATH);
 }
 function addWorkspace(rawPath) {
@@ -16862,17 +17077,17 @@ function resetStepForRetry(plan, stepId) {
 }
 
 // ../core/src/generated/signals/plan-store.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7, readdirSync as readdirSync7, unlinkSync as unlinkSync3, renameSync as renameSync7 } from "fs";
-import { join as join11, resolve as resolve6 } from "path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8, readdirSync as readdirSync8, unlinkSync as unlinkSync3, renameSync as renameSync7 } from "fs";
+import { join as join12, resolve as resolve6 } from "path";
 import { homedir as homedir5 } from "os";
 function getPlansDir() {
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve6(override) : join11(homedir5(), ".agon");
-  return join11(home, "plans");
+  const home = override ? resolve6(override) : join12(homedir5(), ".agon");
+  return join12(home, "plans");
 }
 function ensurePlansDir() {
   ensureAgonHome();
-  mkdirSync7(getPlansDir(), { recursive: true });
+  mkdirSync8(getPlansDir(), { recursive: true });
 }
 function safePlanPath(id) {
   const sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "");
@@ -16887,12 +17102,12 @@ function savePlan(plan) {
   ensurePlansDir();
   const target = safePlanPath(plan.id);
   const tmpPath = target + ".tmp";
-  writeFileSync8(tmpPath, JSON.stringify(plan, null, 2) + "\n");
+  writeFileSync9(tmpPath, JSON.stringify(plan, null, 2) + "\n");
   renameSync7(tmpPath, target);
 }
 function loadPlan(id) {
   try {
-    return JSON.parse(readFileSync10(safePlanPath(id), "utf-8"));
+    return JSON.parse(readFileSync11(safePlanPath(id), "utf-8"));
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.warn(`[agon] failed to load plan ${id}: ${err instanceof Error ? err.message : String(err)}`);
@@ -16904,8 +17119,8 @@ function listPlans(limit) {
   ensurePlansDir();
   try {
     const plansDir = getPlansDir();
-    const files = readdirSync7(plansDir).filter((f) => f.endsWith(".json"));
-    return files.map((f) => JSON.parse(readFileSync10(join11(plansDir, f), "utf-8"))).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, limit ?? 20);
+    const files = readdirSync8(plansDir).filter((f) => f.endsWith(".json"));
+    return files.map((f) => JSON.parse(readFileSync11(join12(plansDir, f), "utf-8"))).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, limit ?? 20);
   } catch (err) {
     console.warn(`[agon] failed to list plans: ${err instanceof Error ? err.message : String(err)}`);
     return [];
@@ -16947,6 +17162,389 @@ function wordWrap(text, width) {
   return result;
 }
 
+// ../core/src/generated/blocks/stack-trace.ts
+import { existsSync as existsSync9, readFileSync as readFileSync12 } from "fs";
+import { basename as basename3, dirname as dirname5, isAbsolute as isAbsolute2, normalize, resolve as resolve7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { createRequire as createRequire2 } from "module";
+import { Buffer as Buffer2 } from "buffer";
+function setBoundedCacheEntry(cache, key, value) {
+  if (!cache || typeof cache.set !== "function") return;
+  const limit = 256;
+  if (cache.has(key)) {
+    cache.delete(key);
+  } else if (cache.size >= limit) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+  cache.set(key, value);
+}
+function normalizeStackFilePath(rawPath) {
+  let filePath = String(rawPath ?? "");
+  if (!filePath) return "";
+  if (filePath.startsWith("file://")) {
+    try {
+      filePath = fileURLToPath2(filePath);
+    } catch {
+      return normalize(filePath);
+    }
+  }
+  return normalize(filePath);
+}
+function readTextFileCached(filePath) {
+  const normalized = normalizeStackFilePath(filePath);
+  if (!normalized) return null;
+  const cache = stackTraceMapperState().sourceTextCache;
+  if (cache.has(normalized)) return cache.get(normalized) ?? null;
+  let content = null;
+  try {
+    if (existsSync9(normalized)) content = readFileSync12(normalized, "utf8");
+  } catch {
+    content = null;
+  }
+  if (content !== null) setBoundedCacheEntry(cache, normalized, content);
+  return content;
+}
+function nodeModuleApi() {
+  try {
+    return createRequire2(import.meta.url)("node:module");
+  } catch {
+    return {};
+  }
+}
+function sourceMappingUrlFromContent(content) {
+  const text = String(content ?? "");
+  const lineMatches = [...text.matchAll(/\/\/\s*[#@]\s*sourceMappingURL\s*=\s*([^\s]+)/g)];
+  const blockMatches = [...text.matchAll(/\/\*\s*[#@]\s*sourceMappingURL\s*=\s*([\s\S]*?)\s*\*\//g)];
+  const matches = [...lineMatches, ...blockMatches].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+  const last = matches[matches.length - 1];
+  return last?.[1]?.trim() || null;
+}
+function loadSourceMapForFile(filePath) {
+  const normalized = normalizeStackFilePath(filePath);
+  if (!normalized) return null;
+  const mod = nodeModuleApi();
+  try {
+    if (typeof mod.findSourceMap === "function") {
+      const found = mod.findSourceMap(normalized);
+      if (found) return found;
+    }
+  } catch {
+  }
+  const cache = stackTraceMapperState().sourceMapCache;
+  if (cache.has(normalized)) return cache.get(normalized) ?? null;
+  let loaded = null;
+  try {
+    const content = readTextFileCached(normalized);
+    const mappingUrl = content ? sourceMappingUrlFromContent(content) : null;
+    if (mappingUrl) {
+      let payload = null;
+      if (mappingUrl.startsWith("data:")) {
+        const base643 = mappingUrl.match(/^data:application\/json(?:;charset=[^;,]+)?;base64,(.+)$/i)?.[1];
+        if (base643) payload = JSON.parse(Buffer2.from(base643, "base64").toString("utf8"));
+      } else {
+        const mapPath = resolve7(dirname5(normalized), decodeURIComponent(mappingUrl));
+        if (existsSync9(mapPath)) payload = JSON.parse(readFileSync12(mapPath, "utf8"));
+      }
+      if (payload && typeof mod.SourceMap === "function") {
+        loaded = new mod.SourceMap(payload);
+      }
+    }
+  } catch {
+    loaded = null;
+  }
+  setBoundedCacheEntry(cache, normalized, loaded);
+  return loaded;
+}
+function sourceContentForOrigin(sourceMap, originFileName) {
+  const payload = sourceMap?.payload;
+  const sources = Array.isArray(payload?.sources) ? payload.sources : [];
+  const contents = Array.isArray(payload?.sourcesContent) ? payload.sourcesContent : [];
+  let index = sources.indexOf(originFileName);
+  if (index < 0) {
+    const normalizedOrigin = String(originFileName ?? "").replace(/\\/g, "/");
+    index = sources.findIndex((source) => String(source ?? "").replace(/\\/g, "/") === normalizedOrigin);
+  }
+  if (index < 0) return null;
+  const content = contents[index];
+  return typeof content === "string" ? content : null;
+}
+function resolveSourceMapSourcePath(mapFilePath, sourceMap, originFileName) {
+  let sourceRef = String(originFileName ?? "");
+  if (!sourceRef) return "";
+  if (sourceRef.startsWith("file://")) {
+    try {
+      return normalize(fileURLToPath2(sourceRef));
+    } catch {
+      return sourceRef;
+    }
+  }
+  if (isAbsolute2(sourceRef)) return normalize(sourceRef);
+  const sourceRoot = String(sourceMap?.payload?.sourceRoot ?? "");
+  if (sourceRoot.startsWith("file://")) {
+    try {
+      return normalize(resolve7(fileURLToPath2(sourceRoot), sourceRef));
+    } catch {
+      return normalize(sourceRef);
+    }
+  }
+  return normalize(resolve7(dirname5(normalizeStackFilePath(mapFilePath)), sourceRoot, sourceRef));
+}
+function sourceMapOriginForLocation(sourceMap, lineNumber, columnNumber) {
+  if (!sourceMap) return null;
+  if (typeof sourceMap.findOrigin === "function") {
+    try {
+      const origin = sourceMap.findOrigin(lineNumber, columnNumber);
+      if (origin?.fileName && Number.isFinite(Number(origin.lineNumber))) {
+        return {
+          fileName: String(origin.fileName),
+          lineNumber: Math.max(1, Math.floor(Number(origin.lineNumber) || 1))
+        };
+      }
+    } catch {
+    }
+  }
+  if (typeof sourceMap.findEntry === "function") {
+    try {
+      const entry = sourceMap.findEntry(Math.max(0, lineNumber - 1), Math.max(0, columnNumber - 1));
+      const fileName = entry?.originalSource ?? entry?.sourceURL ?? entry?.fileName;
+      const rawLine = entry?.originalLine ?? entry?.line ?? entry?.lineNumber;
+      if (fileName && Number.isFinite(Number(rawLine))) {
+        return {
+          fileName: String(fileName),
+          lineNumber: Math.max(1, Math.floor(Number(rawLine)) + 1)
+        };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function generatedSourceTextForLocation(filePath, lineNumber, columnNumber) {
+  const normalized = normalizeStackFilePath(filePath);
+  if (!normalized) return null;
+  const safeLine = Math.max(1, Math.floor(Number(lineNumber) || 1));
+  const rawColumn = Number(columnNumber);
+  const safeColumn = Number.isFinite(rawColumn) ? Math.max(0, Math.floor(rawColumn)) : 1;
+  const sourceMap = loadSourceMapForFile(normalized);
+  if (sourceMap) {
+    try {
+      const origin = sourceMapOriginForLocation(sourceMap, safeLine, safeColumn);
+      if (origin) {
+        const originPath = resolveSourceMapSourcePath(normalized, sourceMap, origin.fileName);
+        const content = readTextFileCached(originPath) ?? sourceContentForOrigin(sourceMap, origin.fileName);
+        if (content) {
+          return {
+            content,
+            filePath: originPath,
+            lineNumber: origin.lineNumber,
+            generatedFile: normalized,
+            generatedLine: safeLine
+          };
+        }
+      }
+    } catch {
+    }
+  }
+  const directContent = readTextFileCached(normalized);
+  if (!directContent) return null;
+  return {
+    content: directContent,
+    filePath: normalized,
+    lineNumber: safeLine,
+    generatedFile: normalized,
+    generatedLine: safeLine
+  };
+}
+function findNearestKernTrace(content, lineNumber) {
+  const lines = String(content ?? "").split(/\r?\n/);
+  const start = Math.max(0, Math.min(lines.length - 1, Math.floor(Number(lineNumber) || 1) - 1));
+  for (let index = start; index >= 0; index -= 1) {
+    const match = lines[index].match(/^\s*\/\/ @kern-source: (.+):(\d+)\s*$/);
+    if (!match) continue;
+    return { sourceName: match[1], line: Math.max(1, Math.floor(Number(match[2]) || 1)) };
+  }
+  return null;
+}
+function generatedHeaderSource(content) {
+  const match = String(content ?? "").match(/^\/\/\s*@generated\s+by\s+kern\b[\s\S]*?\bSource:\s*(.+?)\s*$/m);
+  return match?.[1]?.trim() || null;
+}
+function packageRootForGeneratedPath(generatedFile) {
+  const normalized = normalizeStackFilePath(generatedFile);
+  const slashPath = normalized.replace(/\\/g, "/");
+  const srcMarker = "/src/generated/";
+  const srcIndex = slashPath.indexOf(srcMarker);
+  if (srcIndex >= 0) return normalized.slice(0, srcIndex);
+  const generatedMarker = "/generated/";
+  const generatedIndex = slashPath.indexOf(generatedMarker);
+  if (generatedIndex >= 0) return normalized.slice(0, generatedIndex);
+  return null;
+}
+function resolveKernSourceFile(generatedFile, content, sourceName) {
+  const header = generatedHeaderSource(content);
+  const candidates = [];
+  const root = packageRootForGeneratedPath(generatedFile);
+  if (header) {
+    if (isAbsolute2(header)) candidates.push(normalize(header));
+    if (root) candidates.push(normalize(resolve7(root, header)));
+    candidates.push(normalize(resolve7(dirname5(normalizeStackFilePath(generatedFile)), header)));
+    try {
+      candidates.push(normalize(resolve7(process.cwd(), header)));
+    } catch {
+    }
+  }
+  if (root) {
+    candidates.push(normalize(resolve7(root, "src", "kern", `${sourceName}.kern`)));
+    candidates.push(normalize(resolve7(root, "kern", `${sourceName}.kern`)));
+  }
+  const sourceBase = `${sourceName}.kern`;
+  const matchingHeader = candidates.find((candidate) => basename3(candidate) === sourceBase);
+  const matchingHeaderExists = matchingHeader ? (() => {
+    try {
+      return existsSync9(matchingHeader);
+    } catch {
+      return false;
+    }
+  })() : false;
+  const existing = candidates.find((candidate) => {
+    try {
+      return existsSync9(candidate);
+    } catch {
+      return false;
+    }
+  });
+  return (matchingHeaderExists ? matchingHeader : null) ?? matchingHeader ?? existing ?? candidates[0] ?? sourceBase;
+}
+function resolveKernSourceLocation(filePath, lineNumber, columnNumber) {
+  const normalized = normalizeStackFilePath(filePath);
+  const cache = stackTraceMapperState().locationCache;
+  const cacheKey = `${normalized || String(filePath ?? "")}:${Number(lineNumber) || 0}:${Number(columnNumber) || 0}`;
+  if (cache.has(cacheKey)) return cache.get(cacheKey) ?? null;
+  const source = generatedSourceTextForLocation(filePath, lineNumber, columnNumber);
+  if (!source?.content) {
+    setBoundedCacheEntry(cache, cacheKey, null);
+    return null;
+  }
+  const trace = findNearestKernTrace(source.content, source.lineNumber);
+  if (!trace) {
+    setBoundedCacheEntry(cache, cacheKey, null);
+    return null;
+  }
+  const kernFile = resolveKernSourceFile(source.filePath, source.content, trace.sourceName);
+  const result = {
+    file: kernFile,
+    line: trace.line,
+    sourceName: trace.sourceName,
+    generatedFile: source.filePath,
+    generatedLine: source.lineNumber
+  };
+  setBoundedCacheEntry(cache, cacheKey, result);
+  return result;
+}
+function stackLineLocation(line) {
+  const match = String(line ?? "").match(/((?:file:\/\/\/[A-Za-z]:[\\/].+?|[A-Za-z]:[\\/].+?|file:\/\/\/.+?|\/.+?|\\\\.+?)\.(?:mjs|cjs|js|jsx|ts|tsx|mts|cts|vue|py|json)):(\d+):(\d+)(\)?)(\s*)$/);
+  if (!match || match.index == null) return null;
+  const locationText = `${match[1]}:${match[2]}:${match[3]}`;
+  return {
+    rawFile: match[1],
+    rawLine: match[2],
+    rawColumn: match[3],
+    start: match.index,
+    end: match.index + locationText.length
+  };
+}
+function mapKernStackTrace(stack) {
+  const text = String(stack ?? "");
+  if (!text) return text;
+  return text.split("\n").map((line) => {
+    if (line.includes("[kern: ")) return line;
+    const frame = stackLineLocation(line);
+    if (!frame) return line;
+    const loc = resolveKernSourceLocation(frame.rawFile, Number(frame.rawLine), Number(frame.rawColumn));
+    if (!loc) return line;
+    return `${line.slice(0, frame.end)} [kern: ${loc.file}:${loc.line}]${line.slice(frame.end)}`;
+  }).join("\n");
+}
+function formatDefaultStackTrace(error48, frames) {
+  const name = error48?.name ? String(error48.name) : "Error";
+  const message = error48?.message ? `${name}: ${String(error48.message)}` : name;
+  const lines = [message];
+  for (const frame of frames ?? []) {
+    lines.push(`    at ${String(frame)}`);
+  }
+  return lines.join("\n");
+}
+function stackTraceMapperDisabled() {
+  return !!process.env.AGON_NO_STACK_TRACE_MAPPER;
+}
+function stackTraceMapperState() {
+  const holder = stackTraceMapperState;
+  if (!holder.state) {
+    holder.state = {
+      installed: false,
+      previous: null,
+      wrapper: null,
+      sourceTextCache: /* @__PURE__ */ new Map(),
+      sourceMapCache: /* @__PURE__ */ new Map(),
+      locationCache: /* @__PURE__ */ new Map()
+    };
+  }
+  return holder.state;
+}
+function installKernStackTraceMapper() {
+  if (stackTraceMapperDisabled()) return;
+  const state = stackTraceMapperState();
+  if (state.installed && Error.prepareStackTrace === state.wrapper) return;
+  if (state.installed) {
+    state.installed = false;
+    state.previous = null;
+    state.wrapper = null;
+  }
+  const mod = nodeModuleApi();
+  try {
+    if (typeof mod.setSourceMapsSupport === "function") {
+      mod.setSourceMapsSupport(true, { nodeModules: false, generatedCode: true });
+    }
+  } catch {
+  }
+  const previous = Error.prepareStackTrace;
+  if (state.wrapper && previous === state.wrapper) {
+    state.installed = true;
+    return;
+  }
+  const wrapper = (error48, frames) => {
+    if (typeof previous === "function") {
+      const rendered = previous(error48, frames);
+      return typeof rendered === "string" ? mapKernStackTrace(rendered) : rendered;
+    }
+    return mapKernStackTrace(formatDefaultStackTrace(error48, frames));
+  };
+  try {
+    Error.prepareStackTrace = wrapper;
+  } catch {
+    return;
+  }
+  state.previous = previous;
+  state.wrapper = wrapper;
+  state.installed = true;
+}
+function uninstallKernStackTraceMapper() {
+  const state = stackTraceMapperState();
+  if (state.installed && Error.prepareStackTrace === state.wrapper) {
+    try {
+      Error.prepareStackTrace = state.previous;
+    } catch {
+    }
+  }
+  state.installed = false;
+  state.previous = null;
+  state.wrapper = null;
+  state.sourceTextCache?.clear?.();
+  state.sourceMapCache?.clear?.();
+  state.locationCache?.clear?.();
+}
+
 // ../core/src/generated/signals/output-manager.ts
 function formatSpinnerFrame(frames, index, text) {
   return `  \x1B[38;5;214m${frames[index % frames.length]}\x1B[0m \x1B[2m${text}\x1B[0m`;
@@ -17114,15 +17712,15 @@ async function discoverEngines(registry2, adapter) {
 }
 
 // ../core/src/generated/blocks/patch-apply.ts
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8, renameSync as renameSync8 } from "fs";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync10, mkdirSync as mkdirSync9, renameSync as renameSync8 } from "fs";
+import { join as join14 } from "path";
 import { execSync } from "child_process";
 
 // ../core/src/generated/utils/paths.ts
-import { join as join12, resolve as resolve7 } from "path";
+import { join as join13, resolve as resolve8 } from "path";
 import { homedir as homedir6 } from "os";
 function runtimeAgonPath(...parts) {
-  return join12(resolve7(process.env.AGON_HOME?.trim() || join12(homedir6(), ".agon")), ...parts);
+  return join13(resolve8(process.env.AGON_HOME?.trim() || join13(homedir6(), ".agon")), ...parts);
 }
 function getCacheDir() {
   return runtimeAgonPath("cache");
@@ -17215,12 +17813,12 @@ function invertPatch(content) {
 // ../core/src/generated/blocks/patch-apply.ts
 function readPatchFromManifest(manifestPath) {
   try {
-    const raw = readFileSync11(manifestPath, "utf-8");
+    const raw = readFileSync13(manifestPath, "utf-8");
     const manifest = JSON.parse(raw);
     if (!manifest.winner) return null;
     const patchPath = manifest.patches[manifest.winner];
     if (!patchPath) return null;
-    const content = normalizePatchContent(readFileSync11(patchPath, "utf-8"));
+    const content = normalizePatchContent(readFileSync13(patchPath, "utf-8"));
     const lineCount = content.split("\n").filter(
       (l) => l.startsWith("+") && !l.startsWith("+++") || l.startsWith("-") && !l.startsWith("---")
     ).length;
@@ -17232,7 +17830,7 @@ function readPatchFromManifest(manifestPath) {
 }
 function readPatchFromPath(patchPath) {
   try {
-    const content = normalizePatchContent(readFileSync11(patchPath, "utf-8"));
+    const content = normalizePatchContent(readFileSync13(patchPath, "utf-8"));
     if (!content.trim()) return null;
     const lineCount = content.split("\n").filter(
       (l) => l.startsWith("+") && !l.startsWith("+++") || l.startsWith("-") && !l.startsWith("---")
@@ -17292,7 +17890,7 @@ function preflightApply(cwd, patchPath, manifestPath) {
 }
 function applyPatchWithUndo(cwd, patchContent) {
   const undoDir = getUndoDir();
-  mkdirSync8(undoDir, { recursive: true });
+  mkdirSync9(undoDir, { recursive: true });
   const inverse = invertPatch(patchContent);
   const token = `undo-${Date.now()}`;
   try {
@@ -17301,18 +17899,18 @@ function applyPatchWithUndo(cwd, patchContent) {
     const msg = err instanceof Error ? err.stderr || err.message : String(err);
     return { ok: false, error: msg };
   }
-  const inversePath = join13(undoDir, `${token}.patch`);
-  const tmpPath = join13(undoDir, `${token}.patch.tmp`);
-  writeFileSync9(tmpPath, inverse);
+  const inversePath = join14(undoDir, `${token}.patch`);
+  const tmpPath = join14(undoDir, `${token}.patch.tmp`);
+  writeFileSync10(tmpPath, inverse);
   renameSync8(tmpPath, inversePath);
   return { ok: true, undoToken: token };
 }
 function undoPatch(cwd, undoToken) {
   const undoDir = getUndoDir();
-  const inversePath = join13(undoDir, `${undoToken}.patch`);
+  const inversePath = join14(undoDir, `${undoToken}.patch`);
   let inverse;
   try {
-    inverse = readFileSync11(inversePath, "utf-8");
+    inverse = readFileSync13(inversePath, "utf-8");
   } catch {
     return { ok: false, error: `Undo token not found: ${undoToken}` };
   }
@@ -17326,28 +17924,28 @@ function undoPatch(cwd, undoToken) {
 }
 
 // ../core/src/generated/blocks/file-history.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync10, mkdirSync as mkdirSync9, existsSync as existsSync8, readdirSync as readdirSync8, unlinkSync as unlinkSync4 } from "fs";
-import { join as join14, dirname as dirname5, resolve as resolve8 } from "path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync11, mkdirSync as mkdirSync10, existsSync as existsSync10, readdirSync as readdirSync9, unlinkSync as unlinkSync4 } from "fs";
+import { join as join15, dirname as dirname6, resolve as resolve9 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 import { homedir as homedir7 } from "os";
 function snapshotsDir() {
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve8(override) : join14(homedir7(), ".agon");
-  return join14(home, "snapshots");
+  const home = override ? resolve9(override) : join15(homedir7(), ".agon");
+  return join15(home, "snapshots");
 }
 var MAX_SNAPSHOTS = 50;
 function ensureSnapshotsDir() {
   ensureAgonHome();
-  mkdirSync9(snapshotsDir(), { recursive: true });
+  mkdirSync10(snapshotsDir(), { recursive: true });
 }
 function takeSnapshot(label, cwd, filePaths) {
   ensureSnapshotsDir();
   const files = [];
   for (const fp of filePaths) {
-    const fullPath = resolve8(cwd, fp);
-    if (existsSync8(fullPath)) {
+    const fullPath = resolve9(cwd, fp);
+    if (existsSync10(fullPath)) {
       try {
-        const content = readFileSync12(fullPath, "utf-8");
+        const content = readFileSync14(fullPath, "utf-8");
         files.push({ path: fp, content, timestamp: Date.now(), existed: true });
       } catch (err) {
         console.warn(`[agon] snapshot: could not read ${fp}: ${err instanceof Error ? err.message : String(err)}`);
@@ -17363,36 +17961,36 @@ function takeSnapshot(label, cwd, filePaths) {
     files,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const entryPath = join14(snapshotsDir(), `${entry.id}.json`);
-  writeFileSync10(entryPath, JSON.stringify(entry, null, 2) + "\n");
+  const entryPath = join15(snapshotsDir(), `${entry.id}.json`);
+  writeFileSync11(entryPath, JSON.stringify(entry, null, 2) + "\n");
   pruneSnapshots();
   return entry;
 }
 function revertSnapshot(id) {
   ensureSnapshotsDir();
-  const entryPath = join14(snapshotsDir(), `${id}.json`);
-  if (!existsSync8(entryPath)) {
+  const entryPath = join15(snapshotsDir(), `${id}.json`);
+  if (!existsSync10(entryPath)) {
     return { ok: false, error: `Snapshot ${id} not found`, filesReverted: 0 };
   }
   let entry;
   try {
-    entry = JSON.parse(readFileSync12(entryPath, "utf-8"));
+    entry = JSON.parse(readFileSync14(entryPath, "utf-8"));
   } catch (err) {
     return { ok: false, error: `Corrupt snapshot: ${err instanceof Error ? err.message : String(err)}`, filesReverted: 0 };
   }
   let reverted = 0;
   for (const snap of entry.files) {
-    const fullPath = resolve8(entry.cwd, snap.path);
+    const fullPath = resolve9(entry.cwd, snap.path);
     try {
       const existedBefore = typeof snap.existed === "boolean" ? snap.existed : snap.content !== "";
       if (!existedBefore) {
-        if (existsSync8(fullPath)) {
+        if (existsSync10(fullPath)) {
           unlinkSync4(fullPath);
           reverted++;
         }
       } else {
-        mkdirSync9(dirname5(fullPath), { recursive: true });
-        writeFileSync10(fullPath, snap.content);
+        mkdirSync10(dirname6(fullPath), { recursive: true });
+        writeFileSync11(fullPath, snap.content);
         reverted++;
       }
     } catch (err) {
@@ -17409,10 +18007,10 @@ function revertSnapshot(id) {
 function listSnapshots() {
   ensureSnapshotsDir();
   try {
-    const files = readdirSync8(snapshotsDir()).filter((f) => f.endsWith(".json"));
+    const files = readdirSync9(snapshotsDir()).filter((f) => f.endsWith(".json"));
     const entries = files.map((f) => {
       try {
-        return JSON.parse(readFileSync12(join14(snapshotsDir(), f), "utf-8"));
+        return JSON.parse(readFileSync14(join15(snapshotsDir(), f), "utf-8"));
       } catch {
         return null;
       }
@@ -17429,11 +18027,11 @@ function listSnapshots() {
 }
 function pruneSnapshots() {
   try {
-    const files = readdirSync8(snapshotsDir()).filter((f) => f.endsWith(".json"));
+    const files = readdirSync9(snapshotsDir()).filter((f) => f.endsWith(".json"));
     if (files.length > MAX_SNAPSHOTS) {
       const byAge = files.map((f) => {
         try {
-          const entry = JSON.parse(readFileSync12(join14(snapshotsDir(), f), "utf-8"));
+          const entry = JSON.parse(readFileSync14(join15(snapshotsDir(), f), "utf-8"));
           return { file: f, ts: Date.parse(entry.createdAt ?? "") || 0 };
         } catch {
           return { file: f, ts: 0 };
@@ -17442,7 +18040,7 @@ function pruneSnapshots() {
       const toDelete = byAge.slice(0, files.length - MAX_SNAPSHOTS);
       for (const item of toDelete) {
         try {
-          unlinkSync4(join14(snapshotsDir(), item.file));
+          unlinkSync4(join15(snapshotsDir(), item.file));
         } catch {
         }
       }
@@ -17533,38 +18131,38 @@ function copyToClipboard(text) {
 }
 
 // ../core/src/generated/signals/paste-store.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync11, mkdirSync as mkdirSync10, existsSync as existsSync9, readdirSync as readdirSync9, unlinkSync as unlinkSync5, statSync as statSync8 } from "fs";
-import { join as join15, resolve as resolve9 } from "path";
-import { createHash as createHash2 } from "crypto";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync12, mkdirSync as mkdirSync11, existsSync as existsSync11, readdirSync as readdirSync10, unlinkSync as unlinkSync5, statSync as statSync9 } from "fs";
+import { join as join16, resolve as resolve10 } from "path";
+import { createHash as createHash3 } from "crypto";
 import { homedir as homedir8 } from "os";
 function getPasteStoreDir() {
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve9(override) : join15(homedir8(), ".agon");
-  return join15(home, "paste-cache");
+  const home = override ? resolve10(override) : join16(homedir8(), ".agon");
+  return join16(home, "paste-cache");
 }
 var PASTE_MAX_AGE = 7 * 24 * 60 * 60 * 1e3;
 function ensurePasteDir() {
   ensureAgonHome();
-  mkdirSync10(getPasteStoreDir(), { recursive: true });
+  mkdirSync11(getPasteStoreDir(), { recursive: true });
 }
 var PasteStore = class {
   store(text) {
     ensurePasteDir();
-    const hash2 = createHash2("sha256").update(text).digest("hex");
-    const filePath = join15(getPasteStoreDir(), `${hash2}.txt`);
-    if (!existsSync9(filePath)) {
-      writeFileSync11(filePath, text);
+    const hash2 = createHash3("sha256").update(text).digest("hex");
+    const filePath = join16(getPasteStoreDir(), `${hash2}.txt`);
+    if (!existsSync11(filePath)) {
+      writeFileSync12(filePath, text);
     }
     const lines = text.split("\n");
     const preview = text.slice(0, 200).replace(/\n/g, " ").trim();
     return { hash: hash2, preview, lineCount: lines.length };
   }
   retrieve(hash2) {
-    const filePath = join15(getPasteStoreDir(), `${hash2}.txt`);
-    if (!existsSync9(filePath)) {
+    const filePath = join16(getPasteStoreDir(), `${hash2}.txt`);
+    if (!existsSync11(filePath)) {
       return null;
     }
-    return readFileSync13(filePath, "utf-8");
+    return readFileSync15(filePath, "utf-8");
   }
   cleanup(maxAge) {
     const age = maxAge ?? PASTE_MAX_AGE;
@@ -17573,11 +18171,11 @@ var PasteStore = class {
     ensurePasteDir();
     try {
       const pasteStoreDir = getPasteStoreDir();
-      const files = readdirSync9(pasteStoreDir).filter((f) => f.endsWith(".txt"));
+      const files = readdirSync10(pasteStoreDir).filter((f) => f.endsWith(".txt"));
       for (const f of files) {
-        const fp = join15(pasteStoreDir, f);
+        const fp = join16(pasteStoreDir, f);
         try {
-          const stat = statSync8(fp);
+          const stat = statSync9(fp);
           if (now - stat.mtimeMs > age) {
             unlinkSync5(fp);
             deleted++;
@@ -17597,27 +18195,27 @@ var PasteStore = class {
 var pasteStore = new PasteStore();
 
 // ../core/src/generated/signals/session-store.ts
-import { writeFileSync as writeFileSync12, readFileSync as readFileSync14, existsSync as existsSync10, mkdirSync as mkdirSync11, unlinkSync as unlinkSync6, readdirSync as readdirSync10, rmdirSync, renameSync as renameSync9 } from "fs";
-import { join as join16 } from "path";
-import { createHash as createHash3 } from "crypto";
+import { writeFileSync as writeFileSync13, readFileSync as readFileSync16, existsSync as existsSync12, mkdirSync as mkdirSync12, unlinkSync as unlinkSync6, readdirSync as readdirSync11, rmdirSync, renameSync as renameSync9 } from "fs";
+import { join as join17 } from "path";
+import { createHash as createHash4 } from "crypto";
 var SESSION_SCHEMA_VERSION = 2;
 var SESSION_MAX_MESSAGES = 80;
 var SESSION_TTL_MS = 36e5;
 function sessionStorePath(engineId) {
-  const cwdHash = createHash3("md5").update(process.cwd()).digest("hex").slice(0, 8);
+  const cwdHash = createHash4("md5").update(process.cwd()).digest("hex").slice(0, 8);
   return runtimeAgonPath("sessions", `${engineId}-${cwdHash}.json`);
 }
 function sessionCacheDir(engineId) {
-  const cwdHash = createHash3("md5").update(process.cwd()).digest("hex").slice(0, 8);
+  const cwdHash = createHash4("md5").update(process.cwd()).digest("hex").slice(0, 8);
   return runtimeAgonPath("sessions", `${engineId}-${cwdHash}-cache`);
 }
 function saveToolResultToDisk(engineId, toolCallId, toolName, content) {
   try {
     const cacheDir = sessionCacheDir(engineId);
-    mkdirSync11(cacheDir, { recursive: true });
-    const filePath = join16(cacheDir, `${toolCallId}.txt`);
+    mkdirSync12(cacheDir, { recursive: true });
+    const filePath = join17(cacheDir, `${toolCallId}.txt`);
     const tmpFilePath = filePath + ".tmp";
-    writeFileSync12(tmpFilePath, content, "utf-8");
+    writeFileSync13(tmpFilePath, content, "utf-8");
     renameSync9(tmpFilePath, filePath);
     return {
       toolCallId,
@@ -17634,11 +18232,11 @@ function saveToolResultToDisk(engineId, toolCallId, toolName, content) {
 function loadToolResultFromDisk(engineId, toolCallId) {
   try {
     const cacheDir = sessionCacheDir(engineId);
-    const filePath = join16(cacheDir, `${toolCallId}.txt`);
-    if (!existsSync10(filePath)) {
+    const filePath = join17(cacheDir, `${toolCallId}.txt`);
+    if (!existsSync12(filePath)) {
       return null;
     }
-    return readFileSync14(filePath, "utf-8");
+    return readFileSync16(filePath, "utf-8");
   } catch (e) {
     return null;
   }
@@ -17646,13 +18244,13 @@ function loadToolResultFromDisk(engineId, toolCallId) {
 function pruneToolCache(engineId, keepIds) {
   try {
     const cacheDir = sessionCacheDir(engineId);
-    if (!existsSync10(cacheDir)) return;
-    const files = readdirSync10(cacheDir);
+    if (!existsSync12(cacheDir)) return;
+    const files = readdirSync11(cacheDir);
     for (const f of files) {
       const id = f.replace(/\.txt$/, "");
       if (!keepIds.has(id)) {
         try {
-          unlinkSync6(join16(cacheDir, f));
+          unlinkSync6(join17(cacheDir, f));
         } catch {
         }
       }
@@ -17662,21 +18260,21 @@ function pruneToolCache(engineId, keepIds) {
 }
 function saveSessionState(engineId, state) {
   const dir = runtimeAgonPath("sessions");
-  mkdirSync11(dir, { recursive: true });
+  mkdirSync12(dir, { recursive: true });
   const path = sessionStorePath(engineId);
   const trimmed = state.messageHistory.slice(-SESSION_MAX_MESSAGES);
   const data = { schemaVersion: SESSION_SCHEMA_VERSION, messageHistory: trimmed, compactionSummary: state.compactionSummary ?? null, toolCacheManifest: state.toolCacheManifest ?? [], confidence: state.confidence, savedAt: Date.now() };
   const tmpPath = path + ".tmp";
-  writeFileSync12(tmpPath, JSON.stringify(data), "utf-8");
+  writeFileSync13(tmpPath, JSON.stringify(data), "utf-8");
   renameSync9(tmpPath, path);
 }
 function loadSessionState(engineId) {
   const path = sessionStorePath(engineId);
-  if (!existsSync10(path)) {
+  if (!existsSync12(path)) {
     return null;
   }
   try {
-    const raw = readFileSync14(path, "utf-8");
+    const raw = readFileSync16(path, "utf-8");
     const data = JSON.parse(raw);
     if (data.savedAt && Date.now() - data.savedAt > SESSION_TTL_MS) {
       return null;
@@ -17695,16 +18293,16 @@ function loadSessionState(engineId) {
 function clearSessionState(engineId) {
   const path = sessionStorePath(engineId);
   try {
-    if (existsSync10(path)) unlinkSync6(path);
+    if (existsSync12(path)) unlinkSync6(path);
   } catch {
   }
   try {
     const cacheDir = sessionCacheDir(engineId);
-    if (existsSync10(cacheDir)) {
-      const files = readdirSync10(cacheDir);
+    if (existsSync12(cacheDir)) {
+      const files = readdirSync11(cacheDir);
       for (const f of files) {
         try {
-          unlinkSync6(join16(cacheDir, f));
+          unlinkSync6(join17(cacheDir, f));
         } catch {
         }
       }
@@ -17715,7 +18313,7 @@ function clearSessionState(engineId) {
 }
 var CONVERSATION_SCHEMA_VERSION = 1;
 function conversationStorePath() {
-  const cwdHash = createHash3("md5").update(process.cwd()).digest("hex").slice(0, 8);
+  const cwdHash = createHash4("md5").update(process.cwd()).digest("hex").slice(0, 8);
   return runtimeAgonPath("sessions", `conversation-${cwdHash}.json`);
 }
 function stripEngineArtifacts(messages) {
@@ -17764,22 +18362,22 @@ ${marker}` : marker;
 }
 function saveConversation(messages, sourceEngineId) {
   const dir = runtimeAgonPath("sessions");
-  mkdirSync11(dir, { recursive: true });
+  mkdirSync12(dir, { recursive: true });
   const path = conversationStorePath();
   const trimmed = messages.slice(-SESSION_MAX_MESSAGES);
   const clean = stripEngineArtifacts(trimmed);
   const data = { schemaVersion: CONVERSATION_SCHEMA_VERSION, messageHistory: clean, savedAt: Date.now(), sourceEngine: sourceEngineId };
   const tmpPath = path + ".tmp";
-  writeFileSync12(tmpPath, JSON.stringify(data), "utf-8");
+  writeFileSync13(tmpPath, JSON.stringify(data), "utf-8");
   renameSync9(tmpPath, path);
 }
 function loadConversation() {
   const path = conversationStorePath();
-  if (!existsSync10(path)) {
+  if (!existsSync12(path)) {
     return null;
   }
   try {
-    const raw = readFileSync14(path, "utf-8");
+    const raw = readFileSync16(path, "utf-8");
     const data = JSON.parse(raw);
     if (data.savedAt && Date.now() - data.savedAt > SESSION_TTL_MS) {
       return null;
@@ -17795,7 +18393,7 @@ function loadConversation() {
 function clearConversation() {
   const path = conversationStorePath();
   try {
-    if (existsSync10(path)) unlinkSync6(path);
+    if (existsSync12(path)) unlinkSync6(path);
   } catch {
   }
 }
@@ -17998,7 +18596,7 @@ var Semaphore = class {
       this.permits -= 1;
       return;
     }
-    return new Promise((resolve27, reject) => {
+    return new Promise((resolve28, reject) => {
       const entry = {
         resolve: () => {
           if (entry.onAbort && entry.signal) {
@@ -18007,7 +18605,7 @@ var Semaphore = class {
             } catch {
             }
           }
-          resolve27();
+          resolve28();
         },
         reject: (err) => {
           if (entry.onAbort && entry.signal) {
@@ -18624,8 +19222,8 @@ async function runToolLoop(sendMessage, initialResponse, ctx, registry2, callbac
 }
 
 // ../core/src/generated/tools/tool-read.ts
-import { readFileSync as readFileSync15, statSync as statSync10, existsSync as existsSync11 } from "fs";
-import { resolve as resolve10, relative as relative3 } from "path";
+import { readFileSync as readFileSync17, statSync as statSync11, existsSync as existsSync13 } from "fs";
+import { resolve as resolve11, relative as relative4 } from "path";
 function formatWithLineNumbers(text, startLine) {
   const lines = text.split("\n");
   return lines.map((line, i) => {
@@ -18663,9 +19261,9 @@ function createReadTool() {
     return null;
   };
   const checkPermission = (input, ctx) => {
-    const filePath = resolve10(ctx.cwd, input.file_path);
-    const rel = relative3(ctx.cwd, filePath);
-    if (rel.startsWith("..") || resolve10(ctx.cwd, rel) !== filePath) {
+    const filePath = resolve11(ctx.cwd, input.file_path);
+    const rel = relative4(ctx.cwd, filePath);
+    if (rel.startsWith("..") || resolve11(ctx.cwd, rel) !== filePath) {
       return {
         behavior: "deny",
         message: `Read denied: ${filePath} is outside the working directory`,
@@ -18675,7 +19273,7 @@ function createReadTool() {
     return { behavior: "allow" };
   };
   const execute = async (input, ctx) => {
-    const filePath = resolve10(ctx.cwd, input.file_path);
+    const filePath = resolve11(ctx.cwd, input.file_path);
     if (ctx.virtualFs) {
       const vfsContent = ctx.virtualFs.read(filePath);
       if (vfsContent === null) {
@@ -18687,12 +19285,12 @@ function createReadTool() {
       const sliced2 = limit2 !== void 0 ? lines2.slice(offset2, offset2 + limit2) : lines2.slice(offset2);
       return { ok: true, content: sliced2.join("\n") };
     }
-    if (!existsSync11(filePath)) {
+    if (!existsSync13(filePath)) {
       return { ok: false, content: "", error: `File not found: ${filePath}` };
     }
     let mtime;
     try {
-      const stat = statSync10(filePath);
+      const stat = statSync11(filePath);
       mtime = stat.mtimeMs;
     } catch (err) {
       return { ok: false, content: "", error: `Cannot stat file: ${err instanceof Error ? err.message : String(err)}` };
@@ -18708,7 +19306,7 @@ function createReadTool() {
     }
     let fullContent;
     try {
-      fullContent = readFileSync15(filePath, "utf-8");
+      fullContent = readFileSync17(filePath, "utf-8");
     } catch (err) {
       return { ok: false, content: "", error: `Cannot read file: ${err instanceof Error ? err.message : String(err)}` };
     }
@@ -18739,8 +19337,8 @@ function createReadTool() {
 }
 
 // ../core/src/generated/tools/tool-edit.ts
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync13, statSync as statSync11, existsSync as existsSync12 } from "fs";
-import { resolve as resolve11, relative as relative4 } from "path";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync14, statSync as statSync12, existsSync as existsSync14 } from "fs";
+import { resolve as resolve12, relative as relative5 } from "path";
 function normalizeCurlyQuotes(text) {
   return text.replace(/[\u2018\u2019]/g, "'").replace(/[\u201C\u201D]/g, '"');
 }
@@ -18796,9 +19394,9 @@ function createEditTool() {
         reason: "exploration-mode"
       };
     }
-    const filePath = resolve11(ctx.cwd, input.file_path);
-    const rel = relative4(ctx.cwd, filePath);
-    if (rel.startsWith("..") || resolve11(ctx.cwd, rel) !== filePath) {
+    const filePath = resolve12(ctx.cwd, input.file_path);
+    const rel = relative5(ctx.cwd, filePath);
+    if (rel.startsWith("..") || resolve12(ctx.cwd, rel) !== filePath) {
       return {
         behavior: "deny",
         message: `Edit denied: ${filePath} is outside the working directory`,
@@ -18808,7 +19406,7 @@ function createEditTool() {
     return { behavior: "allow" };
   };
   const execute = async (input, ctx) => {
-    const filePath = resolve11(ctx.cwd, input.file_path);
+    const filePath = resolve12(ctx.cwd, input.file_path);
     const oldString = input.old_string;
     const newString = input.new_string;
     const replaceAll = input.replace_all ?? false;
@@ -18824,7 +19422,7 @@ function createEditTool() {
       ctx.virtualFs.write(filePath, updated);
       return { ok: true, content: `Edited ${filePath} in VirtualFS` };
     }
-    if (!existsSync12(filePath)) {
+    if (!existsSync14(filePath)) {
       return { ok: false, content: "", error: `File not found: ${filePath}` };
     }
     const cache = ctx.readFileState;
@@ -18837,7 +19435,7 @@ function createEditTool() {
     }
     let mtime;
     try {
-      const stat = statSync11(filePath);
+      const stat = statSync12(filePath);
       mtime = stat.mtimeMs;
     } catch (err) {
       return { ok: false, content: "", error: `Cannot stat file: ${err instanceof Error ? err.message : String(err)}` };
@@ -18852,7 +19450,7 @@ function createEditTool() {
     }
     let content;
     try {
-      content = readFileSync16(filePath, "utf-8");
+      content = readFileSync18(filePath, "utf-8");
     } catch (err) {
       return { ok: false, content: "", error: `Cannot read file: ${err instanceof Error ? err.message : String(err)}` };
     }
@@ -18885,15 +19483,15 @@ function createEditTool() {
         };
       }
     }
-    const relPath = relative4(ctx.cwd, filePath);
+    const relPath = relative5(ctx.cwd, filePath);
     const snapshot = takeSnapshot(`Edit: ${relPath}`, ctx.cwd, [relPath]);
     const newContent = replaceAll ? content.split(searchString).join(newString) : content.replace(searchString, newString);
     try {
-      writeFileSync13(filePath, newContent, "utf-8");
+      writeFileSync14(filePath, newContent, "utf-8");
     } catch (err) {
       return { ok: false, content: "", error: `Failed to write file: ${err instanceof Error ? err.message : String(err)}` };
     }
-    const newMtime = statSync11(filePath).mtimeMs;
+    const newMtime = statSync12(filePath).mtimeMs;
     cache.set(filePath, {
       content: newContent,
       timestamp: newMtime,
@@ -18912,8 +19510,8 @@ function createEditTool() {
 }
 
 // ../core/src/generated/tools/tool-write.ts
-import { writeFileSync as writeFileSync14, statSync as statSync12, existsSync as existsSync13, mkdirSync as mkdirSync13 } from "fs";
-import { resolve as resolve12, dirname as dirname8, relative as relative5 } from "path";
+import { writeFileSync as writeFileSync15, statSync as statSync13, existsSync as existsSync15, mkdirSync as mkdirSync14 } from "fs";
+import { resolve as resolve13, dirname as dirname9, relative as relative6 } from "path";
 function createWriteTool() {
   const definition = {
     name: "Write",
@@ -18947,9 +19545,9 @@ function createWriteTool() {
         reason: "exploration-mode"
       };
     }
-    const filePath = resolve12(ctx.cwd, input.file_path);
-    const rel = relative5(ctx.cwd, filePath);
-    if (rel.startsWith("..") || resolve12(ctx.cwd, rel) !== filePath) {
+    const filePath = resolve13(ctx.cwd, input.file_path);
+    const rel = relative6(ctx.cwd, filePath);
+    if (rel.startsWith("..") || resolve13(ctx.cwd, rel) !== filePath) {
       return {
         behavior: "deny",
         message: `Write denied: ${filePath} is outside the working directory`,
@@ -18959,15 +19557,15 @@ function createWriteTool() {
     return { behavior: "allow" };
   };
   const execute = async (input, ctx) => {
-    const filePath = resolve12(ctx.cwd, input.file_path);
+    const filePath = resolve13(ctx.cwd, input.file_path);
     const content = input.content;
-    const relPath = relative5(ctx.cwd, filePath);
+    const relPath = relative6(ctx.cwd, filePath);
     const cache = ctx.readFileState;
     if (ctx.virtualFs) {
       ctx.virtualFs.write(filePath, content);
       return { ok: true, content: `Wrote ${filePath} in VirtualFS (${content.split("\n").length} lines)` };
     }
-    const fileExists = existsSync13(filePath);
+    const fileExists = existsSync15(filePath);
     let snapshot = null;
     if (fileExists) {
       if (!cache.has(filePath)) {
@@ -18979,7 +19577,7 @@ function createWriteTool() {
       }
       let mtime;
       try {
-        const stat = statSync12(filePath);
+        const stat = statSync13(filePath);
         mtime = stat.mtimeMs;
       } catch (err) {
         return { ok: false, content: "", error: `Cannot stat file: ${err instanceof Error ? err.message : String(err)}` };
@@ -18996,20 +19594,20 @@ function createWriteTool() {
     } else {
       snapshot = takeSnapshot(`Write (new): ${relPath}`, ctx.cwd, [relPath]);
     }
-    const parentDir = dirname8(filePath);
-    if (!existsSync13(parentDir)) {
+    const parentDir = dirname9(filePath);
+    if (!existsSync15(parentDir)) {
       try {
-        mkdirSync13(parentDir, { recursive: true });
+        mkdirSync14(parentDir, { recursive: true });
       } catch (err) {
         return { ok: false, content: "", error: `Failed to create directory: ${err instanceof Error ? err.message : String(err)}` };
       }
     }
     try {
-      writeFileSync14(filePath, content, "utf-8");
+      writeFileSync15(filePath, content, "utf-8");
     } catch (err) {
       return { ok: false, content: "", error: `Failed to write file: ${err instanceof Error ? err.message : String(err)}` };
     }
-    const newMtime = statSync12(filePath).mtimeMs;
+    const newMtime = statSync13(filePath).mtimeMs;
     cache.set(filePath, {
       content,
       timestamp: newMtime,
@@ -19112,10 +19710,10 @@ function createBashTool() {
     const readRedirect = tryRedirectToRead(command);
     if (readRedirect) {
       try {
-        const { readFileSync: readFileSync31 } = await import("fs");
-        const { resolve: resolve27 } = await import("path");
-        const filePath = resolve27(ctx.cwd, readRedirect.file);
-        const content = readFileSync31(filePath, "utf-8");
+        const { readFileSync: readFileSync33 } = await import("fs");
+        const { resolve: resolve28 } = await import("path");
+        const filePath = resolve28(ctx.cwd, readRedirect.file);
+        const content = readFileSync33(filePath, "utf-8");
         const lines = content.split("\n");
         const offset = readRedirect.offset ?? 0;
         const limit = readRedirect.limit ?? lines.length;
@@ -19415,7 +20013,7 @@ import { randomUUID as randomUUID3 } from "crypto";
 
 // ../core/src/generated/blocks/file-state-cache.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 var MAX_CACHE_ENTRIES = 100;
 var MAX_CACHE_BYTES = 25 * 1024 * 1024;
 function createTrackedFileStateMap(owner) {
@@ -19520,7 +20118,7 @@ var _projectCaches = /* @__PURE__ */ new Map();
 var _projectFingerprintCache = /* @__PURE__ */ new Map();
 var PROJECT_FINGERPRINT_TTL_MS = 1e3;
 function projectCacheFingerprint(cwd) {
-  const absCwd = resolve13(cwd || process.cwd());
+  const absCwd = resolve14(cwd || process.cwd());
   const now = Date.now();
   const cached2 = _projectFingerprintCache.get(absCwd);
   if (cached2 && cached2.expires > now) return cached2.value;
@@ -19895,21 +20493,21 @@ function createTodoWriteTool() {
 }
 
 // ../core/src/generated/signals/auth-store.ts
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync15, mkdirSync as mkdirSync14, existsSync as existsSync14, chmodSync } from "fs";
-import { join as join17, dirname as dirname9, resolve as resolve14 } from "path";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync16, mkdirSync as mkdirSync15, existsSync as existsSync16, chmodSync } from "fs";
+import { join as join18, dirname as dirname10, resolve as resolve15 } from "path";
 import { homedir as homedir9 } from "os";
 function getAuthFile() {
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve14(override) : join17(homedir9(), ".agon");
-  return join17(home, "auth.json");
+  const home = override ? resolve15(override) : join18(homedir9(), ".agon");
+  return join18(home, "auth.json");
 }
 function loadAuthStore() {
   const authFile = getAuthFile();
-  if (!existsSync14(authFile)) {
+  if (!existsSync16(authFile)) {
     return { entries: {} };
   }
   try {
-    const data = JSON.parse(readFileSync17(authFile, "utf-8"));
+    const data = JSON.parse(readFileSync19(authFile, "utf-8"));
     return { entries: data ?? {} };
   } catch (e) {
     return { entries: {} };
@@ -19917,9 +20515,9 @@ function loadAuthStore() {
 }
 function saveAuthStore(store) {
   const authFile = getAuthFile();
-  const dir = dirname9(authFile);
-  mkdirSync14(dir, { recursive: true });
-  writeFileSync15(authFile, JSON.stringify(store.entries, null, 2) + "\n", { mode: 384 });
+  const dir = dirname10(authFile);
+  mkdirSync15(dir, { recursive: true });
+  writeFileSync16(authFile, JSON.stringify(store.entries, null, 2) + "\n", { mode: 384 });
   try {
     chmodSync(authFile, 384);
   } catch (_e) {
@@ -20469,7 +21067,7 @@ function planEngineIsolation(engine, mode, opts) {
 var fileStateCache = new FileStateCache();
 
 // ../core/src/generated/tools/tool-permissions.ts
-import { resolve as resolve15, relative as relative6, isAbsolute as isAbsolute2 } from "path";
+import { resolve as resolve16, relative as relative7, isAbsolute as isAbsolute3 } from "path";
 import { realpathSync as realpathSync3 } from "fs";
 import { execSync as execSync3 } from "child_process";
 var DANGEROUS_COMMANDS = ["rm -rf /", "rm -rf ~", "rm -rf *", "dd if" + String.fromCharCode(61), "mkfs.", "> /dev/sd", "> /dev/nv", "chmod 777 /", ":(){:|:&}\\x3b:"];
@@ -20524,7 +21122,7 @@ function checkBashPermission(command, ctx) {
   return isDangerousCommand(command) ? { behavior: "deny", message: `Dangerous command blocked: ${command.slice(0, 50)}`, reason: "dangerous_pattern" } : ctx.permissionMode === "deny-all" ? { behavior: "deny", message: "All tool execution is denied" } : ctx.toolPermissions?.["Bash"] === "allow" ? { behavior: "allow" } : ctx.toolPermissions?.["Bash"] === "deny" ? { behavior: "deny", message: "Bash denied in settings" } : isReadOnlyCommand(command) ? { behavior: "allow" } : ctx.allowedCommands?.some((ac) => command.startsWith(ac) || command.trim().split(/\s+/)[0] === ac) ? { behavior: "allow" } : ctx.permissionMode === "smart" ? isSessionAllowed(command, ctx) || ctx.source === "orchestrator" ? { behavior: "allow" } : { behavior: "ask", message: `This command requires approval`, reason: "bash_mutating" } : ctx.permissionMode === "auto" ? { behavior: "allow" } : { behavior: "ask", message: `This command requires approval`, reason: "bash_mutating" };
 }
 function isPathUnderCwd(filePath, cwd) {
-  const resolved = isAbsolute2(filePath) ? filePath : resolve15(cwd, filePath);
+  const resolved = isAbsolute3(filePath) ? filePath : resolve16(cwd, filePath);
   let realPath;
   let realCwd;
   try {
@@ -20537,7 +21135,7 @@ function isPathUnderCwd(filePath, cwd) {
   } catch {
     realCwd = cwd;
   }
-  const rel = relative6(realCwd, realPath);
+  const rel = relative7(realCwd, realPath);
   return !rel.startsWith("..");
 }
 function checkFileReadPermission(filePath, ctx) {
@@ -20547,7 +21145,7 @@ function checkFileReadPermission(filePath, ctx) {
   if (ctx.toolPermissions?.["Read"] === "deny") {
     return { behavior: "deny", message: "Read denied in settings" };
   }
-  const readResolved = isAbsolute2(filePath) ? filePath : resolve15(ctx.cwd, filePath);
+  const readResolved = isAbsolute3(filePath) ? filePath : resolve16(ctx.cwd, filePath);
   if (isPathUnderCwd(readResolved, ctx.cwd)) {
     return { behavior: "allow" };
   }
@@ -20572,11 +21170,11 @@ function checkFileWritePermission(filePath, ctx) {
       return { behavior: "ask", message: `Edit requires approval: ${filePath}` };
     }
   }
-  const writeResolved = isAbsolute2(filePath) ? filePath : resolve15(ctx.cwd, filePath);
-  const basename6 = writeResolved.split("/").pop() ?? "";
+  const writeResolved = isAbsolute3(filePath) ? filePath : resolve16(ctx.cwd, filePath);
+  const basename7 = writeResolved.split("/").pop() ?? "";
   const sensitivePatterns = [".env", "credentials", "secrets", ".pem", ".key", "id_rsa"];
-  if (sensitivePatterns.some((pat) => basename6.includes(pat))) {
-    return { behavior: "ask", message: `Write to sensitive file: ${basename6}` };
+  if (sensitivePatterns.some((pat) => basename7.includes(pat))) {
+    return { behavior: "ask", message: `Write to sensitive file: ${basename7}` };
   }
   if (isPathUnderCwd(writeResolved, ctx.cwd)) {
     return { behavior: "allow" };
@@ -20936,6 +21534,39 @@ function createGoalTool() {
   };
   return { definition, validate, checkPermission, execute };
 }
+function createConquerTool() {
+  const definition = {
+    name: "Conquer",
+    description: "Delegate to the supervised-autonomous conquer controller \u2014 Cesar drives an external builder CLI (--builder codex|claude|agy, default codex) as the user, unattended, until an OPEN-ENDED build is done, then STOPS at a human merge gate (changes left in the tree or pushed to a branch; NEVER auto-merged). The gate command IS the done-spec \u2014 make it discriminating. Fire ONLY when the user explicitly asks to conquer / build unattended; it is a long multi-hour run. After calling, STOP and wait \u2014 runs in the background; track with /jobs or /focus.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        task: { type: "string", description: "Open-ended build task to drive to completion (seeds the run + branch)." },
+        gate: { type: "string", description: 'The done-spec: a discriminating test/verify command that proves the build is complete (e.g. "pnpm test"). Required \u2014 frozen at start.' },
+        builder: { type: "string", description: "External builder CLI Cesar drives as the user: codex | claude | agy. Default codex." },
+        engines: { type: "array", items: { type: "string" }, description: "Optional consult roster for fork escalations (nero/tribunal/council). Omit for active roster." },
+        maxTurns: { type: "number", description: "Optional cap on builder turns (0/omit = controller default)." }
+      },
+      required: ["task", "gate"]
+    },
+    maxResultSizeChars: 500,
+    isReadOnly: false,
+    isConcurrencySafe: false
+  };
+  const validate = (input, _ctx) => {
+    if (!input.task || typeof input.task !== "string" || !input.task.trim()) return "Missing required parameter: task";
+    if (!input.gate || typeof input.gate !== "string" || !input.gate.trim()) return "Missing required parameter: gate (the done-spec test/verify command). Ask the user for the command that proves the build is done.";
+    if (input.engines !== void 0 && (!Array.isArray(input.engines) || !input.engines.every((e) => typeof e === "string" && e.trim().length > 0))) return "engines must be an array of non-empty engine ID strings";
+    return null;
+  };
+  const checkPermission = (_input, _ctx) => {
+    return { behavior: "allow" };
+  };
+  const execute = async (_input, _ctx) => {
+    return { ok: true, content: "Delegation accepted. STOP responding now. The orchestrator will handle the rest." };
+  };
+  return { definition, validate, checkPermission, execute };
+}
 function createPipelineTool() {
   const definition = {
     name: "Pipeline",
@@ -21094,8 +21725,8 @@ function createExitPlanModeTool() {
 }
 
 // ../core/src/generated/cesar/plan.ts
-import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync16, readFileSync as readFileSync18, readdirSync as readdirSync11, renameSync as renameSync10, unlinkSync as unlinkSync7, existsSync as existsSync15 } from "fs";
-import { join as join18, resolve as resolve16 } from "path";
+import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync17, readFileSync as readFileSync20, readdirSync as readdirSync12, renameSync as renameSync10, unlinkSync as unlinkSync7, existsSync as existsSync17 } from "fs";
+import { join as join19, resolve as resolve17 } from "path";
 function getCesarPlansDir() {
   return runtimeAgonPath("plans");
 }
@@ -21108,16 +21739,16 @@ function safeCesarPlanId(planId) {
 }
 function cesarPlanJsonPath(planId) {
   const plansDir = getCesarPlansDir();
-  const full = resolve16(plansDir, `${safeCesarPlanId(planId)}.json`);
-  if (!full.startsWith(resolve16(plansDir))) {
+  const full = resolve17(plansDir, `${safeCesarPlanId(planId)}.json`);
+  if (!full.startsWith(resolve17(plansDir))) {
     throw new Error(`Invalid plan ID: ${planId}`);
   }
   return full;
 }
 function cesarPlanMarkdownPath(planId) {
   const plansDir = getCesarPlansDir();
-  const full = resolve16(plansDir, `${safeCesarPlanId(planId)}.md`);
-  if (!full.startsWith(resolve16(plansDir))) {
+  const full = resolve17(plansDir, `${safeCesarPlanId(planId)}.md`);
+  if (!full.startsWith(resolve17(plansDir))) {
     throw new Error(`Invalid plan ID: ${planId}`);
   }
   return full;
@@ -21202,7 +21833,7 @@ function exitCesarPlan(plan, reason) {
 }
 function saveCesarPlan(plan) {
   const dir = getCesarPlansDir();
-  mkdirSync15(dir, { recursive: true });
+  mkdirSync16(dir, { recursive: true });
   const finalPath = cesarPlanJsonPath(plan.id);
   const persistedPlan = {
     ...plan,
@@ -21210,7 +21841,7 @@ function saveCesarPlan(plan) {
   };
   const tmpPath = `${finalPath}.${process.pid}.${Date.now()}.tmp`;
   try {
-    writeFileSync16(tmpPath, JSON.stringify(persistedPlan, null, 2));
+    writeFileSync17(tmpPath, JSON.stringify(persistedPlan, null, 2));
     renameSync10(tmpPath, finalPath);
   } catch (err) {
     try {
@@ -21230,9 +21861,9 @@ function loadCesarPlan(planId) {
   const paths = [{ filePath: cesarPlanJsonPath(safeId), canonical: true }, { filePath: runtimeAgonPath("runs", `${safeId}.json`), canonical: false }];
   for (const entry of paths) {
     try {
-      const plan = JSON.parse(readFileSync18(entry.filePath, "utf-8"));
+      const plan = JSON.parse(readFileSync20(entry.filePath, "utf-8"));
       const fallbackMarkdownPath = cesarPlanMarkdownPath(plan.id);
-      const hasFallback = entry.canonical || existsSync15(fallbackMarkdownPath);
+      const hasFallback = entry.canonical || existsSync17(fallbackMarkdownPath);
       const fallbackPath = hasFallback ? fallbackMarkdownPath : void 0;
       const planFilePath = plan.planFilePath ?? fallbackPath;
       return planFilePath ? { ...plan, planFilePath } : plan;
@@ -21246,16 +21877,16 @@ function listCesarPlans() {
   const readFromDir = (dir, canonical) => {
     let files = [];
     try {
-      files = readdirSync11(dir).filter((f) => f.startsWith("cplan-") && f.endsWith(".json"));
+      files = readdirSync12(dir).filter((f) => f.startsWith("cplan-") && f.endsWith(".json"));
     } catch {
       return;
     }
     for (const f of files) {
       try {
-        const plan = JSON.parse(readFileSync18(join18(dir, f), "utf-8"));
+        const plan = JSON.parse(readFileSync20(join19(dir, f), "utf-8"));
         if (!plan?.id || byId.has(plan.id)) continue;
         const fallbackMarkdownPath = cesarPlanMarkdownPath(plan.id);
-        const planFilePath = plan.planFilePath ?? (canonical || existsSync15(fallbackMarkdownPath) ? fallbackMarkdownPath : void 0);
+        const planFilePath = plan.planFilePath ?? (canonical || existsSync17(fallbackMarkdownPath) ? fallbackMarkdownPath : void 0);
         byId.set(plan.id, planFilePath ? { ...plan, planFilePath } : plan);
       } catch {
       }
@@ -21404,15 +22035,15 @@ function formatCesarPlanMarkdown(plan) {
 }
 
 // ../core/src/generated/tools/mcp-discovery.ts
-import { readFileSync as readFileSync19, existsSync as existsSync16, statSync as statSync13 } from "fs";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync21, existsSync as existsSync18, statSync as statSync14 } from "fs";
+import { join as join20 } from "path";
 import { homedir as homedir10 } from "os";
 function _readJsonSafe(path) {
   try {
-    if (!existsSync16(path)) {
+    if (!existsSync18(path)) {
       return null;
     }
-    return JSON.parse(readFileSync19(path, "utf-8"));
+    return JSON.parse(readFileSync21(path, "utf-8"));
   } catch (e) {
     return null;
   }
@@ -21445,31 +22076,31 @@ function _extractMcpServers(data) {
 function discoverMcpServers(cwd) {
   const home = homedir10();
   const servers = /* @__PURE__ */ new Map();
-  const claudeSettings = _readJsonSafe(join19(home, ".claude", "settings.json"));
+  const claudeSettings = _readJsonSafe(join20(home, ".claude", "settings.json"));
   if (claudeSettings) {
     for (const s of _extractMcpServers(claudeSettings)) {
       servers.set(s.name, s);
     }
   }
-  const claudeLocal = _readJsonSafe(join19(home, ".claude", "settings.local.json"));
+  const claudeLocal = _readJsonSafe(join20(home, ".claude", "settings.local.json"));
   if (claudeLocal) {
     for (const s of _extractMcpServers(claudeLocal)) {
       servers.set(s.name, s);
     }
   }
-  const vscodeMcp = _readJsonSafe(join19(cwd, ".vscode", "mcp.json"));
+  const vscodeMcp = _readJsonSafe(join20(cwd, ".vscode", "mcp.json"));
   if (vscodeMcp) {
     for (const s of _extractMcpServers(vscodeMcp)) {
       servers.set(s.name, s);
     }
   }
-  const cursorMcp = _readJsonSafe(join19(cwd, ".cursor", "mcp.json"));
+  const cursorMcp = _readJsonSafe(join20(cwd, ".cursor", "mcp.json"));
   if (cursorMcp) {
     for (const s of _extractMcpServers(cursorMcp)) {
       servers.set(s.name, s);
     }
   }
-  const agonProject = _readJsonSafe(join19(cwd, ".agon.json"));
+  const agonProject = _readJsonSafe(join20(cwd, ".agon.json"));
   if (agonProject) {
     for (const s of _extractMcpServers(agonProject)) {
       servers.set(s.name, s);
@@ -21479,12 +22110,12 @@ function discoverMcpServers(cwd) {
 }
 function mcpDiscoveryFingerprint(cwd) {
   const home = homedir10();
-  const paths = [join19(home, ".claude", "settings.json"), join19(home, ".claude", "settings.local.json"), join19(cwd, ".vscode", "mcp.json"), join19(cwd, ".cursor", "mcp.json"), join19(cwd, ".agon.json")];
+  const paths = [join20(home, ".claude", "settings.json"), join20(home, ".claude", "settings.local.json"), join20(cwd, ".vscode", "mcp.json"), join20(cwd, ".cursor", "mcp.json"), join20(cwd, ".agon.json")];
   const parts = [];
   for (const p of paths) {
     try {
-      if (existsSync16(p)) {
-        parts.push(`${p}:${statSync13(p).mtimeMs}`);
+      if (existsSync18(p)) {
+        parts.push(`${p}:${statSync14(p).mtimeMs}`);
       }
     } catch (e) {
     }
@@ -21502,13 +22133,13 @@ function mcpServersToWireFormat(servers) {
 }
 
 // ../core/src/generated/signals/chat-store.ts
-import { mkdirSync as mkdirSync16, appendFileSync, readFileSync as readFileSync20, readdirSync as readdirSync12, statSync as statSync14, unlinkSync as unlinkSync8 } from "fs";
-import { join as join20 } from "path";
+import { mkdirSync as mkdirSync17, appendFileSync, readFileSync as readFileSync22, readdirSync as readdirSync13, statSync as statSync15, unlinkSync as unlinkSync8 } from "fs";
+import { join as join21 } from "path";
 function chatsDir() {
   return runtimeAgonPath("chats");
 }
 function ensureChatsDir() {
-  mkdirSync16(chatsDir(), { recursive: true });
+  mkdirSync17(chatsDir(), { recursive: true });
 }
 var CHAT_RETENTION = 50;
 var CHAT_SUMMARY_TAIL_MESSAGES = 12;
@@ -21517,7 +22148,7 @@ var CHAT_SUMMARY_ENTRY_CHARS = 320;
 function pruneChats() {
   try {
     const dir = chatsDir();
-    const files = readdirSync12(dir).filter((f) => f.endsWith(".ndjson")).map((f) => {
+    const files = readdirSync13(dir).filter((f) => f.endsWith(".ndjson")).map((f) => {
       const ts = parseInt(f.replace("chat-", "").replace(".ndjson", ""), 10);
       return { name: f, ts: isNaN(ts) ? 0 : ts };
     }).sort((a, b) => b.ts - a.ts);
@@ -21525,7 +22156,7 @@ function pruneChats() {
     const toRemove = files.slice(CHAT_RETENTION);
     for (const f of toRemove) {
       try {
-        unlinkSync8(join20(dir, f.name));
+        unlinkSync8(join21(dir, f.name));
       } catch {
       }
     }
@@ -21537,7 +22168,7 @@ function startChatSession(opts) {
   pruneChats();
   const id = `chat-${Date.now()}`;
   const session = { id, startedAt: (/* @__PURE__ */ new Date()).toISOString(), messages: [], cwd: opts?.cwd, branch: opts?.branch, engineIds: opts?.engineIds };
-  const filePath = join20(chatsDir(), `${id}.ndjson`);
+  const filePath = join21(chatsDir(), `${id}.ndjson`);
   const header = { _type: "header", id, startedAt: session.startedAt };
   if (opts?.cwd) {
     header.cwd = opts.cwd;
@@ -21553,7 +22184,7 @@ function startChatSession(opts) {
 }
 function appendMessage(session, msg) {
   session.messages.push(msg);
-  const filePath = join20(chatsDir(), `${session.id}.ndjson`);
+  const filePath = join21(chatsDir(), `${session.id}.ndjson`);
   appendFileSync(filePath, JSON.stringify(msg) + "\n");
   if (updateChatSummary(session)) {
     appendSummaryRecord(session);
@@ -21573,7 +22204,7 @@ function appendUserTurnIfAbsent(session, input) {
   }
   const msg = { role: "user", content: input, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
   session.messages.push(msg);
-  const filePath = join20(chatsDir(), `${session.id}.ndjson`);
+  const filePath = join21(chatsDir(), `${session.id}.ndjson`);
   appendFileSync(filePath, JSON.stringify(msg) + "\n");
   if (updateChatSummary(session)) {
     appendSummaryRecord(session);
@@ -21608,7 +22239,7 @@ function trimChatSummary(summary) {
   return text.slice(0, head).trimEnd() + marker + text.slice(text.length - tail).trimStart();
 }
 function appendSummaryRecord(session) {
-  const filePath = join20(chatsDir(), `${session.id}.ndjson`);
+  const filePath = join21(chatsDir(), `${session.id}.ndjson`);
   appendFileSync(filePath, JSON.stringify({ _type: "summary", summary: session.summary ?? "", summarizedMessageCount: session.summarizedMessageCount ?? 0, timestamp: (/* @__PURE__ */ new Date()).toISOString() }) + "\n");
 }
 function freeSummarizedMessageBodies(messages, from, to) {
@@ -21719,8 +22350,8 @@ function buildHistoryPrimedPrompt(session, input, maxTurns) {
 }
 function loadChatSession(id) {
   try {
-    const filePath = join20(chatsDir(), `${id}.ndjson`);
-    const raw = readFileSync20(filePath, "utf-8");
+    const filePath = join21(chatsDir(), `${id}.ndjson`);
+    const raw = readFileSync22(filePath, "utf-8");
     const lines = raw.trim().split("\n").filter(Boolean);
     if (lines.length === 0) return null;
     const header = JSON.parse(lines[0]);
@@ -21761,9 +22392,9 @@ function listChatSessions(limit) {
   ensureChatsDir();
   try {
     const dir = chatsDir();
-    const files = readdirSync12(dir).filter((f) => f.endsWith(".ndjson")).map((f) => ({
+    const files = readdirSync13(dir).filter((f) => f.endsWith(".ndjson")).map((f) => ({
       name: f,
-      mtime: statSync14(join20(dir, f)).mtimeMs
+      mtime: statSync15(join21(dir, f)).mtimeMs
     })).sort((a, b) => b.mtime - a.mtime).slice(0, limit);
     return files.map((f) => {
       const id = f.name.replace(".ndjson", "");
@@ -21780,8 +22411,8 @@ function latestChatSession() {
 }
 
 // ../core/src/generated/blocks/image.ts
-import { existsSync as existsSync17 } from "fs";
-import { resolve as resolve18, basename as basename3, extname as extname2 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { resolve as resolve19, basename as basename4, extname as extname2 } from "path";
 import { homedir as homedir11 } from "os";
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp"]);
 var MIME_MAP = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp", ".svg": "image/svg+xml", ".bmp": "image/bmp" };
@@ -21798,20 +22429,20 @@ function mimeFromExt(filePath) {
 function resolveImagePath(rawPath, cwd) {
   let resolved;
   if (rawPath.startsWith("~/")) {
-    resolved = resolve18(homedir11(), rawPath.slice(2));
+    resolved = resolve19(homedir11(), rawPath.slice(2));
   } else if (rawPath.startsWith("/")) {
-    resolved = resolve18(rawPath);
+    resolved = resolve19(rawPath);
   } else {
-    resolved = resolve18(cwd, rawPath);
+    resolved = resolve19(cwd, rawPath);
   }
-  return existsSync17(resolved) ? resolved : null;
+  return existsSync19(resolved) ? resolved : null;
 }
 function buildImageAttachment(rawPath, cwd) {
   const resolved = resolveImagePath(rawPath.trim(), cwd);
   if (!resolved) {
     return null;
   }
-  return { path: resolved, filename: basename3(resolved), mimeType: mimeFromExt(resolved) };
+  return { path: resolved, filename: basename4(resolved), mimeType: mimeFromExt(resolved) };
 }
 function extractImagesFromInput(input, cwd) {
   const images = [];
@@ -21841,31 +22472,31 @@ function extractImagesFromInput(input, cwd) {
 }
 
 // ../core/src/generated/signals/flow.ts
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync18, mkdirSync as mkdirSync17, readdirSync as readdirSync13 } from "fs";
-import { join as join21, resolve as resolve19 } from "path";
+import { readFileSync as readFileSync23, writeFileSync as writeFileSync19, mkdirSync as mkdirSync18, readdirSync as readdirSync14 } from "fs";
+import { join as join22, resolve as resolve20 } from "path";
 import { homedir as homedir12 } from "os";
 function getFlowsDir() {
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve19(override) : join21(homedir12(), ".agon");
-  return join21(home, "flows");
+  const home = override ? resolve20(override) : join22(homedir12(), ".agon");
+  return join22(home, "flows");
 }
 var FLOWS_DIR = getFlowsDir();
 var FRICTION_TAGS = ["slow", "wrong-mode", "engine-error", "unclear-output", "timeout", "context-lost", "other"];
 function ensureFlowsDir() {
-  mkdirSync17(getFlowsDir(), { recursive: true });
+  mkdirSync18(getFlowsDir(), { recursive: true });
 }
 function logFlow(record2) {
   ensureFlowsDir();
   const filename = `flow-${record2.id}.json`;
-  const filepath = join21(getFlowsDir(), filename);
-  writeFileSync18(filepath, JSON.stringify(record2, null, 2));
+  const filepath = join22(getFlowsDir(), filename);
+  writeFileSync19(filepath, JSON.stringify(record2, null, 2));
   return filepath;
 }
 function readFlows(limit) {
   ensureFlowsDir();
   let files;
   try {
-    files = readdirSync13(getFlowsDir()).filter((f) => f.startsWith("flow-") && f.endsWith(".json")).sort().reverse();
+    files = readdirSync14(getFlowsDir()).filter((f) => f.startsWith("flow-") && f.endsWith(".json")).sort().reverse();
   } catch (err) {
     console.warn(`[agon] failed to read flows directory: ${err instanceof Error ? err.message : String(err)}`);
     return [];
@@ -21874,7 +22505,7 @@ function readFlows(limit) {
   const records = [];
   for (const file2 of files) {
     try {
-      const data = JSON.parse(readFileSync21(join21(getFlowsDir(), file2), "utf-8"));
+      const data = JSON.parse(readFileSync23(join22(getFlowsDir(), file2), "utf-8"));
       records.push(data);
     } catch (err) {
       console.warn(`[agon] skipping malformed flow record ${file2}: ${err instanceof Error ? err.message : String(err)}`);
@@ -21939,13 +22570,13 @@ async function companionDispatch(opts) {
   const startTime = Date.now();
   if (!isAcp && !isStreamJson) {
     const checkAvailable = () => {
-      return new Promise((resolve27) => {
+      return new Promise((resolve28) => {
         const check2 = spawn2(opts.binaryPath, ["app-server", "--help"], {
           stdio: "pipe",
           timeout: 5e3
         });
-        check2.on("close", (code) => resolve27(code === 0));
-        check2.on("error", () => resolve27(false));
+        check2.on("close", (code) => resolve28(code === 0));
+        check2.on("error", () => resolve28(false));
       });
     };
     const available = await checkAvailable();
@@ -21963,10 +22594,10 @@ async function companionDispatch(opts) {
     detached: true
   });
   let procClosed = false;
-  const procClosedPromise = new Promise((resolve27) => {
+  const procClosedPromise = new Promise((resolve28) => {
     proc.once("close", () => {
       procClosed = true;
-      resolve27();
+      resolve28();
     });
   });
   let nextId = 1;
@@ -21994,7 +22625,7 @@ async function companionDispatch(opts) {
     return normalized;
   }
   function writeStdin(line) {
-    return new Promise((resolve27, reject) => {
+    return new Promise((resolve28, reject) => {
       if (stdinError) {
         reject(stdinError);
         return;
@@ -22006,7 +22637,7 @@ async function companionDispatch(opts) {
       }
       stdin.write(line, (err) => {
         if (err) reject(setStdinError(err));
-        else resolve27();
+        else resolve28();
       });
     });
   }
@@ -22141,12 +22772,12 @@ async function companionDispatch(opts) {
   function send(method, params) {
     const id = nextId++;
     const timeoutMs = method === "initialize" ? 8e3 : opts.timeout * 1e3;
-    return new Promise((resolve27, reject) => {
+    return new Promise((resolve28, reject) => {
       const timer = setTimeout(() => {
         pending.delete(id);
         reject(new Error(`Timeout waiting for ${method}`));
       }, timeoutMs);
-      pending.set(id, { resolve: resolve27, reject, timer });
+      pending.set(id, { resolve: resolve28, reject, timer });
       void writeStdin(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n").catch((err) => {
         pending.delete(id);
         clearTimeout(timer);
@@ -22158,7 +22789,7 @@ async function companionDispatch(opts) {
     fireWriteStdin(JSON.stringify({ jsonrpc: "2.0", method }) + "\n");
   }
   function sleep(ms) {
-    return new Promise((resolve27) => setTimeout(resolve27, ms));
+    return new Promise((resolve28) => setTimeout(resolve28, ms));
   }
   function killProc(signal = "SIGTERM") {
     if (procClosed) return;
@@ -22186,10 +22817,10 @@ async function companionDispatch(opts) {
   }
   function waitForTurnComplete() {
     const deadline = Date.now() + opts.timeout * 1e3;
-    return new Promise((resolve27, reject) => {
+    return new Promise((resolve28, reject) => {
       const check2 = () => {
         if (turnCompleted) {
-          resolve27();
+          resolve28();
           return;
         }
         if (turnError) {
@@ -22303,19 +22934,19 @@ async function companionDispatch(opts) {
 }
 
 // ../core/src/generated/signals/models-registry.ts
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync19, mkdirSync as mkdirSync18, existsSync as existsSync18, statSync as statSync15 } from "fs";
-import { join as join22 } from "path";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync20, mkdirSync as mkdirSync19, existsSync as existsSync20, statSync as statSync16 } from "fs";
+import { join as join23 } from "path";
 var CACHE_TTL_MS = 36e5;
 var MODELS_DEV_URL = "https://models.dev/api.json";
 async function fetchModelsRegistry() {
   const cacheDir = getCacheDir();
-  const cacheFile = join22(cacheDir, "models-dev.json");
-  if (existsSync18(cacheFile)) {
+  const cacheFile = join23(cacheDir, "models-dev.json");
+  if (existsSync20(cacheFile)) {
     try {
-      const stat = statSync15(cacheFile);
+      const stat = statSync16(cacheFile);
       const age = Date.now() - stat.mtimeMs;
       if (age < CACHE_TTL_MS) {
-        return JSON.parse(readFileSync22(cacheFile, "utf-8"));
+        return JSON.parse(readFileSync24(cacheFile, "utf-8"));
       }
     } catch (_e) {
       console.warn(`[agon] models-registry: cache read failed, refetching: ${_e instanceof Error ? _e.message : String(_e)}`);
@@ -22323,14 +22954,14 @@ async function fetchModelsRegistry() {
   }
   const response = await fetch(MODELS_DEV_URL);
   if (!response.ok) {
-    if (existsSync18(cacheFile)) {
-      return JSON.parse(readFileSync22(cacheFile, "utf-8"));
+    if (existsSync20(cacheFile)) {
+      return JSON.parse(readFileSync24(cacheFile, "utf-8"));
     }
     throw new Error(`Failed to fetch models registry: ${response.status}`);
   }
   const data = await response.json();
-  mkdirSync18(cacheDir, { recursive: true });
-  writeFileSync19(cacheFile, JSON.stringify(data));
+  mkdirSync19(cacheDir, { recursive: true });
+  writeFileSync20(cacheFile, JSON.stringify(data));
   return data;
 }
 function resolveModelFormat(providerNpm, model) {
@@ -22432,7 +23063,8 @@ function searchModels(entries, query) {
   });
   return scored.map((s) => s.entry);
 }
-function normalizeBaseUrl(url2) {
+function normalizeBaseUrl(url2, format) {
+  if (format === "anthropic") return url2;
   try {
     const parsed = new URL(url2);
     if (parsed.pathname.startsWith("/anthropic/") || parsed.pathname === "/anthropic") {
@@ -22445,29 +23077,29 @@ function normalizeBaseUrl(url2) {
   }
 }
 function modelEntryToEngineDef(entry) {
-  return { schemaVersion: 3, id: `${entry.providerId}-${entry.modelId}`.replace(/[^a-zA-Z0-9._-]/g, "-").toLowerCase(), displayName: `${entry.providerName} \u2014 ${entry.modelName}`, isLocal: false, tier: "user", timeout: 180, exec: { args: [] }, review: { args: [] }, api: { baseUrl: normalizeBaseUrl(entry.baseUrl), apiKeyEnv: entry.apiKeyEnv, model: entry.modelId, maxTokens: Math.min(entry.contextWindow ? Math.floor(entry.contextWindow / 4) : 4096, 16384), format: entry.format ?? "openai" } };
+  return { schemaVersion: 3, id: `${entry.providerId}-${entry.modelId}`.replace(/[^a-zA-Z0-9._-]/g, "-").toLowerCase(), displayName: `${entry.providerName} \u2014 ${entry.modelName}`, isLocal: false, tier: "user", timeout: 180, exec: { args: [] }, review: { args: [] }, api: { baseUrl: normalizeBaseUrl(entry.baseUrl, entry.format ?? "openai"), apiKeyEnv: entry.apiKeyEnv, model: entry.modelId, maxTokens: Math.min(entry.contextWindow ? Math.floor(entry.contextWindow / 4) : 4096, 16384), format: entry.format ?? "openai" } };
 }
 
 // ../core/src/generated/signals/cli-models-registry.ts
 import { execSync as execSync4 } from "child_process";
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync20, mkdirSync as mkdirSync19, existsSync as existsSync19, statSync as statSync16 } from "fs";
-import { join as join23 } from "path";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync21, mkdirSync as mkdirSync20, existsSync as existsSync21, statSync as statSync17 } from "fs";
+import { join as join24 } from "path";
 import { homedir as homedir13 } from "os";
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 var ENGINE_PROVIDER_MAP = { anthropic: { providerId: "anthropic", engineId: "claude", engineBinary: "claude", versionCmd: ["--version"], listCmd: ["__pty:/model"], effortLevels: ["low", "medium", "high", "xhigh", "max"] }, openai: { providerId: "openai", engineId: "codex", engineBinary: "codex", versionCmd: ["--version"], listCmd: ["__pty:/model"], effortLevels: ["low", "medium", "high", "xhigh"] }, google: { providerId: "google", engineId: "agy", engineBinary: "agy", versionCmd: ["--version"], listCmd: ["__pty:/model"] }, opencode: { providerId: "opencode", engineId: "opencode", engineBinary: "opencode", versionCmd: ["--version"], listCmd: ["models"] }, mistral: { providerId: "mistral", engineId: "mistral", engineBinary: "mistral", versionCmd: ["--version"] }, openrouter: { providerId: "openrouter", engineId: "openrouter", engineBinary: "openrouter", versionCmd: [] } };
 var ENGINE_DISPLAY_NAMES = { claude: "Claude", codex: "Codex", agy: "Antigravity", opencode: "OpenCode", mistral: "Mistral", openrouter: "OpenRouter" };
 var FALLBACK_MODELS = { anthropic: [{ id: "claude-sonnet-4-5-20250929", name: "Claude Sonnet 4.5", contextWindow: 2e5, toolCall: true, reasoning: true }, { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5", contextWindow: 2e5, toolCall: true, reasoning: true }], openai: [{ id: "gpt-4o", name: "GPT-4o", contextWindow: 128e3, toolCall: true, reasoning: false }, { id: "o4-mini", name: "o4-mini", contextWindow: 2e5, toolCall: true, reasoning: true }], google: [{ id: "gemini-3.5-flash", name: "Gemini 3.5 Flash", contextWindow: 1048576, toolCall: true, reasoning: true }, { id: "gemini-3.1-pro", name: "Gemini 3.1 Pro", contextWindow: 1048576, toolCall: true, reasoning: true }, { id: "gemini-3-flash-preview", name: "Gemini 3 Flash", contextWindow: 1048576, toolCall: true, reasoning: true }], mistral: [{ id: "mistral-large-latest", name: "Mistral Large", contextWindow: 128e3, toolCall: true, reasoning: false }, { id: "codestral-latest", name: "Codestral", contextWindow: 256e3, toolCall: true, reasoning: false }], openrouter: [{ id: "auto", name: "Auto (best for task)", toolCall: true, reasoning: false }], opencode: [{ id: "anthropic/claude-sonnet-4", name: "anthropic/claude-sonnet-4", toolCall: true, reasoning: false }, { id: "openai/gpt-5.3-codex", name: "openai/gpt-5.3-codex", toolCall: true, reasoning: false }] };
 var PROBE_TTL_MS = 864e5;
 function probedModelsCacheFile(engineId) {
-  return join23(getCacheDir(), `cli-models-${engineId.replace(/[^a-zA-Z0-9_-]/g, "-")}.json`);
+  return join24(getCacheDir(), `cli-models-${engineId.replace(/[^a-zA-Z0-9_-]/g, "-")}.json`);
 }
 function readProbedCliModels(engineId, ttlMs) {
   try {
     const file2 = probedModelsCacheFile(engineId);
-    if (!existsSync19(file2)) return null;
-    const age = Date.now() - statSync16(file2).mtimeMs;
+    if (!existsSync21(file2)) return null;
+    const age = Date.now() - statSync17(file2).mtimeMs;
     if (age > (ttlMs ?? PROBE_TTL_MS)) return null;
-    const data = JSON.parse(readFileSync23(file2, "utf-8"));
+    const data = JSON.parse(readFileSync25(file2, "utf-8"));
     const raw = Array.isArray(data?.models) ? data.models : [];
     const models = raw.map((m) => ({ id: String(m.id ?? ""), name: String(m.name ?? m.id ?? ""), current: !!m.current })).filter((m) => m.name);
     return models.length > 0 ? models : null;
@@ -22477,7 +23109,7 @@ function readProbedCliModels(engineId, ttlMs) {
 }
 function resolveModelProbeScript() {
   try {
-    const req = createRequire2(import.meta.url);
+    const req = createRequire3(import.meta.url);
     const anchor = req.resolve("@kernlang/agon-engines/cli/claude.js");
     const candidates = [
       // Canonical: the package ships the probe at py/kern_engines/cli/ (see
@@ -22485,16 +23117,16 @@ function resolveModelProbeScript() {
       // to the package root, then into py/. This is the path that actually
       // exists — the dist/cli & root/cli guesses below never matched, so the
       // probe silently never ran and every engine fell back to its static list.
-      join23(anchor, "..", "..", "..", "py", "kern_engines", "cli", "model_probe.py"),
+      join24(anchor, "..", "..", "..", "py", "kern_engines", "cli", "model_probe.py"),
       // dist/cli → root → py/kern_engines/cli
-      join23(anchor, "..", "..", "py", "kern_engines", "cli", "model_probe.py"),
+      join24(anchor, "..", "..", "py", "kern_engines", "cli", "model_probe.py"),
       // (alt layout: cli/claude.js → root)
-      join23(anchor, "..", "..", "..", "cli", "model_probe.py"),
-      join23(anchor, "..", "..", "cli", "model_probe.py"),
-      join23(anchor, "..", "model_probe.py")
+      join24(anchor, "..", "..", "..", "cli", "model_probe.py"),
+      join24(anchor, "..", "..", "cli", "model_probe.py"),
+      join24(anchor, "..", "model_probe.py")
     ];
     for (const c of candidates) {
-      if (existsSync19(c)) return c;
+      if (existsSync21(c)) return c;
     }
     return null;
   } catch {
@@ -22564,8 +23196,8 @@ async function refreshProbedCliModels(engineId, binary, listCmd, pythonBin) {
       return false;
     }
     const dir = getCacheDir();
-    mkdirSync19(dir, { recursive: true });
-    writeFileSync20(probedModelsCacheFile(engineId), JSON.stringify({ ts: Date.now(), engineId, models }));
+    mkdirSync20(dir, { recursive: true });
+    writeFileSync21(probedModelsCacheFile(engineId), JSON.stringify({ ts: Date.now(), engineId, models }));
     return true;
   } catch (e) {
     dbg(`probe threw: ${e?.message ?? e}`);
@@ -22581,10 +23213,10 @@ function findBinary(binary) {
   } catch (e) {
   }
   const home = homedir13();
-  const searchPaths = [join23(home, ".local", "bin"), join23(home, ".npm-global", "bin"), "/usr/local/bin"];
+  const searchPaths = [join24(home, ".local", "bin"), join24(home, ".npm-global", "bin"), "/usr/local/bin"];
   for (const dir of searchPaths) {
-    const fullPath = join23(dir, binary);
-    if (existsSync19(fullPath)) {
+    const fullPath = join24(dir, binary);
+    if (existsSync21(fullPath)) {
       return fullPath;
     }
   }
@@ -22601,6 +23233,29 @@ function getBinaryVersion(binary, versionCmd) {
     return null;
   }
 }
+var VERSION_CACHE = /* @__PURE__ */ new Map();
+async function getBinaryVersionAsync(engineId, binary, versionCmd) {
+  if (!versionCmd.length) return null;
+  const cached2 = VERSION_CACHE.get(engineId);
+  if (cached2) return cached2;
+  try {
+    const result = await spawnWithTimeout({ command: binary, args: versionCmd, cwd: process.cwd(), timeout: 5e3 });
+    if (result.timedOut || result.exitCode !== 0) return null;
+    const v = (result.stdout ?? "").trim() || null;
+    if (v) VERSION_CACHE.set(engineId, v);
+    return v;
+  } catch {
+    return null;
+  }
+}
+async function refreshCliGroupVersion(engineId) {
+  const entry = Object.entries(ENGINE_PROVIDER_MAP).find(([, e]) => e.engineId === engineId);
+  if (!entry) return null;
+  const [, eng] = entry;
+  const binaryPath = findBinary(eng.engineBinary);
+  if (!binaryPath) return null;
+  return getBinaryVersionAsync(eng.engineId, binaryPath, eng.versionCmd);
+}
 function buildCliModelGroups() {
   const groups = [];
   for (const [key, eng] of Object.entries(ENGINE_PROVIDER_MAP)) {
@@ -22626,7 +23281,7 @@ async function buildCliModelGroupsAsync() {
   for (const [key, eng] of Object.entries(ENGINE_PROVIDER_MAP)) {
     const binaryPath = findBinary(eng.engineBinary);
     const installed = binaryPath !== null;
-    const version2 = installed ? getBinaryVersion(eng.engineBinary, eng.versionCmd) : null;
+    const version2 = installed ? await getBinaryVersionAsync(eng.engineId, binaryPath, eng.versionCmd) : null;
     const displayName = ENGINE_DISPLAY_NAMES[eng.engineId] ?? eng.engineId.charAt(0).toUpperCase() + eng.engineId.slice(1);
     const probed = readProbedCliModels(eng.engineId);
     const models = probed && probed.length > 0 ? probed.map((m) => Object.assign({}, { id: m.id, name: m.name, providerId: eng.providerId, providerName: displayName, engineId: eng.engineId, engineBinary: eng.engineBinary, toolCall: true, reasoning: true })) : (FALLBACK_MODELS[key] ?? []).map((m) => Object.assign({}, { id: m.id, name: m.name, providerId: eng.providerId, providerName: displayName, engineId: eng.engineId, engineBinary: eng.engineBinary, contextWindow: m.contextWindow, toolCall: m.toolCall, reasoning: m.reasoning }));
@@ -22639,7 +23294,7 @@ function buildCliGroupsImmediate() {
   for (const [key, eng] of Object.entries(ENGINE_PROVIDER_MAP)) {
     const binaryPath = findBinary(eng.engineBinary);
     const installed = binaryPath !== null;
-    const version2 = installed ? getBinaryVersion(eng.engineBinary, eng.versionCmd) : null;
+    const version2 = installed ? VERSION_CACHE.get(eng.engineId) ?? null : null;
     const displayName = ENGINE_DISPLAY_NAMES[eng.engineId] ?? eng.engineId.charAt(0).toUpperCase() + eng.engineId.slice(1);
     const probed = readProbedCliModels(eng.engineId);
     const probeCapable = Array.isArray(eng.listCmd) && eng.listCmd.length > 0;
@@ -22658,7 +23313,7 @@ async function refreshCliGroup(engineId) {
   const probeCapable = Array.isArray(eng.listCmd) && eng.listCmd.length > 0;
   if (!installed || !probeCapable) return null;
   const displayName = ENGINE_DISPLAY_NAMES[eng.engineId] ?? eng.engineId.charAt(0).toUpperCase() + eng.engineId.slice(1);
-  const version2 = getBinaryVersion(eng.engineBinary, eng.versionCmd);
+  const version2 = await getBinaryVersionAsync(eng.engineId, binaryPath, eng.versionCmd);
   try {
     await refreshProbedCliModels(eng.engineId, binaryPath, eng.listCmd);
   } catch {
@@ -22705,12 +23360,12 @@ function createCompanionSession(config2) {
   function sendRpc(method, params) {
     const id = nextRpcId++;
     const timeoutMs = method === "initialize" ? 8e3 : 9e4;
-    return new Promise((resolve27, reject) => {
+    return new Promise((resolve28, reject) => {
       const timer = setTimeout(() => {
         pending.delete(id);
         reject(new Error(`Timeout waiting for ${method}`));
       }, timeoutMs);
-      pending.set(id, { resolve: resolve27, reject, timer });
+      pending.set(id, { resolve: resolve28, reject, timer });
       proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
     });
   }
@@ -23035,12 +23690,12 @@ function createAcpSession(config2) {
   function sendRpc(method, params) {
     const id = nextRpcId++;
     const timeoutMs = method === "initialize" ? 8e3 : 9e4;
-    return new Promise((resolve27, reject) => {
+    return new Promise((resolve28, reject) => {
       const timer = setTimeout(() => {
         pending.delete(id);
         reject(new Error(`ACP timeout: ${method}`));
       }, timeoutMs);
-      pending.set(id, { resolve: resolve27, reject, timer });
+      pending.set(id, { resolve: resolve28, reject, timer });
       proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
     });
   }
@@ -23486,16 +24141,16 @@ function createStreamJsonSession(config2) {
         alive = false;
         proc = null;
       });
-      const startOk = await new Promise((resolve27) => {
-        const timeout = setTimeout(() => resolve27(true), 5e3);
+      const startOk = await new Promise((resolve28) => {
+        const timeout = setTimeout(() => resolve28(true), 5e3);
         rl.once("line", () => {
           clearTimeout(timeout);
-          resolve27(true);
+          resolve28(true);
         });
         proc.once("close", (code) => {
           clearTimeout(timeout);
           console.error(`[cesar:claude] process died during start, code=${code}`);
-          resolve27(false);
+          resolve28(false);
         });
       });
       if (!startOk || !proc) {
@@ -24656,33 +25311,33 @@ function createStreamBridge(dispatch, opts) {
 }
 
 // ../core/src/generated/forge/virtual-fs.ts
-import { readFileSync as readFileSync24, existsSync as existsSync20, readdirSync as readdirSync14, statSync as statSync17 } from "fs";
-import { join as join24, resolve as resolve20, relative as relative7, dirname as dirname10 } from "path";
-import { createHash as createHash4 } from "crypto";
+import { readFileSync as readFileSync26, existsSync as existsSync22, readdirSync as readdirSync15, statSync as statSync18 } from "fs";
+import { join as join25, resolve as resolve21, relative as relative8, dirname as dirname11 } from "path";
+import { createHash as createHash5 } from "crypto";
 function createFileSnapshot(rootDir) {
-  const snapshotId = createHash4("sha256").update(rootDir + Date.now().toString()).digest("hex").slice(0, 12);
+  const snapshotId = createHash5("sha256").update(rootDir + Date.now().toString()).digest("hex").slice(0, 12);
   return {
     snapshotId,
-    rootDir: resolve20(rootDir),
+    rootDir: resolve21(rootDir),
     cache: /* @__PURE__ */ new Map()
   };
 }
 function snapshotRead(snap, absPath) {
-  const key = resolve20(absPath);
+  const key = resolve21(absPath);
   if (snap.cache.has(key)) {
     return snap.cache.get(key) ?? null;
   }
   try {
-    if (!existsSync20(key)) {
+    if (!existsSync22(key)) {
       snap.cache.set(key, null);
       return null;
     }
-    const st = statSync17(key);
+    const st = statSync18(key);
     if (!st.isFile()) {
       snap.cache.set(key, null);
       return null;
     }
-    const content = readFileSync24(key, "utf-8");
+    const content = readFileSync26(key, "utf-8");
     snap.cache.set(key, content);
     return content;
   } catch (e) {
@@ -24691,15 +25346,15 @@ function snapshotRead(snap, absPath) {
   }
 }
 function snapshotList(snap, absDir) {
-  const dir = resolve20(absDir);
+  const dir = resolve21(absDir);
   try {
-    return readdirSync14(dir).filter((f) => {
+    return readdirSync15(dir).filter((f) => {
       try {
-        return statSync17(join24(dir, f)).isFile();
+        return statSync18(join25(dir, f)).isFile();
       } catch {
         return false;
       }
-    }).map((f) => join24(dir, f));
+    }).map((f) => join25(dir, f));
   } catch {
     return [];
   }
@@ -24725,19 +25380,19 @@ var VirtualFS = class {
   notifyChange(absPath) {
     if (!this.onChange) return;
     try {
-      this.onChange(resolve20(absPath));
+      this.onChange(resolve21(absPath));
     } catch {
     }
   }
   read(absPath) {
-    const key = resolve20(absPath);
+    const key = resolve21(absPath);
     if (this.overlay.has(key)) {
       return this.overlay.get(key) ?? null;
     }
     return snapshotRead(this.snapshot, key);
   }
   write(absPath, content) {
-    const key = resolve20(absPath);
+    const key = resolve21(absPath);
     const previous = this.overlay.has(key) ? this.overlay.get(key) ?? null : snapshotRead(this.snapshot, key);
     this.overlay.set(key, content);
     if (previous !== content) {
@@ -24745,7 +25400,7 @@ var VirtualFS = class {
     }
   }
   delete(absPath) {
-    const key = resolve20(absPath);
+    const key = resolve21(absPath);
     const previous = this.overlay.has(key) ? this.overlay.get(key) ?? null : snapshotRead(this.snapshot, key);
     this.overlay.set(key, null);
     if (previous !== null) {
@@ -24753,19 +25408,19 @@ var VirtualFS = class {
     }
   }
   exists(absPath) {
-    const key = resolve20(absPath);
+    const key = resolve21(absPath);
     if (this.overlay.has(key)) {
       return this.overlay.get(key) !== null;
     }
     return snapshotRead(this.snapshot, key) !== null;
   }
   list(absDir) {
-    const dir = resolve20(absDir);
+    const dir = resolve21(absDir);
     const base = snapshotList(this.snapshot, dir);
     const overlayWritten = [];
     const overlayDeleted = /* @__PURE__ */ new Set();
     for (const [path, content] of this.overlay.entries()) {
-      if (dirname10(path) === dir) {
+      if (dirname11(path) === dir) {
         if (content === null) {
           overlayDeleted.add(path);
         } else {
@@ -24822,9 +25477,9 @@ function applyEffectPackage(pkg, targetDir) {
   const import_fs = __require("fs");
   const modified = [];
   for (const effect of pkg.effects) {
-    const absPath = resolve20(targetDir, effect.kind === "rename" ? effect.from : effect.path);
+    const absPath = resolve21(targetDir, effect.kind === "rename" ? effect.from : effect.path);
     if (effect.kind === "write") {
-      const dir = dirname10(absPath);
+      const dir = dirname11(absPath);
       import_fs.mkdirSync(dir, { recursive: true });
       import_fs.writeFileSync(absPath, effect.content, "utf-8");
       modified.push(absPath);
@@ -24835,8 +25490,8 @@ function applyEffectPackage(pkg, targetDir) {
       }
       modified.push(absPath);
     } else if (effect.kind === "rename") {
-      const dest = resolve20(targetDir, effect.to);
-      import_fs.mkdirSync(dirname10(dest), { recursive: true });
+      const dest = resolve21(targetDir, effect.to);
+      import_fs.mkdirSync(dirname11(dest), { recursive: true });
       import_fs.renameSync(absPath, dest);
       modified.push(absPath);
       modified.push(dest);
@@ -24845,13 +25500,13 @@ function applyEffectPackage(pkg, targetDir) {
   return modified;
 }
 function relocateEffectPackage(pkg, fromDir, toDir) {
-  const fromRoot = resolve20(fromDir);
-  const toRoot = resolve20(toDir);
+  const fromRoot = resolve21(fromDir);
+  const toRoot = resolve21(toDir);
   const relocatePath = (path) => {
-    const abs = resolve20(path);
-    const rel = relative7(fromRoot, abs);
-    if (rel.startsWith("..") || resolve20(fromRoot, rel) !== abs) return abs;
-    return resolve20(toRoot, rel);
+    const abs = resolve21(path);
+    const rel = relative8(fromRoot, abs);
+    if (rel.startsWith("..") || resolve21(fromRoot, rel) !== abs) return abs;
+    return resolve21(toRoot, rel);
   };
   const effects = pkg.effects.map((effect) => {
     if (effect.kind === "write") {
@@ -24914,7 +25569,7 @@ function scoreEffectPackage(pkg, taskKeywords) {
 
 // ../core/src/generated/cesar/speculator.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { resolve as resolve21, join as join25 } from "path";
+import { resolve as resolve22, join as join26 } from "path";
 var Speculator = class {
   runId;
   snapshot;
@@ -24923,7 +25578,7 @@ var Speculator = class {
     this.snapshot = null;
   }
   async run(opts) {
-    const cwd = resolve21(opts.cwd);
+    const cwd = resolve22(opts.cwd);
     const isolate = opts.isolate !== false;
     const root = isolate ? repoRoot(cwd) : cwd;
     this.snapshot = createFileSnapshot(cwd);
@@ -24936,7 +25591,7 @@ var Speculator = class {
     if (isolate) {
       const baseSha = stashSnapshot(root);
       for (const member of opts.members) {
-        const wtPath = join25(root, `.agon/speculate-worktrees/${this.runId}/${member.engineId}`);
+        const wtPath = join26(root, `.agon/speculate-worktrees/${this.runId}/${member.engineId}`);
         try {
           await worktreeCreate(root, wtPath, baseSha);
           worktreesByEngine[member.engineId] = wtPath;
@@ -25109,26 +25764,26 @@ ${sessionLines.join("\n")}`);
 }
 
 // ../core/src/generated/cesar/context-thread.ts
-import { readFileSync as readFileSync25, writeFileSync as writeFileSync21, mkdirSync as mkdirSync20, renameSync as renameSync11, existsSync as existsSync21, readdirSync as readdirSync15, unlinkSync as unlinkSync9, statSync as statSync18, chmodSync as chmodSync2, openSync, fsyncSync, closeSync, appendFileSync as appendFileSync2 } from "fs";
-import { join as join26, resolve as resolve22, basename as basename5 } from "path";
-import { randomUUID as randomUUID5, createHash as createHash5 } from "crypto";
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync22, mkdirSync as mkdirSync21, renameSync as renameSync11, existsSync as existsSync23, readdirSync as readdirSync16, unlinkSync as unlinkSync9, statSync as statSync19, chmodSync as chmodSync2, openSync, fsyncSync, closeSync, appendFileSync as appendFileSync2 } from "fs";
+import { join as join27, resolve as resolve23, basename as basename6 } from "path";
+import { randomUUID as randomUUID5, createHash as createHash6 } from "crypto";
 import { homedir as homedir14 } from "os";
 function threadsDir() {
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve22(override) : join26(homedir14(), ".agon");
-  return join26(home, "threads");
+  const home = override ? resolve23(override) : join27(homedir14(), ".agon");
+  return join27(home, "threads");
 }
 function activePointerPath() {
-  return join26(threadsDir(), "active.json");
+  return join27(threadsDir(), "active.json");
 }
 function projectHash16(projectPath) {
-  return createHash5("sha256").update(projectPath).digest("hex").slice(0, 16);
+  return createHash6("sha256").update(projectPath).digest("hex").slice(0, 16);
 }
 function projectSha8(projectPath) {
   return projectHash16(projectPath);
 }
 function threadDirFor(projectPath) {
-  return join26(threadsDir(), projectHash16(projectPath));
+  return join27(threadsDir(), projectHash16(projectPath));
 }
 var THREAD_ID_RE = /^(thread_\d{10,16}_[0-9a-f]{8}|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/;
 function threadJournalPath(projectPath, threadId) {
@@ -25139,9 +25794,9 @@ function threadFilePath(projectPath, threadId) {
     throw new Error(`Invalid threadId: ${threadId}`);
   }
   const dir = threadDirFor(projectPath);
-  const full = resolve22(dir, `${threadId}.json`);
-  const resolvedDir = resolve22(dir);
-  const nativeSep = join26("a", "b")[1];
+  const full = resolve23(dir, `${threadId}.json`);
+  const resolvedDir = resolve23(dir);
+  const nativeSep = join27("a", "b")[1];
   const isContained = full === resolvedDir || full.startsWith(resolvedDir + "/") || full.startsWith(resolvedDir + nativeSep);
   if (!isContained) {
     throw new Error(`Invalid thread path (traversal attempt): ${threadId}`);
@@ -25150,7 +25805,7 @@ function threadFilePath(projectPath, threadId) {
 }
 function ensureThreadDir(projectPath) {
   ensureAgonHome();
-  mkdirSync20(threadDirFor(projectPath), { recursive: true });
+  mkdirSync21(threadDirFor(projectPath), { recursive: true });
 }
 var LOCK_MAX_RETRIES = 8;
 var LOCK_BASE_DELAY_MS = 20;
@@ -25161,7 +25816,7 @@ async function acquireLock(lockPath) {
   for (let attempt = 0; attempt < LOCK_MAX_RETRIES; attempt++) {
     try {
       const fd = openSync(lockPath, "wx", 384);
-      writeFileSync21(fd, String(process.pid));
+      writeFileSync22(fd, String(process.pid));
       closeSync(fd);
       return attempt;
     } catch (err) {
@@ -25210,7 +25865,7 @@ var SECRET_PATTERNS = [
 var SECRET_PATH_BLOCKLIST = [".env", ".env.local", ".env.production", ".env.staging", ".env.development", "credentials.json", "secrets.json", "auth.json", ".ssh/id_rsa", ".ssh/id_ed25519", ".ssh/id_ecdsa", ".aws/credentials", ".docker/config.json", ".netrc", ".pgpass", ".my.cnf"];
 function isSecretPath(path) {
   const lower = path.toLowerCase();
-  const name = basename5(lower);
+  const name = basename6(lower);
   for (const needle of SECRET_PATH_BLOCKLIST) {
     if (name === needle || lower.endsWith("/" + needle) || lower.endsWith("\\" + needle)) {
       return true;
@@ -25334,14 +25989,14 @@ var ContextThread = class {
     const now = Date.now();
     if (config2.threadId) {
       const candidatePath = threadFilePath(this.projectPath, config2.threadId);
-      if (existsSync21(candidatePath)) {
+      if (existsSync23(candidatePath)) {
         try {
-          const stat = statSync18(candidatePath);
+          const stat = statSync19(candidatePath);
           if (stat.size > MAX_THREAD_FILE_BYTES) {
             console.warn(`[agon] context-thread: ${candidatePath} is ${stat.size} bytes (> ${MAX_THREAD_FILE_BYTES}), refusing to load. Run /thread compact or /thread fork.`);
             throw new Error("thread file too large");
           }
-          const raw = readFileSync25(candidatePath, "utf-8");
+          const raw = readFileSync27(candidatePath, "utf-8");
           const snap = JSON.parse(raw);
           if (snap && typeof snap === "object" && Array.isArray(snap.messages)) {
             const filteredMessages = (snap.messages ?? []).filter((m) => m && m.role !== "system");
@@ -25359,9 +26014,9 @@ var ContextThread = class {
             this.fileTouches = snap.fileTouches ?? {};
             this.hydrated = true;
             const jPathOnLoad = threadFilePath(this.projectPath, this.threadId).replace(/\.json$/, ".journal.jsonl");
-            if (existsSync21(jPathOnLoad)) {
+            if (existsSync23(jPathOnLoad)) {
               try {
-                const journalLines = readFileSync25(jPathOnLoad, "utf-8").split("\n").filter(Boolean);
+                const journalLines = readFileSync27(jPathOnLoad, "utf-8").split("\n").filter(Boolean);
                 const knownOnLoad = new Set(this.messages.map((m) => m.id));
                 let merged = false;
                 for (const line of journalLines) {
@@ -25631,8 +26286,8 @@ ${msg.content}` };
     let bytes = 0;
     try {
       const path = threadFilePath(this.projectPath, this.threadId);
-      if (existsSync21(path)) {
-        bytes = readFileSync25(path, "utf-8").length;
+      if (existsSync23(path)) {
+        bytes = readFileSync27(path, "utf-8").length;
       }
     } catch {
     }
@@ -25665,7 +26320,7 @@ ${msg.content}` };
       let fd = -1;
       try {
         fd = openSync(tmpPath, "w", 384);
-        writeFileSync21(fd, body, "utf-8");
+        writeFileSync22(fd, body, "utf-8");
         fsyncSync(fd);
       } finally {
         if (fd >= 0) try {
@@ -25681,7 +26336,7 @@ ${msg.content}` };
       this.dirty = false;
       this.hydrated = true;
       const jPath = threadJournalPath(this.projectPath, this.threadId);
-      if (existsSync21(jPath)) unlinkSync9(jPath);
+      if (existsSync23(jPath)) unlinkSync9(jPath);
       this.journaledIds.clear();
     } catch {
     }
@@ -25713,9 +26368,9 @@ ${msg.content}` };
     }
     try {
       const jPath = threadJournalPath(this.projectPath, this.threadId);
-      if (existsSync21(jPath)) {
+      if (existsSync23(jPath)) {
         try {
-          const journalLines = readFileSync25(jPath, "utf-8").split("\n").filter(Boolean);
+          const journalLines = readFileSync27(jPath, "utf-8").split("\n").filter(Boolean);
           const known = new Set(this.messages.map((m) => m.id));
           for (const line of journalLines) {
             try {
@@ -25734,11 +26389,11 @@ ${msg.content}` };
           console.warn(`[agon] context-thread: journal merge failed (will overwrite): ${err instanceof Error ? err.message : String(err)}`);
         }
       }
-      if (existsSync21(target)) {
+      if (existsSync23(target)) {
         try {
-          const stat = statSync18(target);
+          const stat = statSync19(target);
           if (stat.size <= MAX_THREAD_FILE_BYTES) {
-            const raw = readFileSync25(target, "utf-8");
+            const raw = readFileSync27(target, "utf-8");
             const onDisk = JSON.parse(raw);
             if (onDisk && Array.isArray(onDisk.messages)) {
               const known = new Set(this.messages.map((m) => m.id));
@@ -25777,7 +26432,7 @@ ${msg.content}` };
       let fd = -1;
       try {
         fd = openSync(tmpPath, "w", 384);
-        writeFileSync21(fd, body, "utf-8");
+        writeFileSync22(fd, body, "utf-8");
         fsyncSync(fd);
       } finally {
         if (fd >= 0) {
@@ -25796,7 +26451,7 @@ ${msg.content}` };
       this.dirty = false;
       this.hydrated = true;
       try {
-        if (existsSync21(jPath)) unlinkSync9(jPath);
+        if (existsSync23(jPath)) unlinkSync9(jPath);
         this.journaledIds.clear();
       } catch {
       }
@@ -25817,8 +26472,8 @@ ${msg.content}` };
 function loadActivePointer() {
   try {
     const path = activePointerPath();
-    if (existsSync21(path)) {
-      const raw = readFileSync25(path, "utf-8");
+    if (existsSync23(path)) {
+      const raw = readFileSync27(path, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && parsed.byProject) {
         return parsed;
@@ -25832,9 +26487,9 @@ function loadActivePointer() {
 function saveActivePointer(pointer) {
   ensureAgonHome();
   const path = activePointerPath();
-  mkdirSync20(threadsDir(), { recursive: true });
+  mkdirSync21(threadsDir(), { recursive: true });
   const tmpPath = path + ".tmp";
-  writeFileSync21(tmpPath, JSON.stringify(pointer, null, 2) + "\n", "utf-8");
+  writeFileSync22(tmpPath, JSON.stringify(pointer, null, 2) + "\n", "utf-8");
   renameSync11(tmpPath, path);
 }
 var _WeakRefCtor = globalThis.WeakRef;
@@ -25890,9 +26545,9 @@ async function forkActiveThread(projectPath, systemPrompt) {
 }
 function listThreadsForProject(projectPath) {
   const dir = threadDirFor(projectPath);
-  if (!existsSync21(dir)) return [];
+  if (!existsSync23(dir)) return [];
   try {
-    return readdirSync15(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5));
+    return readdirSync16(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5));
   } catch (err) {
     console.warn(`[agon] context-thread: failed to list threads: ${err instanceof Error ? err.message : String(err)}`);
     return [];
@@ -26432,7 +27087,7 @@ var AgentSession = class {
 };
 
 // ../core/src/generated/cesar/agent-team.ts
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 function makeAgentTeamError(message, cause) {
   const err = new Error(`AgentTeam: ${message}`);
@@ -26515,7 +27170,7 @@ var AgentTeam = class {
       if (!this.config.isolate) {
         return { m, wt: null };
       }
-      const wt = join27(this.config.cwd, ".agon", "agent-worktrees", this.runId, m.engineId);
+      const wt = join28(this.config.cwd, ".agon", "agent-worktrees", this.runId, m.engineId);
       worktreeCreate(root, wt, this.baseSha);
       return { m, wt };
     });
@@ -27341,10 +27996,10 @@ function hooksOutput(results) {
 }
 
 // ../core/src/generated/blocks/skill-loader.ts
-import { readFileSync as readFileSync26, readdirSync as readdirSync16, existsSync as existsSync22 } from "fs";
-import { join as join28, dirname as dirname11, resolve as resolve23 } from "path";
+import { readFileSync as readFileSync28, readdirSync as readdirSync17, existsSync as existsSync24 } from "fs";
+import { join as join29, dirname as dirname12, resolve as resolve24 } from "path";
 import { homedir as homedir15 } from "os";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 function parseFrontmatter(content) {
   const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
   if (!match) {
@@ -27363,7 +28018,7 @@ function parseFrontmatter(content) {
 }
 function loadSkillFile(filePath) {
   try {
-    const content = readFileSync26(filePath, "utf-8");
+    const content = readFileSync28(filePath, "utf-8");
     const { meta: meta3, body } = parseFrontmatter(content);
     if (!meta3.name || !meta3.trigger) return null;
     return {
@@ -27381,11 +28036,11 @@ function loadSkillFile(filePath) {
 }
 function loadSkillsFromDir(dir, source) {
   const skills = [];
-  if (!existsSync22(dir)) return skills;
+  if (!existsSync24(dir)) return skills;
   try {
-    const files = readdirSync16(dir).filter((f) => f.endsWith(".md"));
+    const files = readdirSync17(dir).filter((f) => f.endsWith(".md"));
     for (const file2 of files) {
-      const skill = loadSkillFile(join28(dir, file2));
+      const skill = loadSkillFile(join29(dir, file2));
       if (skill) {
         skill.source = source;
         skills.push(skill);
@@ -27399,12 +28054,12 @@ function loadSkillsFromDir(dir, source) {
 function loadSkills(cwd) {
   const skills = [];
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve23(override) : join28(homedir15(), ".agon");
-  const builtinDir = join28(dirname11(fileURLToPath2(import.meta.url)), "../../skills");
+  const home = override ? resolve24(override) : join29(homedir15(), ".agon");
+  const builtinDir = join29(dirname12(fileURLToPath3(import.meta.url)), "../../skills");
   skills.push(...loadSkillsFromDir(builtinDir, "builtin"));
-  skills.push(...loadSkillsFromDir(join28(home, "skills"), "global"));
+  skills.push(...loadSkillsFromDir(join29(home, "skills"), "global"));
   if (cwd) {
-    skills.push(...loadSkillsFromDir(join28(cwd, ".agon", "skills"), "project"));
+    skills.push(...loadSkillsFromDir(join29(cwd, ".agon", "skills"), "project"));
   }
   const seen = /* @__PURE__ */ new Map();
   for (const skill of skills) {
@@ -27421,17 +28076,17 @@ function renderSkillPrompt(skill, input) {
 }
 
 // ../core/src/generated/blocks/engine-memory.ts
-import { readFileSync as readFileSync27, writeFileSync as writeFileSync22, mkdirSync as mkdirSync21, renameSync as renameSync12 } from "fs";
-import { join as join29, resolve as resolve24 } from "path";
+import { readFileSync as readFileSync29, writeFileSync as writeFileSync23, mkdirSync as mkdirSync22, renameSync as renameSync12 } from "fs";
+import { join as join30, resolve as resolve25 } from "path";
 import { homedir as homedir16 } from "os";
 function memoryPath() {
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve24(override) : join29(homedir16(), ".agon");
-  return join29(home, "engine-memory.json");
+  const home = override ? resolve25(override) : join30(homedir16(), ".agon");
+  return join30(home, "engine-memory.json");
 }
 function loadEngineMemory() {
   try {
-    return JSON.parse(readFileSync27(memoryPath(), "utf-8"));
+    return JSON.parse(readFileSync29(memoryPath(), "utf-8"));
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.warn(`[agon] failed to load engine memory: ${err instanceof Error ? err.message : String(err)}`);
@@ -27441,12 +28096,12 @@ function loadEngineMemory() {
 }
 function saveEngineMemory(record2) {
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve24(override) : join29(homedir16(), ".agon");
-  mkdirSync21(home, { recursive: true });
+  const home = override ? resolve25(override) : join30(homedir16(), ".agon");
+  mkdirSync22(home, { recursive: true });
   record2.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   const path = memoryPath();
   const tmpPath = path + ".tmp";
-  writeFileSync22(tmpPath, JSON.stringify(record2, null, 2) + "\n");
+  writeFileSync23(tmpPath, JSON.stringify(record2, null, 2) + "\n");
   renameSync12(tmpPath, path);
 }
 function ensureProfile(record2, engineId) {
@@ -27674,13 +28329,13 @@ function assignForgeRoles(engineIds, taskClass) {
 }
 
 // ../core/src/generated/blocks/sidechain-logger.ts
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync22 } from "fs";
-import { join as join30 } from "path";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync23 } from "fs";
+import { join as join31 } from "path";
 function createSidechainLogger(opts) {
   const suffix = opts.parentId ? `_sidechain_${opts.parentId}` : "";
   const filename = `${opts.sessionType}_${opts.sessionId}${suffix}.jsonl`;
-  const logPath = join30(opts.outputDir, filename);
-  mkdirSync22(opts.outputDir, { recursive: true });
+  const logPath = join31(opts.outputDir, filename);
+  mkdirSync23(opts.outputDir, { recursive: true });
   function log(type, engineId, data) {
     const event = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -27709,12 +28364,12 @@ function createSidechainLogger(opts) {
 }
 
 // ../core/src/generated/blocks/provenance.ts
-import { readFileSync as readFileSync28, writeFileSync as writeFileSync23, mkdirSync as mkdirSync23 } from "fs";
-import { join as join31, resolve as resolve25 } from "path";
-import { createHash as createHash6 } from "crypto";
+import { readFileSync as readFileSync30, writeFileSync as writeFileSync24, mkdirSync as mkdirSync24 } from "fs";
+import { join as join32, resolve as resolve26 } from "path";
+import { createHash as createHash7 } from "crypto";
 function sha256OfFile(path) {
   try {
-    return "sha256:" + createHash6("sha256").update(readFileSync28(path)).digest("hex");
+    return "sha256:" + createHash7("sha256").update(readFileSync30(path)).digest("hex");
   } catch (e) {
     console.warn(`[agon] provenance: could not hash ${path}: ${e instanceof Error ? e.message : String(e)}`);
     return "unavailable";
@@ -27874,18 +28529,18 @@ function renderProvenanceMarkdown(led) {
 function writeProvenanceReport(manifest, manifestPath, outDir, format) {
   const fmt = format ?? "md";
   const ledger = buildForgeProvenance(manifest, manifestPath);
-  mkdirSync23(outDir, { recursive: true });
+  mkdirSync24(outDir, { recursive: true });
   if (fmt === "md" || fmt === "both") {
-    const mdPath = resolve25(join31(outDir, "provenance.md"));
-    writeFileSync23(mdPath, renderProvenanceMarkdown(ledger), "utf-8");
+    const mdPath = resolve26(join32(outDir, "provenance.md"));
+    writeFileSync24(mdPath, renderProvenanceMarkdown(ledger), "utf-8");
     if (fmt === "md") return mdPath;
   }
   if (fmt === "json" || fmt === "both") {
-    const jsonPath = resolve25(join31(outDir, "provenance.json"));
-    writeFileSync23(jsonPath, renderProvenanceJson(ledger), "utf-8");
+    const jsonPath = resolve26(join32(outDir, "provenance.json"));
+    writeFileSync24(jsonPath, renderProvenanceJson(ledger), "utf-8");
     if (fmt === "json") return jsonPath;
   }
-  return resolve25(join31(outDir, "provenance.md"));
+  return resolve26(join32(outDir, "provenance.md"));
 }
 
 // ../core/src/generated/models/extension-manifest.ts
@@ -27991,8 +28646,8 @@ var CommandRegistry = class {
 };
 
 // ../core/src/generated/blocks/extension-loader.ts
-import { join as join32, resolve as resolve26 } from "path";
-import { readdirSync as readdirSync17, readFileSync as readFileSync29, existsSync as existsSync23 } from "fs";
+import { join as join33, resolve as resolve27 } from "path";
+import { readdirSync as readdirSync18, readFileSync as readFileSync31, existsSync as existsSync25 } from "fs";
 import { homedir as homedir17 } from "os";
 
 // ../core/src/generated/signals/event-bus.ts
@@ -28083,31 +28738,31 @@ function bridgeShellHooks(bus, hooks) {
 function discoverExtensionDirs(cwd) {
   const results = [];
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve26(override) : join32(homedir17(), ".agon");
-  const userDir = join32(home, "extensions");
-  if (existsSync23(userDir)) {
+  const home = override ? resolve27(override) : join33(homedir17(), ".agon");
+  const userDir = join33(home, "extensions");
+  if (existsSync25(userDir)) {
     try {
-      const entries = readdirSync17(userDir, { withFileTypes: true });
+      const entries = readdirSync18(userDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const manifestPath = join32(userDir, entry.name, "manifest.json");
-          if (existsSync23(manifestPath)) {
-            results.push({ dir: join32(userDir, entry.name), source: "user" });
+          const manifestPath = join33(userDir, entry.name, "manifest.json");
+          if (existsSync25(manifestPath)) {
+            results.push({ dir: join33(userDir, entry.name), source: "user" });
           }
         }
       }
     } catch {
     }
   }
-  const repoDir = join32(cwd, ".agon", "extensions");
-  if (existsSync23(repoDir)) {
+  const repoDir = join33(cwd, ".agon", "extensions");
+  if (existsSync25(repoDir)) {
     try {
-      const entries = readdirSync17(repoDir, { withFileTypes: true });
+      const entries = readdirSync18(repoDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const manifestPath = join32(repoDir, entry.name, "manifest.json");
-          if (existsSync23(manifestPath)) {
-            results.push({ dir: join32(repoDir, entry.name), source: "repo" });
+          const manifestPath = join33(repoDir, entry.name, "manifest.json");
+          if (existsSync25(manifestPath)) {
+            results.push({ dir: join33(repoDir, entry.name), source: "repo" });
           }
         }
       }
@@ -28117,9 +28772,9 @@ function discoverExtensionDirs(cwd) {
   return results;
 }
 function loadExtensionManifest(dir, source) {
-  const manifestPath = join32(dir, "manifest.json");
+  const manifestPath = join33(dir, "manifest.json");
   try {
-    const raw = JSON.parse(readFileSync29(manifestPath, "utf-8"));
+    const raw = JSON.parse(readFileSync31(manifestPath, "utf-8"));
     const result = validateManifest(raw, manifestPath);
     if (!result.ok || !result.data) {
       console.warn(`[agon] skipping extension ${dir}: ${result.error}`);
@@ -28151,7 +28806,7 @@ async function registerExtensionCommands(ext, commandRegistry) {
   if (!commands || commands.length === 0) return registered;
   for (const cmd of commands) {
     try {
-      const handlerPath = resolve26(ext.dir, cmd.handler);
+      const handlerPath = resolve27(ext.dir, cmd.handler);
       const mod = await import(handlerPath);
       if (typeof mod.execute !== "function") {
         console.warn(`[agon] extension '${ext.manifest.id}' command '${cmd.name}': handler missing execute() export`);
@@ -28187,8 +28842,8 @@ function registerExtensionEngines(ext, engineRegistry) {
   }
   for (const enginePath of enginePaths) {
     try {
-      const fullPath = resolve26(ext.dir, enginePath);
-      const raw = JSON.parse(readFileSync29(fullPath, "utf-8"));
+      const fullPath = resolve27(ext.dir, enginePath);
+      const raw = JSON.parse(readFileSync31(fullPath, "utf-8"));
       if (raw.id) {
         engineRegistry.register(raw);
         registered.push(raw.id);
@@ -28209,12 +28864,12 @@ function registerExtensionSkills(ext) {
       trigger: sc.trigger.startsWith("/") ? sc.trigger : "/" + sc.trigger,
       description: sc.description || "",
       prompt: sc.prompt || "",
-      source: resolve26(ext.dir, "manifest.json"),
+      source: resolve27(ext.dir, "manifest.json"),
       tools: sc.tools
     };
     if (sc.handler) {
       try {
-        const handlerPath = resolve26(ext.dir, sc.handler);
+        const handlerPath = resolve27(ext.dir, sc.handler);
         skill._handlerPath = handlerPath;
         skill.handler = async (args, ctx) => {
           const mod = await import(handlerPath);
@@ -28238,7 +28893,7 @@ async function registerExtensionHooks(ext, eventBus) {
   if (!hookContribs || hookContribs.length === 0) return registered;
   for (const hook of hookContribs) {
     try {
-      const handlerPath = resolve26(ext.dir, hook.handler);
+      const handlerPath = resolve27(ext.dir, hook.handler);
       const mod = await import(handlerPath);
       if (typeof mod.handler !== "function" && typeof mod.default !== "function") {
         console.warn(`[agon] extension '${ext.manifest.id}' hook '${hook.event}': handler missing handler() or default() export`);
@@ -28601,8 +29256,8 @@ function computeContributionWeights(team, trace) {
 }
 
 // ../core/src/generated/teams/team-elo.ts
-import { readFileSync as readFileSync30, writeFileSync as writeFileSync24, mkdirSync as mkdirSync24, renameSync as renameSync13 } from "fs";
-import { dirname as dirname12 } from "path";
+import { readFileSync as readFileSync32, writeFileSync as writeFileSync25, mkdirSync as mkdirSync25, renameSync as renameSync13 } from "fs";
+import { dirname as dirname13 } from "path";
 function defaultCompositionRating(lineupKey2) {
   return { lineupKey: lineupKey2, rating: 1500, wins: 0, losses: 0, draws: 0, matches: 0 };
 }
@@ -28611,7 +29266,7 @@ function defaultRoleRating(engineId, role) {
 }
 function loadTeamElo() {
   try {
-    return JSON.parse(readFileSync30(TEAM_ELO_PATH, "utf-8"));
+    return JSON.parse(readFileSync32(TEAM_ELO_PATH, "utf-8"));
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.warn(`[agon] failed to load team ELO: ${err instanceof Error ? err.message : String(err)}`);
@@ -28620,10 +29275,10 @@ function loadTeamElo() {
   }
 }
 function saveTeamElo(record2) {
-  mkdirSync24(dirname12(TEAM_ELO_PATH), { recursive: true });
+  mkdirSync25(dirname13(TEAM_ELO_PATH), { recursive: true });
   record2.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   const tmpPath = TEAM_ELO_PATH + ".tmp";
-  writeFileSync24(tmpPath, JSON.stringify(record2, null, 2) + "\n");
+  writeFileSync25(tmpPath, JSON.stringify(record2, null, 2) + "\n");
   renameSync13(tmpPath, TEAM_ELO_PATH);
 }
 function expectedScore(rA, rB) {
@@ -28816,6 +29471,10 @@ export {
   EngineRegistry,
   isKernProject,
   scanProjectContext,
+  collectSourceFiles,
+  extractSymbols,
+  buildCodebaseMap,
+  clearCodebaseMapCache,
   addWorkspace,
   removeWorkspace,
   listWorkspaces,
@@ -28842,6 +29501,10 @@ export {
   listPlans,
   deletePlan,
   wordWrap,
+  resolveKernSourceLocation,
+  mapKernStackTrace,
+  installKernStackTraceMapper,
+  uninstallKernStackTraceMapper,
   formatSpinnerFrame,
   formatEngineBlock,
   formatStatusLine,
@@ -28940,6 +29603,7 @@ export {
   createAgentTool,
   createQuickNeroTool,
   createGoalTool,
+  createConquerTool,
   createPipelineTool,
   createProposePlanTool,
   createExitPlanModeTool,
@@ -28990,6 +29654,8 @@ export {
   refreshProbedCliModels,
   findBinary,
   getBinaryVersion,
+  getBinaryVersionAsync,
+  refreshCliGroupVersion,
   buildCliModelGroups,
   buildCliModelGroupsAsync,
   buildCliGroupsImmediate,
@@ -29106,4 +29772,4 @@ export {
   predictTeamRating,
   updateTeamElo
 };
-//# sourceMappingURL=chunk-7PMMOQZ7.js.map
+//# sourceMappingURL=chunk-PFHGKBQT.js.map