@kernlang/agon 0.1.3 → 0.1.5

package/dist/{chunk-PFHGKBQT.js → chunk-HAJIKZGU.js}

@@ -5,7 +5,7 @@ import {
   __require,
   __toCommonJS,
   apiStreamDispatchWithHistory
-} from "./chunk-5QMVQPHY.js";
+} from "./chunk-SOUF7XTW.js";
 
 // ../core/src/generated/signals/glicko.ts
 var glicko_exports = {};
@@ -380,6 +380,7 @@ var DEFAULT_AGON_CONFIG = {
   allowedCommands: [],
   toolPermissions: {},
   hiddenEngines: [],
+  removedEngines: [],
   engineModels: {},
   engineEfforts: {},
   engineIsolation: "workspace-pure",
@@ -396,6 +397,7 @@ var DEFAULT_AGON_CONFIG = {
 var DEFAULT_CONFIG = DEFAULT_AGON_CONFIG;
 
 // ../core/src/generated/models/errors.ts
+var AGON_MODE_NAMES = ["forge", "brainstorm", "tribunal", "campfire", "council", "synthesis", "conquer", "goal", "agent", "pipeline", "review", "nero", "think"];
 var AgonError = class extends Error {
   constructor(message) {
     super(message);
@@ -404,7 +406,8 @@ var AgonError = class extends Error {
 };
 var EngineNotFoundError = class extends AgonError {
   constructor(engineId, installHint) {
-    const hint = installHint ? `. Install: ${installHint}` : "";
+    const modeId = engineId.toLowerCase();
+    const hint = AGON_MODE_NAMES.includes(modeId) ? `. "${engineId}" is an Agon mode (a command), not an engine \u2014 run /${modeId} instead. Engines are backends like codex, claude, or agy.` : installHint ? `. Install: ${installHint}` : "";
     super(`Engine "${engineId}" not found${hint}`);
     this.engineId = engineId;
     this.installHint = installHint;
@@ -504,6 +507,7 @@ function loadConfig(cwd) {
   const merged = { ...DEFAULT_AGON_CONFIG, ...global, ...local, ...localPrivate };
   if (!Array.isArray(merged.forgeEnabledEngines)) merged.forgeEnabledEngines = [];
   if (!Array.isArray(merged.hiddenEngines)) merged.hiddenEngines = [];
+  if (!Array.isArray(merged.removedEngines)) merged.removedEngines = [];
   if (!["auto", "explicit"].includes(String(merged.engineActivationMode))) merged.engineActivationMode = "auto";
   if (!merged.hooks || typeof merged.hooks === "string") merged.hooks = {};
   if (!merged.allowedCommands || typeof merged.allowedCommands === "string") merged.allowedCommands = [];
@@ -4923,10 +4927,10 @@ function isValidJWT(token, algorithm = null) {
     const tokensParts = token.split(".");
     if (tokensParts.length !== 3)
       return false;
-    const [header] = tokensParts;
-    if (!header)
+    const [header2] = tokensParts;
+    if (!header2)
       return false;
-    const parsedHeader = JSON.parse(atob(header));
+    const parsedHeader = JSON.parse(atob(header2));
     if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
       return false;
     if (!parsedHeader.alg)
@@ -16361,8 +16365,8 @@ var EngineRegistry = class {
     return this.availableEngines().map((e) => e.id);
   }
   activeEngines(config2) {
-    const hidden = new Set(config2?.hiddenEngines ?? []);
-    const available = this.availableEngines().filter((e) => !hidden.has(e.id));
+    const excluded = /* @__PURE__ */ new Set([...config2?.hiddenEngines ?? [], ...config2?.removedEngines ?? []]);
+    const available = this.availableEngines().filter((e) => !excluded.has(e.id));
     if (!config2 || config2.engineActivationMode !== "explicit") {
       return available;
     }
@@ -16372,6 +16376,24 @@ var EngineRegistry = class {
   activeIds(config2) {
     return this.activeEngines(config2).map((e) => e.id);
   }
+  partitionRoster(requested, config2) {
+    if (!requested) {
+      return { active: this.activeIds(config2), removed: [] };
+    }
+    const removedSet = new Set(config2?.removedEngines ?? []);
+    const active = [];
+    const removed = [];
+    for (const raw of requested) {
+      const id = this.resolveId(String(raw ?? "").trim());
+      if (id && removedSet.has(id) && !removed.includes(id)) {
+        removed.push(id);
+      }
+      if (id && !removedSet.has(id) && !active.includes(id)) {
+        active.push(id);
+      }
+    }
+    return { active, removed };
+  }
   pickStarter(available, strategy, preferred) {
     if (available.length === 0) {
       throw new EngineNotFoundError("(any)", "No engines available");
@@ -16407,7 +16429,213 @@ var EngineRegistry = class {
 
 // ../core/src/generated/blocks/context-scanner.ts
 import { readFileSync as readFileSync8, readdirSync as readdirSync6, statSync as statSync6, existsSync as existsSync6 } from "fs";
-import { join as join9, basename } from "path";
+import { join as join9, basename, dirname as dirname5 } from "path";
+import { createRequire as createRequire2 } from "module";
+
+// ../../node_modules/@kernlang/context/dist/spine.js
+var CHARS_PER_TOKEN = 4;
+var DEFAULT_SPINE_TOKENS = 1500;
+var MAX_SITES_PER_SYMBOL = 3;
+var MAX_TOKEN_CHARS = 80;
+var UNSAFE_TOKEN_CHARS = /[\u0000-\u001f\u007f-\u009f<>;{},`]/g;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function sanitize(raw) {
+  const cleaned = raw.replace(UNSAFE_TOKEN_CHARS, " ").replace(/\s+/g, " ").trim();
+  return cleaned.length > MAX_TOKEN_CHARS ? `${cleaned.slice(0, MAX_TOKEN_CHARS)}\u2026` : cleaned;
+}
+var KIND_ABBR = {
+  function: "fn",
+  method: "fn",
+  class: "cls",
+  const: "const",
+  type: "type",
+  module: "mod"
+};
+function usageVerb(kind) {
+  return kind === "const" || kind === "type" || kind === "module" ? "readby" : "callby";
+}
+function confGlyph(c) {
+  if (c === "unresolved")
+    return "~";
+  if (c === "heuristic")
+    return "?";
+  return "";
+}
+function renderSite(s) {
+  return `${confGlyph(s.confidence)}${sanitize(s.path)}:${s.line}`;
+}
+function prepareSymbols(artifact, batchSet) {
+  const fileById = new Map(artifact.files.map((f) => [f.id, f]));
+  const prepared = [];
+  for (const sym of artifact.symbols) {
+    const file2 = fileById.get(sym.fileId);
+    if (!file2 || !batchSet.has(file2.path))
+      continue;
+    const usage = artifact.usage[sym.id];
+    prepared.push({
+      name: sym.name,
+      kind: sym.kind,
+      exported: sym.exported,
+      publicApi: sym.publicApi ?? false,
+      fileId: sym.fileId,
+      line: sym.line,
+      sites: usage?.callers ?? [],
+      totalCount: usage?.totalCount ?? 0
+    });
+  }
+  prepared.sort((a, b) => {
+    if (a.publicApi !== b.publicApi)
+      return a.publicApi ? -1 : 1;
+    if (a.exported !== b.exported)
+      return a.exported ? -1 : 1;
+    if (a.totalCount !== b.totalCount)
+      return b.totalCount - a.totalCount;
+    if (a.name !== b.name)
+      return a.name < b.name ? -1 : 1;
+    if (a.fileId !== b.fileId)
+      return a.fileId < b.fileId ? -1 : 1;
+    return a.line - b.line;
+  });
+  return prepared;
+}
+function symbolLineA(s) {
+  const flags = [s.exported ? "exp" : "", s.publicApi ? "public" : ""].filter(Boolean).join(" ");
+  const shown = s.sites.slice(0, MAX_SITES_PER_SYMBOL).map(renderSite).join(" ");
+  const rest = s.totalCount - Math.min(s.sites.length, MAX_SITES_PER_SYMBOL);
+  const tail = rest > 0 ? ` +${rest}` : "";
+  const usagePart = s.totalCount > 0 ? ` ${usageVerb(s.kind)} ${shown}${tail}` : " unused";
+  const head = `sym ${sanitize(s.name)} ${KIND_ABBR[s.kind]}${flags ? ` ${flags}` : ""} line${s.line}`;
+  return `${head}${usagePart}`;
+}
+function symbolLineB(s) {
+  const flags = [s.exported ? "exp" : "", s.publicApi ? "public" : ""].filter(Boolean).join(" ");
+  return `sym ${sanitize(s.name)} ${KIND_ABBR[s.kind]}${flags ? ` ${flags}` : ""} used=${s.totalCount}`;
+}
+function symbolLineC(s) {
+  return `sym ${sanitize(s.name)} used=${s.totalCount}`;
+}
+function depsLine(artifact, batchSet) {
+  const deps = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of artifact.files) {
+    if (!batchSet.has(f.path))
+      continue;
+    for (const imp of f.imports ?? []) {
+      if (batchSet.has(imp.path) || seen.has(imp.path))
+        continue;
+      seen.add(imp.path);
+      const names = imp.symbols?.length ? `{${imp.symbols.map(sanitize).join(",")}}` : "";
+      deps.push(`${sanitize(imp.path)}${names}`);
+    }
+  }
+  return deps.length ? `deps ${deps.join(" ")}` : null;
+}
+function taintLines(artifact) {
+  return (artifact.taint ?? []).map((t) => `taint ${sanitize(t.source)} -> ${sanitize(t.through)} -> ${sanitize(t.sink)} conf=${t.confidence}`);
+}
+function elsewhereLine(otherBatches) {
+  if (!otherBatches?.length)
+    return null;
+  const parts = otherBatches.map((b) => b.dirs.map((d) => `${sanitize(d)}/*#${sanitize(b.id)}`).join(" ")).filter(Boolean);
+  return parts.length ? `elsewhere ${parts.join(" ")}` : null;
+}
+function header(opts, fileTotal) {
+  const batch = opts.batchIndex && opts.batchTotal ? ` batch=${opts.batchIndex}/${opts.batchTotal}` : "";
+  return `<kern-map v=1${batch} files=${fileTotal}>`;
+}
+function renderTier(tier, symbols, artifact, batchSet, opts) {
+  const lines = [];
+  if (tier === "A") {
+    for (const s of symbols)
+      lines.push(symbolLineA(s));
+    const deps = depsLine(artifact, batchSet);
+    if (deps)
+      lines.push(deps);
+    lines.push(...taintLines(artifact));
+    const elsewhere = elsewhereLine(opts.otherBatches);
+    if (elsewhere)
+      lines.push(elsewhere);
+  } else if (tier === "B") {
+    for (const s of symbols)
+      lines.push(symbolLineB(s));
+    const elsewhere = elsewhereLine(opts.otherBatches);
+    if (elsewhere)
+      lines.push(elsewhere);
+  } else {
+    for (const s of symbols.filter((sym) => sym.exported))
+      lines.push(symbolLineC(s));
+  }
+  return lines;
+}
+function buildSpine(artifact, opts) {
+  const batchSet = new Set(opts.batchFiles);
+  const symbols = prepareSymbols(artifact, batchSet);
+  if (symbols.length === 0)
+    return "";
+  const budget = opts.tokenBudget ?? DEFAULT_SPINE_TOKENS;
+  const head = header(opts, artifact.files.length);
+  const close = "</kern-map>";
+  const envelope = estimateTokens(`${head}
+${close}`);
+  const assemble = (bodyLines) => [head, ...bodyLines, close].join("\n");
+  for (const tier of ["A", "B", "C"]) {
+    const body = renderTier(tier, symbols, artifact, batchSet, opts);
+    const text = assemble(body);
+    if (estimateTokens(text) <= budget)
+      return text;
+    if (tier === "C") {
+      return clipToBudget(symbols, head, close, envelope, budget);
+    }
+  }
+  return assemble(renderTier("C", symbols, artifact, batchSet, opts));
+}
+var MARKER_RESERVE_TOKENS = 4;
+function clipToBudget(symbols, head, close, envelope, budget) {
+  if (envelope + MARKER_RESERVE_TOKENS > budget)
+    return "";
+  const exported = symbols.filter((s) => s.exported);
+  const kept = [];
+  let used = envelope;
+  let droppedExported = 0;
+  for (const s of exported) {
+    const line = symbolLineC(s);
+    const cost = estimateTokens(`${line}
+`);
+    if (used + cost + MARKER_RESERVE_TOKENS <= budget) {
+      kept.push(line);
+      used += cost;
+    } else {
+      droppedExported++;
+    }
+  }
+  const dropped = droppedExported + (symbols.length - exported.length);
+  if (dropped > 0)
+    kept.push(`+${dropped} more`);
+  return [head, ...kept, close].join("\n");
+}
+
+// ../core/src/generated/blocks/context-scanner.ts
+var PROJECT_BRIEF_FILES = [".agon/project.md", "AGON.md", "AGENT.md", "CLAUDE.md", "CODEX.md"];
+var MAX_PROJECT_BRIEF_BYTES = 512 * 1024;
+function projectBriefCap(file2) {
+  return file2 === ".agon/project.md" || file2 === "AGON.md" ? 4e3 : 2e3;
+}
+function hasProjectBrief(cwd) {
+  for (const file2 of PROJECT_BRIEF_FILES) {
+    try {
+      const path = join9(cwd, file2);
+      const st = existsSync6(path) ? statSync6(path) : null;
+      if (st && st.isFile() && st.size > 0) {
+        if (st.size > MAX_PROJECT_BRIEF_BYTES) return true;
+        if (readFileSync8(path, "utf-8").trim().length > 0) return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
 function isKernProject(cwd) {
   if (existsSync6(join9(cwd, "kern.config.ts"))) return true;
   try {
@@ -16519,14 +16747,15 @@ ${tree}`);
 ${diff}`);
     }
   }
-  const instructionFiles = ["AGON.md", "AGENT.md", "CLAUDE.md", "CODEX.md"];
-  for (const file2 of instructionFiles) {
+  for (const file2 of PROJECT_BRIEF_FILES) {
     try {
       const path = join9(cwd, file2);
       if (existsSync6(path)) {
         const content = readFileSync8(path, "utf-8").trim();
         if (content) {
-          const capped = content.length > 2e3 ? content.slice(0, 2e3) + "\n... (truncated)" : content;
+          const cap = projectBriefCap(file2);
+          const capped = content.length > cap ? content.slice(0, cap) + `
+... (truncated at ${cap} chars)` : content;
           sections.push(`Project instructions (${file2}):
 ${capped}`);
           break;
@@ -16550,6 +16779,78 @@ ${result}
   }
   return result;
 }
+var KERN_SPINE_TTL_MS = 5 * 60 * 1e3;
+var KERN_SPINE_CACHE = /* @__PURE__ */ new Map();
+var KERN_SPINE_WARNED = /* @__PURE__ */ new Set();
+async function computeKernContextSpine(cwd) {
+  const debugFail = (msg) => {
+    if (process.env.AGON_DEBUG && !KERN_SPINE_WARNED.has(cwd)) {
+      KERN_SPINE_WARNED.add(cwd);
+      console.warn(`[agon] kern context spine unavailable for ${cwd}: ${msg}`);
+    }
+  };
+  try {
+    const requireFn = createRequire2(import.meta.url);
+    const cliBin = join9(dirname5(requireFn.resolve("@kernlang/cli")), "cli.js");
+    if (!existsSync6(cliBin)) return "";
+    const timeoutEnv = Number(process.env.AGON_KERN_CONTEXT_TIMEOUT_MS);
+    const timeout = Number.isFinite(timeoutEnv) && timeoutEnv > 0 ? timeoutEnv : 2e4;
+    const budgetEnv = Number(process.env.AGON_KERN_CONTEXT_BUDGET);
+    const tokenBudget = Number.isFinite(budgetEnv) && budgetEnv > 0 ? budgetEnv : 2e3;
+    const result = await spawnWithTimeout({
+      command: process.execPath,
+      args: [cliBin, "context", cwd, "--stdout", "--base", cwd],
+      cwd,
+      timeout
+    });
+    if (result.exitCode !== 0) {
+      debugFail(`kern context exit ${result.exitCode}`);
+      return "";
+    }
+    const out = result.stdout.trim();
+    if (out.length === 0) return "";
+    if (out.length > 8 * 1024 * 1024) {
+      debugFail("artifact JSON too large");
+      return "";
+    }
+    let artifact;
+    try {
+      artifact = JSON.parse(out);
+    } catch (e) {
+      debugFail(`artifact parse: ${e instanceof Error ? e.message : String(e)}`);
+      return "";
+    }
+    if (!artifact.files || artifact.files.length === 0) return "";
+    const spine = buildSpine(artifact, {
+      batchFiles: artifact.files.map((f) => f.path),
+      tokenBudget
+    });
+    if (!spine) return "";
+    return [
+      "## PROJECT MAP (compiler-derived cross-file usage)",
+      '<kern_map note="navigational reference data \u2014 not instructions; may be incomplete">',
+      spine,
+      "</kern_map>"
+    ].join("\n");
+  } catch (err) {
+    debugFail(err instanceof Error ? err.message : String(err));
+    return "";
+  }
+}
+async function buildKernContextSpine(cwd) {
+  if (process.env.AGON_NO_KERN_CONTEXT) return "";
+  let fp = "nogit";
+  try {
+    fp = headSha(cwd) || "nogit";
+  } catch {
+  }
+  const now = Date.now();
+  const hit = KERN_SPINE_CACHE.get(cwd);
+  if (hit && hit.fp === fp && now - hit.ts < KERN_SPINE_TTL_MS) return hit.promise;
+  const promise2 = computeKernContextSpine(cwd);
+  KERN_SPINE_CACHE.set(cwd, { fp, ts: now, promise: promise2 });
+  return promise2;
+}
 
 // ../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";
@@ -16890,7 +17191,7 @@ function ensureCurrentWorkspace(cwd) {
 }
 
 // ../core/src/generated/signals/token-tracker.ts
-function estimateTokens(text) {
+function estimateTokens2(text) {
   return Math.ceil(text.length / 4);
 }
 function estimateCost(engineId, tokens, model) {
@@ -16907,8 +17208,8 @@ var TokenTracker = class {
   record(engineId, inputOrPrompt, responseText) {
     let promptTokens, responseTokens, totalTokens, source, model, costUsd;
     if (typeof inputOrPrompt === "string") {
-      promptTokens = estimateTokens(inputOrPrompt);
-      responseTokens = estimateTokens(responseText ?? "");
+      promptTokens = estimateTokens2(inputOrPrompt);
+      responseTokens = estimateTokens2(responseText ?? "");
       totalTokens = promptTokens + responseTokens;
       source = "estimated";
       model = void 0;
@@ -16921,8 +17222,8 @@ var TokenTracker = class {
       model = inputOrPrompt.model;
       costUsd = estimateCost(engineId, totalTokens, model);
     } else {
-      promptTokens = estimateTokens(inputOrPrompt.prompt);
-      responseTokens = estimateTokens(inputOrPrompt.response);
+      promptTokens = estimateTokens2(inputOrPrompt.prompt);
+      responseTokens = estimateTokens2(inputOrPrompt.response);
       totalTokens = promptTokens + responseTokens;
       source = "estimated";
       model = void 0;
@@ -17164,9 +17465,9 @@ function wordWrap(text, width) {
 
 // ../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 { basename as basename3, dirname as dirname6, isAbsolute as isAbsolute2, normalize, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 import { Buffer as Buffer2 } from "buffer";
 function setBoundedCacheEntry(cache, key, value) {
   if (!cache || typeof cache.set !== "function") return;
@@ -17207,7 +17508,7 @@ function readTextFileCached(filePath) {
 }
 function nodeModuleApi() {
   try {
-    return createRequire2(import.meta.url)("node:module");
+    return createRequire3(import.meta.url)("node:module");
   } catch {
     return {};
   }
@@ -17243,7 +17544,7 @@ function loadSourceMapForFile(filePath) {
         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));
+        const mapPath = resolve7(dirname6(normalized), decodeURIComponent(mappingUrl));
         if (existsSync9(mapPath)) payload = JSON.parse(readFileSync12(mapPath, "utf8"));
       }
       if (payload && typeof mod.SourceMap === "function") {
@@ -17288,7 +17589,7 @@ function resolveSourceMapSourcePath(mapFilePath, sourceMap, originFileName) {
       return normalize(sourceRef);
     }
   }
-  return normalize(resolve7(dirname5(normalizeStackFilePath(mapFilePath)), sourceRoot, sourceRef));
+  return normalize(resolve7(dirname6(normalizeStackFilePath(mapFilePath)), sourceRoot, sourceRef));
 }
 function sourceMapOriginForLocation(sourceMap, lineNumber, columnNumber) {
   if (!sourceMap) return null;
@@ -17382,15 +17683,15 @@ function packageRootForGeneratedPath(generatedFile) {
   return null;
 }
 function resolveKernSourceFile(generatedFile, content, sourceName) {
-  const header = generatedHeaderSource(content);
+  const header2 = 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)));
+  if (header2) {
+    if (isAbsolute2(header2)) candidates.push(normalize(header2));
+    if (root) candidates.push(normalize(resolve7(root, header2)));
+    candidates.push(normalize(resolve7(dirname6(normalizeStackFilePath(generatedFile)), header2)));
     try {
-      candidates.push(normalize(resolve7(process.cwd(), header)));
+      candidates.push(normalize(resolve7(process.cwd(), header2)));
     } catch {
     }
   }
@@ -17925,7 +18226,7 @@ function undoPatch(cwd, undoToken) {
 
 // ../core/src/generated/blocks/file-history.ts
 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 { join as join15, dirname as dirname7, resolve as resolve9 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 import { homedir as homedir7 } from "os";
 function snapshotsDir() {
@@ -17989,7 +18290,7 @@ function revertSnapshot(id) {
           reverted++;
         }
       } else {
-        mkdirSync10(dirname6(fullPath), { recursive: true });
+        mkdirSync10(dirname7(fullPath), { recursive: true });
         writeFileSync11(fullPath, snap.content);
         reverted++;
       }
@@ -19511,7 +19812,7 @@ function createEditTool() {
 
 // ../core/src/generated/tools/tool-write.ts
 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";
+import { resolve as resolve13, dirname as dirname10, relative as relative6 } from "path";
 function createWriteTool() {
   const definition = {
     name: "Write",
@@ -19594,7 +19895,7 @@ function createWriteTool() {
     } else {
       snapshot = takeSnapshot(`Write (new): ${relPath}`, ctx.cwd, [relPath]);
     }
-    const parentDir = dirname9(filePath);
+    const parentDir = dirname10(filePath);
     if (!existsSync15(parentDir)) {
       try {
         mkdirSync14(parentDir, { recursive: true });
@@ -19642,6 +19943,13 @@ function extractBaseCommand(command) {
   }
   return cmd;
 }
+function guiUnavailableHint(command, stderr) {
+  const cmd = (command ?? "").trim();
+  const launchesGui = /(^|\s)electron(\s|$)/i.test(cmd) || /(^|\s)(pnpm|npm|yarn|bun)\s+(run\s+)?(studio|gui)(\s|$)/i.test(cmd);
+  const displayFailure = /(DISPLAY\s+not\s+set|cannot\s+open\s+display|Missing X server)/i.test(stderr ?? "");
+  if (!launchesGui && !displayFailure) return null;
+  return "This looks like a GUI/desktop app, which cannot run in this headless shell. Use a headless equivalent (a build/test/CLI script, or a --headless flag), or run the GUI on your own machine.";
+}
 function createBashTool() {
   const definition = {
     name: "Bash",
@@ -19710,10 +20018,10 @@ function createBashTool() {
     const readRedirect = tryRedirectToRead(command);
     if (readRedirect) {
       try {
-        const { readFileSync: readFileSync33 } = await import("fs");
+        const { readFileSync: readFileSync36 } = await import("fs");
         const { resolve: resolve28 } = await import("path");
         const filePath = resolve28(ctx.cwd, readRedirect.file);
-        const content = readFileSync33(filePath, "utf-8");
+        const content = readFileSync36(filePath, "utf-8");
         const lines = content.split("\n");
         const offset = readRedirect.offset ?? 0;
         const limit = readRedirect.limit ?? lines.length;
@@ -19758,19 +20066,23 @@ function createBashTool() {
     }
     const durationMs = Date.now() - start;
     const exitCode = closeResult?.exitCode ?? 1;
+    const guiHint = guiUnavailableHint(command, stderr);
     if (closeResult?.timedOut) {
       return {
         ok: false,
         content: stdout,
-        error: `Command timed out after ${timeout}ms`,
+        error: `Command timed out after ${timeout}ms` + (guiHint ? `
+${guiHint}` : ""),
         metadata: { exitCode: 124, durationMs, timedOut: true }
       };
     }
     if (exitCode !== 0) {
+      const baseErr = stderr || `Process exited with code ${exitCode}`;
       return {
         ok: false,
         content: stdout,
-        error: stderr || `Process exited with code ${exitCode}`,
+        error: guiHint ? `${baseErr}
+${guiHint}` : baseErr,
         metadata: { exitCode, durationMs, timedOut: false }
       };
     }
@@ -20494,7 +20806,7 @@ function createTodoWriteTool() {
 
 // ../core/src/generated/signals/auth-store.ts
 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 { join as join18, dirname as dirname11, resolve as resolve15 } from "path";
 import { homedir as homedir9 } from "os";
 function getAuthFile() {
   const override = process.env.AGON_HOME?.trim();
@@ -20515,7 +20827,7 @@ function loadAuthStore() {
 }
 function saveAuthStore(store) {
   const authFile = getAuthFile();
-  const dir = dirname10(authFile);
+  const dir = dirname11(authFile);
   mkdirSync15(dir, { recursive: true });
   writeFileSync16(authFile, JSON.stringify(store.entries, null, 2) + "\n", { mode: 384 });
   try {
@@ -22169,17 +22481,17 @@ function startChatSession(opts) {
   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 = join21(chatsDir(), `${id}.ndjson`);
-  const header = { _type: "header", id, startedAt: session.startedAt };
+  const header2 = { _type: "header", id, startedAt: session.startedAt };
   if (opts?.cwd) {
-    header.cwd = opts.cwd;
+    header2.cwd = opts.cwd;
   }
   if (opts?.branch) {
-    header.branch = opts.branch;
+    header2.branch = opts.branch;
   }
   if (opts?.engineIds) {
-    header.engineIds = opts.engineIds;
+    header2.engineIds = opts.engineIds;
   }
-  appendFileSync(filePath, JSON.stringify(header) + "\n");
+  appendFileSync(filePath, JSON.stringify(header2) + "\n");
   return session;
 }
 function appendMessage(session, msg) {
@@ -22354,10 +22666,10 @@ function loadChatSession(id) {
     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]);
+    const header2 = JSON.parse(lines[0]);
     const messages = [];
-    let summary = typeof header.summary === "string" ? header.summary : void 0;
-    let summarizedMessageCount = typeof header.summarizedMessageCount === "number" ? header.summarizedMessageCount : void 0;
+    let summary = typeof header2.summary === "string" ? header2.summary : void 0;
+    let summarizedMessageCount = typeof header2.summarizedMessageCount === "number" ? header2.summarizedMessageCount : void 0;
     for (let i = 1; i < lines.length; i++) {
       const msg = JSON.parse(lines[i]);
       if (msg._type === "summary") {
@@ -22371,12 +22683,12 @@ function loadChatSession(id) {
       freeSummarizedMessageBodies(messages, 0, Math.min(summarizedMessageCount, messages.length));
     }
     return {
-      id: header.id ?? id,
-      startedAt: header.startedAt ?? "",
+      id: header2.id ?? id,
+      startedAt: header2.startedAt ?? "",
       messages,
-      cwd: header.cwd,
-      branch: header.branch,
-      engineIds: header.engineIds,
+      cwd: header2.cwd,
+      branch: header2.branch,
+      engineIds: header2.engineIds,
       summary,
       summarizedMessageCount
     };
@@ -22414,9 +22726,9 @@ function latestChatSession() {
 import { existsSync as existsSync19 } from "fs";
 import { resolve as resolve19, basename as basename4, extname as extname2 } from "path";
 import { homedir as homedir11 } from "os";
+import { fileURLToPath as fileURLToPath3 } from "url";
 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" };
-var IMAGE_PATH_REGEX = /(?:^|\s)((?:\/[\w.\-]+)+\.(?:png|jpe?g|gif|webp|svg|bmp)|~\/[\w.\-\/]+\.(?:png|jpe?g|gif|webp|svg|bmp)|\.{1,2}\/[\w.\-\/]+\.(?:png|jpe?g|gif|webp|svg|bmp))/gi;
 var IMG_CMD_REGEX = /^\/img\s+(.+)$/i;
 function isImagePath(filePath) {
   const ext = extname2(filePath).toLowerCase();
@@ -22444,59 +22756,404 @@ function buildImageAttachment(rawPath, cwd) {
   }
   return { path: resolved, filename: basename4(resolved), mimeType: mimeFromExt(resolved) };
 }
+function normalizeDroppedPath(raw) {
+  let p = raw.trim();
+  const sq = p.startsWith("'") && p.endsWith("'");
+  const dq = p.startsWith('"') && p.endsWith('"');
+  if (sq || dq) p = p.slice(1, -1);
+  if (p.startsWith("file://")) {
+    try {
+      return fileURLToPath3(p).trim();
+    } catch {
+      p = p.slice("file://".length);
+      try {
+        p = decodeURIComponent(p);
+      } catch {
+      }
+      return p.trim();
+    }
+  }
+  p = p.replace(/\\(.)/g, "$1");
+  return p.trim();
+}
 function extractImagesFromInput(input, cwd) {
   const images = [];
   const imgCmdMatch = IMG_CMD_REGEX.exec(input.trim());
   if (imgCmdMatch) {
-    const att = buildImageAttachment(imgCmdMatch[1], cwd);
+    const att = buildImageAttachment(normalizeDroppedPath(imgCmdMatch[1]), cwd);
     if (att) images.push(att);
     return { text: "", images };
   }
+  const EXT = "(?:png|jpe?g|gif|webp|svg|bmp)";
+  const detector = new RegExp(
+    "'([^']*\\." + EXT + `)'|"([^"]*\\.` + EXT + ')"|(file:\\/\\/\\S+?\\.' + EXT + `)|(?:^|\\s)((?:\\/|~\\/|\\.{1,2}\\/)(?:\\\\\\x20|[^\\s'"])*\\.` + EXT + ")",
+    "gi"
+  );
   let text = input;
-  const pathRegex = new RegExp(IMAGE_PATH_REGEX.source, "gi");
   let match;
-  const paths = [];
-  while ((match = pathRegex.exec(input)) !== null) {
-    const rawPath = match[1].trim();
-    const att = buildImageAttachment(rawPath, cwd);
+  const hits = [];
+  while ((match = detector.exec(input)) !== null) {
+    const raw = match[1] ?? match[2] ?? match[3] ?? match[4];
+    if (raw) hits.push({ raw, whole: match[0] });
+  }
+  for (const hit of hits) {
+    const att = buildImageAttachment(normalizeDroppedPath(hit.raw), cwd);
     if (att) {
       images.push(att);
-      paths.push(match[0]);
+      text = text.replace(hit.whole, "");
     }
   }
-  for (const p of paths) {
-    text = text.replace(p, "");
+  if (images.length === 0) {
+    const whole = normalizeDroppedPath(input);
+    if (isImagePath(whole)) {
+      const att = buildImageAttachment(whole, cwd);
+      if (att) {
+        images.push(att);
+        text = "";
+      }
+    }
   }
   text = text.replace(/\s{2,}/g, " ").trim();
   return { text, images };
 }
 
+// ../core/src/generated/rooms/store.ts
+import { mkdirSync as mkdirSync18, existsSync as existsSync20, readFileSync as readFileSync23, writeFileSync as writeFileSync19, appendFileSync as appendFileSync2, readdirSync as readdirSync14, openSync, closeSync, unlinkSync as unlinkSync9, statSync as statSync16 } from "fs";
+import { join as join22 } from "path";
+var LOCK_TIMEOUT_MS = 2e3;
+var LOCK_STALE_MS = 5e3;
+function roomsDir() {
+  return runtimeAgonPath("rooms");
+}
+function roomDir(roomId) {
+  return join22(roomsDir(), roomId);
+}
+function eventsPath(roomId) {
+  return join22(roomDir(roomId), "events.ndjson");
+}
+function metaPath(roomId) {
+  return join22(roomDir(roomId), "room.json");
+}
+function slugifyRoomId(name) {
+  const slug = String(name ?? "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "room";
+}
+function roomExists(roomId) {
+  return existsSync20(metaPath(roomId));
+}
+function readMeta(roomId) {
+  try {
+    return JSON.parse(readFileSync23(metaPath(roomId), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeMeta(meta3) {
+  mkdirSync18(roomDir(meta3.roomId), { recursive: true });
+  writeFileSync19(metaPath(meta3.roomId), JSON.stringify(meta3, null, 2) + "\n");
+}
+function createRoom(name) {
+  const roomId = slugifyRoomId(name);
+  const existing = readMeta(roomId);
+  if (existing) return existing;
+  mkdirSync18(roomDir(roomId), { recursive: true });
+  const meta3 = {
+    roomId,
+    name: String(name ?? roomId),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    nextSeq: 1,
+    closed: false
+  };
+  writeMeta(meta3);
+  if (!existsSync20(eventsPath(roomId))) writeFileSync19(eventsPath(roomId), "");
+  return meta3;
+}
+function listRooms() {
+  let ids;
+  try {
+    ids = readdirSync14(roomsDir());
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const id of ids) {
+    const meta3 = readMeta(id);
+    if (meta3) out.push(meta3);
+  }
+  out.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  return out;
+}
+function parseMentions(text) {
+  const out = [];
+  const re = /(?:^|[^\w@])@([a-z0-9][\w-]*)/gi;
+  let m;
+  while ((m = re.exec(String(text ?? ""))) !== null) {
+    const tag = m[1].toLowerCase();
+    if (!out.includes(tag)) out.push(tag);
+  }
+  return out;
+}
+function withRoomLock(roomId, work) {
+  mkdirSync18(roomDir(roomId), { recursive: true });
+  const lock = join22(roomDir(roomId), ".lock");
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  let fd = null;
+  while (fd === null) {
+    try {
+      fd = openSync(lock, "wx");
+    } catch (err) {
+      if (err?.code !== "EEXIST") throw err;
+      try {
+        const st = statSync16(lock);
+        if (Date.now() - st.mtimeMs > LOCK_STALE_MS) {
+          unlinkSync9(lock);
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() > deadline) throw new Error(`room lock timeout: ${roomId}`);
+      const spinUntil = Date.now() + 12;
+      while (Date.now() < spinUntil) {
+      }
+    }
+  }
+  try {
+    work();
+  } finally {
+    try {
+      closeSync(fd);
+    } catch {
+    }
+    try {
+      unlinkSync9(lock);
+    } catch {
+    }
+  }
+}
+function appendEvent(roomId, input) {
+  let result = null;
+  withRoomLock(roomId, () => {
+    const meta3 = readMeta(roomId) ?? createRoom(roomId);
+    const seq = meta3.nextSeq;
+    const event = {
+      seq,
+      id: `evt_${Date.now().toString(36)}${Math.floor(Math.random() * 1e9).toString(36)}`,
+      roomId,
+      kind: input.kind,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      actor: input.actor,
+      repoHint: input.repoHint,
+      body: input.body,
+      mentions: input.mentions,
+      replyTo: input.replyTo,
+      auto: input.auto === true
+    };
+    appendFileSync2(eventsPath(roomId), JSON.stringify(event) + "\n");
+    meta3.nextSeq = seq + 1;
+    writeMeta(meta3);
+    result = event;
+  });
+  if (!result) throw new Error(`appendEvent: lock produced no event for ${roomId}`);
+  return result;
+}
+function readEvents(roomId, sinceSeq, limit) {
+  let raw;
+  try {
+    raw = readFileSync23(eventsPath(roomId), "utf-8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const ev = JSON.parse(line);
+      if (typeof ev.seq === "number" && ev.seq > sinceSeq) out.push(ev);
+    } catch {
+    }
+  }
+  if (limit > 0 && out.length > limit) return out.slice(out.length - limit);
+  return out;
+}
+function closeRoom(roomId) {
+  const meta3 = readMeta(roomId);
+  if (!meta3) return;
+  meta3.closed = true;
+  writeMeta(meta3);
+}
+function isRoomClosed(roomId) {
+  const meta3 = readMeta(roomId);
+  return meta3 ? meta3.closed === true : false;
+}
+
+// ../core/src/generated/rooms/presence.ts
+import { mkdirSync as mkdirSync19, readFileSync as readFileSync24, writeFileSync as writeFileSync20 } from "fs";
+import { join as join23 } from "path";
+var PRESENCE_TTL_MS = 9e4;
+function presencePath(roomId) {
+  return join23(roomDir(roomId), "presence.json");
+}
+function readPresenceRaw(roomId) {
+  try {
+    return JSON.parse(readFileSync24(presencePath(roomId), "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function recordPresence(roomId, actor, lastReadSeq, auto) {
+  mkdirSync19(roomDir(roomId), { recursive: true });
+  const map2 = readPresenceRaw(roomId);
+  map2[actor.callsign] = {
+    callsign: actor.callsign,
+    actorId: actor.actorId,
+    status: "here",
+    lastSeenAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastReadSeq,
+    auto,
+    cli: actor.cli
+  };
+  writeFileSync20(presencePath(roomId), JSON.stringify(map2, null, 2) + "\n");
+}
+function removePresence(roomId, callsign) {
+  const map2 = readPresenceRaw(roomId);
+  if (!map2[callsign]) return;
+  delete map2[callsign];
+  try {
+    writeFileSync20(presencePath(roomId), JSON.stringify(map2, null, 2) + "\n");
+  } catch {
+  }
+}
+function listPresence(roomId) {
+  const map2 = readPresenceRaw(roomId);
+  const now = Date.now();
+  const out = [];
+  for (const key of Object.keys(map2)) {
+    const entry = map2[key];
+    const age = now - new Date(entry.lastSeenAt).getTime();
+    const status = !Number.isFinite(age) ? "left" : age <= PRESENCE_TTL_MS ? "here" : age <= PRESENCE_TTL_MS * 4 ? "stale" : "left";
+    out.push({ ...entry, status });
+  }
+  out.sort((a, b) => a.callsign.localeCompare(b.callsign));
+  return out;
+}
+
+// ../core/src/generated/rooms/leases.ts
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync21 } from "fs";
+import { join as join24 } from "path";
+function leasesPath(roomId) {
+  return join24(roomDir(roomId), "leases.json");
+}
+function readActiveLease(roomId) {
+  try {
+    const raw = JSON.parse(readFileSync25(leasesPath(roomId), "utf-8"));
+    if (!raw || !raw.leaseId) return null;
+    if (Date.now() >= new Date(raw.expiresAt).getTime()) return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function acquireTurnLease(roomId, holder, triggerSeq, ttlMs) {
+  let acquired = null;
+  withRoomLock(roomId, () => {
+    const active = readActiveLease(roomId);
+    if (active && active.holder !== holder) return;
+    const now = Date.now();
+    const lease = {
+      leaseId: `lease_${now.toString(36)}${Math.floor(Math.random() * 1e9).toString(36)}`,
+      holder,
+      triggerSeq,
+      acquiredAt: new Date(now).toISOString(),
+      expiresAt: new Date(now + Math.max(1e3, ttlMs)).toISOString()
+    };
+    writeFileSync21(leasesPath(roomId), JSON.stringify(lease, null, 2) + "\n");
+    acquired = lease;
+  });
+  return acquired;
+}
+function releaseTurnLease(roomId, leaseId) {
+  withRoomLock(roomId, () => {
+    const active = readActiveLease(roomId);
+    if (active && active.leaseId === leaseId) {
+      try {
+        writeFileSync21(leasesPath(roomId), JSON.stringify(null) + "\n");
+      } catch {
+      }
+    }
+  });
+}
+
+// ../core/src/generated/rooms/auto-policy.ts
+function detectTrigger(events, myCallsign, openFloor, quietMs) {
+  if (!Array.isArray(events) || events.length === 0) return { trigger: false, triggerSeq: 0, reason: "no-events" };
+  for (let i = events.length - 1; i >= 0; i--) {
+    const ev = events[i];
+    if (ev.kind !== "post") continue;
+    if (ev.actor.callsign === myCallsign) return { trigger: false, triggerSeq: 0, reason: "self-latest" };
+    if (Array.isArray(ev.mentions) && ev.mentions.includes(myCallsign)) {
+      return { trigger: true, triggerSeq: ev.seq, reason: "mentioned" };
+    }
+    if (openFloor) {
+      const ageMs = Date.now() - new Date(ev.createdAt).getTime();
+      if (ageMs >= quietMs) return { trigger: true, triggerSeq: ev.seq, reason: "open-floor" };
+      return { trigger: false, triggerSeq: 0, reason: "waiting-quiet" };
+    }
+    return { trigger: false, triggerSeq: 0, reason: "not-mentioned" };
+  }
+  return { trigger: false, triggerSeq: 0, reason: "no-posts" };
+}
+function detectPingPong(events) {
+  const posts = events.filter((e) => e.kind === "post").slice(-4);
+  if (posts.length < 4) return false;
+  if (!posts.every((p) => p.auto === true)) return false;
+  const a = posts[0].actor.callsign;
+  const b = posts[1].actor.callsign;
+  if (a === b) return false;
+  return posts[2].actor.callsign === a && posts[3].actor.callsign === b;
+}
+function evaluateStop(state, config2, events) {
+  if (state.turns >= config2.maxTurns) return { stop: true, reason: `max-turns (${config2.maxTurns})` };
+  if (Date.now() - state.startedAtMs >= config2.maxWallMs) return { stop: true, reason: "max-wall-time" };
+  if (detectPingPong(events)) return { stop: true, reason: "ping-pong-halt" };
+  if (config2.untilHuman && state.turns >= 1) {
+    const human = events.find((e) => e.kind === "post" && e.auto !== true && e.actor.callsign !== config2.callsign && e.seq > state.lastSelfSeq);
+    if (human) return { stop: true, reason: "human-replied" };
+  }
+  if (config2.stopPhrase) {
+    const needle = config2.stopPhrase.toLowerCase();
+    const hit = events.find((e) => e.kind === "post" && e.actor.callsign !== config2.callsign && e.body.toLowerCase().includes(needle));
+    if (hit) return { stop: true, reason: "stop-phrase" };
+  }
+  return { stop: false, reason: "" };
+}
+
 // ../core/src/generated/signals/flow.ts
-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 { readFileSync as readFileSync26, writeFileSync as writeFileSync22, mkdirSync as mkdirSync20, readdirSync as readdirSync15 } from "fs";
+import { join as join25, resolve as resolve20 } from "path";
 import { homedir as homedir12 } from "os";
 function getFlowsDir() {
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve20(override) : join22(homedir12(), ".agon");
-  return join22(home, "flows");
+  const home = override ? resolve20(override) : join25(homedir12(), ".agon");
+  return join25(home, "flows");
 }
 var FLOWS_DIR = getFlowsDir();
 var FRICTION_TAGS = ["slow", "wrong-mode", "engine-error", "unclear-output", "timeout", "context-lost", "other"];
 function ensureFlowsDir() {
-  mkdirSync18(getFlowsDir(), { recursive: true });
+  mkdirSync20(getFlowsDir(), { recursive: true });
 }
 function logFlow(record2) {
   ensureFlowsDir();
   const filename = `flow-${record2.id}.json`;
-  const filepath = join22(getFlowsDir(), filename);
-  writeFileSync19(filepath, JSON.stringify(record2, null, 2));
+  const filepath = join25(getFlowsDir(), filename);
+  writeFileSync22(filepath, JSON.stringify(record2, null, 2));
   return filepath;
 }
 function readFlows(limit) {
   ensureFlowsDir();
   let files;
   try {
-    files = readdirSync14(getFlowsDir()).filter((f) => f.startsWith("flow-") && f.endsWith(".json")).sort().reverse();
+    files = readdirSync15(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 [];
@@ -22505,7 +23162,7 @@ function readFlows(limit) {
   const records = [];
   for (const file2 of files) {
     try {
-      const data = JSON.parse(readFileSync23(join22(getFlowsDir(), file2), "utf-8"));
+      const data = JSON.parse(readFileSync26(join25(getFlowsDir(), file2), "utf-8"));
       records.push(data);
     } catch (err) {
       console.warn(`[agon] skipping malformed flow record ${file2}: ${err instanceof Error ? err.message : String(err)}`);
@@ -22934,19 +23591,19 @@ async function companionDispatch(opts) {
 }
 
 // ../core/src/generated/signals/models-registry.ts
-import { readFileSync as readFileSync24, writeFileSync as writeFileSync20, mkdirSync as mkdirSync19, existsSync as existsSync20, statSync as statSync16 } from "fs";
-import { join as join23 } from "path";
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync23, mkdirSync as mkdirSync21, existsSync as existsSync22, statSync as statSync17 } from "fs";
+import { join as join26 } from "path";
 var CACHE_TTL_MS = 36e5;
 var MODELS_DEV_URL = "https://models.dev/api.json";
 async function fetchModelsRegistry() {
   const cacheDir = getCacheDir();
-  const cacheFile = join23(cacheDir, "models-dev.json");
-  if (existsSync20(cacheFile)) {
+  const cacheFile = join26(cacheDir, "models-dev.json");
+  if (existsSync22(cacheFile)) {
     try {
-      const stat = statSync16(cacheFile);
+      const stat = statSync17(cacheFile);
       const age = Date.now() - stat.mtimeMs;
       if (age < CACHE_TTL_MS) {
-        return JSON.parse(readFileSync24(cacheFile, "utf-8"));
+        return JSON.parse(readFileSync27(cacheFile, "utf-8"));
       }
     } catch (_e) {
       console.warn(`[agon] models-registry: cache read failed, refetching: ${_e instanceof Error ? _e.message : String(_e)}`);
@@ -22954,14 +23611,14 @@ async function fetchModelsRegistry() {
   }
   const response = await fetch(MODELS_DEV_URL);
   if (!response.ok) {
-    if (existsSync20(cacheFile)) {
-      return JSON.parse(readFileSync24(cacheFile, "utf-8"));
+    if (existsSync22(cacheFile)) {
+      return JSON.parse(readFileSync27(cacheFile, "utf-8"));
     }
     throw new Error(`Failed to fetch models registry: ${response.status}`);
   }
   const data = await response.json();
-  mkdirSync19(cacheDir, { recursive: true });
-  writeFileSync20(cacheFile, JSON.stringify(data));
+  mkdirSync21(cacheDir, { recursive: true });
+  writeFileSync23(cacheFile, JSON.stringify(data));
   return data;
 }
 function resolveModelFormat(providerNpm, model) {
@@ -23082,24 +23739,24 @@ function modelEntryToEngineDef(entry) {
 
 // ../core/src/generated/signals/cli-models-registry.ts
 import { execSync as execSync4 } from "child_process";
-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 { readFileSync as readFileSync28, writeFileSync as writeFileSync24, mkdirSync as mkdirSync22, existsSync as existsSync23, statSync as statSync18 } from "fs";
+import { join as join27 } from "path";
 import { homedir as homedir13 } from "os";
-import { createRequire as createRequire3 } from "module";
+import { createRequire as createRequire4 } 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 join24(getCacheDir(), `cli-models-${engineId.replace(/[^a-zA-Z0-9_-]/g, "-")}.json`);
+  return join27(getCacheDir(), `cli-models-${engineId.replace(/[^a-zA-Z0-9_-]/g, "-")}.json`);
 }
 function readProbedCliModels(engineId, ttlMs) {
   try {
     const file2 = probedModelsCacheFile(engineId);
-    if (!existsSync21(file2)) return null;
-    const age = Date.now() - statSync17(file2).mtimeMs;
+    if (!existsSync23(file2)) return null;
+    const age = Date.now() - statSync18(file2).mtimeMs;
     if (age > (ttlMs ?? PROBE_TTL_MS)) return null;
-    const data = JSON.parse(readFileSync25(file2, "utf-8"));
+    const data = JSON.parse(readFileSync28(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;
@@ -23109,7 +23766,7 @@ function readProbedCliModels(engineId, ttlMs) {
 }
 function resolveModelProbeScript() {
   try {
-    const req = createRequire3(import.meta.url);
+    const req = createRequire4(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
@@ -23117,16 +23774,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.
-      join24(anchor, "..", "..", "..", "py", "kern_engines", "cli", "model_probe.py"),
+      join27(anchor, "..", "..", "..", "py", "kern_engines", "cli", "model_probe.py"),
       // dist/cli → root → py/kern_engines/cli
-      join24(anchor, "..", "..", "py", "kern_engines", "cli", "model_probe.py"),
+      join27(anchor, "..", "..", "py", "kern_engines", "cli", "model_probe.py"),
       // (alt layout: cli/claude.js → root)
-      join24(anchor, "..", "..", "..", "cli", "model_probe.py"),
-      join24(anchor, "..", "..", "cli", "model_probe.py"),
-      join24(anchor, "..", "model_probe.py")
+      join27(anchor, "..", "..", "..", "cli", "model_probe.py"),
+      join27(anchor, "..", "..", "cli", "model_probe.py"),
+      join27(anchor, "..", "model_probe.py")
     ];
     for (const c of candidates) {
-      if (existsSync21(c)) return c;
+      if (existsSync23(c)) return c;
     }
     return null;
   } catch {
@@ -23196,8 +23853,8 @@ async function refreshProbedCliModels(engineId, binary, listCmd, pythonBin) {
       return false;
     }
     const dir = getCacheDir();
-    mkdirSync20(dir, { recursive: true });
-    writeFileSync21(probedModelsCacheFile(engineId), JSON.stringify({ ts: Date.now(), engineId, models }));
+    mkdirSync22(dir, { recursive: true });
+    writeFileSync24(probedModelsCacheFile(engineId), JSON.stringify({ ts: Date.now(), engineId, models }));
     return true;
   } catch (e) {
     dbg(`probe threw: ${e?.message ?? e}`);
@@ -23213,10 +23870,10 @@ function findBinary(binary) {
   } catch (e) {
   }
   const home = homedir13();
-  const searchPaths = [join24(home, ".local", "bin"), join24(home, ".npm-global", "bin"), "/usr/local/bin"];
+  const searchPaths = [join27(home, ".local", "bin"), join27(home, ".npm-global", "bin"), "/usr/local/bin"];
   for (const dir of searchPaths) {
-    const fullPath = join24(dir, binary);
-    if (existsSync21(fullPath)) {
+    const fullPath = join27(dir, binary);
+    if (existsSync23(fullPath)) {
       return fullPath;
     }
   }
@@ -24382,7 +25039,7 @@ function createResumeSession(config2) {
           }
           return 50;
         };
-        const estimateTokens2 = (msgs) => msgs.reduce((sum, m) => {
+        const estimateTokens3 = (msgs) => msgs.reduce((sum, m) => {
           if (m._tokenEstimate === void 0) {
             m._tokenEstimate = estimateSingle(m);
           }
@@ -24403,7 +25060,7 @@ function createResumeSession(config2) {
         })();
         const COMPACTION_BUFFER = Math.max(2e4, Math.round(CONTEXT_LIMIT * 0.15));
         const PRUNE_PROTECT_TURNS = 6;
-        const totalTokens = estimateTokens2(messageHistory);
+        const totalTokens = estimateTokens3(messageHistory);
         if (totalTokens > CONTEXT_LIMIT - COMPACTION_BUFFER) {
           const hasSystem = messageHistory[0].role === "system";
           const startIdx = hasSystem ? 1 : 0;
@@ -24430,7 +25087,7 @@ function createResumeSession(config2) {
               delete msg._tokenEstimate;
             }
           }
-          const afterTier1 = estimateTokens2(messageHistory);
+          const afterTier1 = estimateTokens3(messageHistory);
           if (afterTier1 > CONTEXT_LIMIT - COMPACTION_BUFFER) {
             const old = messageHistory.slice(startIdx, protectFrom);
             const recent = messageHistory.slice(protectFrom);
@@ -24529,11 +25186,11 @@ ${newSummary.decisions.map((d) => `  - ${d}`).join("\n")}` : "",
               }
             }
           }
-          const afterTier2 = estimateTokens2(messageHistory);
+          const afterTier2 = estimateTokens3(messageHistory);
           const tier3CompactionEnabled = process.env.AGON_DISABLE_TIER3_COMPACTION !== "1";
           if (tier3CompactionEnabled && afterTier2 > CONTEXT_LIMIT - COMPACTION_BUFFER && config2.engine.api) {
             try {
-              const { apiDispatch: apiDispatch2 } = await import("./dispatch-6LQSMMGI.js");
+              const { apiDispatch: apiDispatch2 } = await import("./dispatch-XHLJ44TF.js");
               const compactionPrompt = `Summarize this conversation context into a concise briefing. Preserve: the user's goal, key discoveries, files read/modified, important decisions, and current progress. Drop: verbose tool outputs, repeated attempts, and pleasantries.
 
   CONTEXT TO SUMMARIZE:
@@ -24553,7 +25210,7 @@ ${newSummary.decisions.map((d) => `  - ${d}`).join("\n")}` : "",
 ${compactionResult.stdout}` },
                   ...protectedRecent
                 );
-                console.log(`[agon] Tier 3 LLM compaction fired: ${afterTier2} \u2192 ${estimateTokens2(messageHistory)} tokens`);
+                console.log(`[agon] Tier 3 LLM compaction fired: ${afterTier2} \u2192 ${estimateTokens3(messageHistory)} tokens`);
               }
             } catch (tier3Err) {
               console.warn(`[agon] Tier 3 compaction failed (non-fatal): ${tier3Err instanceof Error ? tier3Err.message : String(tier3Err)}`);
@@ -24571,7 +25228,7 @@ ${compactionResult.stdout}` },
           toolCacheManifest = toolCacheManifest.filter((e) => activeIds.has(e.toolCallId));
         }
         {
-          const ctxTokens = totalTokens <= CONTEXT_LIMIT - COMPACTION_BUFFER ? totalTokens : estimateTokens2(messageHistory);
+          const ctxTokens = totalTokens <= CONTEXT_LIMIT - COMPACTION_BUFFER ? totalTokens : estimateTokens3(messageHistory);
           const ctxPct = Math.round(ctxTokens / CONTEXT_LIMIT * 100);
           const cachedCount = toolCacheManifest.length;
           const compactedCount = compactionSummary?.messagesCompacted ?? 0;
@@ -25311,8 +25968,8 @@ function createStreamBridge(dispatch, opts) {
 }
 
 // ../core/src/generated/forge/virtual-fs.ts
-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 { readFileSync as readFileSync29, existsSync as existsSync24, readdirSync as readdirSync16, statSync as statSync19 } from "fs";
+import { join as join28, resolve as resolve21, relative as relative8, dirname as dirname12 } from "path";
 import { createHash as createHash5 } from "crypto";
 function createFileSnapshot(rootDir) {
   const snapshotId = createHash5("sha256").update(rootDir + Date.now().toString()).digest("hex").slice(0, 12);
@@ -25328,16 +25985,16 @@ function snapshotRead(snap, absPath) {
     return snap.cache.get(key) ?? null;
   }
   try {
-    if (!existsSync22(key)) {
+    if (!existsSync24(key)) {
       snap.cache.set(key, null);
       return null;
     }
-    const st = statSync18(key);
+    const st = statSync19(key);
     if (!st.isFile()) {
       snap.cache.set(key, null);
       return null;
     }
-    const content = readFileSync26(key, "utf-8");
+    const content = readFileSync29(key, "utf-8");
     snap.cache.set(key, content);
     return content;
   } catch (e) {
@@ -25348,13 +26005,13 @@ function snapshotRead(snap, absPath) {
 function snapshotList(snap, absDir) {
   const dir = resolve21(absDir);
   try {
-    return readdirSync15(dir).filter((f) => {
+    return readdirSync16(dir).filter((f) => {
       try {
-        return statSync18(join25(dir, f)).isFile();
+        return statSync19(join28(dir, f)).isFile();
       } catch {
         return false;
       }
-    }).map((f) => join25(dir, f));
+    }).map((f) => join28(dir, f));
   } catch {
     return [];
   }
@@ -25420,7 +26077,7 @@ var VirtualFS = class {
     const overlayWritten = [];
     const overlayDeleted = /* @__PURE__ */ new Set();
     for (const [path, content] of this.overlay.entries()) {
-      if (dirname11(path) === dir) {
+      if (dirname12(path) === dir) {
         if (content === null) {
           overlayDeleted.add(path);
         } else {
@@ -25479,7 +26136,7 @@ function applyEffectPackage(pkg, targetDir) {
   for (const effect of pkg.effects) {
     const absPath = resolve21(targetDir, effect.kind === "rename" ? effect.from : effect.path);
     if (effect.kind === "write") {
-      const dir = dirname11(absPath);
+      const dir = dirname12(absPath);
       import_fs.mkdirSync(dir, { recursive: true });
       import_fs.writeFileSync(absPath, effect.content, "utf-8");
       modified.push(absPath);
@@ -25491,7 +26148,7 @@ function applyEffectPackage(pkg, targetDir) {
       modified.push(absPath);
     } else if (effect.kind === "rename") {
       const dest = resolve21(targetDir, effect.to);
-      import_fs.mkdirSync(dirname11(dest), { recursive: true });
+      import_fs.mkdirSync(dirname12(dest), { recursive: true });
       import_fs.renameSync(absPath, dest);
       modified.push(absPath);
       modified.push(dest);
@@ -25569,7 +26226,7 @@ function scoreEffectPackage(pkg, taskKeywords) {
 
 // ../core/src/generated/cesar/speculator.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { resolve as resolve22, join as join26 } from "path";
+import { resolve as resolve22, join as join29 } from "path";
 var Speculator = class {
   runId;
   snapshot;
@@ -25591,7 +26248,7 @@ var Speculator = class {
     if (isolate) {
       const baseSha = stashSnapshot(root);
       for (const member of opts.members) {
-        const wtPath = join26(root, `.agon/speculate-worktrees/${this.runId}/${member.engineId}`);
+        const wtPath = join29(root, `.agon/speculate-worktrees/${this.runId}/${member.engineId}`);
         try {
           await worktreeCreate(root, wtPath, baseSha);
           worktreesByEngine[member.engineId] = wtPath;
@@ -25764,17 +26421,17 @@ ${sessionLines.join("\n")}`);
 }
 
 // ../core/src/generated/cesar/context-thread.ts
-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 { readFileSync as readFileSync30, writeFileSync as writeFileSync25, mkdirSync as mkdirSync23, renameSync as renameSync11, existsSync as existsSync25, readdirSync as readdirSync17, unlinkSync as unlinkSync10, statSync as statSync20, chmodSync as chmodSync2, openSync as openSync2, fsyncSync, closeSync as closeSync2, appendFileSync as appendFileSync3 } from "fs";
+import { join as join30, 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 ? resolve23(override) : join27(homedir14(), ".agon");
-  return join27(home, "threads");
+  const home = override ? resolve23(override) : join30(homedir14(), ".agon");
+  return join30(home, "threads");
 }
 function activePointerPath() {
-  return join27(threadsDir(), "active.json");
+  return join30(threadsDir(), "active.json");
 }
 function projectHash16(projectPath) {
   return createHash6("sha256").update(projectPath).digest("hex").slice(0, 16);
@@ -25783,7 +26440,7 @@ function projectSha8(projectPath) {
   return projectHash16(projectPath);
 }
 function threadDirFor(projectPath) {
-  return join27(threadsDir(), projectHash16(projectPath));
+  return join30(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) {
@@ -25796,7 +26453,7 @@ function threadFilePath(projectPath, threadId) {
   const dir = threadDirFor(projectPath);
   const full = resolve23(dir, `${threadId}.json`);
   const resolvedDir = resolve23(dir);
-  const nativeSep = join27("a", "b")[1];
+  const nativeSep = join30("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}`);
@@ -25805,7 +26462,7 @@ function threadFilePath(projectPath, threadId) {
 }
 function ensureThreadDir(projectPath) {
   ensureAgonHome();
-  mkdirSync21(threadDirFor(projectPath), { recursive: true });
+  mkdirSync23(threadDirFor(projectPath), { recursive: true });
 }
 var LOCK_MAX_RETRIES = 8;
 var LOCK_BASE_DELAY_MS = 20;
@@ -25815,9 +26472,9 @@ function threadLockPath(projectPath, threadId) {
 async function acquireLock(lockPath) {
   for (let attempt = 0; attempt < LOCK_MAX_RETRIES; attempt++) {
     try {
-      const fd = openSync(lockPath, "wx", 384);
-      writeFileSync22(fd, String(process.pid));
-      closeSync(fd);
+      const fd = openSync2(lockPath, "wx", 384);
+      writeFileSync25(fd, String(process.pid));
+      closeSync2(fd);
       return attempt;
     } catch (err) {
       if (err?.code !== "EEXIST") throw err;
@@ -25829,7 +26486,7 @@ async function acquireLock(lockPath) {
 }
 function releaseLock(lockPath) {
   try {
-    unlinkSync9(lockPath);
+    unlinkSync10(lockPath);
   } catch {
   }
 }
@@ -25989,14 +26646,14 @@ var ContextThread = class {
     const now = Date.now();
     if (config2.threadId) {
       const candidatePath = threadFilePath(this.projectPath, config2.threadId);
-      if (existsSync23(candidatePath)) {
+      if (existsSync25(candidatePath)) {
         try {
-          const stat = statSync19(candidatePath);
+          const stat = statSync20(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 = readFileSync27(candidatePath, "utf-8");
+          const raw = readFileSync30(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");
@@ -26014,9 +26671,9 @@ var ContextThread = class {
             this.fileTouches = snap.fileTouches ?? {};
             this.hydrated = true;
             const jPathOnLoad = threadFilePath(this.projectPath, this.threadId).replace(/\.json$/, ".journal.jsonl");
-            if (existsSync23(jPathOnLoad)) {
+            if (existsSync25(jPathOnLoad)) {
               try {
-                const journalLines = readFileSync27(jPathOnLoad, "utf-8").split("\n").filter(Boolean);
+                const journalLines = readFileSync30(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) {
@@ -26100,7 +26757,7 @@ var ContextThread = class {
       ensureThreadDir(this.projectPath);
       const jPath = threadJournalPath(this.projectPath, this.threadId);
       const line = JSON.stringify({ _kind: "msg", ...msg }) + "\n";
-      appendFileSync2(jPath, line, { encoding: "utf-8", mode: 384, flag: "a" });
+      appendFileSync3(jPath, line, { encoding: "utf-8", mode: 384, flag: "a" });
       this.journaledIds.add(msg.id);
     } catch {
     }
@@ -26286,8 +26943,8 @@ ${msg.content}` };
     let bytes = 0;
     try {
       const path = threadFilePath(this.projectPath, this.threadId);
-      if (existsSync23(path)) {
-        bytes = readFileSync27(path, "utf-8").length;
+      if (existsSync25(path)) {
+        bytes = readFileSync30(path, "utf-8").length;
       }
     } catch {
     }
@@ -26319,12 +26976,12 @@ ${msg.content}` };
       const tmpPath = target + ".tmp";
       let fd = -1;
       try {
-        fd = openSync(tmpPath, "w", 384);
-        writeFileSync22(fd, body, "utf-8");
+        fd = openSync2(tmpPath, "w", 384);
+        writeFileSync25(fd, body, "utf-8");
         fsyncSync(fd);
       } finally {
         if (fd >= 0) try {
-          closeSync(fd);
+          closeSync2(fd);
         } catch {
         }
       }
@@ -26336,7 +26993,7 @@ ${msg.content}` };
       this.dirty = false;
       this.hydrated = true;
       const jPath = threadJournalPath(this.projectPath, this.threadId);
-      if (existsSync23(jPath)) unlinkSync9(jPath);
+      if (existsSync25(jPath)) unlinkSync10(jPath);
       this.journaledIds.clear();
     } catch {
     }
@@ -26368,9 +27025,9 @@ ${msg.content}` };
     }
     try {
       const jPath = threadJournalPath(this.projectPath, this.threadId);
-      if (existsSync23(jPath)) {
+      if (existsSync25(jPath)) {
         try {
-          const journalLines = readFileSync27(jPath, "utf-8").split("\n").filter(Boolean);
+          const journalLines = readFileSync30(jPath, "utf-8").split("\n").filter(Boolean);
           const known = new Set(this.messages.map((m) => m.id));
           for (const line of journalLines) {
             try {
@@ -26389,11 +27046,11 @@ ${msg.content}` };
           console.warn(`[agon] context-thread: journal merge failed (will overwrite): ${err instanceof Error ? err.message : String(err)}`);
         }
       }
-      if (existsSync23(target)) {
+      if (existsSync25(target)) {
         try {
-          const stat = statSync19(target);
+          const stat = statSync20(target);
           if (stat.size <= MAX_THREAD_FILE_BYTES) {
-            const raw = readFileSync27(target, "utf-8");
+            const raw = readFileSync30(target, "utf-8");
             const onDisk = JSON.parse(raw);
             if (onDisk && Array.isArray(onDisk.messages)) {
               const known = new Set(this.messages.map((m) => m.id));
@@ -26431,13 +27088,13 @@ ${msg.content}` };
       const body = JSON.stringify(snapshot, null, 2) + "\n";
       let fd = -1;
       try {
-        fd = openSync(tmpPath, "w", 384);
-        writeFileSync22(fd, body, "utf-8");
+        fd = openSync2(tmpPath, "w", 384);
+        writeFileSync25(fd, body, "utf-8");
         fsyncSync(fd);
       } finally {
         if (fd >= 0) {
           try {
-            closeSync(fd);
+            closeSync2(fd);
           } catch {
           }
         }
@@ -26451,7 +27108,7 @@ ${msg.content}` };
       this.dirty = false;
       this.hydrated = true;
       try {
-        if (existsSync23(jPath)) unlinkSync9(jPath);
+        if (existsSync25(jPath)) unlinkSync10(jPath);
         this.journaledIds.clear();
       } catch {
       }
@@ -26472,8 +27129,8 @@ ${msg.content}` };
 function loadActivePointer() {
   try {
     const path = activePointerPath();
-    if (existsSync23(path)) {
-      const raw = readFileSync27(path, "utf-8");
+    if (existsSync25(path)) {
+      const raw = readFileSync30(path, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && parsed.byProject) {
         return parsed;
@@ -26487,9 +27144,9 @@ function loadActivePointer() {
 function saveActivePointer(pointer) {
   ensureAgonHome();
   const path = activePointerPath();
-  mkdirSync21(threadsDir(), { recursive: true });
+  mkdirSync23(threadsDir(), { recursive: true });
   const tmpPath = path + ".tmp";
-  writeFileSync22(tmpPath, JSON.stringify(pointer, null, 2) + "\n", "utf-8");
+  writeFileSync25(tmpPath, JSON.stringify(pointer, null, 2) + "\n", "utf-8");
   renameSync11(tmpPath, path);
 }
 var _WeakRefCtor = globalThis.WeakRef;
@@ -26545,9 +27202,9 @@ async function forkActiveThread(projectPath, systemPrompt) {
 }
 function listThreadsForProject(projectPath) {
   const dir = threadDirFor(projectPath);
-  if (!existsSync23(dir)) return [];
+  if (!existsSync25(dir)) return [];
   try {
-    return readdirSync16(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5));
+    return readdirSync17(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 [];
@@ -26555,9 +27212,9 @@ function listThreadsForProject(projectPath) {
 }
 function deleteThread(projectPath, threadId) {
   try {
-    unlinkSync9(threadFilePath(projectPath, threadId));
+    unlinkSync10(threadFilePath(projectPath, threadId));
     try {
-      unlinkSync9(threadJournalPath(projectPath, threadId));
+      unlinkSync10(threadJournalPath(projectPath, threadId));
     } catch {
     }
     return true;
@@ -26908,7 +27565,7 @@ var AgentSession = class {
     this.state = "running";
     const perStepSec = this.config.perStepTimeoutSec ?? Math.floor(remainingMs / 1e3);
     const timeoutSec = Math.min(perStepSec, Math.floor(remainingMs / 1e3));
-    const promptTokens = estimateTokens(prompt);
+    const promptTokens = estimateTokens2(prompt);
     const onEvent = opts?.onEvent;
     const thread = this.config.thread;
     const windowTokens = this.config.contextWindowTokens;
@@ -26969,7 +27626,7 @@ var AgentSession = class {
     }
     if (this.abortController.signal.aborted) {
       this.state = "cancelled";
-      const partialResponseTokens = estimateTokens(result.response ?? "");
+      const partialResponseTokens = estimateTokens2(result.response ?? "");
       const partialTotal = promptTokens + partialResponseTokens;
       this.turnsUsed += 1;
       this.tokensUsed += partialTotal;
@@ -27001,7 +27658,7 @@ var AgentSession = class {
         engineFault: result.engineFault ?? false
       };
     }
-    const responseTokens = estimateTokens(result.response);
+    const responseTokens = estimateTokens2(result.response);
     const stepTokens = promptTokens + responseTokens;
     const stepCost = estimateCost(this.config.engineId, stepTokens, this.config.api.model);
     this.turnsUsed += 1;
@@ -27087,7 +27744,7 @@ var AgentSession = class {
 };
 
 // ../core/src/generated/cesar/agent-team.ts
-import { join as join28 } from "path";
+import { join as join31 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 function makeAgentTeamError(message, cause) {
   const err = new Error(`AgentTeam: ${message}`);
@@ -27170,7 +27827,7 @@ var AgentTeam = class {
       if (!this.config.isolate) {
         return { m, wt: null };
       }
-      const wt = join28(this.config.cwd, ".agon", "agent-worktrees", this.runId, m.engineId);
+      const wt = join31(this.config.cwd, ".agon", "agent-worktrees", this.runId, m.engineId);
       worktreeCreate(root, wt, this.baseSha);
       return { m, wt };
     });
@@ -27503,10 +28160,10 @@ function buildAgentSynthesisPrompt(opts) {
   let remaining = maxLoserContent;
   for (let i = 0; i < opts.losers.length; i++) {
     const loser = opts.losers[i];
-    const header = `## OTHER ENGINE ${i + 1}: ${loser.engineId}${loser.passedFitness ? " (passed fitness gate)" : " (did NOT pass fitness gate)"}`;
-    lines.push(header);
+    const header2 = `## OTHER ENGINE ${i + 1}: ${loser.engineId}${loser.passedFitness ? " (passed fitness gate)" : " (did NOT pass fitness gate)"}`;
+    lines.push(header2);
     lines.push(`<untrusted_data engine="${loser.engineId}">`);
-    remaining -= header.length + 50;
+    remaining -= header2.length + 50;
     if (remaining <= 0) {
       lines.push(`*(trimmed for prompt budget)*`);
       lines.push(`</untrusted_data>`);
@@ -27996,10 +28653,10 @@ function hooksOutput(results) {
 }
 
 // ../core/src/generated/blocks/skill-loader.ts
-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 { readFileSync as readFileSync31, readdirSync as readdirSync18, existsSync as existsSync26 } from "fs";
+import { join as join32, dirname as dirname13, resolve as resolve24 } from "path";
 import { homedir as homedir15 } from "os";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 function parseFrontmatter(content) {
   const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
   if (!match) {
@@ -28018,7 +28675,7 @@ function parseFrontmatter(content) {
 }
 function loadSkillFile(filePath) {
   try {
-    const content = readFileSync28(filePath, "utf-8");
+    const content = readFileSync31(filePath, "utf-8");
     const { meta: meta3, body } = parseFrontmatter(content);
     if (!meta3.name || !meta3.trigger) return null;
     return {
@@ -28036,11 +28693,11 @@ function loadSkillFile(filePath) {
 }
 function loadSkillsFromDir(dir, source) {
   const skills = [];
-  if (!existsSync24(dir)) return skills;
+  if (!existsSync26(dir)) return skills;
   try {
-    const files = readdirSync17(dir).filter((f) => f.endsWith(".md"));
+    const files = readdirSync18(dir).filter((f) => f.endsWith(".md"));
     for (const file2 of files) {
-      const skill = loadSkillFile(join29(dir, file2));
+      const skill = loadSkillFile(join32(dir, file2));
       if (skill) {
         skill.source = source;
         skills.push(skill);
@@ -28054,12 +28711,12 @@ function loadSkillsFromDir(dir, source) {
 function loadSkills(cwd) {
   const skills = [];
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve24(override) : join29(homedir15(), ".agon");
-  const builtinDir = join29(dirname12(fileURLToPath3(import.meta.url)), "../../skills");
+  const home = override ? resolve24(override) : join32(homedir15(), ".agon");
+  const builtinDir = join32(dirname13(fileURLToPath4(import.meta.url)), "../../skills");
   skills.push(...loadSkillsFromDir(builtinDir, "builtin"));
-  skills.push(...loadSkillsFromDir(join29(home, "skills"), "global"));
+  skills.push(...loadSkillsFromDir(join32(home, "skills"), "global"));
   if (cwd) {
-    skills.push(...loadSkillsFromDir(join29(cwd, ".agon", "skills"), "project"));
+    skills.push(...loadSkillsFromDir(join32(cwd, ".agon", "skills"), "project"));
   }
   const seen = /* @__PURE__ */ new Map();
   for (const skill of skills) {
@@ -28076,17 +28733,17 @@ function renderSkillPrompt(skill, input) {
 }
 
 // ../core/src/generated/blocks/engine-memory.ts
-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 { readFileSync as readFileSync32, writeFileSync as writeFileSync26, mkdirSync as mkdirSync24, renameSync as renameSync12 } from "fs";
+import { join as join33, resolve as resolve25 } from "path";
 import { homedir as homedir16 } from "os";
 function memoryPath() {
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve25(override) : join30(homedir16(), ".agon");
-  return join30(home, "engine-memory.json");
+  const home = override ? resolve25(override) : join33(homedir16(), ".agon");
+  return join33(home, "engine-memory.json");
 }
 function loadEngineMemory() {
   try {
-    return JSON.parse(readFileSync29(memoryPath(), "utf-8"));
+    return JSON.parse(readFileSync32(memoryPath(), "utf-8"));
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.warn(`[agon] failed to load engine memory: ${err instanceof Error ? err.message : String(err)}`);
@@ -28096,12 +28753,12 @@ function loadEngineMemory() {
 }
 function saveEngineMemory(record2) {
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve25(override) : join30(homedir16(), ".agon");
-  mkdirSync22(home, { recursive: true });
+  const home = override ? resolve25(override) : join33(homedir16(), ".agon");
+  mkdirSync24(home, { recursive: true });
   record2.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   const path = memoryPath();
   const tmpPath = path + ".tmp";
-  writeFileSync23(tmpPath, JSON.stringify(record2, null, 2) + "\n");
+  writeFileSync26(tmpPath, JSON.stringify(record2, null, 2) + "\n");
   renameSync12(tmpPath, path);
 }
 function ensureProfile(record2, engineId) {
@@ -28293,7 +28950,7 @@ function rankByTaskClass(engineIds, taskClass) {
     let specialization;
     if (i === 0 && r.total >= 3) {
       role = "lead";
-      specialization = `You are the top-rated engine for ${taskClass} tasks (${r.classElo} ELO, ${Math.round(r.winRate * 100)}% win rate). Lead with your best approach.`;
+      specialization = `You are the top-rated engine for ${taskClass} tasks (${r.classElo} Glicko, ${Math.round(r.winRate * 100)}% win rate). Lead with your best approach.`;
     } else if (i === ranked.length - 1 && r.total >= 3) {
       role = "challenger";
       specialization = `You are the challenger. Focus on what the lead engine might miss: edge cases, error handling, performance pitfalls. Your contrarian perspective is your strength.`;
@@ -28329,13 +28986,13 @@ function assignForgeRoles(engineIds, taskClass) {
 }
 
 // ../core/src/generated/blocks/sidechain-logger.ts
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync23 } from "fs";
-import { join as join31 } from "path";
+import { appendFileSync as appendFileSync4, mkdirSync as mkdirSync25 } from "fs";
+import { join as join34 } from "path";
 function createSidechainLogger(opts) {
   const suffix = opts.parentId ? `_sidechain_${opts.parentId}` : "";
   const filename = `${opts.sessionType}_${opts.sessionId}${suffix}.jsonl`;
-  const logPath = join31(opts.outputDir, filename);
-  mkdirSync23(opts.outputDir, { recursive: true });
+  const logPath = join34(opts.outputDir, filename);
+  mkdirSync25(opts.outputDir, { recursive: true });
   function log(type, engineId, data) {
     const event = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -28347,7 +29004,7 @@ function createSidechainLogger(opts) {
       ...data && { data }
     };
     try {
-      appendFileSync3(logPath, JSON.stringify(event) + "\n");
+      appendFileSync4(logPath, JSON.stringify(event) + "\n");
     } catch (err) {
       console.warn(`[agon] sidechain write failed (${logPath}): ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -28364,12 +29021,12 @@ function createSidechainLogger(opts) {
 }
 
 // ../core/src/generated/blocks/provenance.ts
-import { readFileSync as readFileSync30, writeFileSync as writeFileSync24, mkdirSync as mkdirSync24 } from "fs";
-import { join as join32, resolve as resolve26 } from "path";
+import { readFileSync as readFileSync33, writeFileSync as writeFileSync27, mkdirSync as mkdirSync26 } from "fs";
+import { join as join35, resolve as resolve26 } from "path";
 import { createHash as createHash7 } from "crypto";
 function sha256OfFile(path) {
   try {
-    return "sha256:" + createHash7("sha256").update(readFileSync30(path)).digest("hex");
+    return "sha256:" + createHash7("sha256").update(readFileSync33(path)).digest("hex");
   } catch (e) {
     console.warn(`[agon] provenance: could not hash ${path}: ${e instanceof Error ? e.message : String(e)}`);
     return "unavailable";
@@ -28529,18 +29186,18 @@ function renderProvenanceMarkdown(led) {
 function writeProvenanceReport(manifest, manifestPath, outDir, format) {
   const fmt = format ?? "md";
   const ledger = buildForgeProvenance(manifest, manifestPath);
-  mkdirSync24(outDir, { recursive: true });
+  mkdirSync26(outDir, { recursive: true });
   if (fmt === "md" || fmt === "both") {
-    const mdPath = resolve26(join32(outDir, "provenance.md"));
-    writeFileSync24(mdPath, renderProvenanceMarkdown(ledger), "utf-8");
+    const mdPath = resolve26(join35(outDir, "provenance.md"));
+    writeFileSync27(mdPath, renderProvenanceMarkdown(ledger), "utf-8");
     if (fmt === "md") return mdPath;
   }
   if (fmt === "json" || fmt === "both") {
-    const jsonPath = resolve26(join32(outDir, "provenance.json"));
-    writeFileSync24(jsonPath, renderProvenanceJson(ledger), "utf-8");
+    const jsonPath = resolve26(join35(outDir, "provenance.json"));
+    writeFileSync27(jsonPath, renderProvenanceJson(ledger), "utf-8");
     if (fmt === "json") return jsonPath;
   }
-  return resolve26(join32(outDir, "provenance.md"));
+  return resolve26(join35(outDir, "provenance.md"));
 }
 
 // ../core/src/generated/models/extension-manifest.ts
@@ -28646,8 +29303,8 @@ var CommandRegistry = class {
 };
 
 // ../core/src/generated/blocks/extension-loader.ts
-import { join as join33, resolve as resolve27 } from "path";
-import { readdirSync as readdirSync18, readFileSync as readFileSync31, existsSync as existsSync25 } from "fs";
+import { join as join36, resolve as resolve27 } from "path";
+import { readdirSync as readdirSync19, readFileSync as readFileSync34, existsSync as existsSync27 } from "fs";
 import { homedir as homedir17 } from "os";
 
 // ../core/src/generated/signals/event-bus.ts
@@ -28738,31 +29395,31 @@ function bridgeShellHooks(bus, hooks) {
 function discoverExtensionDirs(cwd) {
   const results = [];
   const override = process.env.AGON_HOME?.trim();
-  const home = override ? resolve27(override) : join33(homedir17(), ".agon");
-  const userDir = join33(home, "extensions");
-  if (existsSync25(userDir)) {
+  const home = override ? resolve27(override) : join36(homedir17(), ".agon");
+  const userDir = join36(home, "extensions");
+  if (existsSync27(userDir)) {
     try {
-      const entries = readdirSync18(userDir, { withFileTypes: true });
+      const entries = readdirSync19(userDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const manifestPath = join33(userDir, entry.name, "manifest.json");
-          if (existsSync25(manifestPath)) {
-            results.push({ dir: join33(userDir, entry.name), source: "user" });
+          const manifestPath = join36(userDir, entry.name, "manifest.json");
+          if (existsSync27(manifestPath)) {
+            results.push({ dir: join36(userDir, entry.name), source: "user" });
           }
         }
       }
     } catch {
     }
   }
-  const repoDir = join33(cwd, ".agon", "extensions");
-  if (existsSync25(repoDir)) {
+  const repoDir = join36(cwd, ".agon", "extensions");
+  if (existsSync27(repoDir)) {
     try {
-      const entries = readdirSync18(repoDir, { withFileTypes: true });
+      const entries = readdirSync19(repoDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const manifestPath = join33(repoDir, entry.name, "manifest.json");
-          if (existsSync25(manifestPath)) {
-            results.push({ dir: join33(repoDir, entry.name), source: "repo" });
+          const manifestPath = join36(repoDir, entry.name, "manifest.json");
+          if (existsSync27(manifestPath)) {
+            results.push({ dir: join36(repoDir, entry.name), source: "repo" });
           }
         }
       }
@@ -28772,9 +29429,9 @@ function discoverExtensionDirs(cwd) {
   return results;
 }
 function loadExtensionManifest(dir, source) {
-  const manifestPath = join33(dir, "manifest.json");
+  const manifestPath = join36(dir, "manifest.json");
   try {
-    const raw = JSON.parse(readFileSync31(manifestPath, "utf-8"));
+    const raw = JSON.parse(readFileSync34(manifestPath, "utf-8"));
     const result = validateManifest(raw, manifestPath);
     if (!result.ok || !result.data) {
       console.warn(`[agon] skipping extension ${dir}: ${result.error}`);
@@ -28843,7 +29500,7 @@ function registerExtensionEngines(ext, engineRegistry) {
   for (const enginePath of enginePaths) {
     try {
       const fullPath = resolve27(ext.dir, enginePath);
-      const raw = JSON.parse(readFileSync31(fullPath, "utf-8"));
+      const raw = JSON.parse(readFileSync34(fullPath, "utf-8"));
       if (raw.id) {
         engineRegistry.register(raw);
         registered.push(raw.id);
@@ -28992,7 +29649,7 @@ function registerBuiltinCommands(registry2) {
     // Info
     { name: "tokens", desc: "                        \u2014 show token usage & costs", category: "info" },
     { name: "doctor", desc: "[engines|harness]        \u2014 diagnose engines, worktree, or Cesar harness", category: "info" },
-    { name: "leaderboard", desc: "                        \u2014 ELO rankings", category: "info" },
+    { name: "leaderboard", desc: "                        \u2014 Glicko rankings", category: "info" },
     { name: "history", desc: "[id]                    \u2014 past forge runs", category: "info" },
     { name: "provenance", desc: "[id] [-f md|json|both] [-o file] \u2014 AI-contribution / transparency report", category: "info" },
     { name: "flow", desc: "                        \u2014 log this session", category: "info" },
@@ -29000,12 +29657,14 @@ function registerBuiltinCommands(registry2) {
     { name: "chats", desc: "[id|resume <id>]        \u2014 chat history or resume session", category: "info" },
     { name: "jobs", desc: "                        \u2014 list running/completed jobs", category: "info" },
     { name: "focus", desc: "<id>                    \u2014 switch to background job output", category: "info" },
+    { name: "update", desc: "[version] [--check]     \u2014 self-update from npm (also runs from the in-app banner)", category: "info" },
     // Session
     { name: "mcp", desc: "connect <name|url> | disconnect | list \u2014 manage session MCP servers", category: "session" },
     { name: "explore", desc: "                        \u2014 toggle exploration mode (read-only)", category: "session" },
     { name: "nero", desc: "                        \u2014 toggle Nero mode (adversarial)", category: "session" },
     { name: "btw", desc: "<question>               \u2014 ask something while engines work", category: "session" },
-    { name: "clear", desc: "                        \u2014 reset session", category: "session", aliases: ["clean"] },
+    { name: "compact", desc: "                        \u2014 shrink Cesar context without clearing transcript", category: "session" },
+    { name: "clear", desc: "                        \u2014 reset session (saves chat, clears brain)", category: "session", aliases: ["clean"] },
     // Utility
     { name: "worktree", desc: "new|list|rm|prune|rehydrate <branch> \u2014 isolated per-session git worktrees", category: "utility", aliases: ["wt"] },
     { name: "create-skill", desc: "<name>                  \u2014 scaffold a new skill (.agon/skills/)", category: "utility" },
@@ -29256,8 +29915,8 @@ function computeContributionWeights(team, trace) {
 }
 
 // ../core/src/generated/teams/team-elo.ts
-import { readFileSync as readFileSync32, writeFileSync as writeFileSync25, mkdirSync as mkdirSync25, renameSync as renameSync13 } from "fs";
-import { dirname as dirname13 } from "path";
+import { readFileSync as readFileSync35, writeFileSync as writeFileSync28, mkdirSync as mkdirSync27, renameSync as renameSync13 } from "fs";
+import { dirname as dirname14 } from "path";
 function defaultCompositionRating(lineupKey2) {
   return { lineupKey: lineupKey2, rating: 1500, wins: 0, losses: 0, draws: 0, matches: 0 };
 }
@@ -29266,7 +29925,7 @@ function defaultRoleRating(engineId, role) {
 }
 function loadTeamElo() {
   try {
-    return JSON.parse(readFileSync32(TEAM_ELO_PATH, "utf-8"));
+    return JSON.parse(readFileSync35(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)}`);
@@ -29275,10 +29934,10 @@ function loadTeamElo() {
   }
 }
 function saveTeamElo(record2) {
-  mkdirSync25(dirname13(TEAM_ELO_PATH), { recursive: true });
+  mkdirSync27(dirname14(TEAM_ELO_PATH), { recursive: true });
   record2.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   const tmpPath = TEAM_ELO_PATH + ".tmp";
-  writeFileSync25(tmpPath, JSON.stringify(record2, null, 2) + "\n");
+  writeFileSync28(tmpPath, JSON.stringify(record2, null, 2) + "\n");
   renameSync13(tmpPath, TEAM_ELO_PATH);
 }
 function expectedScore(rA, rB) {
@@ -29365,6 +30024,7 @@ function updateTeamElo(match, kFactor) {
 export {
   DEFAULT_AGON_CONFIG,
   DEFAULT_CONFIG,
+  AGON_MODE_NAMES,
   AgonError,
   EngineNotFoundError,
   EngineTimeoutError,
@@ -29469,8 +30129,10 @@ export {
   validateEngineConfig,
   validateEngineDir,
   EngineRegistry,
+  hasProjectBrief,
   isKernProject,
   scanProjectContext,
+  buildKernContextSpine,
   collectSourceFiles,
   extractSymbols,
   buildCodebaseMap,
@@ -29484,7 +30146,7 @@ export {
   snapshotWorkspace,
   resolveWorkingDir,
   ensureCurrentWorkspace,
-  estimateTokens,
+  estimateTokens2 as estimateTokens,
   estimateCost,
   tracker,
   createPlan,
@@ -29639,7 +30301,29 @@ export {
   mimeFromExt,
   resolveImagePath,
   buildImageAttachment,
+  normalizeDroppedPath,
   extractImagesFromInput,
+  roomsDir,
+  roomDir,
+  slugifyRoomId,
+  roomExists,
+  createRoom,
+  listRooms,
+  parseMentions,
+  appendEvent,
+  readEvents,
+  closeRoom,
+  isRoomClosed,
+  PRESENCE_TTL_MS,
+  recordPresence,
+  removePresence,
+  listPresence,
+  readActiveLease,
+  acquireTurnLease,
+  releaseTurnLease,
+  detectTrigger,
+  detectPingPong,
+  evaluateStop,
   FLOWS_DIR,
   FRICTION_TAGS,
   logFlow,
@@ -29772,4 +30456,4 @@ export {
   predictTeamRating,
   updateTeamElo
 };
-//# sourceMappingURL=chunk-PFHGKBQT.js.map
+//# sourceMappingURL=chunk-HAJIKZGU.js.map