@kernlang/agon 0.1.4 → 0.1.6

package/dist/{chunk-C22VTCS6.js → chunk-TMNHJOKU.js}

@@ -5,7 +5,7 @@ import {
   __require,
   __toCommonJS,
   apiStreamDispatchWithHistory
-} from "./chunk-5QMVQPHY.js";
+} from "./chunk-XWHC6VAH.js";
 
 // ../core/src/generated/signals/glicko.ts
 var glicko_exports = {};
@@ -4927,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)
@@ -16429,7 +16429,194 @@ 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) {
@@ -16592,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";
@@ -16932,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) {
@@ -16949,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;
@@ -16963,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;
@@ -17206,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;
@@ -17249,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 {};
   }
@@ -17285,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") {
@@ -17330,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;
@@ -17424,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 {
     }
   }
@@ -17967,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() {
@@ -18031,7 +18290,7 @@ function revertSnapshot(id) {
           reverted++;
         }
       } else {
-        mkdirSync10(dirname6(fullPath), { recursive: true });
+        mkdirSync10(dirname7(fullPath), { recursive: true });
         writeFileSync11(fullPath, snap.content);
         reverted++;
       }
@@ -19553,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",
@@ -19636,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 });
@@ -19759,10 +20018,10 @@ function createBashTool() {
     const readRedirect = tryRedirectToRead(command);
     if (readRedirect) {
       try {
-        const { readFileSync: readFileSync33 } = await import("fs");
+        const { readFileSync: readFileSync38 } = await import("fs");
         const { resolve: resolve28 } = await import("path");
         const filePath = resolve28(ctx.cwd, readRedirect.file);
-        const content = readFileSync33(filePath, "utf-8");
+        const content = readFileSync38(filePath, "utf-8");
         const lines = content.split("\n");
         const offset = readRedirect.offset ?? 0;
         const limit = readRedirect.limit ?? lines.length;
@@ -20547,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();
@@ -20568,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 {
@@ -21806,6 +22065,8 @@ function cesarPlanMarkdownPath(planId) {
   }
   return full;
 }
+var CESAR_STEP_TYPE_TABLE = { self: true, forge: true, teamforge: true, delegate: true, brainstorm: true, campfire: true, tribunal: true, pipeline: true, review: true, agent: true, "team-agent": true };
+var CESAR_STEP_TYPES = Object.keys(CESAR_STEP_TYPE_TABLE);
 function createCesarPlan(intent, steps) {
   const id = `cplan-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const initializedSteps = steps.map((s) => Object.assign({}, s, { state: s.dependsOn && s.dependsOn.length > 0 ? "blocked" : "pending" }));
@@ -21821,10 +22082,11 @@ function advanceCesarStep(plan, stepId, result) {
   const stepIdx = plan.steps.findIndex((s) => s.id === stepId);
   if (stepIdx === -1) return plan;
   const isSuccess = result.status === "success";
-  const stepState = isSuccess ? "done" : "failed";
+  const isPaused = result.status === "paused";
+  const stepState = isSuccess ? "done" : isPaused ? "pending" : "failed";
   const now = (/* @__PURE__ */ new Date()).toISOString();
   let newSteps = plan.steps.map(
-    (s, i) => i === stepIdx ? { ...s, state: stepState, result, completedAt: now } : s
+    (s, i) => i === stepIdx ? { ...s, state: stepState, result: isPaused ? void 0 : result, completedAt: isPaused ? void 0 : now } : s
   );
   if (isSuccess) {
     newSteps = newSteps.map((s) => {
@@ -22222,17 +22484,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) {
@@ -22407,10 +22669,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") {
@@ -22424,12 +22686,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
     };
@@ -22464,13 +22726,16 @@ function latestChatSession() {
 }
 
 // ../core/src/generated/blocks/image.ts
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync23, statSync as statSync16 } 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;
+var MAX_DISPATCH_IMAGE_BYTES = 5 * 1024 * 1024;
+var MAX_DISPATCH_IMAGES = 4;
+var DISPATCH_VISION_MIME = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
 function isImagePath(filePath) {
   const ext = extname2(filePath).toLowerCase();
   return IMAGE_EXTENSIONS.has(ext);
@@ -22497,59 +22762,450 @@ 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 };
 }
+function encodeImagesRaw(paths, maxBytes, maxImages) {
+  const lim = maxBytes ?? MAX_DISPATCH_IMAGE_BYTES;
+  const cap = maxImages ?? MAX_DISPATCH_IMAGES;
+  const images = [];
+  const skipped = [];
+  const kb = (n) => `${Math.round(n / 1024)}KB`;
+  for (const p of paths) {
+    const name = basename4(p);
+    if (images.length >= cap) {
+      skipped.push(`${name} (exceeds ${cap}-image limit)`);
+      continue;
+    }
+    try {
+      if (!existsSync19(p)) {
+        skipped.push(`${name} (not found)`);
+        continue;
+      }
+      const mediaType = mimeFromExt(p);
+      if (!DISPATCH_VISION_MIME.has(mediaType)) {
+        skipped.push(`${name} (unsupported type ${mediaType})`);
+        continue;
+      }
+      const st = statSync16(p);
+      if (!st.isFile()) {
+        skipped.push(`${name} (not a regular file)`);
+        continue;
+      }
+      if (st.size > lim) {
+        skipped.push(`${name} (${kb(st.size)} over ${kb(lim)} limit)`);
+        continue;
+      }
+      const data = readFileSync23(p).toString("base64");
+      images.push({ data, mediaType });
+    } catch {
+      skipped.push(`${name} (read error)`);
+    }
+  }
+  return { images, skipped };
+}
+function encodeImagesForDispatch(paths, maxBytes, maxImages) {
+  const { images, skipped } = encodeImagesRaw(paths, maxBytes, maxImages);
+  return {
+    parts: images.map((i) => ({ type: "image", image: `data:${i.mediaType};base64,${i.data}`, mediaType: i.mediaType })),
+    skipped
+  };
+}
+
+// ../core/src/generated/rooms/store.ts
+import { mkdirSync as mkdirSync18, existsSync as existsSync20, readFileSync as readFileSync24, writeFileSync as writeFileSync19, appendFileSync as appendFileSync2, readdirSync as readdirSync14, openSync, closeSync, unlinkSync as unlinkSync9, statSync as statSync17 } 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(readFileSync24(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 = statSync17(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 = readFileSync24(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 readFileSync25, 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(readFileSync25(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 readFileSync26, 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(readFileSync26(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 readFileSync27, 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 [];
@@ -22558,7 +23214,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(readFileSync27(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)}`);
@@ -22987,19 +23643,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 readFileSync28, writeFileSync as writeFileSync23, mkdirSync as mkdirSync21, existsSync as existsSync22, statSync as statSync18 } 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 = statSync18(cacheFile);
       const age = Date.now() - stat.mtimeMs;
       if (age < CACHE_TTL_MS) {
-        return JSON.parse(readFileSync24(cacheFile, "utf-8"));
+        return JSON.parse(readFileSync28(cacheFile, "utf-8"));
       }
     } catch (_e) {
       console.warn(`[agon] models-registry: cache read failed, refetching: ${_e instanceof Error ? _e.message : String(_e)}`);
@@ -23007,14 +23663,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(readFileSync28(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) {
@@ -23135,24 +23791,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 readFileSync29, writeFileSync as writeFileSync24, mkdirSync as mkdirSync22, existsSync as existsSync23, statSync as statSync19 } 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() - statSync19(file2).mtimeMs;
     if (age > (ttlMs ?? PROBE_TTL_MS)) return null;
-    const data = JSON.parse(readFileSync25(file2, "utf-8"));
+    const data = JSON.parse(readFileSync29(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;
@@ -23162,7 +23818,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
@@ -23170,16 +23826,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 {
@@ -23249,8 +23905,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}`);
@@ -23266,10 +23922,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;
     }
   }
@@ -23387,6 +24043,7 @@ async function discoverCliModelsAsync() {
 // ../core/src/generated/sessions/session-companion.ts
 import { spawn as spawn3 } from "child_process";
 import { createInterface as createInterface2 } from "readline";
+import { existsSync as existsSync24 } from "fs";
 function createCompanionSession(config2) {
   let proc = null;
   let alive = false;
@@ -23692,9 +24349,37 @@ ${config2.systemPrompt}
 ${message}`;
         }
         firstTurn = false;
+        const input = [{ type: "text", text: message, text_elements: [] }];
+        if (opts.images?.length) {
+          if (config2.engine.capabilities?.includes("vision")) {
+            let attached = 0;
+            const skipped = [];
+            for (const p of opts.images) {
+              if (attached >= MAX_DISPATCH_IMAGES) {
+                skipped.push(`${p} (exceeds ${MAX_DISPATCH_IMAGES}-image limit)`);
+                continue;
+              }
+              if (!existsSync24(p) || !isImagePath(p)) {
+                skipped.push(`${p} (not found or not an image)`);
+                continue;
+              }
+              if (!DISPATCH_VISION_MIME.has(mimeFromExt(p))) {
+                skipped.push(`${p} (unsupported type ${mimeFromExt(p)})`);
+                continue;
+              }
+              input.push({ type: "localImage", path: p });
+              attached++;
+            }
+            if (skipped.length) {
+              chunks.push({ type: "status", content: `image(s) not sent: ${skipped.join("; ")}` });
+            }
+          } else {
+            chunks.push({ type: "status", content: `${config2.engine.id} has no vision capability \u2014 ${opts.images.length} image(s) not sent to the model` });
+          }
+        }
         await sendRpc("turn/start", {
           threadId,
-          input: [{ type: "text", text: message, text_elements: [] }]
+          input
         });
         while (!turnDone) {
           if (chunks.length > 0) {
@@ -24427,7 +25112,41 @@ function createResumeSession(config2) {
           }
           firstTurn = false;
         }
-        messageHistory.push({ role: "user", content: opts.message });
+        const hasVision = !!config2.engine.capabilities?.includes("vision");
+        let turnImageParts = [];
+        if (opts.images?.length) {
+          if (hasVision) {
+            const enc = encodeImagesForDispatch(opts.images);
+            turnImageParts = enc.parts;
+            if (enc.skipped.length) {
+              yield { type: "status", content: `image(s) not sent: ${enc.skipped.join("; ")}` };
+            }
+          } else {
+            yield { type: "status", content: `${config2.engine.id} has no vision capability \u2014 ${opts.images.length} image(s) not sent to the model` };
+          }
+        }
+        const userTurnMsg = { role: "user", content: opts.message };
+        messageHistory.push(userTurnMsg);
+        const withImages = (history) => {
+          if (!turnImageParts.length) return history;
+          let idx = history.indexOf(userTurnMsg);
+          if (idx < 0) {
+            for (let i = history.length - 1; i >= 0; i--) {
+              const m = history[i];
+              if (m?.role === "user" && typeof m.content === "string" && m.content === userTurnMsg.content) {
+                idx = i;
+                break;
+              }
+            }
+          }
+          if (idx < 0) return history;
+          const base = history[idx];
+          const text = typeof base.content === "string" ? base.content : "";
+          const content = text.trim() ? [{ type: "text", text }, ...turnImageParts] : [...turnImageParts];
+          const cloned = history.slice();
+          cloned[idx] = { ...base, content };
+          return cloned;
+        };
         const estimateSingle = (m) => {
           if (typeof m.content === "string") return Math.ceil(m.content.length / 3.5);
           if (m.content === null && m.tool_calls) {
@@ -24435,7 +25154,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);
           }
@@ -24456,7 +25175,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;
@@ -24483,7 +25202,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);
@@ -24582,11 +25301,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-S3CR5HKX.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:
@@ -24606,7 +25325,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)}`);
@@ -24624,7 +25343,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;
@@ -24721,7 +25440,7 @@ ${compactionResult.stdout}` },
           } else {
             yield { type: "status", content: `tool loop turn ${step}/${budget}\u2026` };
           }
-          const gen = apiStreamDispatchWithHistory(config2.engine.api, messageHistory, config2.engine.timeout ?? 180, opts.signal, effectiveTools);
+          const gen = apiStreamDispatchWithHistory(config2.engine.api, withImages(messageHistory), config2.engine.timeout ?? 180, opts.signal, effectiveTools);
           try {
             while (true) {
               const { value, done: done2 } = await gen.next();
@@ -25262,6 +25981,191 @@ ${compactionResult.stdout}` },
   return session;
 }
 
+// ../core/src/generated/sessions/session-pty.ts
+import { existsSync as existsSync25, readFileSync as readFileSync30, rmSync as rmSync5 } from "fs";
+function createPtySession(config2) {
+  let claudeSession = null;
+  let alive = false;
+  let firstTurn = true;
+  let turnActive = false;
+  let pendingDrain = null;
+  const TURN_TIMEOUT_MS = 15 * 60 * 1e3;
+  function buildExtraArgv() {
+    const args = [];
+    if (config2.mcpServers && config2.mcpServers.length > 0) {
+      const mcpConfig = JSON.stringify({
+        mcpServers: Object.fromEntries(
+          config2.mcpServers.map((s) => [s.name ?? s.command ?? "mcp", s])
+        )
+      });
+      args.push("--mcp-config", mcpConfig, "--strict-mcp-config");
+    }
+    args.push("--disallowedTools", "Bash Edit Write MultiEdit NotebookEdit");
+    args.push("--allowedTools", "Read Grep Glob mcp__agon-orchestration");
+    if (config2.claudePtyLaunchArgs && config2.claudePtyLaunchArgs.length > 0) {
+      args.push(...config2.claudePtyLaunchArgs);
+    }
+    return args;
+  }
+  function readAnswer() {
+    const p = config2.answerChannelPath;
+    if (!p) return null;
+    try {
+      if (!existsSync25(p)) return null;
+      const parsed = JSON.parse(readFileSync30(p, "utf-8"));
+      const t = parsed?.text;
+      return typeof t === "string" ? t : null;
+    } catch {
+      return null;
+    }
+  }
+  function clearAnswer() {
+    const p = config2.answerChannelPath;
+    if (!p) return;
+    try {
+      rmSync5(p, { force: true });
+    } catch {
+    }
+  }
+  const session = {
+    get alive() {
+      return alive;
+    },
+    sessionId: null,
+    engineId: config2.engine.id,
+    get pid() {
+      return null;
+    },
+    async start() {
+      if (alive) return;
+      const mod = await import("@kernlang/agon-engines/cli/claude.js");
+      claudeSession = await mod.ClaudeCliSession.spawn({
+        mode: "agent",
+        cwd: config2.cwd,
+        extraArgv: buildExtraArgv(),
+        daemonTimeoutMs: 6e4
+      });
+      alive = true;
+      firstTurn = true;
+    },
+    async *send(opts) {
+      if (turnActive) {
+        yield { type: "error", content: "claude PTY session busy (concurrent turn rejected)" };
+        return;
+      }
+      turnActive = true;
+      try {
+        if (pendingDrain) {
+          try {
+            await pendingDrain;
+          } catch {
+          }
+          pendingDrain = null;
+        }
+        if (!alive || !claudeSession) {
+          try {
+            await session.start();
+          } catch (e) {
+            yield { type: "error", content: `claude PTY session not alive: ${e instanceof Error ? e.message : String(e)}` };
+            return;
+          }
+        }
+        if (opts.signal?.aborted) {
+          yield { type: "done", content: "cancelled" };
+          return;
+        }
+        clearAnswer();
+        const sys = firstTurn ? opts.systemPrompt ?? config2.systemPrompt : void 0;
+        firstTurn = false;
+        const composed = sys ? `[System Instructions]
+${sys}
+
+[User Message]
+${opts.message}` : opts.message;
+        let aborted2 = false;
+        const onAbort = () => {
+          aborted2 = true;
+          try {
+            claudeSession?.close?.();
+          } catch {
+          }
+          claudeSession = null;
+          alive = false;
+        };
+        opts.signal?.addEventListener("abort", onAbort, { once: true });
+        let scrapedFinal = "";
+        let driverError = null;
+        const it = claudeSession.askStream(composed, TURN_TIMEOUT_MS);
+        const driver = (async () => {
+          try {
+            let res = await it.next();
+            while (!res.done) {
+              res = await it.next();
+            }
+            scrapedFinal = typeof res.value === "string" ? res.value : "";
+          } catch (e) {
+            driverError = e;
+          }
+        })();
+        pendingDrain = driver;
+        let driverDone = false;
+        void driver.then(() => {
+          driverDone = true;
+        });
+        await new Promise((resolve28) => {
+          const tick = setInterval(() => {
+            if (driverDone || readAnswer() !== null) {
+              clearInterval(tick);
+              resolve28();
+            }
+          }, 100);
+          void driver.finally(() => {
+            clearInterval(tick);
+            resolve28();
+          });
+        });
+        opts.signal?.removeEventListener("abort", onAbort);
+        if (aborted2) {
+          yield { type: "done", content: "cancelled" };
+          return;
+        }
+        const answer = readAnswer();
+        if (answer !== null && answer.length > 0) {
+          yield { type: "text", content: answer };
+          yield { type: "done", content: "end_turn" };
+          return;
+        }
+        await driver;
+        pendingDrain = null;
+        if (driverError) {
+          alive = false;
+          claudeSession = null;
+          yield { type: "error", content: `claude PTY turn failed: ${driverError instanceof Error ? driverError.message : String(driverError)}` };
+          return;
+        }
+        if (scrapedFinal && scrapedFinal.trim()) {
+          yield { type: "text", content: scrapedFinal };
+        }
+        yield { type: "done", content: "end_turn" };
+      } finally {
+        turnActive = false;
+      }
+    },
+    close() {
+      try {
+        claudeSession?.close?.();
+      } catch {
+      }
+      claudeSession = null;
+      alive = false;
+    },
+    getMessageHistory() {
+      return [];
+    }
+  };
+  return session;
+}
+
 // ../core/src/generated/sessions/persistent-session.ts
 function createPersistentSession(config2) {
   const engine = config2.engine;
@@ -25269,7 +26173,11 @@ function createPersistentSession(config2) {
     return createResumeSession(config2);
   }
   if ((engine.companion?.protocol === "stream-json" || engine.id === "claude" || engine.binary === "claude") && config2.binaryPath) {
-    return createStreamJsonSession(config2);
+    const printOptOut = process.env.AGON_CLAUDE_PRINT;
+    if (printOptOut === "1" || printOptOut === "true") {
+      return createStreamJsonSession(config2);
+    }
+    return createPtySession(config2);
   }
   if (engine.companion && engine.companion.protocol === "acp") {
     return createAcpSession(config2);
@@ -25364,8 +26272,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 readFileSync31, existsSync as existsSync26, readdirSync as readdirSync16, statSync as statSync20 } 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);
@@ -25381,16 +26289,16 @@ function snapshotRead(snap, absPath) {
     return snap.cache.get(key) ?? null;
   }
   try {
-    if (!existsSync22(key)) {
+    if (!existsSync26(key)) {
       snap.cache.set(key, null);
       return null;
     }
-    const st = statSync18(key);
+    const st = statSync20(key);
     if (!st.isFile()) {
       snap.cache.set(key, null);
       return null;
     }
-    const content = readFileSync26(key, "utf-8");
+    const content = readFileSync31(key, "utf-8");
     snap.cache.set(key, content);
     return content;
   } catch (e) {
@@ -25401,13 +26309,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 statSync20(join28(dir, f)).isFile();
       } catch {
         return false;
       }
-    }).map((f) => join25(dir, f));
+    }).map((f) => join28(dir, f));
   } catch {
     return [];
   }
@@ -25473,7 +26381,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 {
@@ -25532,7 +26440,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);
@@ -25544,7 +26452,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);
@@ -25622,7 +26530,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;
@@ -25644,7 +26552,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;
@@ -25817,17 +26725,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 readFileSync32, writeFileSync as writeFileSync25, mkdirSync as mkdirSync23, renameSync as renameSync11, existsSync as existsSync27, readdirSync as readdirSync17, unlinkSync as unlinkSync10, statSync as statSync21, 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);
@@ -25836,7 +26744,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) {
@@ -25849,7 +26757,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}`);
@@ -25858,7 +26766,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;
@@ -25868,9 +26776,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;
@@ -25882,7 +26790,7 @@ async function acquireLock(lockPath) {
 }
 function releaseLock(lockPath) {
   try {
-    unlinkSync9(lockPath);
+    unlinkSync10(lockPath);
   } catch {
   }
 }
@@ -26042,14 +26950,14 @@ var ContextThread = class {
     const now = Date.now();
     if (config2.threadId) {
       const candidatePath = threadFilePath(this.projectPath, config2.threadId);
-      if (existsSync23(candidatePath)) {
+      if (existsSync27(candidatePath)) {
         try {
-          const stat = statSync19(candidatePath);
+          const stat = statSync21(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 = readFileSync32(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");
@@ -26067,9 +26975,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 (existsSync27(jPathOnLoad)) {
               try {
-                const journalLines = readFileSync27(jPathOnLoad, "utf-8").split("\n").filter(Boolean);
+                const journalLines = readFileSync32(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) {
@@ -26153,7 +27061,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 {
     }
@@ -26339,8 +27247,8 @@ ${msg.content}` };
     let bytes = 0;
     try {
       const path = threadFilePath(this.projectPath, this.threadId);
-      if (existsSync23(path)) {
-        bytes = readFileSync27(path, "utf-8").length;
+      if (existsSync27(path)) {
+        bytes = readFileSync32(path, "utf-8").length;
       }
     } catch {
     }
@@ -26372,12 +27280,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 {
         }
       }
@@ -26389,7 +27297,7 @@ ${msg.content}` };
       this.dirty = false;
       this.hydrated = true;
       const jPath = threadJournalPath(this.projectPath, this.threadId);
-      if (existsSync23(jPath)) unlinkSync9(jPath);
+      if (existsSync27(jPath)) unlinkSync10(jPath);
       this.journaledIds.clear();
     } catch {
     }
@@ -26421,9 +27329,9 @@ ${msg.content}` };
     }
     try {
       const jPath = threadJournalPath(this.projectPath, this.threadId);
-      if (existsSync23(jPath)) {
+      if (existsSync27(jPath)) {
         try {
-          const journalLines = readFileSync27(jPath, "utf-8").split("\n").filter(Boolean);
+          const journalLines = readFileSync32(jPath, "utf-8").split("\n").filter(Boolean);
           const known = new Set(this.messages.map((m) => m.id));
           for (const line of journalLines) {
             try {
@@ -26442,11 +27350,11 @@ ${msg.content}` };
           console.warn(`[agon] context-thread: journal merge failed (will overwrite): ${err instanceof Error ? err.message : String(err)}`);
         }
       }
-      if (existsSync23(target)) {
+      if (existsSync27(target)) {
         try {
-          const stat = statSync19(target);
+          const stat = statSync21(target);
           if (stat.size <= MAX_THREAD_FILE_BYTES) {
-            const raw = readFileSync27(target, "utf-8");
+            const raw = readFileSync32(target, "utf-8");
             const onDisk = JSON.parse(raw);
             if (onDisk && Array.isArray(onDisk.messages)) {
               const known = new Set(this.messages.map((m) => m.id));
@@ -26484,13 +27392,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 {
           }
         }
@@ -26504,7 +27412,7 @@ ${msg.content}` };
       this.dirty = false;
       this.hydrated = true;
       try {
-        if (existsSync23(jPath)) unlinkSync9(jPath);
+        if (existsSync27(jPath)) unlinkSync10(jPath);
         this.journaledIds.clear();
       } catch {
       }
@@ -26525,8 +27433,8 @@ ${msg.content}` };
 function loadActivePointer() {
   try {
     const path = activePointerPath();
-    if (existsSync23(path)) {
-      const raw = readFileSync27(path, "utf-8");
+    if (existsSync27(path)) {
+      const raw = readFileSync32(path, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && parsed.byProject) {
         return parsed;
@@ -26540,9 +27448,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;
@@ -26598,9 +27506,9 @@ async function forkActiveThread(projectPath, systemPrompt) {
 }
 function listThreadsForProject(projectPath) {
   const dir = threadDirFor(projectPath);
-  if (!existsSync23(dir)) return [];
+  if (!existsSync27(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 [];
@@ -26608,9 +27516,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;
@@ -26656,6 +27564,39 @@ var PlanCostEstimator = class {
 };
 var planCostEstimator = new PlanCostEstimator();
 
+// ../core/src/generated/cesar/plan-validation.ts
+var VALID_STEP_TYPES = new Set(CESAR_STEP_TYPES);
+function sanitizePlanSteps(rawSteps) {
+  const SAFE_ID = /^[a-z0-9_-]{1,64}$/;
+  const sanitizeId = (raw, fallback) => {
+    if (typeof raw === "string" && SAFE_ID.test(raw)) return raw;
+    return fallback;
+  };
+  const input = Array.isArray(rawSteps) ? rawSteps : [];
+  const steps = input.filter((s) => s && VALID_STEP_TYPES.has(s.type)).map((s, i) => {
+    const est = planCostEstimator.estimate(s.type, s.engines ?? []);
+    return {
+      id: sanitizeId(s.id, `step-${i}-${Math.random().toString(36).slice(2, 8)}`),
+      type: s.type,
+      description: typeof s.description === "string" && s.description.trim().length > 0 ? s.description : "(no description)",
+      engines: s.engines,
+      engine: s.engine,
+      fitnessCmd: s.fitnessCmd,
+      tribunalMode: s.tribunalMode,
+      parallel: s.parallel ?? false,
+      dependsOn: s.dependsOn,
+      exports: typeof s.exports === "string" ? [s.exports] : s.exports,
+      imports: typeof s.imports === "string" ? [s.imports] : s.imports,
+      estimatedTokens: est.tokens,
+      estimatedCostUsd: est.costUsd,
+      rationale: s.rationale,
+      verifyCmd: s.verifyCmd
+    };
+  });
+  const dropped = input.length - steps.length;
+  return { steps, dropped };
+}
+
 // ../core/src/generated/cesar/plan-executor.ts
 function getReadySteps(plan) {
   return plan.steps.filter((s) => s.state === "pending");
@@ -26961,7 +27902,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;
@@ -27022,7 +27963,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;
@@ -27054,7 +27995,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;
@@ -27140,7 +28081,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}`);
@@ -27223,7 +28164,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 };
     });
@@ -27556,10 +28497,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>`);
@@ -28049,10 +28990,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 readFileSync33, readdirSync as readdirSync18, existsSync as existsSync28 } 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) {
@@ -28071,7 +29012,7 @@ function parseFrontmatter(content) {
 }
 function loadSkillFile(filePath) {
   try {
-    const content = readFileSync28(filePath, "utf-8");
+    const content = readFileSync33(filePath, "utf-8");
     const { meta: meta3, body } = parseFrontmatter(content);
     if (!meta3.name || !meta3.trigger) return null;
     return {
@@ -28089,11 +29030,11 @@ function loadSkillFile(filePath) {
 }
 function loadSkillsFromDir(dir, source) {
   const skills = [];
-  if (!existsSync24(dir)) return skills;
+  if (!existsSync28(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);
@@ -28107,12 +29048,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) {
@@ -28129,17 +29070,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 readFileSync34, 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(readFileSync34(memoryPath(), "utf-8"));
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.warn(`[agon] failed to load engine memory: ${err instanceof Error ? err.message : String(err)}`);
@@ -28149,12 +29090,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) {
@@ -28346,7 +29287,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.`;
@@ -28382,13 +29323,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(),
@@ -28400,7 +29341,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)}`);
     }
@@ -28417,12 +29358,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 readFileSync35, 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(readFileSync35(path)).digest("hex");
   } catch (e) {
     console.warn(`[agon] provenance: could not hash ${path}: ${e instanceof Error ? e.message : String(e)}`);
     return "unavailable";
@@ -28582,18 +29523,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
@@ -28699,8 +29640,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 readFileSync36, existsSync as existsSync29 } from "fs";
 import { homedir as homedir17 } from "os";
 
 // ../core/src/generated/signals/event-bus.ts
@@ -28791,31 +29732,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 (existsSync29(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 (existsSync29(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 (existsSync29(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 (existsSync29(manifestPath)) {
+            results.push({ dir: join36(repoDir, entry.name), source: "repo" });
           }
         }
       }
@@ -28825,9 +29766,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(readFileSync36(manifestPath, "utf-8"));
     const result = validateManifest(raw, manifestPath);
     if (!result.ok || !result.data) {
       console.warn(`[agon] skipping extension ${dir}: ${result.error}`);
@@ -28896,7 +29837,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(readFileSync36(fullPath, "utf-8"));
       if (raw.id) {
         engineRegistry.register(raw);
         registered.push(raw.id);
@@ -29045,7 +29986,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" },
@@ -29311,8 +30252,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 readFileSync37, 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 };
 }
@@ -29321,7 +30262,7 @@ function defaultRoleRating(engineId, role) {
 }
 function loadTeamElo() {
   try {
-    return JSON.parse(readFileSync32(TEAM_ELO_PATH, "utf-8"));
+    return JSON.parse(readFileSync37(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)}`);
@@ -29330,10 +30271,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) {
@@ -29528,6 +30469,7 @@ export {
   hasProjectBrief,
   isKernProject,
   scanProjectContext,
+  buildKernContextSpine,
   collectSourceFiles,
   extractSymbols,
   buildCodebaseMap,
@@ -29541,7 +30483,7 @@ export {
   snapshotWorkspace,
   resolveWorkingDir,
   ensureCurrentWorkspace,
-  estimateTokens,
+  estimateTokens2 as estimateTokens,
   estimateCost,
   tracker,
   createPlan,
@@ -29667,6 +30609,7 @@ export {
   getCesarPlansDir,
   cesarPlanJsonPath,
   cesarPlanMarkdownPath,
+  CESAR_STEP_TYPES,
   createCesarPlan,
   approveCesarPlan,
   advanceCesarStep,
@@ -29696,7 +30639,30 @@ export {
   mimeFromExt,
   resolveImagePath,
   buildImageAttachment,
+  normalizeDroppedPath,
   extractImagesFromInput,
+  encodeImagesForDispatch,
+  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,
@@ -29744,6 +30710,7 @@ export {
   listThreadsForProject,
   deleteThread,
   planCostEstimator,
+  sanitizePlanSteps,
   getReadySteps,
   executePlan,
   makeAssistantChunk,
@@ -29829,4 +30796,4 @@ export {
   predictTeamRating,
   updateTeamElo
 };
-//# sourceMappingURL=chunk-C22VTCS6.js.map
+//# sourceMappingURL=chunk-TMNHJOKU.js.map