@kernlang/agon 0.1.8 → 0.2.0

package/dist/{chunk-GMVFKWQA.js → chunk-24EWX243.js}

@@ -4,28 +4,34 @@ import {
   cleanEngineOutput,
   icons,
   parseMarkdownBlocks
-} from "./chunk-I2PMSXJ3.js";
+} from "./chunk-6GENPQFW.js";
 import {
   AGON_MODE_NAMES,
   CORPUS_PATH,
   FitnessError,
+  PERMISSION_DENIED_MESSAGE,
   RUNS_DIR,
   Semaphore,
   ToolRegistry,
   agonPath,
+  appendAttribution,
   appendMessage,
   appendUserTurnIfAbsent,
   applyPatch,
   assignForgeRoles,
+  bashRanGate,
+  budgetRatioPct,
   buildCodebaseMap,
   buildCritiquePrompt,
   buildForgePrompt,
   buildHistoryPrimedPrompt,
   buildKernContextSpine,
+  buildProjectMemoryBlock,
   buildSpecializedPrompt,
   buildStageContext,
   buildSynthesisPrompt,
   buildToolSystemPrompt,
+  checkSessionBudget,
   classifyDispatchFailure,
   classifyTask,
   composeTeams,
@@ -44,6 +50,7 @@ import {
   createGoalTool,
   createGrepTool,
   createListPlansTool,
+  createMultiEditTool,
   createPersistentSession,
   createPipelineTool,
   createProposePlanTool,
@@ -52,6 +59,7 @@ import {
   createReportConfidenceTool,
   createRetrieveResultTool,
   createReviewTool,
+  createSaveMemoryTool,
   createSidechainLogger,
   createStreamBridge,
   createTodoWriteTool,
@@ -62,11 +70,14 @@ import {
   determineWinner,
   diffFileCount,
   diffLineCount,
+  discoverGate,
   discoverMcpServers,
   engineHealth,
   ensureAgonHome,
   estimateCost,
+  estimateSessionTokens,
   estimateTokens,
+  evaluateToolRules,
   executeToolCall,
   extractPatchFilePatterns,
   formatChatContextForPrompt,
@@ -77,6 +88,7 @@ import {
   getRatings,
   gitChangedFiles,
   hasProjectBrief,
+  isGateSkipSignal,
   isReadOnlyCommand,
   listCesarPlans,
   loadConfig,
@@ -84,7 +96,9 @@ import {
   makeFormat,
   mcpDiscoveryFingerprint,
   mcpServersToWireFormat,
+  parsePermissionRuleSet,
   parseToolCalls,
+  parseToolHooks,
   pickTopRatedEngine,
   planCostEstimator,
   rankByTaskClass,
@@ -102,6 +116,7 @@ import {
   stashSnapshot,
   toolsToOpenAIFormat,
   tracker,
+  updateChatSummary,
   updateGlickoRanked,
   updateTeamElo,
   validateSyntax,
@@ -110,7 +125,7 @@ import {
   worktreeDiff,
   worktreePruneOrphaned,
   worktreeRemoveBestEffort
-} from "./chunk-BPKY4OF2.js";
+} from "./chunk-MWF4RHRU.js";
 
 // ../forge/src/generated/forge.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -166,7 +181,7 @@ async function healthCheckEngine(engineId, registry, adapter, _cwd, timeoutSec,
     }
     const message = err instanceof Error ? err.message : String(err);
     const status = classifyDispatchFailure({ errorMessage: message });
-    if (status === "auth-failed" || status === "unreachable") {
+    if (status === "auth-failed" || status === "unreachable" || status === "binary-missing") {
       engineHealth.mark(engineId, status, message);
     }
     return {
@@ -190,7 +205,7 @@ async function healthCheckEngine(engineId, registry, adapter, _cwd, timeoutSec,
   }
   if (exitCode !== 0) {
     const status = classifyDispatchFailure({ stderr, exitCode, errorMessage: stderr });
-    if (status === "auth-failed" || status === "unreachable") {
+    if (status === "auth-failed" || status === "unreachable" || status === "binary-missing") {
       engineHealth.mark(engineId, status, stderr || `exit-${exitCode}`);
     }
     return {
@@ -260,7 +275,7 @@ async function preflightHealthFilter(opts) {
   const afterQuarantine = [];
   for (const id of engineIds) {
     const health = engineHealth.get(id);
-    if (health && (health.status === "auth-failed" || health.status === "unreachable")) {
+    if (health && (health.status === "auth-failed" || health.status === "unreachable" || health.status === "binary-missing")) {
       skipped.push({ engineId: id, status: health.status, reason: health.reason || "quarantined this session" });
     } else {
       afterQuarantine.push(id);
@@ -1720,7 +1735,7 @@ async function runForge(options, registry, adapter, onEvent) {
         return false;
       }
       const health = engineHealth.get(id);
-      if (health && (health.status === "auth-failed" || health.status === "unreachable")) {
+      if (health && (health.status === "auth-failed" || health.status === "unreachable" || health.status === "binary-missing")) {
         skippedQuarantine.push({ id, reason: health.reason, status: health.status });
         return false;
       }
@@ -3435,7 +3450,7 @@ async function runCouncil(opts) {
     }
     if (cesarId && !engines.includes(cesarId)) {
       const __ch = engineHealth.get(cesarId);
-      if (__ch && (__ch.status === "auth-failed" || __ch.status === "unreachable")) {
+      if (__ch && (__ch.status === "auth-failed" || __ch.status === "unreachable" || __ch.status === "binary-missing")) {
         warnings.push(`Configured Cesar chair '${cesarId}' is quarantined this session (${__ch.status}); falling back to ${engines[0]} as chair.`);
         cesarId = "";
       }
@@ -5225,6 +5240,75 @@ async function runThinkChain(opts) {
   };
 }
 
+// ../forge/src/generated/pr-text.ts
+function buildPrTextPrompt(opts) {
+  const lines = [];
+  lines.push("Write the pull-request text for a change that was just pushed. You are writing for the human reviewer who will merge it.");
+  lines.push("");
+  lines.push("TASK / INTENT:");
+  lines.push(opts.intent.trim());
+  if (opts.context && opts.context.trim()) {
+    lines.push("");
+    lines.push("RUN FACTS (verified \u2014 you may state these):");
+    lines.push(opts.context.trim());
+  }
+  if (opts.commits.trim()) {
+    lines.push("");
+    lines.push("COMMITS ON THIS BRANCH:");
+    lines.push(opts.commits.trim());
+  }
+  lines.push("");
+  lines.push("DIFF (may be truncated):");
+  lines.push(opts.diff.trim() || "(diff unavailable \u2014 describe from the commits and run facts only)");
+  lines.push("");
+  lines.push("Requirements:");
+  lines.push("- Title: ONE imperative line, max 72 chars, conventional-commit style when natural (feat:/fix:/refactor:/\u2026). No trailing period.");
+  lines.push("- Body: GitHub markdown with exactly these sections:");
+  lines.push("  ## Summary \u2014 2-4 sentences: what changed and why.");
+  lines.push("  ## Changes \u2014 bullets of the concrete changes, grouped by area, naming key files.");
+  lines.push("  ## Verification \u2014 how it was verified. ONLY state what the run facts/diff show (gate command, tests in the diff); never invent test runs or results.");
+  lines.push("- No preamble, no sign-off, no emojis, no flattery, nothing the diff does not support.");
+  lines.push("");
+  lines.push('Reply EXACTLY in this format (first line literally starts with "TITLE: "):');
+  lines.push("TITLE: <the title>");
+  lines.push("");
+  lines.push("<the body markdown>");
+  return lines.join("\n");
+}
+function parsePrText(raw) {
+  let cleaned = raw.replace(/<think>[\s\S]*?<\/think>\s*/gi, "").trim();
+  const fence = cleaned.match(/^```[a-z]*\s*\n([\s\S]*?)\n```\s*$/i);
+  if (fence) cleaned = fence[1].trim();
+  if (!cleaned) return null;
+  const lines = cleaned.split("\n");
+  const i = lines.findIndex((l) => /^\s*TITLE:\s*\S/.test(l));
+  if (i < 0) return null;
+  const title = lines[i].replace(/^\s*TITLE:\s*/, "").trim();
+  let body = lines.slice(i + 1).join("\n").trim();
+  body = body.replace(/^BODY:\s*/i, "").trim();
+  if (!title || !body) return null;
+  return { title, body };
+}
+async function runPrText(opts) {
+  try {
+    const r = await runDelegate({
+      engineId: opts.engineId,
+      task: buildPrTextPrompt(opts),
+      cwd: opts.cwd,
+      registry: opts.registry,
+      adapter: opts.adapter,
+      timeout: opts.timeout,
+      outputDir: opts.outputDir,
+      signal: opts.signal
+    });
+    const parsed = parsePrText(r.response ?? "");
+    if (!parsed) return { ok: false, title: "", body: "", engineId: opts.engineId };
+    return { ok: true, title: parsed.title, body: parsed.body, engineId: opts.engineId };
+  } catch {
+    return { ok: false, title: "", body: "", engineId: opts.engineId };
+  }
+}
+
 // ../forge/src/generated/goal/journal.ts
 import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, renameSync as renameSync4 } from "fs";
 import { dirname as dirname2 } from "path";
@@ -6078,7 +6162,7 @@ ${gate2.stdout || ""}`), detail: `gate failed after fix pass${logPath ? ` \u2014
         if (rev.blocking) throw { kind: "review", detail: rev.summary };
       }
       await git(["add", "-A"], wt);
-      const commit = await git(["commit", "-m", `goal(${spec.goalId}): ${task.source}`, "--no-verify"], wt);
+      const commit = await git(["commit", "-m", appendAttribution(`goal(${spec.goalId}): ${task.source}`, loadConfig(repoRoot2)), "--no-verify"], wt);
       if (commit.exitCode !== 0) throw { kind: "error", detail: `commit failed: ${commit.stderr.trim()}` };
       const headRes = await git(["rev-parse", "HEAD"], wt);
       const newSha = headRes.stdout.trim();
@@ -6695,10 +6779,11 @@ function filterDefaultOrchestrationEngines(engineIds) {
 
 // src/generated/cesar/brain.ts
 import { join as join14 } from "path";
-import { mkdirSync as mkdirSync13, appendFileSync as appendFileSync2, existsSync as existsSync13, readFileSync as readFileSync13, unlinkSync, readdirSync, writeFileSync as writeFileSync11 } from "fs";
+import { mkdirSync as mkdirSync13, appendFileSync as appendFileSync2, existsSync as existsSync14, readFileSync as readFileSync14, unlinkSync, readdirSync, writeFileSync as writeFileSync11 } from "fs";
 
 // src/generated/cesar/confidence.ts
 var CONFIDENCE_TIERS = { direct: 96, quickNero: 93, nero: 88, brainstorm: 72, advisor: 72 };
+var ESCALATION_SUGGESTION_THRESHOLD = 85;
 function parseConfidence(response) {
   const tildeMatch = response.match(/^~(\d{1,3})%\s*/);
   if (tildeMatch) {
@@ -6716,6 +6801,26 @@ function parseConfidence(response) {
   }
   return { value: null, rest: response };
 }
+function extractStrictConfidence(text) {
+  if (!text) {
+    return null;
+  }
+  const all = Array.from(text.matchAll(/\bCONFIDENCE:\s*~?(\d{1,3})\s*%/gi));
+  const m = all.length > 0 ? all[all.length - 1] : null;
+  if (!m) {
+    return null;
+  }
+  const n = parseInt(m[1], 10);
+  if (!Number.isFinite(n) || n < 0 || n > 100) {
+    return null;
+  }
+  return n;
+}
+function buildEscalationSuggestionLine(value) {
+  const dim = "\x1B[2m";
+  const reset = "\x1B[0m";
+  return `${dim}${value}% \u2014 want a nero/tribunal on this?${reset}`;
+}
 function confidenceColor(value) {
   if (value >= 96) return "\x1B[32m";
   if (value >= 93) return "\x1B[33m";
@@ -6762,8 +6867,61 @@ function parseSuggestion(response) {
   return { action, rest, hardened, tribunalMode, team };
 }
 
+// src/generated/cesar/todos-marker.ts
+function parseLiveTodos(response) {
+  const blockRe = /\[TODOS\]([\s\S]*?)\[\/TODOS\]/gi;
+  let found = false;
+  let lastBody = null;
+  let rest = response;
+  const matches = response.match(blockRe);
+  if (!matches || matches.length === 0) {
+    return { todos: [], found: false, rest: response };
+  }
+  found = true;
+  rest = response.replace(blockRe, "").trim();
+  let m;
+  const re2 = /\[TODOS\]([\s\S]*?)\[\/TODOS\]/gi;
+  while ((m = re2.exec(response)) !== null) {
+    lastBody = m[1];
+  }
+  if (lastBody === null) return { todos: [], found, rest };
+  const allowed = /* @__PURE__ */ new Set(["pending", "running", "done", "failed", "cancelled"]);
+  let parsed;
+  try {
+    parsed = JSON.parse(lastBody.trim());
+  } catch {
+    return { todos: [], found, rest };
+  }
+  if (!Array.isArray(parsed)) return { todos: [], found, rest };
+  const MAX_LIVE_TODOS = 50;
+  const order = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const raw of parsed.slice(0, MAX_LIVE_TODOS)) {
+    if (!raw || typeof raw !== "object") continue;
+    const r = raw;
+    const id = r.id !== void 0 && r.id !== null ? String(r.id) : "";
+    const text = r.text !== void 0 && r.text !== null ? String(r.text) : "";
+    if (!id || !text) continue;
+    const state = allowed.has(String(r.state)) ? String(r.state) : "pending";
+    const note = r.note !== void 0 && r.note !== null ? String(r.note) : void 0;
+    if (!byId.has(id)) order.push(id);
+    byId.set(id, { id, text, state, note, source: "live" });
+  }
+  const todos = order.map((id) => byId.get(id)).filter(Boolean);
+  return { todos, found, rest };
+}
+function parsePreamble(response) {
+  const text = String(response ?? "");
+  const m = text.match(/^(\s*)\[INTENT\][ \t]*([^\r\n]*)(\r?\n)?/i);
+  if (!m) return { intent: null, found: false, rest: text };
+  const intent = String(m[2] ?? "").trim();
+  if (!intent) return { intent: null, found: false, rest: text };
+  const rest = text.slice(m[0].length).replace(/^\r?\n/, "");
+  return { intent, found: true, rest };
+}
+
 // src/generated/cesar/session.ts
-import { readFileSync as readFileSync12, statSync as statSync4, existsSync as existsSync12 } from "fs";
+import { readFileSync as readFileSync13, statSync as statSync5, existsSync as existsSync13 } from "fs";
 import { isAbsolute as isAbsolute2, resolve as resolve3, dirname as dirname5 } from "path";
 import { join as join12 } from "path";
 import { mkdirSync as mkdirSync11 } from "fs";
@@ -6775,6 +6933,7 @@ function createCesarToolRegistry(engineId) {
   const toolRegistry = new ToolRegistry();
   toolRegistry.register(createReadTool());
   toolRegistry.register(createEditTool());
+  toolRegistry.register(createMultiEditTool());
   toolRegistry.register(createWriteTool());
   toolRegistry.register(createBashTool());
   toolRegistry.register(createGrepTool());
@@ -6792,6 +6951,7 @@ function createCesarToolRegistry(engineId) {
   toolRegistry.register(createReportConfidenceTool());
   toolRegistry.register(createQuickNeroTool());
   toolRegistry.register(createTodoWriteTool());
+  toolRegistry.register(createSaveMemoryTool());
   toolRegistry.register(createProposePlanTool());
   toolRegistry.register(createExitPlanModeTool());
   toolRegistry.register(createListPlansTool());
@@ -6802,7 +6962,7 @@ function createEagerToolContext(ctx, config, signal, dispatch) {
   const cwd = resolveWorkingDir();
   const fsc = getProjectFileStateCache(cwd);
   const explorationMode = ctx.explorationMode ?? false;
-  return { cwd, readFileState: fsc.cache, abortSignal: signal, permissionMode: config.permissionMode ?? "ask", explorationMode, allowedCommands: config.allowedCommands ?? [], toolPermissions: config.toolPermissions ?? {}, source: "orchestrator", onProgress: (msg) => dispatch({ type: "spinner-update", message: `Cesar: ${msg}` }) };
+  return { cwd, readFileState: fsc.cache, abortSignal: signal, permissionMode: config.permissionMode ?? "ask", explorationMode, allowedCommands: config.allowedCommands ?? [], toolPermissions: config.toolPermissions ?? {}, source: "orchestrator", permissionRules: parsePermissionRuleSet(config.permissions), toolHooks: parseToolHooks(config.hooks), onProgress: (msg) => dispatch({ type: "spinner-update", message: `Cesar: ${msg}` }) };
 }
 function parseEagerToolInput(toolName, input) {
   const raw = typeof input === "string" ? input : input === void 0 ? "" : (() => {
@@ -6860,7 +7020,7 @@ async function executeEagerTool(toolName, meta, toolRegistry, toolCtx, dispatch,
       result: { ok: false, content: "", error },
       durationMs: 0
     };
-    dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "error", output: error });
+    dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "error", output: error, durationMs: result2.durationMs });
     return result2;
   }
   const parsedInput = parsed.input ?? {};
@@ -6891,9 +7051,9 @@ async function executeEagerTool(toolName, meta, toolRegistry, toolCtx, dispatch,
   const out = result.result.ok ? result.result.content : result.result.error;
   const status = result.result.ok ? "done" : "error";
   if (streamStarted) {
-    dispatch({ type: "tool-stream-end", streamId, engineId: cesarEngineId, tool: toolName, input: toolInput, status, output: out });
+    dispatch({ type: "tool-stream-end", streamId, engineId: cesarEngineId, tool: toolName, input: toolInput, status, output: out, durationMs: result.durationMs });
   } else {
-    dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status, output: out });
+    dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status, output: out, durationMs: result.durationMs });
   }
   return result;
 }
@@ -7042,6 +7202,9 @@ function updateTodoState(todos, id, state, note) {
 function clearTodos() {
   return [];
 }
+function clearLiveTodos(todos) {
+  return todos.filter((t) => t.source !== "live");
+}
 function todosFromPlanSteps(steps) {
   const allowed = /* @__PURE__ */ new Set(["pending", "running", "done", "failed", "cancelled"]);
   return steps.map((s) => ({
@@ -7117,7 +7280,7 @@ function _showNextPermission(actions) {
   _drainAutoApproved(actions);
   if (_permissionQueue.length === 0) return;
   const next = _permissionQueue[0];
-  actions.addBlock({ type: "permission-ask", tool: next.tool, command: next.command, description: next.description, reason: next.reason, resolve: next.resolve });
+  actions.addBlock({ type: "permission-ask", tool: next.tool, command: next.command, description: next.description, reason: next.reason, diffPreview: next.diffPreview, fallbackNote: next.fallbackNote, resolve: next.resolve });
   const permResolve = next.resolve;
   const permCommand = next.command;
   actions.setQuestionState({
@@ -7127,6 +7290,8 @@ function _showNextPermission(actions) {
     command: permCommand,
     description: next.description,
     reason: next.reason,
+    diffPreview: next.diffPreview,
+    fallbackNote: next.fallbackNote,
     choices: [
       { key: "y", label: "Yes", color: "#4ade80" },
       { key: "n", label: "No", color: "#ef4444" },
@@ -7192,6 +7357,7 @@ function handleOutputEvent(event, state, actions, mode, chatStartTime) {
     "context-usage",
     "streaming-chunk",
     "streaming-start",
+    "streaming-preview",
     "thinking-chunk",
     "thinking-start",
     "thinking-stop",
@@ -7238,16 +7404,35 @@ function handleOutputEvent(event, state, actions, mode, chatStartTime) {
       }
       return;
     }
+    case "streaming-preview": {
+      const eid = event.engineId;
+      const draftText = event.content;
+      actions.setStreamingText((prev) => {
+        const existing = prev[eid];
+        if (existing && !existing.draft) return prev;
+        return {
+          ...prev,
+          [eid]: {
+            engineId: eid,
+            content: draftText,
+            startedAt: existing ? existing.startedAt : Date.now(),
+            draft: true
+          }
+        };
+      });
+      return;
+    }
     case "streaming-chunk": {
       const eid = event.engineId;
       const chunk = event.chunk;
       actions.setStreamingText((prev) => {
         const existing = prev[eid];
+        const base = existing && !existing.draft ? existing.content : "";
         return {
           ...prev,
           [eid]: {
             engineId: eid,
-            content: existing ? existing.content + chunk : chunk,
+            content: base + chunk,
             startedAt: existing ? existing.startedAt : Date.now()
           }
         };
@@ -7258,6 +7443,14 @@ function handleOutputEvent(event, state, actions, mode, chatStartTime) {
       const eid = event.engineId;
       const st = state.streamingText[eid];
       if (st) {
+        if (st.draft) {
+          actions.setStreamingText((prev) => {
+            const next = { ...prev };
+            delete next[eid];
+            return next;
+          });
+          return;
+        }
         const color = actions.getEngineColor(st.engineId);
         const cleaned = cleanEngineOutput(st.content);
         actions.setStreamingText((prev) => {
@@ -7291,7 +7484,12 @@ function handleOutputEvent(event, state, actions, mode, chatStartTime) {
       return;
     }
     case "todos-clear": {
-      actions.setTodos(clearTodos());
+      const scope = event.scope;
+      if (scope === "live") {
+        actions.setTodos((prev) => clearLiveTodos(prev));
+      } else {
+        actions.setTodos(clearTodos());
+      }
       return;
     }
     case "clear":
@@ -7345,6 +7543,8 @@ function handleOutputEvent(event, state, actions, mode, chatStartTime) {
         command: event.command,
         description: event.description,
         reason: event.reason,
+        diffPreview: event.diffPreview,
+        fallbackNote: event.fallbackNote,
         resolve: event.resolve
       };
       _permissionQueue.push(entry);
@@ -7389,7 +7589,7 @@ function handleOutputEvent(event, state, actions, mode, chatStartTime) {
     }
     case "context-usage": {
       const e = event;
-      actions.setCesarContext({ pct: e.pct, used: e.used, limit: e.limit, compacted: e.compacted ?? 0, cached: e.cached ?? 0 });
+      actions.setCesarContext({ pct: e.pct, used: e.used, limit: e.limit, compacted: e.compacted ?? 0, cached: e.cached ?? 0, source: e.source ?? "estimate" });
       return;
     }
     case "agent-step-start": {
@@ -7568,7 +7768,8 @@ function handleOutputEvent(event, state, actions, mode, chatStartTime) {
         tool: e.tool ?? existing.tool ?? "",
         input: e.input ?? existing.input ?? "",
         status: e.status,
-        output
+        output,
+        ...e.durationMs !== void 0 ? { durationMs: e.durationMs } : {}
       };
       const key = toolCallKey(toolCallEvent);
       if (e.status === "done" || e.status === "error") {
@@ -8226,8 +8427,22 @@ function shouldSpeculate(hints, config) {
 
 // src/generated/cesar/brain-helpers.ts
 var yieldToInk = () => new Promise((resolve4) => setImmediate(resolve4));
+function recordCesarTurn(ctx, cesarEngineId, input, response) {
+  try {
+    const s = ctx.cesarSession;
+    const u = s && typeof s.getTurnUsage === "function" ? s.getTurnUsage() : null;
+    if (u && u.totalTokens > 0) {
+      return tracker.record(cesarEngineId, {
+        usage: { promptTokens: u.promptTokens, completionTokens: u.completionTokens, totalTokens: u.totalTokens, source: u.source ?? "sdk" },
+        model: u.model
+      });
+    }
+  } catch {
+  }
+  return tracker.record(cesarEngineId, { prompt: input, response });
+}
 var splitBeforeToolMarkup = (text) => {
-  const markers = ["<tool ", "<invoke ", "<tool_call", "<toolcall", "<tool_call_tool>", "<function=", "[TOOL_CALLS]"];
+  const markers = ["<tool ", "<invoke ", "<tool_call", "<toolcall", "<tool_call_tool>", "<function=", "[TOOL_CALLS]", "[TODOS]"];
   const lower = text.toLowerCase();
   let idx = -1;
   for (const marker of markers) {
@@ -8238,6 +8453,109 @@ var splitBeforeToolMarkup = (text) => {
   return { visible: text.slice(0, idx), hasToolMarkup: true };
 };
 var XML_TOOL_MARKUP_HOLD_CHARS = 24;
+var createTodosDisplayStripper = () => {
+  let insideBlock = false;
+  let hold = "";
+  const OPEN = "[todos]";
+  const CLOSE = "[/todos]";
+  const trailingPrefixLen = (combined, marker) => {
+    const lower = combined.toLowerCase();
+    for (let n = Math.min(marker.length - 1, combined.length); n > 0; n--) {
+      if (lower.slice(combined.length - n) === marker.slice(0, n)) return n;
+    }
+    return 0;
+  };
+  return (chunk, force = false) => {
+    let combined = hold + chunk;
+    hold = "";
+    if (force) {
+      insideBlock = false;
+      return combined;
+    }
+    let out = "";
+    while (combined.length > 0) {
+      if (insideBlock) {
+        const end = combined.toLowerCase().indexOf(CLOSE);
+        if (end < 0) {
+          const p = trailingPrefixLen(combined, CLOSE);
+          if (p > 0) hold = combined.slice(combined.length - p);
+          combined = "";
+          break;
+        }
+        insideBlock = false;
+        combined = combined.slice(end + CLOSE.length);
+        continue;
+      }
+      const start = combined.toLowerCase().indexOf(OPEN);
+      if (start < 0) break;
+      out += combined.slice(0, start);
+      insideBlock = true;
+      combined = combined.slice(start + OPEN.length);
+    }
+    if (!insideBlock) {
+      const p = trailingPrefixLen(combined, OPEN);
+      if (p > 0) {
+        hold = combined.slice(combined.length - p);
+        combined = combined.slice(0, combined.length - p);
+      }
+      out += combined;
+    }
+    return out;
+  };
+};
+var createPreambleStripper = () => {
+  const MARKER = "[intent]";
+  let decided = false;
+  let hold = "";
+  const couldBeMarker = (lowerTrimmed) => {
+    const n = Math.min(lowerTrimmed.length, MARKER.length);
+    return lowerTrimmed.slice(0, n) === MARKER.slice(0, n);
+  };
+  const stripLeadingPreamble = (text) => {
+    const m = text.match(/^(\s*)\[intent\][ \t]*([^\r\n]*)(\r?\n)?/i);
+    if (!m) return text;
+    if (!String(m[2] ?? "").trim()) return text;
+    return text.slice(m[0].length).replace(/^\r?\n/, "");
+  };
+  return (chunk, force = false) => {
+    if (decided) return chunk;
+    hold += chunk;
+    if (force) {
+      decided = true;
+      const afterWs2 = hold.replace(/^\s*/, "");
+      const out = couldBeMarker(afterWs2.toLowerCase()) && afterWs2.toLowerCase().startsWith(MARKER) ? stripLeadingPreamble(hold) : hold;
+      hold = "";
+      return out;
+    }
+    const leadingWsMatch = hold.match(/^\s*/);
+    const leadingWs = leadingWsMatch ? leadingWsMatch[0] : "";
+    const afterWs = hold.slice(leadingWs.length);
+    const lower = afterWs.toLowerCase();
+    if (!couldBeMarker(lower)) {
+      decided = true;
+      const out = hold;
+      hold = "";
+      return out;
+    }
+    if (lower.length < MARKER.length) return "";
+    const nlIdx = afterWs.search(/\r?\n/);
+    if (nlIdx < 0) {
+      return "";
+    }
+    if (!afterWs.slice(MARKER.length, nlIdx).trim()) {
+      decided = true;
+      const out = hold;
+      hold = "";
+      return out;
+    }
+    const nlMatch = afterWs.slice(nlIdx).match(/^\r?\n/);
+    const nlLen = nlMatch ? nlMatch[0].length : 0;
+    const rest = afterWs.slice(nlIdx + nlLen);
+    decided = true;
+    hold = "";
+    return rest;
+  };
+};
 function isUserDirectedQuestion(lastLine) {
   const last = String(lastLine ?? "").trim();
   if (!/\?\s*$/.test(last)) return false;
@@ -8281,20 +8599,50 @@ function detectNarratedToolStall(text) {
   const STALL_RE = /\b(?:let me (?:check|look|examine|read|search|find|see|review|explore|investigate|understand|get|grab|continue)|i (?:need|want|should|will) (?:to )?(?:check|look|examine|read|search|find|see|review|explore|investigate|understand|get|grab|continue)|now (?:let me|i'll)|continu(?:e|ing)|keep (?:reading|investigating|looking)|next[,.]?\s*(?:i|let)|before (?:i can|proceeding|implementing|deciding))\b/i;
   return FAKE_GATE_RE.test(tail) || READ_INTENT_RE.test(tail) || SEARCH_INTENT_RE.test(tail) || DIR_INTENT_RE.test(tail) || STALL_RE.test(tail);
 }
+function stripNonAssertionSpans(text) {
+  let body = String(text ?? "");
+  const KEEP_CLAIM_RE = /^(?:i(?:'ll|'m|\s+will|\s+have|\s+need\s+to|\s+want\s+to|\s+already)\b|let\s+me\b|please\s+\w+)/i;
+  body = body.replace(/```[\s\S]*?(?:```|$)/g, " ");
+  body = body.replace(/`([^`\n]{1,300})`/g, (_m, inner) => KEEP_CLAIM_RE.test(inner.trim()) ? ` ${inner} ` : " ");
+  body = body.replace(/["“”]([^"“”\n]{1,300})["“”]/g, (_m, inner) => KEEP_CLAIM_RE.test(inner.trim()) ? ` ${inner} ` : " ");
+  body = body.replace(/\([A-Z][A-Za-z]*(?:\s*[,/&]\s*[A-Z][A-Za-z]*)+\)/g, " ");
+  return body;
+}
 function detectMutationIntentStall(text) {
-  const body = String(text ?? "").trim();
+  const body = stripNonAssertionSpans(String(text ?? "")).trim();
   if (!body) return false;
-  const MUTATION_INTENT_RE = /\b(?:edit|write|apply|patch|implement|insert|replace|land it|commit it|the (?:change|fix|diff|patch|edit)|make the (?:edit|change)s?|ready to (?:paste|apply))\b/i;
-  const HANDBACK_RE = /\b(?:read-?only|can'?t (?:write|edit|apply|mutate|touch)|no (?:write|edit|bash) tool|(?:edit|write|bash)(?: tool)?(?: is)? (?:not enabled|disabled|not wired|not available|unavailable)|not (?:enabled|wired|reachable) in this (?:context|session|turn)|spawn (?:an? )?agent|dispatch (?:an? )?agent|paste (?:it|this|the\b)|apply (?:it|this)\b|git apply|you (?:can )?(?:run|apply|paste)|in your terminal|hand you the (?:patch|diff|commands?)|copy[- ]?paste)\b/i;
-  return MUTATION_INTENT_RE.test(body) && HANDBACK_RE.test(body);
+  const CANNOT_RE = /\b(?:i\s+(?:cannot|can'?t|am\s+unable\s+to)\s+(?:write|edit|apply|mutate|touch)|i'?m\s+read-?only|(?:this|the)\s+(?:session|environment|context|sandbox)\s+is\s+read-?only|i\s+have\s+no\s+(?:write|edit|bash)\s+tools?|no\s+(?:write|edit)\s+access|(?:edit|write|bash)(?:\s+tool)?\s+is\s+(?:not\s+(?:enabled|available|wired)|disabled|unavailable)|not\s+(?:enabled|wired|reachable)\s+in\s+this\s+(?:context|session|turn))\b/i;
+  const USER_APPLY_RE = /\b(?:paste\s+(?:it|this|the)\b|git\s+apply\b|apply\s+(?:it|this)\b|in\s+your\s+terminal|you\s+(?:can\s+)?(?:run|apply|paste)\b|copy[- ]?paste|hand\s+you\s+the\s+(?:patch|diff|commands?))/i;
+  const AGENT_ESCAPE_RE = /\b(?:spawn|dispatch)\s+(?:an?\s+)?agent\b/i;
+  const INTENT_RE = /\b(?:i(?:'ll|\s+will|\s+need\s+to|\s+want\s+to|'?m\s+going\s+to)|let\s+me)\s+(?:\w+\s+){0,3}?(?:edit|write|apply|commit|patch|fix|update|implement|modify|create|make)\b/i;
+  const RESULT_FIRST_RE = /\b(?:patch|fix|change|diff|edit|update)e?s?\s+(?:is|are)?\s*(?:ready|done|complete|prepared|below|attached)\b|\bready\s+to\s+(?:paste|apply)\b/i;
+  const PAST_DONE_RE = /\bi(?:'ve)?\s+(?:already\s+)?(?:made|updated|edited|wrote|written|applied|changed|fixed|patched|implemented|created|prepared)\b/i;
+  const PRESENTATION_RE = /\bhere(?:'s|\s+is|\s+are)\s+(?:the\s+|a\s+)?(?:full\s+)?(?:diff|patch|change|fix|edit|code)\b|\b(?:diff|patch)\s+(?:is\s+)?(?:below|above)\b/i;
+  const intentish = INTENT_RE.test(body) || RESULT_FIRST_RE.test(body) || PAST_DONE_RE.test(body) || PRESENTATION_RE.test(body);
+  if (CANNOT_RE.test(body) && (intentish || USER_APPLY_RE.test(body) || AGENT_ESCAPE_RE.test(body))) return true;
+  if (USER_APPLY_RE.test(body) && intentish) return true;
+  if (AGENT_ESCAPE_RE.test(body) && (intentish || CANNOT_RE.test(body))) return true;
+  return false;
 }
 function detectFabricatedDelegation(text) {
-  const body = String(text ?? "").trim();
+  const body = stripNonAssertionSpans(String(text ?? "")).trim();
   if (!body) return false;
   const TARGET_RE = /\b(?:review(?:er)?s?|forg(?:e|ing)|tribunal|brainstorm|campfire|agents?|engines?|jobs?)\b/i;
   if (!TARGET_RE.test(body)) return false;
-  const DISPATCH_RE = /\b(?:kick(?:ed|ing)?\s*(?:it|them|that|the\s+\w+)?\s*off|fired?\s*(?:it|them|off)|dispatch(?:ed|ing)|delegat(?:ed|ing)|(?:is|are|now)\s+running|running\s+(?:in|now)|in\s+parallel|reading\s+the\s+(?:diff|changes|code)|working\s+(?:on\s+it|in\s+parallel)|in\s+progress|under\s*way|i'?ll\s+(?:get\s+back|report|let\s+you\s+know|surface|update)|report(?:s|ing)?\s+back|when\s+they\s+(?:report|land|return|finish|come\s+back)|still\s+(?:running|going|working|in\s+progress)|spun?\s+up|started\s+(?:the|a)\s+(?:review|forge|job|tribunal|brainstorm))\b/i;
-  return DISPATCH_RE.test(body);
+  const FP_DISPATCH_RE = /\b(?:i(?:'ve)?\s+(?:already\s+)?(?:kick(?:ed)?\s*(?:it|them|that|the\s+\w+)?\s*off|fired\s+(?:it|them|off)|dispatch(?:ed)?|delegat(?:ed)?|started|launched|spun\s+up|queued)|i'?m\s+(?:running|dispatching|launching|starting))\b/i;
+  const DELEGATED_TO_RE = /\b(?:review|forge|tribunal|brainstorm|campfire|jobs?|agents?)\s+(?:was|were|has\s+been|have\s+been)?\s*delegated\s+to\b/i;
+  const RUNNING_STATE_RE = /\b(?:review(?:er)?s?|forge|tribunal|brainstorm|campfire|agents?|engines?|jobs?)\b[^.!?\n]{0,60}?(?:\b(?:is|are)\s+(?:still\s+|currently\s+|each\s+|now\s+)?(?:running|working|reading|evaluating|analyzing|reviewing|on\s+it)\b|\bin\s+progress\b|\bunder\s*way\b)/i;
+  const PASSIVE_DISPATCH_RE = /\b(?:review(?:er)?s?|forge|tribunal|brainstorm|campfire|agents?|engines?|jobs?)\b[^.!?\n]{0,60}?\b(?:was|were|has\s+been|have\s+been|is|are)\s+(?:queued|dispatched|launched|kicked\s+off|spun\s+up|fired\s+off)\b/i;
+  const REPORT_BACK_RE = /\bi'?ll\s+(?:get\s+back|report\s+back|let\s+you\s+know|surface|update)\b|\bwhen\s+they\s+(?:report|land|return|finish|come\s+back)\b/i;
+  return FP_DISPATCH_RE.test(body) || DELEGATED_TO_RE.test(body) || RUNNING_STATE_RE.test(body) || PASSIVE_DISPATCH_RE.test(body) || REPORT_BACK_RE.test(body);
+}
+function shouldDeescalateGuard(opts) {
+  const kind = String(opts.intakeKind ?? "");
+  const flow = String(opts.recommendedFlow ?? "");
+  const conversational = kind === "chat" && flow === "answer" || kind === "exploration" && (flow === "campfire" || flow === "brainstorm" || flow === "answer");
+  if (!conversational) return false;
+  if (opts.usedMutatingTool !== false) return false;
+  return true;
 }
 function eagerFailedToolNames(results) {
   const names = [];
@@ -8323,6 +8671,17 @@ function shouldStopAfterXmlToolCall(toolName) {
   const HANDOFF_TOOLS = /* @__PURE__ */ new Set(["Forge", "Brainstorm", "Tribunal", "Campfire", "Pipeline", "Review", "Agent", "Goal", "ProposePlan", "ExitPlanMode"]);
   return HANDOFF_TOOLS.has(String(toolName ?? ""));
 }
+function stripAgonToolPrefix(name) {
+  const n = String(name ?? "");
+  return n.toLowerCase().startsWith("agon") ? n.slice(4) : n;
+}
+function isBashToolName(name) {
+  return stripAgonToolPrefix(name).toLowerCase() === "bash";
+}
+var WRITE_TOOL_NAMES = /* @__PURE__ */ new Set(["edit", "write", "multiedit", "notebookedit"]);
+function isWriteToolName(name) {
+  return WRITE_TOOL_NAMES.has(stripAgonToolPrefix(name).toLowerCase());
+}
 function buildReviewFollowupPrompt(input, ctx) {
   const trimmed = input.trim();
   const match = trimmed.match(/^fix it(?:\s+with\s+([a-z0-9._-]+))?[\s?!.,;:]*$/i);
@@ -8383,6 +8742,9 @@ function canonicalToolName(tool) {
   if (lower === "agonedit" || lower === "edit" || lower === "fileedit" || lower === "filechange") {
     return "Edit";
   }
+  if (lower === "agonmultiedit" || lower === "multiedit" || lower === "multi_edit") {
+    return "MultiEdit";
+  }
   if (lower === "agonwrite" || lower === "write") {
     return "Write";
   }
@@ -8391,6 +8753,32 @@ function canonicalToolName(tool) {
   }
   return tool;
 }
+function estimateMultiEditApproval(cachedContent, edits) {
+  if (!Array.isArray(edits) || edits.length === 0) {
+    return { ok: false, reason: "missing edits array", nextContent: "", tokens: 0 };
+  }
+  let working = cachedContent;
+  let tokens = 0;
+  for (let i = 0; i < edits.length; i++) {
+    const e = edits[i] ?? {};
+    const oldS = e.old_string;
+    const newS = e.new_string;
+    if (typeof oldS !== "string" || typeof newS !== "string" || oldS === "") {
+      return { ok: false, reason: `edits[${i}] missing/empty old_string or new_string`, nextContent: "", tokens: 0 };
+    }
+    const occ = countOccurrences(working, oldS);
+    if (occ <= 0) {
+      return { ok: false, reason: `edits[${i}] old_string not found in cached content`, nextContent: "", tokens: 0 };
+    }
+    const replaceAll = e.replace_all === true;
+    if (!replaceAll && occ > 1) {
+      return { ok: false, reason: `edits[${i}] old_string not unique and replace_all not set`, nextContent: "", tokens: 0 };
+    }
+    tokens += estimateChangedTokens(oldS, newS) * (replaceAll ? occ : 1);
+    working = replaceAll ? working.split(oldS).join(newS) : working.replace(oldS, newS);
+  }
+  return { ok: true, reason: "ok", nextContent: working, tokens };
+}
 function approvalArgsFromCommand(tool, command) {
   const raw = String(command ?? "").trim();
   if (!raw) return {};
@@ -8512,7 +8900,7 @@ function applyCesarSelfTurnApproval(tool, args, toolCtx, config) {
     return { approve: false, reason: "read-only mode active" };
   }
   const t = canonicalToolName(tool);
-  if (t !== "Edit" && t !== "Write") {
+  if (t !== "Edit" && t !== "Write" && t !== "MultiEdit") {
     return { approve: false, reason: "not a file edit/write" };
   }
   const configured = toolCtx.toolPermissions?.[t];
@@ -8560,6 +8948,13 @@ function applyCesarSelfTurnApproval(tool, args, toolCtx, config) {
     const editMultiplier = normalizedArgs.replace_all === true ? occurrences : 1;
     diffTokens = perEditTokens * editMultiplier;
     nextContent = normalizedArgs.replace_all === true ? cached.content.split(oldString).join(newString) : cached.content.replace(oldString, newString);
+  } else if (t === "MultiEdit") {
+    const meRes = estimateMultiEditApproval(cached.content, normalizedArgs.edits);
+    if (!meRes.ok) {
+      return { approve: false, reason: `MultiEdit ${meRes.reason}`, tool: t, path: filePath };
+    }
+    diffTokens = meRes.tokens;
+    nextContent = meRes.nextContent;
   } else {
     const content = normalizedArgs.content;
     if (typeof content !== "string") {
@@ -8577,8 +8972,264 @@ function applyCesarSelfTurnApproval(tool, args, toolCtx, config) {
   return { approve: true, reason: `bounded ${t} on previously read file (${diffTokens} tokens)`, tool: t, path: filePath, diffTokens };
 }
 
+// src/generated/cesar/approval-diff.ts
+import { existsSync as existsSync11, readFileSync as readFileSync11, statSync as statSync4 } from "fs";
+var APPROVAL_DIFF_MAX_LINES_PER_FILE = 8;
+var APPROVAL_DIFF_MAX_TOTAL_LINES = 24;
+var APPROVAL_DIFF_MAX_FILE_BYTES = 262144;
+var APPROVAL_DIFF_MAX_CONTENT_CHARS = 262144;
+function approvalToolIsFileMutating(tool) {
+  const key = String(tool ?? "").toLowerCase();
+  return key === "edit" || key === "write" || key === "agonedit" || key === "agonwrite" || key === "multiedit" || key === "agonmultiedit";
+}
+function isProbablyBinary(text) {
+  const sample = text.slice(0, 8192);
+  return sample.indexOf("\0") !== -1;
+}
+function normalizeCurlyQuotes(text) {
+  return text.replace(/[\u2018\u2019]/g, "'").replace(/[\u201C\u201D]/g, '"');
+}
+function countOccurrences2(haystack, needle) {
+  if (!needle) return 0;
+  let count = 0;
+  let pos = 0;
+  while (true) {
+    pos = haystack.indexOf(needle, pos);
+    if (pos === -1) break;
+    count++;
+    pos += needle.length;
+  }
+  return count;
+}
+function buildApprovalDiffPreview(tool, args) {
+  const key = String(tool ?? "").toLowerCase();
+  const filePath = typeof args?.file_path === "string" ? String(args.file_path) : "";
+  if (!filePath) return null;
+  const cwd = process.cwd();
+  const relPath = filePath.startsWith(cwd) ? filePath.slice(cwd.length).replace(/^[/\\]/, "") : filePath;
+  let oldContent = "";
+  let newContent = "";
+  let status = "edited";
+  if (key === "write" || key === "agonwrite") {
+    if (typeof args?.content !== "string") return null;
+    newContent = String(args.content);
+    const exists = existsSync11(filePath);
+    if (!exists) {
+      status = "created";
+      oldContent = "";
+    } else {
+      status = "edited";
+      try {
+        const st = statSync4(filePath);
+        if (st.size > APPROVAL_DIFF_MAX_FILE_BYTES) {
+          return { fallback: `file is ${Math.round(st.size / 1024)}KB \u2014 diff hidden` };
+        }
+        oldContent = readFileSync11(filePath, "utf-8");
+      } catch {
+        oldContent = "";
+      }
+    }
+    if (newContent.length > APPROVAL_DIFF_MAX_CONTENT_CHARS) {
+      return { fallback: `new content is ${Math.round(newContent.length / 1024)}KB \u2014 diff hidden` };
+    }
+  } else if (key === "edit" || key === "agonedit") {
+    const oldStr = typeof args?.old_string === "string" ? String(args.old_string) : "";
+    const newStr = typeof args?.new_string === "string" ? String(args.new_string) : "";
+    const replaceAll = args?.replace_all === true;
+    if (oldStr === "") return { fallback: "empty old_string \u2014 edit will fail" };
+    if (!existsSync11(filePath)) return null;
+    try {
+      const st = statSync4(filePath);
+      if (st.size > APPROVAL_DIFF_MAX_FILE_BYTES) {
+        return { fallback: `file is ${Math.round(st.size / 1024)}KB \u2014 diff hidden` };
+      }
+      oldContent = readFileSync11(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+    let searchStr = oldStr;
+    let baseContent = oldContent;
+    if (oldStr && !baseContent.includes(searchStr)) {
+      const normContent = normalizeCurlyQuotes(baseContent);
+      const normSearch = normalizeCurlyQuotes(oldStr);
+      if (normContent.includes(normSearch)) {
+        baseContent = normContent;
+        searchStr = normSearch;
+      } else {
+        return null;
+      }
+    }
+    if (searchStr && !replaceAll) {
+      const occurrences = countOccurrences2(baseContent, searchStr);
+      if (occurrences > 1) {
+        return { fallback: `old_string matches ${occurrences} locations \u2014 edit will fail` };
+      }
+    }
+    oldContent = baseContent;
+    newContent = searchStr ? replaceAll ? baseContent.split(searchStr).join(newStr) : baseContent.replace(searchStr, newStr) : baseContent;
+  } else if (key === "multiedit" || key === "agonmultiedit") {
+    const edits = Array.isArray(args?.edits) ? args.edits : null;
+    if (!edits || edits.length === 0) return null;
+    if (!existsSync11(filePath)) return null;
+    try {
+      const st = statSync4(filePath);
+      if (st.size > APPROVAL_DIFF_MAX_FILE_BYTES) {
+        return { fallback: `file is ${Math.round(st.size / 1024)}KB \u2014 diff hidden` };
+      }
+      oldContent = readFileSync11(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+    let working = oldContent;
+    let failed = false;
+    for (let i = 0; i < edits.length; i++) {
+      const e = edits[i] ?? {};
+      const oldStr2 = typeof e.old_string === "string" ? e.old_string : "";
+      const newStr2 = typeof e.new_string === "string" ? e.new_string : "";
+      const replaceAll2 = e.replace_all === true;
+      if (oldStr2 === "") {
+        failed = true;
+        break;
+      }
+      let search2 = oldStr2;
+      let base2 = working;
+      if (!base2.includes(search2)) {
+        const nb = normalizeCurlyQuotes(base2);
+        const ns = normalizeCurlyQuotes(oldStr2);
+        if (nb.includes(ns)) {
+          base2 = nb;
+          search2 = ns;
+        } else {
+          failed = true;
+          break;
+        }
+      }
+      if (!replaceAll2 && countOccurrences2(base2, search2) > 1) {
+        failed = true;
+        break;
+      }
+      working = replaceAll2 ? base2.split(search2).join(newStr2) : base2.replace(search2, newStr2);
+    }
+    if (failed) return { fallback: "one or more edits will not apply \u2014 see prompt" };
+    status = "edited";
+    newContent = working;
+  } else {
+    return null;
+  }
+  if (isProbablyBinary(oldContent) || isProbablyBinary(newContent)) {
+    return { fallback: "binary file \u2014 diff hidden" };
+  }
+  if (oldContent === newContent) {
+    return null;
+  }
+  const file = computeFileDiffPreview(
+    filePath,
+    relPath,
+    status,
+    oldContent,
+    newContent,
+    APPROVAL_DIFF_MAX_LINES_PER_FILE,
+    APPROVAL_DIFF_MAX_TOTAL_LINES
+  );
+  if (!file) return null;
+  return { files: [file], totalFiles: 1 };
+}
+function computeFileDiffPreview(path, relPath, status, oldContent, newContent, maxLines, maxTotal) {
+  const oldAll = oldContent.length === 0 ? [] : oldContent.replace(/\n$/, "").split("\n");
+  const newAll = newContent.length === 0 ? [] : newContent.replace(/\n$/, "").split("\n");
+  const APPROVAL_DIFF_MAX_LCS_LINES = 1200;
+  let pre = 0;
+  const oldLenAll = oldAll.length;
+  const newLenAll = newAll.length;
+  while (pre < oldLenAll && pre < newLenAll && oldAll[pre] === newAll[pre]) pre++;
+  let suf = 0;
+  while (suf < oldLenAll - pre && suf < newLenAll - pre && oldAll[oldLenAll - 1 - suf] === newAll[newLenAll - 1 - suf]) suf++;
+  const oldLines = oldAll.slice(pre, oldLenAll - suf);
+  const newLines = newAll.slice(pre, newLenAll - suf);
+  const n = oldLines.length;
+  const m = newLines.length;
+  if (n + m > APPROVAL_DIFF_MAX_LCS_LINES) {
+    const addCount = m;
+    const delCount = n;
+    return {
+      path,
+      relPath,
+      status,
+      additions: addCount,
+      deletions: delCount,
+      lines: [`@@ +${addCount}/-${delCount} lines \u2014 diff too large to preview @@`],
+      omitted: addCount + delCount
+    };
+  }
+  const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      lcs[i2][j2] = oldLines[i2] === newLines[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+    }
+  }
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (oldLines[i] === newLines[j]) {
+      ops.push({ kind: " ", text: oldLines[i] });
+      i++;
+      j++;
+    } else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+      ops.push({ kind: "-", text: oldLines[i] });
+      i++;
+    } else {
+      ops.push({ kind: "+", text: newLines[j] });
+      j++;
+    }
+  }
+  while (i < n) {
+    ops.push({ kind: "-", text: oldLines[i] });
+    i++;
+  }
+  while (j < m) {
+    ops.push({ kind: "+", text: newLines[j] });
+    j++;
+  }
+  let additions = 0;
+  let deletions = 0;
+  for (const op of ops) {
+    if (op.kind === "+") additions++;
+    else if (op.kind === "-") deletions++;
+  }
+  if (additions === 0 && deletions === 0) return null;
+  const perFileCap = Math.max(1, Math.min(maxLines, maxTotal));
+  const visibleLines = [];
+  let interesting = 0;
+  for (const op of ops) {
+    if (op.kind === " ") continue;
+    interesting++;
+    if (visibleLines.length < perFileCap) {
+      visibleLines.push(`${op.kind}${truncateDiffLine(op.text, 120)}`);
+    }
+  }
+  const omitted = Math.max(0, interesting - visibleLines.length);
+  const headerLine = `@@ ${status === "created" ? "new file" : `-${deletions} +${additions}`} @@`;
+  return {
+    path,
+    relPath,
+    status,
+    additions,
+    deletions,
+    lines: [headerLine, ...visibleLines],
+    omitted
+  };
+}
+function truncateDiffLine(line, max) {
+  const text = String(line ?? "").replace(/\t/g, "  ");
+  if (text.length <= max) {
+    return text;
+  }
+  return text.slice(0, Math.max(0, max - 1)) + "\u2026";
+}
+
 // src/generated/cesar/tool-observability.ts
-import { appendFileSync, mkdirSync as mkdirSync10, existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
+import { appendFileSync, mkdirSync as mkdirSync10, existsSync as existsSync12, readFileSync as readFileSync12 } from "fs";
 import { join as join11 } from "path";
 function createCesarTurnId() {
   return `cesar-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
@@ -8726,11 +9377,11 @@ function recordCesarConfidence(record) {
   }
 }
 function readJsonlRecords(filePath) {
-  if (!existsSync11(filePath)) {
+  if (!existsSync12(filePath)) {
     return [];
   }
   const out = [];
-  const text = readFileSync11(filePath, "utf-8");
+  const text = readFileSync12(filePath, "utf-8");
   for (const line of text.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) {
@@ -8957,8 +9608,15 @@ RULE 4b \u2014 MODE PURPOSE (don't mix them up \u2014 and don't always default t
   Your code will be auto-reviewed after implementation \u2014 write carefully the first time.
 RULE 4c \u2014 REVIEW: Use Review(target?, engine?, engines?) to delegate read-only code review. Default target is "uncommitted". Targets: "uncommitted", "branch:NAME", "commit:SHA". Specify engine ONLY when the user explicitly names one via "with <engine>"; if they name multiple reviewers, specify engines:["codex","claude"] or the named set and Agon will run them in parallel. Otherwise choose two diverse engines for high-stakes reviews or omit engine/engines and let Agon auto-select. If the user asks to review AND fix, do NOT stop at Review; call Pipeline(task, fitnessCmd?, engines?) so the findings are fixed immediately through Agon's agent harness.
 RULE 5 \u2014 WORKSPACE: Use Read for files. Use Grep for search. NEVER use cat/head/tail/grep via Bash. For shell commands use AgonBash (MCP tool), for edits use AgonEdit, for new files use AgonWrite. The user will see a Y/N/Always prompt for write operations. If they choose "Always", that command is auto-approved going forward. When the user says "commit", call AgonBash with the git commands. Don't say "I can't" or "I need permission" \u2014 call the tool and the permission system handles it.
+RULE 5b \u2014 DURABLE MEMORY: Call SaveMemory(memory, section) to record a fact that should survive into FUTURE sessions \u2014 and ONLY for that. section is one of Decisions / Constraints / Conventions / Session Notes. Use it when a real, durable fact is established: an architectural decision ("we chose session tokens over JWT"), a hard constraint ("Node 20 floor", "no top-level await"), or a project convention ("commits use conventional format"). Do NOT save transient/session state, the current TODO, things obvious from the code, or speculation \u2014 that is noise next session. One fact per call, no date (it is added automatically); the user confirms each memory. Saved memory comes back as a [PROJECT MEMORY] block at the top of your context in later sessions, so don't re-save what is already there.
 RULE 6 \u2014 AFTER DELEGATION: After calling Forge/Brainstorm/Tribunal/Campfire/Pipeline/Review/Agent, STOP. Do not continue responding. The orchestrator handles the rest. After calling Delegate, WAIT for the result \u2014 do NOT stop. Incorporate the delegated result into your response.
 RULE 7 \u2014 NO NARRATION: NEVER narrate your research process. Do not write "Reading the file...", "I'm checking...", "Let me look at...", "I've confirmed...". The user sees your text output \u2014 if you narrate exploration it looks like you have no clue. Instead: call tools SILENTLY, then speak ONLY when you have the answer or decision. Your visible output should be conclusions, answers, and actions \u2014 never a play-by-play of your investigation. If you need to read files or search code, call Read/Grep/Glob directly without announcing it.
+RULE 7b \u2014 LIVE TODO CHECKLIST (the sanctioned exception to RULE 7): For multi-step work \u2014 more than 2 distinct steps \u2014 pin a live checklist so the user can watch progress without you narrating it. Emit a [TODOS] block: one JSON array, each item {"id","text","state"} where state is pending|running|done|failed. It is INVISIBLE to the user (the runtime strips it and renders a pinned checklist instead) \u2014 never describe it in prose. Re-emit the WHOLE block (latest snapshot) whenever a step's state changes \u2014 typically right after a tool finishes \u2014 so items tick from running to done as you work. OPTIONAL: skip it for single-step or chat turns. Example for "refactor the parser and add a test":
+  [TODOS]
+  [{"id":"1","text":"Read the parser module","state":"done"},{"id":"2","text":"Refactor the parse loop","state":"running"},{"id":"3","text":"Add a unit test","state":"pending"}]
+  [/TODOS]
+Keep texts short (\u22646 words). Do NOT use [TODOS] in plan mode \u2014 there ProposePlan owns the checklist.
+RULE 7c \u2014 INTENT PREAMBLE (the second sanctioned exception to RULE 7): Before multi-step work, you MAY open your response with ONE short intent line as the VERY FIRST line: [INTENT] <one line>. It is INVISIBLE prose to the user (the runtime strips it and renders a distinct dim line BEFORE your tool work) \u2014 never describe it. Only at the start of the response counts; keep it to one line, e.g. [INTENT] Tracing the dispatch path before changing timeouts. OPTIONAL: skip it for single-step or chat turns.
 
 RULE 8 \u2014 AUTONOMOUS PLANS: Plan mode is optional, not the default. Stay live unless staged execution is genuinely useful. Switch to planning when the task needs multiple dependent steps, expensive orchestration, resumability, explicit approval, or cost visibility. When you call ProposePlan, decide whether to set autoApprove=true. Set it ONLY when (a) the user clearly described a multi-stage workflow ("plan it, build it, review it"; "investigate then forge it"; "do the whole thing autonomously") AND (b) you have HIGH confidence in the steps after investigation (not before). The runtime applies a layered policy and may still ask the user \u2014 your autoApprove=true is permission, not a guarantee. Default to autoApprove=false (or omit it) whenever you are uncertain or when the plan touches mutating steps and the user did not explicitly invite autonomous execution. selfReview defaults to true for mutating plans \u2014 only set selfReview=false for purely advisory plans (brainstorm/tribunal/research only) where a code-review gate would have nothing to review.
 RULE 8b \u2014 AUTONOMOUS BUILD TOOLS (Goal / Conquer): These run a build to completion in the BACKGROUND. Goal(intent, queue?, gate?) drives a finite, machine-verifiable task QUEUE (forge \u2192 witness \u2192 review \u2192 commit per task on a goal/* branch). Conquer(task, gate, builder?, engines?) is for an OPEN-ENDED build you'd otherwise babysit: it drives an external builder CLI as the user (builder defaults to codex \u2014 pass builder:"codex" / "claude" / "agy") unattended until the gate passes, convening nero/tribunal/council on forks, then STOPS at a human merge gate (NEVER auto-merges). Fire EITHER ONLY when the user explicitly asks to build it unattended ("conquer this with codex", "build it autonomously") \u2014 NEVER on a vague request; both are long, real-spend, multi-hour runs. Conquer REQUIRES a discriminating gate (the done-spec, e.g. gate:"pnpm test"); if the user did not give one, ASK for the command that proves the build is done before calling. After calling either, STOP and wait \u2014 the background job and the merge gate handle the rest.
@@ -8976,7 +9634,12 @@ RULE 10 \u2014 TURN CLOSURE: End every turn with one clear closing line so the u
 
   FORBIDDEN closure shapes: "Standing by \u2014 awaiting your call on: 1. Commit? 2. Tests? 3. Both?" \u2014 that reads as still-thinking, not a closure. "Or move on to something else." trailing line \u2014 that's filler. A menu of next-steps you could simply do yourself \u2014 that is not a genuine fork. Stopping after only a recap with no done/asking/fork line \u2014 forbidden, always.
 
-  CONFIDENCE REFRESH: If your confidence changed materially during the turn (e.g. started at 40% "need to verify" and verified successfully \u2192 real confidence is now 95%), call ReportConfidence again with the new number BEFORE the closing line. Stale initial confidence in the recap misleads the user about what state you're in.`;
+  LEAD WITH FINDINGS: Your FIRST sentence answers what happened or what you found \u2014 the conclusion, not the preamble. Supporting detail comes after. Use prose for a simple answer; reach for bullets only when the content is genuinely a list. No filler openers ("Great question", "Let me explain", "Sure!"). Don't bury the lede under a recap of what you did.
+    GOOD: "The leak is in brain.kern \u2014 the drain timer never clears on early return. Added the cleanup at line 793; typecheck green."
+    BAD: "Great question! So I went and looked into this. There are a few things going on here. First, let me walk through the architecture. The session has a drain timer..."
+
+  CONFIDENCE REFRESH: If your confidence changed materially during the turn (e.g. started at 40% "need to verify" and verified successfully \u2192 real confidence is now 95%), call ReportConfidence again with the new number BEFORE the closing line. Stale initial confidence in the recap misleads the user about what state you're in.
+  If you END the turn still below ~85%, write CONFIDENCE: NN% once near your closing line \u2014 the UI uses that exact shape to offer the user an escalation (nero/tribunal).`;
 function buildCesarSystemPrompt(ctx) {
   const config = ctx.config;
   const cesarCwd = resolveWorkingDir();
@@ -9008,6 +9671,18 @@ MODES vs ENGINES: the names above are ENGINES \u2014 runnable backends you deleg
     systemParts.push(`## OPERATING MODE
 Exploration mode is ON. Stay read-only: inspect files, search, and use read-only shell commands only. Do not call Edit or Write. Do not run non-read-only Bash commands.`);
   }
+  const commitCoAuthor = (config.commitCoAuthor || "").replace(/[`\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+  if (commitCoAuthor) {
+    systemParts.push(`COMMIT ATTRIBUTION: When you create a git commit yourself via Bash, end the commit message with a trailer line \`Co-Authored-By: ${commitCoAuthor}\`. This attribution is configurable (config.commitCoAuthor) and is ON by default.
+- If the user asks to REMOVE/DISABLE the commit logo/attribution, first ask whether to disable it for THIS PROJECT or MACHINE-WIDE, then disable it: machine-wide, run \`agon config set commitCoAuthor ""\` (writes ~/.agon/config.json); per-project, safely edit ./.agon.json with your file tools (read the JSON if it exists, set/merge the key \`"commitCoAuthor": ""\`, write it back \u2014 never clobber other keys). Confirm once done.
+- If the user asks to CHANGE the identity instead, set the new value the same way (\`agon config set commitCoAuthor "<value>"\` machine-wide, or merge it into ./.agon.json per-project).`);
+  }
+  try {
+    const projectMemory = buildProjectMemoryBlock(cesarCwd);
+    if (projectMemory) systemParts.push(projectMemory);
+  } catch (err) {
+    console.warn(`[agon] project memory block skipped: ${err instanceof Error ? err.message : String(err)}`);
+  }
   if (ctx.cesarMemory) {
     const memoryCtx = ctx.cesarMemory.toPromptContext();
     if (memoryCtx) systemParts.push(memoryCtx);
@@ -9034,14 +9709,14 @@ ${fragments.join("\n")}`);
     } else {
       const stats = tracker.getStats();
       let budgetWarning = "";
-      if (stats.totalCostUsd > 0.5) {
+      if (stats.meteredCostUsd > 0.5) {
         budgetWarning = `
 
-URGENT: Planning has spent $${stats.totalCostUsd.toFixed(2)}. Stop investigating and decide NOW \u2014 call ProposePlan or ExitPlanMode.`;
-      } else if (stats.totalCostUsd > 0.25) {
+URGENT: Planning has spent $${stats.meteredCostUsd.toFixed(2)}. Stop investigating and decide NOW \u2014 call ProposePlan or ExitPlanMode.`;
+      } else if (stats.meteredCostUsd > 0.25) {
         budgetWarning = `
 
-WARNING: Planning has spent $${stats.totalCostUsd.toFixed(2)}. Wrap up and decide \u2014 call ProposePlan or ExitPlanMode.`;
+WARNING: Planning has spent $${stats.meteredCostUsd.toFixed(2)}. Wrap up and decide \u2014 call ProposePlan or ExitPlanMode.`;
       }
       systemParts.push(`RULE 9 \u2014 PLAN MODE: You are in PLAN MODE because the user asked for planning, so proposing a plan is usually the right call here. But you are NEVER trapped and never forced: if you decide a plan is not the right approach \u2014 the task is simple enough to do live, or planning is blocking progress \u2014 call ExitPlanMode with a one-line reason and work live instead. You decide.
 
@@ -9147,6 +9822,16 @@ function capSnapshotMessageContent(content) {
   return `${content.slice(0, CESAR_SNAPSHOT_MSG_CHAR_CAP)}
 \u2026 [${content.length - CESAR_SNAPSHOT_MSG_CHAR_CAP} chars truncated for Cesar context]`;
 }
+function renderToolPermissionCommand(tool, args) {
+  const a = args && typeof args === "object" ? args : {};
+  if (tool === "SaveMemory") {
+    return `[${String(a.section ?? "")}] ${String(a.memory ?? "")}`.trim();
+  }
+  if (tool === "MultiEdit") {
+    return JSON.stringify(args ?? {});
+  }
+  return String(a.command ?? a.file_path ?? JSON.stringify(args ?? {}));
+}
 function buildCesarConversationSnapshot(session, chatSession) {
   const directHistory = session?.getMessageHistory?.() ?? [];
   if (directHistory.length > 0) {
@@ -9197,12 +9882,20 @@ function buildOnToolCall(ctx, toolRegistry, config) {
     allowedCommands: config.allowedCommands ?? [],
     toolPermissions: config.toolPermissions ?? {},
     sessionAllowList: getSessionAllowList(),
-    source: "orchestrator"
+    source: "orchestrator",
+    // CC-parity allow/deny rules reach the API tool-execution path here:
+    // executeToolCall → handler.checkPermission consults ctx.permissionRules
+    // (deny-first, before any mode-based auto-allow). Without this, a
+    // Bash(rm:*) deny rule never fires for API engines under 'smart' mode.
+    permissionRules: parsePermissionRuleSet(config.permissions),
+    // CC-parity PreToolUse/PostToolUse hooks reach the API tool-execution
+    // path here: executeToolCall fires them around handler.execute.
+    toolHooks: parseToolHooks(config.hooks)
   };
   return async (name, args, callId) => {
     const activePlan = ctx.activePlan;
     if (activePlan && ["planning", "awaiting_approval"].includes(activePlan.state)) {
-      const BLOCKED_IN_PLAN = ["Forge", "Pipeline", "Agent", "Goal", "Edit", "Write"];
+      const BLOCKED_IN_PLAN = ["Forge", "Pipeline", "Agent", "Goal", "Edit", "Write", "MultiEdit"];
       if (BLOCKED_IN_PLAN.includes(name)) {
         return `[BLOCKED] Tool "${name}" is not available in plan mode. Use ProposePlan to propose your execution strategy.`;
       }
@@ -9269,7 +9962,7 @@ ${cleaned}`;
       }
     }
     if (name === "ExitPlanMode") {
-      const { handleExitPlanMode } = await import("./plan-mode-5IQ2SKIS.js");
+      const { handleExitPlanMode } = await import("./plan-mode-I3BZOBFB.js");
       return "[DELEGATION_BREAK] " + handleExitPlanMode(String(args.reason ?? ""), ctx.cesar?.planDispatch ?? null, ctx);
     }
     if (name === "ProposePlan") {
@@ -9292,7 +9985,7 @@ ${cleaned}`;
           }
         }
       }
-      const { handleProposePlan } = await import("./plan-mode-5IQ2SKIS.js");
+      const { handleProposePlan } = await import("./plan-mode-I3BZOBFB.js");
       const dispatch = ctx.cesar.planDispatch;
       if (!dispatch) {
         return "[PLAN_ERROR] Internal plan display dispatch unavailable. Retry the plan request so Agon can render the approval panel.";
@@ -9358,8 +10051,15 @@ ${cleaned}`;
         return new Promise((resolve4) => {
           const d = ctx.cesar.lastDispatch;
           if (d) {
-            const cmd = args.command ?? args.file_path ?? JSON.stringify(args);
-            d({ type: "permission-ask", tool, command: cmd, reason: message, resolve: resolve4 });
+            const cmd = renderToolPermissionCommand(tool, args);
+            let permDiffPreview = void 0;
+            if (approvalToolIsFileMutating(tool)) {
+              try {
+                permDiffPreview = buildApprovalDiffPreview(String(tool), args);
+              } catch {
+              }
+            }
+            d({ type: "permission-ask", tool, command: cmd, reason: message, diffPreview: permDiffPreview && Array.isArray(permDiffPreview.files) ? permDiffPreview : void 0, fallbackNote: permDiffPreview && typeof permDiffPreview.fallback === "string" ? permDiffPreview.fallback : void 0, resolve: resolve4 });
           } else {
             resolve4(true);
           }
@@ -9367,11 +10067,15 @@ ${cleaned}`;
       }
     );
     let output = result.result.ok ? result.result.content : result.result.error ?? "Tool execution failed";
-    if (!result.result.ok) {
+    const isPermissionDenial = !result.result.ok && typeof result.result.error === "string" && (result.result.error.includes(PERMISSION_DENIED_MESSAGE) || result.result.error.includes("User denied permission") || result.result.error.startsWith("DENIED:"));
+    if (!result.result.ok && !isPermissionDenial) {
       const diag = buildToolErrorDiagnostic(name, args, result.result.error);
       const retryKey = `${name}:${JSON.stringify(args)}`;
       const used = nativeToolErrorRetries.get(retryKey) ?? 0;
-      if (used <= 0) {
+      const isPermissionDenial2 = typeof result.result.error === "string" && result.result.error.includes(PERMISSION_DENIED_MESSAGE);
+      if (isPermissionDenial2) {
+        output = result.result.error;
+      } else if (used <= 0) {
         nativeToolErrorRetries.set(retryKey, 1);
         output = `[RETRYABLE_TOOL_ERROR] ${diag}
 Retry this ${name} call ONCE with corrected input that matches the tool's schema. Do not narrate before retrying.`;
@@ -9384,7 +10088,7 @@ Repair retry already used for this exact ${name} input in this turn. Stop retryi
     }
     if (CACHEABLE_TOOLS.has(name)) {
       toolResultCache.set(cacheKey, output);
-    } else if (["Edit", "Write", "Bash"].includes(name)) {
+    } else if (["Edit", "Write", "MultiEdit", "Bash"].includes(name)) {
       toolResultCache.clear();
       ctx.cesar.blockedOnConfidence = null;
     }
@@ -9408,9 +10112,12 @@ function buildOnApproval(ctx, engineId) {
     const perms = cfg.toolPermissions ?? {};
     const allowed = cfg.allowedCommands ?? [];
     const mode = cfg.permissionMode ?? "ask";
-    const toolMap = { shell: "Bash", bash: "Bash", edit: "Edit", write: "Write", read: "Read", grep: "Grep", glob: "Glob" };
+    const toolMap = { shell: "Bash", bash: "Bash", edit: "Edit", write: "Write", multiedit: "MultiEdit", read: "Read", grep: "Grep", glob: "Glob" };
     const agonTool = toolMap[tool.toLowerCase()] ?? tool;
     const perm = perms[agonTool];
+    const ruleSet = parsePermissionRuleSet(cfg.permissions);
+    const ruleArg = agonTool === "Bash" ? command : String(approvalArgsFromCommand(agonTool, command)?.file_path ?? "");
+    const ruleDecision = evaluateToolRules(agonTool, ruleArg, resolveWorkingDir(), ruleSet);
     const turnId = ctx.cesar?.turnId;
     const cwd = resolveWorkingDir();
     const logApproval = (decision, source, reason, args) => {
@@ -9445,7 +10152,7 @@ function buildOnApproval(ctx, engineId) {
       }
     };
     if (ctx.explorationMode) {
-      const WRITE_TOOLS = ["Edit", "Write", "Bash"];
+      const WRITE_TOOLS = ["Edit", "Write", "MultiEdit", "Bash"];
       if (WRITE_TOOLS.includes(agonTool)) {
         logApproval("blocked", "policy.exploration", "exploration mode is read-only");
         return "BLOCKED: Exploration mode is read-only. Use Read, Grep, Glob tools only. Do not narrate around this. Either keep investigating, or wait for the user to disable exploration mode before retrying the same tool.";
@@ -9461,7 +10168,7 @@ function buildOnApproval(ctx, engineId) {
         logApproval("blocked", "policy.plan-mode", "plan mode blocks mutating Bash");
         return "BLOCKED: Plan mode \u2014 mutating Bash is not allowed before approval. Use Read/Grep/Glob or read-only Bash for investigation, call ProposePlan, then wait for the user to type go/yes before retrying this command.";
       }
-      const WRITE_TOOLS = ["Edit", "Write"];
+      const WRITE_TOOLS = ["Edit", "Write", "MultiEdit"];
       if (WRITE_TOOLS.includes(agonTool)) {
         logApproval("blocked", "policy.plan-mode", "plan mode blocks file writes");
         return "BLOCKED: Plan mode \u2014 no code changes allowed. Call ProposePlan with the execution plan now, then wait for approval before retrying the same tool. Do not narrate instead of acting.";
@@ -9487,7 +10194,7 @@ function buildOnApproval(ctx, engineId) {
       }
     }
     if (!ctx.cesar.confidenceSatisfied) {
-      const WRITE_TOOLS = ["Edit", "Write"];
+      const WRITE_TOOLS = ["Edit", "Write", "MultiEdit"];
       if (WRITE_TOOLS.includes(agonTool)) {
         const blocks = (ctx.cesar.confidenceBlockCount ?? 0) + 1;
         ctx.cesar.confidenceBlockCount = blocks;
@@ -9500,11 +10207,19 @@ function buildOnApproval(ctx, engineId) {
         ctx.cesar.blockedOnConfidence = null;
       }
     }
+    if (ruleDecision === "deny") {
+      logApproval("denied", "settings.permissions", `${agonTool} denied by permissions rule`);
+      return `DENIED: ${agonTool}${agonTool === "Bash" ? ` (${command})` : ""} is blocked by a deny rule in .agon.json permissions. Do not retry this \u2014 choose a different approach or ask the user to amend the rule.`;
+    }
     if (perm === "deny" || mode === "deny-all") {
       logApproval("denied", perm === "deny" ? "settings.toolPermissions" : "settings.permissionMode", perm === "deny" ? `${agonTool} denied in settings` : "permissionMode=deny-all");
       return false;
     }
-    if (agonTool === "Edit" || agonTool === "Write") {
+    if (ruleDecision === "allow") {
+      logApproval("approved", "settings.permissions", `${agonTool} allowed by permissions rule`);
+      return true;
+    }
+    if (agonTool === "Edit" || agonTool === "Write" || agonTool === "MultiEdit") {
       const approvalCwd = resolveWorkingDir();
       const approvalCache = getProjectFileStateCache(approvalCwd);
       const approvalArgs = approvalArgsFromCommand(agonTool, command);
@@ -9552,7 +10267,14 @@ function buildOnApproval(ctx, engineId) {
       const dispatch = ctx.cesar.lastDispatch;
       if (dispatch) {
         logApproval("prompted", "user-prompt", `Cesar (${engineId}) wants to execute`);
-        dispatch({ type: "permission-ask", tool: agonTool, command, reason: `Cesar (${engineId}) wants to execute`, resolve: (approved) => {
+        let permDiffPreview = void 0;
+        if (approvalToolIsFileMutating(agonTool)) {
+          try {
+            permDiffPreview = buildApprovalDiffPreview(agonTool, approvalArgsFromCommand(agonTool, command));
+          } catch {
+          }
+        }
+        dispatch({ type: "permission-ask", tool: agonTool, command, reason: `Cesar (${engineId}) wants to execute`, diffPreview: permDiffPreview && Array.isArray(permDiffPreview.files) ? permDiffPreview : void 0, fallbackNote: permDiffPreview && typeof permDiffPreview.fallback === "string" ? permDiffPreview.fallback : void 0, resolve: (approved) => {
           const wasApproved = typeof approved === "string" ? approved === "y" || approved === "a" : !!approved;
           logApproval(wasApproved ? "approved" : "denied", "user-prompt", wasApproved ? "user approved" : "user denied");
           resolve4(wasApproved);
@@ -9596,7 +10318,7 @@ function loadCesarMcpServers(config, cwd) {
   const resolvedPath = isAbsolute2(rawPath) ? rawPath : resolve3(cwd, rawPath);
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync12(resolvedPath, "utf-8"));
+    parsed = JSON.parse(readFileSync13(resolvedPath, "utf-8"));
   } catch (err) {
     throw new Error(`Failed to load Cesar MCP config at ${resolvedPath}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -9620,7 +10342,7 @@ function mcpConfigFingerprint(config) {
   if (enabled && configPath) {
     try {
       const resolvedPath = isAbsolute2(configPath) ? configPath : resolve3(resolveWorkingDir(), configPath);
-      mtime = String(statSync4(resolvedPath).mtimeMs);
+      mtime = String(statSync5(resolvedPath).mtimeMs);
     } catch {
     }
   }
@@ -9631,17 +10353,17 @@ function resolveAgonMcpServerPath(fromUrl) {
   const raw = fromUrl ?? import.meta.url;
   const url = raw.startsWith("file:") ? raw : pathToFileURL(raw).href;
   const bundledSibling = join12(dirname5(fileURLToPath(url)), "mcp", "index.js");
-  if (existsSync12(bundledSibling)) return bundledSibling;
+  if (existsSync13(bundledSibling)) return bundledSibling;
   try {
     const req = createRequire(url);
     const resolved = req.resolve("@kernlang/agon-mcp");
-    if (existsSync12(resolved)) return resolved;
+    if (existsSync13(resolved)) return resolved;
   } catch {
   }
   let dir = dirname5(fileURLToPath(url));
   for (let i = 0; i < 12; i++) {
     const cand = join12(dir, "packages", "mcp", "dist", "index.js");
-    if (existsSync12(cand)) return cand;
+    if (existsSync13(cand)) return cand;
     const parent = dirname5(dir);
     if (parent === dir) break;
     dir = parent;
@@ -9760,7 +10482,7 @@ async function ensureCesarSession(ctx) {
     mkdirSync11(signalDir, { recursive: true });
     const sessionSignalId = `cesar-${Date.now()}`;
     const mcpServerPath = resolveAgonMcpServerPath();
-    if (!existsSync12(mcpServerPath)) {
+    if (!existsSync13(mcpServerPath)) {
       console.error(`[agon] cesar: agon-orchestration MCP server not found at ${mcpServerPath} \u2014 orchestration tools (Forge/Tribunal/AgonBash/DeliverAnswer) will be UNAVAILABLE and Cesar will fall back to slow scraping.`);
     }
     const mcpEnv = { AGON_SIGNAL_DIR: signalDir, AGON_SESSION_ID: sessionSignalId };
@@ -9811,9 +10533,177 @@ async function ensureCesarSession(ctx) {
   await session.start();
   ctx.setCesarSession(session);
   ctx.cesar.mcpFingerprint = currentMcpFp;
+  ctx.cesar.budgetWarned = false;
   return session;
 }
 
+// src/generated/cesar/context-budget.ts
+var TOOL_PROMPT_OVERHEAD_TOKENS = 2500;
+function estimateBrainTokens(ctx, session, backend, budget, pendingInput) {
+  if (backend === "api" && session && typeof session.getContextUsage === "function") {
+    try {
+      const live = session.getContextUsage();
+      if (live && Number.isFinite(live.tokens) && live.tokens > 0 && live.source !== "estimate") {
+        const pendingTokens = pendingInput ? estimateSessionTokens({ messageHistory: [{ role: "user", content: pendingInput }] }, budget) : 0;
+        return live.tokens + pendingTokens;
+      }
+    } catch {
+    }
+  }
+  if (backend === "api" && session && typeof session.getMessageHistory === "function") {
+    try {
+      const history = session.getMessageHistory() ?? [];
+      if (Array.isArray(history) && history.length > 0) {
+        const withPending = pendingInput ? [...history, { role: "user", content: pendingInput }] : history;
+        return estimateSessionTokens({ messageHistory: withPending }, budget);
+      }
+    } catch {
+    }
+  }
+  let systemPromptChars = 0;
+  try {
+    systemPromptChars = (buildCesarSystemPrompt(ctx) ?? "").length;
+  } catch {
+  }
+  const chat = ctx.chatSession;
+  let continuityChars = 0;
+  let userTurnsChars = 0;
+  let toolResultsChars = 0;
+  if (chat) {
+    continuityChars += (chat.summary ?? "").length;
+    const msgs = Array.isArray(chat.messages) ? chat.messages : [];
+    for (const m of msgs) {
+      const len = typeof m?.content === "string" ? m.content.length : 0;
+      if (m?.role === "user") userTurnsChars += len;
+      else toolResultsChars += len;
+    }
+  }
+  try {
+    const digest = ctx.cesarMemory?.toPromptContext?.();
+    if (typeof digest === "string") continuityChars += digest.length;
+  } catch {
+  }
+  const base = estimateSessionTokens({
+    pty: {
+      systemPromptChars,
+      userTurnsChars,
+      toolResultsChars,
+      continuityChars,
+      pendingInputChars: (pendingInput ?? "").length
+    }
+  }, budget);
+  return base + TOOL_PROMPT_OVERHEAD_TOKENS;
+}
+async function enforceContextBudget(ctx, session, engine, backend, dispatch, pendingInput) {
+  const budget = engine?.sessionBudget;
+  if (!budget || typeof budget.contextWindow !== "number" || budget.contextWindow <= 0) {
+    return { proceed: true, compacted: false };
+  }
+  let estimated = 0;
+  try {
+    estimated = estimateBrainTokens(ctx, session, backend, budget, pendingInput);
+  } catch {
+    return { proceed: true, compacted: false };
+  }
+  const engineId = engine && typeof engine.id === "string" ? engine.id : "this engine";
+  const check = checkSessionBudget(estimated, budget);
+  const pct = budgetRatioPct(check.ratio);
+  const autoMode = ctx.autoModeQueued === true || ctx.cesar?.autoModeQueued === true;
+  const doCompactReboot = () => {
+    let folded = false;
+    try {
+      if (ctx.chatSession) folded = updateChatSummary(ctx.chatSession);
+    } catch {
+    }
+    try {
+      session?.close?.();
+    } catch {
+    }
+    try {
+      ctx.setCesarSession(null);
+    } catch {
+    }
+    try {
+      ctx.cesarMemory?.clearSession?.();
+    } catch {
+    }
+    return folded;
+  };
+  const live = session && typeof session.getContextUsage === "function" ? session.getContextUsage() : null;
+  const canCompactInPlace = !!(backend === "api" && session && typeof session.compact === "function" && live && Number(live.limit) > 0 && live.source !== "estimate");
+  if (canCompactInPlace) {
+    const limit = Number(live.limit);
+    const warnLimit = Math.floor(limit * 0.7);
+    const softLimit = Math.max(warnLimit + 1, Number.isFinite(Number(live.softLimit)) && Number(live.softLimit) > 0 ? Number(live.softLimit) : Math.floor(limit * 0.85));
+    const hardLimit = Math.floor(limit * 0.95);
+    const pendingTokens = pendingInput ? estimateSessionTokens({ messageHistory: [{ role: "user", content: pendingInput }] }, budget) : 0;
+    const projected = Number(live.tokens) + pendingTokens;
+    const pctOf = (n) => Math.max(0, Math.round(n / limit * 100));
+    if (projected < warnLimit) return { proceed: true, compacted: false };
+    if (projected < softLimit) {
+      if (!autoMode && ctx.cesar && !ctx.cesar.budgetWarned) {
+        ctx.cesar.budgetWarned = true;
+        dispatch({ type: "info", message: `Context at ${pctOf(projected)}% of ${engineId}'s window \u2014 Cesar will auto-compact in place around ${pctOf(softLimit)}%. Run /compact to fold older turns now.` });
+      }
+      return { proceed: true, compacted: false };
+    }
+    let res = null;
+    try {
+      res = await session.compact();
+    } catch {
+      res = null;
+    }
+    if (res && res.ok) {
+      dispatch({ type: "info", message: `Compacted context in place: ${pctOf(res.beforeTokens)}% \u2192 ${pctOf(res.afterTokens)}% of ${engineId}'s window (${res.method === "llm" ? "older turns summarized by the engine" : "older turns folded into a structured summary"}). The session continues.` });
+      dispatch({ type: "context-usage", pct: pctOf(res.afterTokens), used: res.afterTokens, limit, compacted: 1, cached: 0, source: "projected" });
+      if (res.afterTokens + pendingTokens < hardLimit) {
+        return { proceed: true, compacted: true };
+      }
+    }
+    const foldedIp = doCompactReboot();
+    let postEstimateIp = projected;
+    try {
+      postEstimateIp = estimateBrainTokens(ctx, null, backend, budget, pendingInput);
+    } catch {
+    }
+    const postCheckIp = checkSessionBudget(postEstimateIp, budget);
+    if (postCheckIp.level !== "hard-stop") {
+      dispatch({ type: "info", message: `In-place compaction couldn't free enough at ${pctOf(projected)}% \u2014 auto-compacted Cesar context${foldedIp ? " (folded older turns into a summary)" : ""} and rebooted the brain with fresh context. The transcript is preserved.` });
+      return { proceed: true, compacted: true };
+    }
+    dispatch({ type: "error", message: `Cesar context is still at ${budgetRatioPct(postCheckIp.ratio)}% of ${engineId}'s window after compaction \u2014 too full to safely send this turn. Trim the message, or run /clear to reset the session, then resend.` });
+    return { proceed: false, compacted: true };
+  }
+  if (check.level === "ok") {
+    return { proceed: true, compacted: false };
+  }
+  if (check.level === "warn") {
+    if (!autoMode && ctx.cesar && !ctx.cesar.budgetWarned) {
+      ctx.cesar.budgetWarned = true;
+      dispatch({ type: "info", message: `Context at ${pct}% of ${engineId}'s window \u2014 Cesar will auto-compact soon. Run /compact now to fold older turns, or /clear to reset.` });
+    }
+    return { proceed: true, compacted: false };
+  }
+  if (check.level === "compact") {
+    const folded = doCompactReboot();
+    dispatch({ type: "info", message: `Context reached ${pct}% \u2014 auto-compacted Cesar context${folded ? " (folded older turns into a summary)" : ""} and rebooted the brain with fresh context. The transcript is preserved.` });
+    return { proceed: true, compacted: true };
+  }
+  const foldedHs = doCompactReboot();
+  let postEstimate = estimated;
+  try {
+    postEstimate = estimateBrainTokens(ctx, null, backend, budget, pendingInput);
+  } catch {
+  }
+  const postCheck = checkSessionBudget(postEstimate, budget);
+  if (postCheck.level !== "hard-stop") {
+    dispatch({ type: "info", message: `Context hit ${pct}% \u2014 auto-compacted Cesar context${foldedHs ? " (folded older turns into a summary)" : ""} and rebooted the brain (now ~${budgetRatioPct(postCheck.ratio)}%). The transcript is preserved.` });
+    return { proceed: true, compacted: true };
+  }
+  dispatch({ type: "error", message: `Cesar context is still at ${budgetRatioPct(postCheck.ratio)}% of ${engineId}'s window after auto-compaction \u2014 too full to safely send this turn. Trim the message, or run /clear to reset the session, then resend.` });
+  return { proceed: false, compacted: true };
+}
+
 // src/generated/cesar/escalation.ts
 import { join as join13 } from "path";
 import { mkdirSync as mkdirSync12 } from "fs";
@@ -9883,18 +10773,94 @@ async function promptDelegation(action, dispatch, hardened, tribunalMode, team)
   return { approved: answer === "y" };
 }
 
+// src/generated/cesar/steering.ts
+var _queue = [];
+var _activeTurnId = { value: null };
+var _listeners = [];
+function _notify() {
+  const active = _activeTurnId.value;
+  let n = 0;
+  if (active) {
+    for (const entry of _queue) if (entry.turnId === active) n++;
+  }
+  for (const cb of _listeners) {
+    try {
+      cb(n);
+    } catch {
+    }
+  }
+}
+function onSteeringChange(cb) {
+  _listeners.push(cb);
+  return () => {
+    const i = _listeners.indexOf(cb);
+    if (i >= 0) _listeners.splice(i, 1);
+  };
+}
+function markSteeringTurn(turnId) {
+  _activeTurnId.value = turnId;
+  _queue.length = 0;
+  _notify();
+}
+function pushSteering(input, images) {
+  const active = _activeTurnId.value;
+  if (!active) {
+    return false;
+  }
+  _queue.push({ turnId: active, input, images });
+  _notify();
+  return true;
+}
+function drainSteering(turnId) {
+  const mine = [];
+  const rest = [];
+  for (const entry of _queue) {
+    if (entry.turnId === turnId) mine.push({ input: entry.input, images: entry.images });
+    else rest.push(entry);
+  }
+  _queue.length = 0;
+  for (const entry of rest) _queue.push(entry);
+  _notify();
+  return mine;
+}
+function peekSteeringCount() {
+  const active = _activeTurnId.value;
+  if (!active) return 0;
+  let n = 0;
+  for (const entry of _queue) if (entry.turnId === active) n++;
+  return n;
+}
+function releaseSteeringTurn(turnId) {
+  if (_activeTurnId.value === turnId) {
+    _activeTurnId.value = null;
+    _notify();
+  }
+}
+function drainLeftoverSteering() {
+  const all = _queue.map((e) => ({ input: e.input, images: e.images }));
+  _queue.length = 0;
+  _notify();
+  return all;
+}
+function clearSteering() {
+  _queue.length = 0;
+  _activeTurnId.value = null;
+  _notify();
+}
+
 // src/generated/cesar/brain.ts
 async function commitTurnAndDelegate(pendingDel, input, response, cesarEngineId, streaming, dispatch, ctx, telemetry) {
   if (streaming) {
     dispatch({ type: "streaming-end", engineId: cesarEngineId });
   }
   if (!streaming) {
+    dispatch({ type: "streaming-end", engineId: cesarEngineId });
     dispatch({ type: "spinner-stop" });
   }
   await yieldToInk();
   appendMessage(ctx.chatSession, { role: "user", content: input, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   appendMessage(ctx.chatSession, { role: "engine", engineId: cesarEngineId, content: response, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-  tracker.record(cesarEngineId, { prompt: input, response });
+  recordCesarTurn(ctx, cesarEngineId, input, response);
   const delResult = await promptDelegation(pendingDel.action, dispatch, pendingDel.hardened, pendingDel.tribunalMode, pendingDel.team);
   const happened = buildWhatHappenedSummary(telemetry ?? {});
   if (happened) {
@@ -9916,12 +10882,13 @@ async function commitTurnAndSuggest(suggestion, input, response, cesarEngineId,
     dispatch({ type: "streaming-end", engineId: cesarEngineId });
   }
   if (!streaming) {
+    dispatch({ type: "streaming-end", engineId: cesarEngineId });
     dispatch({ type: "spinner-stop" });
   }
   await yieldToInk();
   appendMessage(ctx.chatSession, { role: "user", content: input, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   appendMessage(ctx.chatSession, { role: "engine", engineId: cesarEngineId, content: response, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-  tracker.record(cesarEngineId, { prompt: input, response });
+  recordCesarTurn(ctx, cesarEngineId, input, response);
   if (suggestion.rest) {
     dispatch({ type: "engine-block", engineId: cesarEngineId, color, content: suggestion.rest });
   }
@@ -9958,6 +10925,22 @@ async function handleCesarBrain(input, dispatch, ctx, images) {
   }
   const _toolsUsed = [];
   const _toolUseKeys = /* @__PURE__ */ new Set();
+  const _gate = discoverGate(_turnCwd);
+  if (ctx.cesar) ctx.cesar.discoveredGate = _gate;
+  if (ctx.cesar?.gateNudgedClaim && isGateSkipSignal(input)) ctx.cesar.gateWaived = true;
+  if (ctx.cesar) ctx.cesar.gateNudgedClaim = void 0;
+  let _ranGate = false;
+  const _noteBashForGate = (toolName, rawInput) => {
+    if (_ranGate || !_gate.matchers.length) return;
+    if (!isBashToolName(toolName)) return;
+    let cmd = String(rawInput ?? "");
+    try {
+      const parsed = JSON.parse(cmd);
+      if (parsed && typeof parsed.command === "string") cmd = parsed.command;
+    } catch {
+    }
+    if (bashRanGate(cmd, _gate.matchers)) _ranGate = true;
+  };
   let _toolEventCount = 0;
   let _readToolEventCount = 0;
   let _toolCallTurns = 0;
@@ -9967,6 +10950,7 @@ async function handleCesarBrain(input, dispatch, ctx, images) {
   let _narratedToolStalls = 0;
   let _autoToolExecutions = 0;
   let _confidenceToolUsed = false;
+  let _liveTodosEmitted = false;
   let _actualCesarEngineId = "";
   let _actualCesarBackend = "unknown";
   let _actualHasNativeTools = false;
@@ -9979,6 +10963,7 @@ async function handleCesarBrain(input, dispatch, ctx, images) {
   };
   const recordToolUse = (name, source, input2, status) => {
     const toolName = String(name || "tool");
+    _noteBashForGate(toolName, input2);
     const normalizedSource = source === "eager" ? "xml" : source === "auto" ? "native" : source;
     const key = `${normalizedSource}:${toolName}:${String(input2 ?? "").slice(0, 500)}`;
     _toolEventCount++;
@@ -10003,6 +10988,45 @@ async function handleCesarBrain(input, dispatch, ctx, images) {
       input: input2
     });
   };
+  const _toolStartMs = /* @__PURE__ */ new Map();
+  const dispatchToolCall = (evt, opts) => {
+    const key = String(opts?.toolCallId || evt.tool || "tool");
+    let durationMs = evt.durationMs;
+    if (evt.status === "running") {
+      if (!opts?.eager && !opts?.standalone) _toolStartMs.set(key, Date.now());
+    } else if (opts?.standalone) {
+    } else {
+      const startedAt = _toolStartMs.get(key);
+      if (startedAt !== void 0) {
+        if (durationMs === void 0) durationMs = Date.now() - startedAt;
+        _toolStartMs.delete(key);
+      }
+    }
+    dispatch({ ...evt, ...durationMs !== void 0 ? { durationMs } : {} });
+  };
+  let _preambleEmitted = false;
+  const emitPreamble = (text) => {
+    const parsed = parsePreamble(text);
+    if (!parsed.found || !parsed.intent) return text;
+    if (!_preambleEmitted) {
+      _preambleEmitted = true;
+      dispatch({ type: "cesar-preamble", engineId: _actualCesarEngineId || void 0, intent: parsed.intent });
+    }
+    return parsed.rest;
+  };
+  const emitLiveTodos = (text) => {
+    const planActive = !!(ctx.activePlan && ["planning", "awaiting_approval", "running", "paused"].includes(ctx.activePlan.state));
+    if (planActive) return text;
+    const parsed = parseLiveTodos(text);
+    if (!parsed.found) return text;
+    if (parsed.todos.length > 0) {
+      _liveTodosEmitted = true;
+      dispatch({ type: "todos-set", todos: parsed.todos });
+    } else {
+      dispatch({ type: "todos-clear", scope: "live" });
+    }
+    return parsed.rest;
+  };
   const normalizeConfidenceReasoning = (value) => {
     return String(value ?? "").replace(/\s+/g, " ").trim();
   };
@@ -10029,7 +11053,8 @@ async function handleCesarBrain(input, dispatch, ctx, images) {
     xmlToolCalls: _xmlToolCalls,
     narratedToolStalls: _narratedToolStalls,
     autoToolExecutions: _autoToolExecutions,
-    confidenceToolUsed: _confidenceToolUsed
+    confidenceToolUsed: _confidenceToolUsed,
+    liveTodosEmitted: _liveTodosEmitted
   });
   const FOLLOWUP_RE = /^(still\??|and\??|go on|continue|yes|no|ok|why\??|how\??|what\??|really\??|more|details|explain|show me|huh\??|so\??|\?\??|y|n)$/i;
   const _isFollowUp = FOLLOWUP_RE.test(input.trim());
@@ -10065,11 +11090,6 @@ async function handleCesarBrain(input, dispatch, ctx, images) {
       ctx.cesar.queue = null;
       ctx.cesar.abortSignal = null;
     } else {
-      if (_isFollowUp) {
-        const elapsed = Math.round((Date.now() - busySince) / 1e3);
-        dispatch({ type: "info", message: `Cesar still working\u2026 ${elapsed}s` });
-        return { delegated: false, responded: true };
-      }
       const existing = ctx.cesar.queue;
       if (existing) {
         existing.input = existing.input + "\n\n" + input;
@@ -10094,6 +11114,7 @@ async function handleCesarBrain(input, dispatch, ctx, images) {
   ctx.cesar.searchNudged = false;
   ctx.cesar.turnId = _turnId;
   ctx.cesar.planDispatch = dispatch;
+  markSteeringTurn(_turnId);
   const _brainStartMs = Date.now();
   if (ctx.eventBus) await ctx.eventBus.emit("pre:cesar-brain", { input });
   try {
@@ -10106,6 +11127,33 @@ async function handleCesarBrain(input, dispatch, ctx, images) {
     }
     const cesarEngineId = config.cesarEngine ?? config.forgeFixedStarter ?? "claude";
     _actualCesarEngineId = cesarEngineId;
+    let _lastDrainedSteerImages = null;
+    const drainSteeringIntoSend = (carrier, source) => {
+      _lastDrainedSteerImages = null;
+      const pending = drainSteering(_turnId);
+      if (pending.length === 0) return carrier;
+      const blocks = [];
+      const drainedImages = [];
+      for (const msg of pending) {
+        const text = (msg.input ?? "").trim();
+        for (const img of msg.images ?? []) {
+          const p = img?.path;
+          if (typeof p === "string" && p) drainedImages.push(p);
+        }
+        if (!text) continue;
+        dispatch({ type: "user-message", content: text });
+        appendMessage(ctx.chatSession, { role: "user", content: text, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        blocks.push(text);
+        recordTimeline({ event: "steering_injected", engineId: cesarEngineId, cwd: _turnCwd, source, input: { text, images: drainedImages.length || void 0 } });
+      }
+      if (drainedImages.length) _lastDrainedSteerImages = drainedImages;
+      if (blocks.length === 0) return carrier;
+      const steer = blocks.map((b) => `[User steering \u2014 injected mid-turn]
+${b}`).join("\n\n");
+      return carrier ? `${carrier}
+
+${steer}` : steer;
+    };
     recordTimeline({
       event: "turn_start",
       engineId: cesarEngineId,
@@ -10126,9 +11174,26 @@ async function handleCesarBrain(input, dispatch, ctx, images) {
     ctx.setActiveAbort(abort);
     ctx.cesar.abortSignal = abort.signal;
     ctx.cesar.lastDispatch = dispatch;
+    dispatch({ type: "todos-clear", scope: "live" });
     dispatch({ type: "confidence-update", value: null });
     dispatch({ type: "spinner-start", message: "Cesar thinking\u2026", color });
     await yieldToInk();
+    try {
+      const _budgetBackend = resolveCesarBackend(ctx, cesarEngineId);
+      const _budgetGate = await enforceContextBudget(
+        ctx,
+        ctx.cesarSession ?? null,
+        _budgetBackend.engine,
+        _budgetBackend.backend,
+        dispatch,
+        input
+      );
+      if (!_budgetGate.proceed) {
+        dispatch({ type: "spinner-stop" });
+        return { delegated: false, responded: false };
+      }
+    } catch {
+    }
     let session;
     try {
       session = await ensureCesarSession(ctx);
@@ -10161,14 +11226,18 @@ async function handleCesarBrain(input, dispatch, ctx, images) {
         if (freshResult.stdout.trim()) {
           dispatch({ type: "engine-block", engineId: cesarEngineId, color, content: freshResult.stdout.trim() });
           appendMessage(ctx.chatSession, { role: "engine", engineId: cesarEngineId, content: freshResult.stdout.trim(), timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-          tracker.record(cesarEngineId, { prompt: input, response: freshResult.stdout.trim() });
+          if (freshResult.usage && freshResult.usage.totalTokens > 0) {
+            tracker.record(cesarEngineId, { usage: freshResult.usage });
+          } else {
+            tracker.record(cesarEngineId, { prompt: input, response: freshResult.stdout.trim() });
+          }
           return { delegated: false, responded: true };
         }
         appendUserTurnIfAbsent(ctx.chatSession, input);
         const brainHint = (freshResult.stderr || "").split("\n")[0].slice(0, 200).trim();
         if (brainHint) dispatch({ type: "warning", message: `Cesar (${cesarEngineId}) returned no response: ${brainHint}` });
         const health = engineHealth.get(cesarEngineId);
-        if (health && (health.status === "auth-failed" || health.status === "unreachable")) {
+        if (health && (health.status === "auth-failed" || health.status === "unreachable" || health.status === "binary-missing")) {
           dispatch({ type: "warning", message: `Engine ${cesarEngineId} marked ${health.status} \u2014 run /cesar to switch to a healthy engine, or /engines to fix credentials.` });
         }
         return { delegated: false, responded: false };
@@ -10186,17 +11255,21 @@ async function handleCesarBrain(input, dispatch, ctx, images) {
     let response = "";
     let streaming = false;
     let wasStreamed = false;
+    let previewShown = false;
     let parsedConfidence = null;
     let confidenceParsed = false;
     let insideThinkBlock = false;
     let suppressXmlToolDisplay = false;
     let sawStreamingXmlToolCall = false;
     let xmlDisplayHold = "";
+    const stripTodosForDisplay = createTodosDisplayStripper();
+    const stripPreambleForDisplay = createPreambleStripper();
     let hadToolActivity = false;
     let _engineErrored = false;
     let _engineErrorMsg = "";
     let secondOpinionPromise = null;
     let usedQuickNero = false;
+    let _escalationSuggested = false;
     const eagerPromises = [];
     let eagerToolCtx = null;
     const shouldInterruptForXmlTool = () => {
@@ -10342,12 +11415,12 @@ ${enrichedInput}`;
     const signalDir = ctx.cesar.mcpSignalPath ? join14(ctx.cesar.mcpSignalPath, "..") : null;
     const processMcpSideChannel = () => {
       try {
-        if (!signalDir || !existsSync13(signalDir)) return;
+        if (!signalDir || !existsSync14(signalDir)) return;
         const completions = readdirSync(signalDir).filter((f) => f.includes("-tool-") && f.endsWith(".json"));
         for (const f of completions) {
           const donePath = join14(signalDir, f);
           try {
-            const done = JSON.parse(readFileSync13(donePath, "utf-8"));
+            const done = JSON.parse(readFileSync14(donePath, "utf-8"));
             if (done.type !== "tool-completion") continue;
             try {
               unlinkSync(donePath);
@@ -10357,21 +11430,21 @@ ${enrichedInput}`;
             const status = done.status === "error" ? "error" : "done";
             const toolInput = typeof done.args === "string" ? done.args : JSON.stringify(done.args ?? {});
             recordToolUse(String(done.tool ?? "tool"), "mcp", toolInput, status);
-            dispatch({
+            dispatchToolCall({
               type: "tool-call",
               engineId: cesarEngineId,
               tool: String(done.tool ?? "tool"),
               input: toolInput,
               status,
               output: typeof done.output === "string" ? done.output : void 0
-            });
+            }, { standalone: true });
           } catch {
           }
         }
         const files = readdirSync(signalDir).filter((f) => f.includes("-perm-") && !f.includes("-response"));
         for (const f of files) {
           const reqPath = join14(signalDir, f);
-          const req = JSON.parse(readFileSync13(reqPath, "utf-8"));
+          const req = JSON.parse(readFileSync14(reqPath, "utf-8"));
           if (req.type !== "permission-request") continue;
           if (Date.now() - req.timestamp > 65e3) {
             try {
@@ -10381,7 +11454,7 @@ ${enrichedInput}`;
             continue;
           }
           const respPath = reqPath.replace(".json", "-response.json");
-          if (existsSync13(respPath)) continue;
+          if (existsSync14(respPath)) continue;
           const cfg = loadConfig();
           const allowed = cfg.allowedCommands ?? [];
           const cmdBase = (req.args?.command ?? "").toString().trim().split(/\s+/)[0];
@@ -10414,12 +11487,30 @@ ${enrichedInput}`;
               input: reqArgs
             });
           };
+          if (String(cfg.permissionMode ?? "ask") === "deny-all") {
+            logMcpApproval("denied", "settings.permissionMode", "permissionMode=deny-all");
+            writeFileSync11(respPath, JSON.stringify({ type: "permission-response", id: req.id, approved: false, reason: "All tool execution is denied (permissionMode=deny-all)" }));
+            continue;
+          }
+          const mcpRuleSet = parsePermissionRuleSet(cfg.permissions);
+          const mcpRuleArg = reqTool === "Bash" ? String(req.args?.command ?? "") : String(req.args?.file_path ?? "");
+          const mcpRuleDecision = evaluateToolRules(reqTool, mcpRuleArg, resolveWorkingDir(), mcpRuleSet);
+          if (mcpRuleDecision === "deny") {
+            logMcpApproval("denied", "settings.permissions", `${reqTool} denied by permissions rule`);
+            writeFileSync11(respPath, JSON.stringify({ type: "permission-response", id: req.id, approved: false, reason: `${reqTool} blocked by deny rule in .agon.json permissions` }));
+            continue;
+          }
+          if (mcpRuleDecision === "allow") {
+            logMcpApproval("approved", "settings.permissions", `${reqTool} allowed by permissions rule`);
+            writeFileSync11(respPath, JSON.stringify({ type: "permission-response", id: req.id, approved: true }));
+            continue;
+          }
           if (cmdBase && allowed.some((a) => cmdBase.toLowerCase().startsWith(a.toLowerCase()))) {
             logMcpApproval("approved", "mcp.allowedCommands", "command matched allowedCommands");
             writeFileSync11(respPath, JSON.stringify({ type: "permission-response", id: req.id, approved: true }));
             continue;
           }
-          if (reqTool === "Edit" || reqTool === "Write") {
+          if (reqTool === "Edit" || reqTool === "Write" || reqTool === "MultiEdit") {
             const approvalCwd = resolveWorkingDir();
             const approvalCache = getProjectFileStateCache(approvalCwd);
             const activePlan = ctx.activePlan;
@@ -10441,7 +11532,16 @@ ${enrichedInput}`;
             }
           }
           logMcpApproval("prompted", "mcp.user-prompt", "Cesar wants to execute");
-          dispatch({ type: "permission-ask", tool: req.tool, command: String(req.args?.command ?? req.args?.file_path ?? JSON.stringify(req.args)), reason: `Cesar wants to execute`, resolve: (approved) => {
+          const askCommand = renderToolPermissionCommand(reqTool, reqArgs);
+          const askReason = reqTool === "SaveMemory" ? "Cesar wants to save a durable project memory" : "Cesar wants to execute";
+          let permDiffPreview = void 0;
+          if (approvalToolIsFileMutating(req.tool)) {
+            try {
+              permDiffPreview = buildApprovalDiffPreview(String(req.tool), reqArgs);
+            } catch {
+            }
+          }
+          dispatch({ type: "permission-ask", tool: req.tool, command: askCommand, reason: askReason, diffPreview: permDiffPreview && Array.isArray(permDiffPreview.files) ? permDiffPreview : void 0, fallbackNote: permDiffPreview && typeof permDiffPreview.fallback === "string" ? permDiffPreview.fallback : void 0, resolve: (approved) => {
             const wasApproved = typeof approved === "string" ? approved === "y" || approved === "a" : approved;
             logMcpApproval(wasApproved ? "approved" : "denied", "mcp.user-prompt", wasApproved ? "user approved" : "user denied");
             if (typeof approved === "string" && approved === "a" || approved === true) {
@@ -10470,6 +11570,13 @@ ${enrichedInput}`;
       const gen = session.send(sendOptions);
       for await (const chunk of gen) {
         if (abort.signal.aborted) break;
+        if (chunk.type === "preview") {
+          if (!abort.signal.aborted && !streaming && !wasStreamed) {
+            previewShown = true;
+            dispatch({ type: "streaming-preview", engineId: cesarEngineId, content: String(chunk.content ?? "") });
+          }
+          continue;
+        }
         if (chunk.type === "status") {
           const statusText = String(chunk.content ?? "");
           const _ctxMeta = chunk.metadata ?? {};
@@ -10480,7 +11587,8 @@ ${enrichedInput}`;
               used: Number(_ctxMeta.used ?? 0),
               limit: Number(_ctxMeta.limit ?? 0),
               compacted: Number(_ctxMeta.compacted ?? 0),
-              cached: Number(_ctxMeta.cached ?? 0)
+              cached: Number(_ctxMeta.cached ?? 0),
+              source: typeof _ctxMeta.source === "string" ? _ctxMeta.source : void 0
             });
             continue;
           }
@@ -10507,7 +11615,7 @@ ${enrichedInput}`;
           dispatch({ type: "spinner-update", message: `Cesar: ${toolName}\u2026` });
           if (meta.input && STREAM_ORCH.has(toolName)) {
             if (cesarFastPath) {
-              dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "error", output: `Blocked by fast-${fastPathMode}: do the direct work without orchestration.` });
+              dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "error", output: `Blocked by fast-${fastPathMode}: do the direct work without orchestration.` });
               continue;
             }
             if (!ctx.cesar.pendingDelegation) {
@@ -10515,35 +11623,35 @@ ${enrichedInput}`;
               ctx.eventBus?.emit("cesar:delegation", { action: toolName.toLowerCase(), source: `stream-${toolStatus}` }).catch(() => {
               });
             }
-            dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "done", output: typeof meta.output === "string" ? meta.output : void 0 });
+            dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "done", output: typeof meta.output === "string" ? meta.output : void 0 });
             continue;
           }
           if (toolStatus === "done") {
-            dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "done", output: typeof meta.output === "string" ? meta.output : void 0 });
+            dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "done", output: typeof meta.output === "string" ? meta.output : void 0 }, { toolCallId: meta.toolCallId });
           } else if (toolStatus === "native") {
-            dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "running" });
+            dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "running" }, { toolCallId: meta.toolCallId });
           } else if (toolStatus === "running" && meta.input && toolRegistry && !ctx.cesar.hasNativeTools) {
             if (ctx.cesar.pendingDelegation) {
-              dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "done" });
+              dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "done" }, { toolCallId: meta.toolCallId });
               continue;
             }
             const EAGER_ORCH = STREAM_ORCH;
             if (EAGER_ORCH.has(toolName)) {
               if (cesarFastPath) {
-                dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "error", output: `Blocked by fast-${fastPathMode}: do the direct work without orchestration.` });
+                dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "error", output: `Blocked by fast-${fastPathMode}: do the direct work without orchestration.` });
                 continue;
               }
               ctx.cesar.pendingDelegation = extractDelegation(toolName, meta.input ?? {});
               ctx.eventBus?.emit("cesar:delegation", { action: toolName.toLowerCase(), source: "stream" }).catch(() => {
               });
-              dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "done" });
+              dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "done" });
               continue;
             }
-            dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "running" });
+            dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "running" }, { toolCallId: meta.toolCallId, eager: true });
             if (!eagerToolCtx) eagerToolCtx = createEagerToolContext(ctx, config, abort.signal, dispatch);
             eagerPromises.push(executeEagerTool(toolName, meta, toolRegistry, eagerToolCtx, dispatch, cesarEngineId));
           } else {
-            dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: toolStatus, output: typeof meta.output === "string" ? meta.output : void 0 });
+            dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: toolStatus, output: typeof meta.output === "string" ? meta.output : void 0 }, { toolCallId: meta.toolCallId });
           }
           continue;
         }
@@ -10557,6 +11665,7 @@ ${enrichedInput}`;
           const errBody = _errFull.slice(0, 200) || "unknown stream error";
           const _deterministic = /\b(?:400|401|403|404)\b|not found|unauthorized|invalid api key|authentication|no such (?:route|endpoint)/i.test(_errFull);
           dispatch({ type: "warning", message: `Cesar (${cesarEngineId}) stream error before any output: ${errBody}.${_deterministic ? " Looks like an engine config/auth issue \u2014 check the engine with /engines." : " Try again or switch engine with /engine."}` });
+          if (previewShown) dispatch({ type: "streaming-end", engineId: cesarEngineId });
           clearInterval(heartbeat);
           processMcpSideChannel();
           if (mcpWatcherInterval) clearInterval(mcpWatcherInterval);
@@ -10624,19 +11733,29 @@ ${enrichedInput}`;
                 cleanFirst = response.replace(/<think>[\s\S]*/gi, "");
               }
             }
+            emitPreamble(response);
+            cleanFirst = stripPreambleForDisplay(cleanFirst);
             if (!ctx.cesar.hasNativeTools) {
               const split = splitBeforeToolMarkup(cleanFirst);
               cleanFirst = split.visible;
               if (split.hasToolMarkup) suppressXmlToolDisplay = true;
+            } else {
+              cleanFirst = stripTodosForDisplay(cleanFirst);
             }
             if (cleanFirst.trim()) dispatch({ type: "streaming-chunk", engineId: cesarEngineId, chunk: cleanFirst });
           } else {
             response += chunk.content;
             noteXmlToolDetected(true);
             let displayChunk = chunk.content;
+            emitPreamble(response);
+            displayChunk = stripPreambleForDisplay(displayChunk);
+            if (!displayChunk) continue;
             if (!ctx.cesar.hasNativeTools) {
               displayChunk = takeXmlSafeDisplayChunk(displayChunk);
               if (!displayChunk) continue;
+            } else {
+              displayChunk = stripTodosForDisplay(displayChunk);
+              if (!displayChunk && !insideThinkBlock) continue;
             }
             if (insideThinkBlock) {
               if (displayChunk.includes("</think>")) {
@@ -10670,10 +11789,21 @@ ${enrichedInput}`;
           }
         }
       }
+      const trailingPreambleSafe = stripPreambleForDisplay("", true);
+      if (streaming && trailingPreambleSafe) {
+        const routed = ctx.cesar.hasNativeTools ? stripTodosForDisplay(trailingPreambleSafe) : takeXmlSafeDisplayChunk(trailingPreambleSafe);
+        if (routed.trim()) dispatch({ type: "streaming-chunk", engineId: cesarEngineId, chunk: routed });
+      }
       const trailingXmlSafe = takeXmlSafeDisplayChunk("", true);
       if (streaming && trailingXmlSafe.trim()) {
         dispatch({ type: "streaming-chunk", engineId: cesarEngineId, chunk: trailingXmlSafe });
       }
+      if (ctx.cesar.hasNativeTools) {
+        const trailingTodosSafe = stripTodosForDisplay("", true);
+        if (streaming && trailingTodosSafe.trim()) {
+          dispatch({ type: "streaming-chunk", engineId: cesarEngineId, chunk: trailingTodosSafe });
+        }
+      }
     } catch (err) {
       clearInterval(heartbeat);
       processMcpSideChannel();
@@ -10684,6 +11814,7 @@ ${enrichedInput}`;
         dispatch({ type: "warning", message: `Cesar stream error (partial response preserved): ${(err.message ?? "").slice(0, 80)}` });
       } else {
         dispatch({ type: "warning", message: "Cesar session error \u2014 will restart on next message" });
+        if (previewShown) dispatch({ type: "streaming-end", engineId: cesarEngineId });
         return { delegated: false, responded: false, decisionReason: "stream-error" };
       }
     }
@@ -10692,6 +11823,7 @@ ${enrichedInput}`;
     if (mcpWatcherInterval) clearInterval(mcpWatcherInterval);
     if (abort.signal.aborted) {
       dispatch({ type: "spinner-stop" });
+      if (previewShown) dispatch({ type: "streaming-end", engineId: cesarEngineId });
       const elapsed = Math.round((Date.now() - _turnStart) / 1e3);
       if (elapsed >= cesarTimeout) {
         dispatch({ type: "warning", message: `Cesar timed out after ${elapsed}s. Try a simpler question, or use /forge for complex tasks.` });
@@ -10704,6 +11836,8 @@ ${enrichedInput}`;
     if (ctx.cesar.hasNativeTools) {
       response = response.replace(/<tool\s+name="[^"]+">[\s\S]*?<\/tool>/g, "").trim();
     }
+    response = emitPreamble(response);
+    response = emitLiveTodos(response);
     if (eagerPromises.length > 0 && !ctx.cesar.hasNativeTools && session.alive && !abort.signal.aborted) {
       dispatch({ type: "spinner-start", message: `Cesar: awaiting ${eagerPromises.length} tool result${eagerPromises.length > 1 ? "s" : ""}\u2026`, color });
       const eagerResults = await Promise.all(eagerPromises);
@@ -10716,7 +11850,8 @@ ${enrichedInput}`;
         const failedTools = eagerFailedToolNames(eagerResults);
         const repairUsed = [];
         const repairResults = [];
-        const contGen = session.send({ message: formatted, signal: abort.signal });
+        const _steerMsg = drainSteeringIntoSend(formatted, "xml");
+        const contGen = session.send({ message: _steerMsg, signal: abort.signal, ..._lastDrainedSteerImages ? { images: _lastDrainedSteerImages } : {} });
         for await (const chunk of contGen) {
           if (chunk.type === "text") continuation += chunk.content;
           if (chunk.type === "tool_call") {
@@ -10733,9 +11868,9 @@ ${enrichedInput}`;
               continue;
             }
             if (toolStatus !== "running" && toolStatus !== "native") {
-              dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: toolStatus, output: typeof meta.output === "string" ? meta.output : void 0 });
+              dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: toolStatus, output: typeof meta.output === "string" ? meta.output : void 0 });
             } else if (failedTools.includes(toolName)) {
-              dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "error", output: "Repair retry already used for this tool in this turn." });
+              dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "error", output: "Repair retry already used for this tool in this turn." });
             }
           }
           if (chunk.type === "done" || chunk.type === "error") break;
@@ -10754,7 +11889,7 @@ ${enrichedInput}`;
                 const meta = chunk.metadata ?? {};
                 const toolName = chunk.content || "tool";
                 const toolInput = typeof meta.input === "string" ? meta.input : meta.input ? JSON.stringify(meta.input) : "";
-                dispatch({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "error", output: "Tool repair loop is one retry per failed tool; further tool calls were not executed automatically." });
+                dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: toolName, input: toolInput, status: "error", output: "Tool repair loop is one retry per failed tool; further tool calls were not executed automatically." });
               }
               if (chunk.type === "done" || chunk.type === "error") break;
             }
@@ -10762,7 +11897,7 @@ ${enrichedInput}`;
           }
         }
         dispatch({ type: "spinner-stop" });
-        if (continuation.trim()) response = continuation.trim();
+        if (continuation.trim()) response = emitLiveTodos(emitPreamble(continuation.trim()));
       }
     }
     if (!confidenceParsed && response) {
@@ -10798,22 +11933,22 @@ ${enrichedInput}`;
     if (!ctx.cesar.pendingDelegation && ctx.cesar.mcpSignalPath) {
       try {
         const signalPath = ctx.cesar.mcpSignalPath;
-        if (existsSync13(signalPath)) {
-          const signals = JSON.parse(readFileSync13(signalPath, "utf-8"));
+        if (existsSync14(signalPath)) {
+          const signals = JSON.parse(readFileSync14(signalPath, "utf-8"));
           unlinkSync(signalPath);
           for (const signal of Array.isArray(signals) ? signals : [signals]) {
             if (!signal.timestamp || Date.now() - signal.timestamp >= 6e4) continue;
             if (cesarFastPath && FAST_PATH_BLOCKED_TOOLS.includes(signal.tool)) {
               const toolInput = JSON.stringify(signal.args ?? {});
               recordToolUse(signal.tool, "mcp", toolInput, "error");
-              dispatch({
+              dispatchToolCall({
                 type: "tool-call",
                 engineId: cesarEngineId,
                 tool: signal.tool,
                 input: toolInput,
                 status: "error",
                 output: `Blocked by fast-${fastPathMode}: do the direct work without orchestration.`
-              });
+              }, { standalone: true });
               continue;
             }
             if (signal.tool === "ReportConfidence") {
@@ -10843,17 +11978,17 @@ ${enrichedInput}`;
               recordToolUse("ProposePlan", "mcp", JSON.stringify(signal.args ?? {}), "done");
               const activePlan = ctx.activePlan;
               if (activePlan && ["planning", "running", "paused"].includes(activePlan.state)) {
-                dispatch({
+                dispatchToolCall({
                   type: "tool-call",
                   engineId: cesarEngineId,
                   tool: "ProposePlan",
                   input: JSON.stringify(signal.args ?? {}),
                   status: "error",
                   output: "A Cesar plan is already active; nested plans are blocked. Resume or cancel the current plan before proposing another."
-                });
+                }, { standalone: true });
                 continue;
               }
-              const { handleProposePlan } = await import("./plan-mode-5IQ2SKIS.js");
+              const { handleProposePlan } = await import("./plan-mode-I3BZOBFB.js");
               const planDispatch = ctx.cesar.planDispatch ?? dispatch;
               if (planDispatch) {
                 try {
@@ -10866,11 +12001,11 @@ ${enrichedInput}`;
               }
             } else if (signal.tool === "ExitPlanMode") {
               recordToolUse("ExitPlanMode", "mcp", JSON.stringify(signal.args ?? {}), "done");
-              const { handleExitPlanMode } = await import("./plan-mode-5IQ2SKIS.js");
+              const { handleExitPlanMode } = await import("./plan-mode-I3BZOBFB.js");
               const planDispatch = ctx.cesar.planDispatch ?? dispatch;
               try {
                 const exitResult = handleExitPlanMode(String(signal.args?.reason ?? ""), planDispatch, ctx);
-                dispatch({ type: "tool-call", engineId: cesarEngineId, tool: "ExitPlanMode", input: JSON.stringify(signal.args ?? {}), status: "done", output: exitResult });
+                dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: "ExitPlanMode", input: JSON.stringify(signal.args ?? {}), status: "done", output: exitResult }, { standalone: true });
               } catch (err) {
                 console.warn(`[agon] ExitPlanMode via MCP signal failed: ${err instanceof Error ? err.message : String(err)}`);
               }
@@ -10923,7 +12058,14 @@ ${enrichedInput}`;
       // Phase 1: investigate only — mutating tools blocked until after escalation check
       blockedTools: cesarFastPath ? FAST_PATH_BLOCKED_TOOLS : void 0,
       blockedToolMessage: cesarFastPath ? `Blocked by fast-${fastPathMode}: do the direct work without orchestration.` : void 0,
-      source: "orchestrator"
+      source: "orchestrator",
+      // CC-parity allow/deny rules reach all three XML runToolLoop paths via
+      // this shared toolCtx (runToolLoop → executeToolCalls → executeToolCall
+      // → handler.checkPermission). deny-first, before mode-based auto-allow.
+      permissionRules: parsePermissionRuleSet(config.permissions),
+      // CC-parity PreToolUse/PostToolUse hooks reach all three XML
+      // runToolLoop paths via this shared toolCtx (→ executeToolCall).
+      toolHooks: parseToolHooks(config.hooks)
     };
     const _lastToolInputs = {};
     const xmlToolBridge = createStreamBridge(dispatch, { initialEngineId: cesarEngineId });
@@ -10969,12 +12111,13 @@ ${enrichedInput}`;
           async (message) => {
             if (ctx.cesar.pendingDelegation) return "[Delegation pending]";
             if (!session.alive || abort.signal.aborted) return "";
+            const sendMessage = drainSteeringIntoSend(message, "xml");
             dispatch({ type: "spinner-start", message: "Cesar processing results\u2026", color });
             _engineErrored = false;
             _engineErrorMsg = "";
             let nextResponse = "";
             const gen = session.send({
-              message,
+              message: sendMessage,
               signal: abort.signal,
               toolLoopBaseBudget: cesarFastPath ? fastPathBaseBudget : void 0,
               toolLoopMaxBudget: cesarFastPath ? fastPathMaxBudget : void 0
@@ -11046,7 +12189,7 @@ ${enrichedInput}`;
                 const lastInput = _lastToolInputs[tool] ?? "{}";
                 let command = "";
                 try {
-                  command = JSON.parse(lastInput).command ?? JSON.parse(lastInput).file_path ?? lastInput;
+                  command = renderToolPermissionCommand(tool, JSON.parse(lastInput));
                 } catch {
                   command = lastInput;
                 }
@@ -11073,7 +12216,7 @@ ${enrichedInput}`;
       try {
         const activePlan = ctx.activePlan;
         if (activePlan && ["planning", "running", "paused"].includes(activePlan.state)) {
-          dispatch({
+          dispatchToolCall({
             type: "tool-call",
             engineId: cesarEngineId,
             tool: "ProposePlan",
@@ -11082,7 +12225,7 @@ ${enrichedInput}`;
             output: "A Cesar plan is already active; nested plans are blocked. Resume or cancel the current plan before proposing another."
           });
         } else {
-          const { handleProposePlan } = await import("./plan-mode-5IQ2SKIS.js");
+          const { handleProposePlan } = await import("./plan-mode-I3BZOBFB.js");
           const planDispatch = ctx.cesar.planDispatch ?? dispatch;
           const plan = await handleProposePlan(ppArgs, planDispatch, ctx);
           if (ctx.setActivePlan) ctx.setActivePlan(plan);
@@ -11106,10 +12249,10 @@ ${enrichedInput}`;
       const epArgs = ctx.cesar._exitPlanModeArgs;
       delete ctx.cesar._exitPlanModeArgs;
       try {
-        const { handleExitPlanMode } = await import("./plan-mode-5IQ2SKIS.js");
+        const { handleExitPlanMode } = await import("./plan-mode-I3BZOBFB.js");
         const planDispatch = ctx.cesar.planDispatch ?? dispatch;
         const exitResult = handleExitPlanMode(String(epArgs?.reason ?? ""), planDispatch, ctx);
-        dispatch({ type: "tool-call", engineId: cesarEngineId, tool: "ExitPlanMode", input: JSON.stringify(epArgs ?? {}), status: "done", output: exitResult });
+        dispatchToolCall({ type: "tool-call", engineId: cesarEngineId, tool: "ExitPlanMode", input: JSON.stringify(epArgs ?? {}), status: "done", output: exitResult });
       } catch (err) {
         console.warn(`[agon] ExitPlanMode via tool loop failed: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -11135,7 +12278,7 @@ ${enrichedInput}`;
         confidenceParsed = true;
       }
     }
-    const shouldQuickNero = parsedConfidence !== null && !cesarFastPath && !secondOpinionPromise && !ctx.cesar.advisorPending && !_isFollowUp && !abort.signal.aborted && !ctx.cesar.pendingDelegation && (ctx.cesar.quickNeroRequested === true || routingHints.uncertaintyFamily === "challenge" || routingHints.uncertaintyFamily === "tradeoff" || routingHints.uncertaintyFamily === "implementation" && parsedConfidence < 86 || mutationDeferred && parsedConfidence < 90);
+    const shouldQuickNero = parsedConfidence !== null && !cesarFastPath && !secondOpinionPromise && !ctx.cesar.advisorPending && !_isFollowUp && !abort.signal.aborted && !ctx.cesar.pendingDelegation && ctx.cesar.quickNeroRequested === true;
     if (ctx.cesar.quickNeroRequested) ctx.cesar.quickNeroRequested = false;
     if (shouldQuickNero) {
       const quickNeroConfidence = parsedConfidence;
@@ -11175,7 +12318,7 @@ ${qnResult.challengeText}` : ""
             appendMessage(ctx.chatSession, { role: "engine", engineId: ch.engineId, content: ch.content, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
           }
         }
-        tracker.record(cesarEngineId, { prompt: input, response });
+        recordCesarTurn(ctx, cesarEngineId, input, response);
         return {
           mode: escalationAction,
           delegated: true,
@@ -11189,12 +12332,24 @@ ${qnResult.challengeText}` : ""
         };
       }
     }
+    if (!_escalationSuggested && !usedQuickNero && !cesarFastPath && !_isFollowUp && !abort.signal.aborted && !ctx.cesar.pendingDelegation) {
+      const _strictConf = extractStrictConfidence(response);
+      if (_strictConf !== null && _strictConf < ESCALATION_SUGGESTION_THRESHOLD) {
+        _escalationSuggested = true;
+        dispatch({ type: "info", message: buildEscalationSuggestionLine(_strictConf) });
+      }
+    }
     const investigationResponse = response;
     let mutationStallForced = false;
     if (!mutationDeferred && !inPlanMode && !ctx.cesar.pendingDelegation && (hadToolActivity || ranToolLoop) && session.alive && !abort.signal.aborted && detectMutationIntentStall(response)) {
-      mutationDeferred = true;
-      mutationStallForced = true;
-      dispatch({ type: "warning", message: "Cesar described a write but called no tool \u2014 unlocking execution and pushing it to apply directly." });
+      const _usedMutatingTool = _toolsUsed.some((t) => isWriteToolName(t) || isBashToolName(t));
+      if (shouldDeescalateGuard({ intakeKind: routingHints.intakeKind, recommendedFlow: routingHints.recommendedFlow, usedMutatingTool: _usedMutatingTool })) {
+        dispatch({ type: "warning", message: "Cesar guard: write-narration matched on a conversational turn \u2014 warning only, no auto-unlock (de-escalated)." });
+      } else {
+        mutationDeferred = true;
+        mutationStallForced = true;
+        dispatch({ type: "warning", message: "Cesar described a write but called no tool \u2014 unlocking execution and pushing it to apply directly." });
+      }
     }
     if (mutationDeferred && toolRegistry && session.alive && !abort.signal.aborted) {
       toolCtx.readOnlyMode = false;
@@ -11214,10 +12369,11 @@ ${qnResult.challengeText}` : ""
             async (message) => {
               if (ctx.cesar.pendingDelegation) return "[Delegation pending]";
               if (!session.alive || abort.signal.aborted) return "";
+              const sendMessage = drainSteeringIntoSend(message, "exec");
               dispatch({ type: "spinner-start", message: "Cesar executing\u2026", color });
               let nextResponse = "";
               const gen = session.send({
-                message,
+                message: sendMessage,
                 signal: abort.signal,
                 toolLoopBaseBudget: cesarFastPath ? fastPathBaseBudget : void 0,
                 toolLoopMaxBudget: cesarFastPath ? fastPathMaxBudget : void 0
@@ -11293,7 +12449,14 @@ ${qnResult.challengeText}` : ""
         dispatch({ type: "spinner-stop" });
       }
     }
-    if (!ctx.cesar.pendingDelegation && session.alive && !abort.signal.aborted && detectFabricatedDelegation(response.trim())) {
+    const _fabDelegationDetected = !ctx.cesar.pendingDelegation && session.alive && !abort.signal.aborted && detectFabricatedDelegation(response.trim());
+    if (_fabDelegationDetected && shouldDeescalateGuard({
+      intakeKind: routingHints.intakeKind,
+      recommendedFlow: routingHints.recommendedFlow,
+      usedMutatingTool: _toolsUsed.some((t) => isWriteToolName(t) || isBashToolName(t))
+    })) {
+      dispatch({ type: "warning", message: "Cesar guard: dispatch-claim matched on a conversational turn \u2014 warning only, no grounding turn (de-escalated)." });
+    } else if (_fabDelegationDetected) {
       dispatch({ type: "warning", message: "Cesar claimed a job was running but never dispatched one \u2014 grounding..." });
       dispatch({ type: "spinner-start", message: "Cesar grounding\u2026", color });
       try {
@@ -11405,12 +12568,11 @@ ${cleanFinalAnswer}` : cleanFinalAnswer;
         dispatch({ type: "spinner-stop" });
       }
     }
-    const _AUTO_CONT_WRITE_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
     const _AUTO_CONT_LOOP_ORCH = /* @__PURE__ */ new Set(["Forge", "Brainstorm", "Tribunal", "Campfire", "Pipeline", "Review", "Agent", "Goal", "Conquer"]);
     const _AUTO_CONT_CONTINUE_RE = /\b(?:now i'?ll|next i'?ll|still need|let me also|i'?ll also|then i'?ll|next step|next up)\b/i;
     const _AUTO_CONT_READONLY_DONE_RE = /\b(?:tests? passed|all (?:tests|checks) pass|no matches found|no issues found|no errors|all clean|nothing to (?:do|fix|change)|already (?:correct|fixed|in place|done))\b/i;
     const _detectTurnState = (resp, baselineToolCount) => {
-      const wroteSinceBaseline = _toolsUsed.slice(baselineToolCount).some((t) => _AUTO_CONT_WRITE_TOOLS.has(t));
+      const wroteSinceBaseline = _toolsUsed.slice(baselineToolCount).some((t) => isWriteToolName(t));
       if (findTrailingUserQuestion(resp)) return "asks-user";
       if (wroteSinceBaseline && !_AUTO_CONT_CONTINUE_RE.test(resp)) return "done";
       const effectSummary = /(?:created|modified|deleted|updated|added|removed|fixed|implemented|renamed)\b[^.]{0,80}(?:\b(?:and|,)\b[^.]{0,80}\b(?:created|modified|deleted|updated|added|removed|fixed|implemented|renamed)\b)/i.test(resp);
@@ -11419,6 +12581,18 @@ ${cleanFinalAnswer}` : cleanFinalAnswer;
       if (_AUTO_CONT_READONLY_DONE_RE.test(resp)) return "done";
       return "stuck";
     };
+    const _doneClaimSignature = (resp) => {
+      return `${_toolsUsed.length}:${resp.trim().slice(-200)}`;
+    };
+    const _shouldGateNudge = (resp) => {
+      const g = ctx.cesar?.discoveredGate;
+      if (!g || !g.command || !g.matchers.length) return false;
+      if (ctx.cesar?.gateWaived) return false;
+      if (_ranGate) return false;
+      if (!_toolsUsed.some((t) => isWriteToolName(t))) return false;
+      if (ctx.cesar?.gateNudgedClaim === _doneClaimSignature(resp)) return false;
+      return true;
+    };
     const _buildContToolLoopOpts = () => ({
       onToolCall: (name, inp) => {
         _lastToolInputs[name] = JSON.stringify(inp);
@@ -11453,7 +12627,7 @@ ${cleanFinalAnswer}` : cleanFinalAnswer;
           const lastInput = _lastToolInputs[tool] ?? "{}";
           let command = "";
           try {
-            command = JSON.parse(lastInput).command ?? JSON.parse(lastInput).file_path ?? lastInput;
+            command = renderToolPermissionCommand(tool, JSON.parse(lastInput));
           } catch {
             command = lastInput;
           }
@@ -11477,8 +12651,85 @@ ${cleanFinalAnswer}` : cleanFinalAnswer;
       let _consecutiveNoProgress = 0;
       while (_continuations < MAX_CONTINUATIONS && session.alive && !abort.signal.aborted && !ctx.cesar.pendingDelegation) {
         const state = _detectTurnState(response, _loopStartToolCount);
-        if (state === "asks-user" || state === "done") break;
-        const wroteFiles = _toolsUsed.some((t) => _AUTO_CONT_WRITE_TOOLS.has(t));
+        if (state === "asks-user") break;
+        if (state === "done") {
+          if (_shouldGateNudge(response)) {
+            if (ctx.cesar) ctx.cesar.gateNudgedClaim = _doneClaimSignature(response);
+            const _g = ctx.cesar.discoveredGate;
+            const _gateNudge = `[SYSTEM] You claimed the task is done but never ran the project's verification gate (${_g.command}) this turn. Run it now to confirm the change is green, or tell me in one sentence why it should be skipped.`;
+            _continuations++;
+            dispatch({ type: "warning", message: `Cesar claimed done without running the gate (${_g.command}) \u2014 nudging to verify (${_continuations}/${MAX_CONTINUATIONS}).` });
+            dispatch({ type: "spinner-start", message: `${cesarEngineId} verifying\u2026`, color });
+            let _gateResp = "";
+            try {
+              const _gateGen = session.send({
+                message: _gateNudge,
+                signal: abort.signal,
+                toolLoopBaseBudget: cesarFastPath ? fastPathBaseBudget : void 0,
+                toolLoopMaxBudget: cesarFastPath ? fastPathMaxBudget : void 0
+              });
+              for await (const _c of _gateGen) {
+                if (abort.signal.aborted) break;
+                if (_c.type === "text") _gateResp += _c.content;
+                if (_c.type === "error" && !_gateResp.trim()) {
+                  _engineErrored = true;
+                  _engineErrorMsg = String(_c.content ?? "").slice(0, 300);
+                }
+                if (_c.type === "done" || _c.type === "error") break;
+              }
+            } catch (gateErr) {
+              dispatch({ type: "spinner-stop" });
+              _engineErrored = true;
+              _engineErrorMsg = gateErr instanceof Error ? gateErr.message : String(gateErr);
+              break;
+            }
+            dispatch({ type: "spinner-stop" });
+            if (_engineErrored) break;
+            const _cleanGate = _gateResp.replace(/<think>[\s\S]*?<\/think>\s*/gi, "").trim();
+            try {
+              const _parsedGate = parseToolCalls(_cleanGate);
+              if (_parsedGate.hasToolCalls && toolRegistry) {
+                const _gateResult = await runToolLoop(
+                  async (message) => {
+                    if (!session.alive || abort.signal.aborted) return "";
+                    _engineErrored = false;
+                    _engineErrorMsg = "";
+                    let _nr = "";
+                    const _g2 = session.send({ message, signal: abort.signal, toolLoopBaseBudget: cesarFastPath ? fastPathBaseBudget : void 0, toolLoopMaxBudget: cesarFastPath ? fastPathMaxBudget : void 0 });
+                    for await (const _ch of _g2) {
+                      if (_ch.type === "text") _nr += _ch.content;
+                      if (_ch.type === "error" && !_nr.trim()) {
+                        _engineErrored = true;
+                        _engineErrorMsg = String(_ch.content ?? "").slice(0, 300);
+                      }
+                      if (_ch.type === "done" || _ch.type === "error") break;
+                    }
+                    return _nr.trim() || (_engineErrorMsg ? `[Engine error: ${_engineErrorMsg}]` : "[No response from engine]");
+                  },
+                  _cleanGate,
+                  toolCtx,
+                  toolRegistry,
+                  _buildContToolLoopOpts()
+                );
+                response = response + "\n\n" + (_gateResult.finalText?.trim() ?? "");
+                _toolCallTurns += _gateResult.turns ?? 0;
+              } else if (_cleanGate) {
+                dispatch({ type: "engine-block", engineId: cesarEngineId, color, content: _cleanGate });
+                response = response + "\n\n" + _cleanGate;
+              }
+            } catch {
+              if (_cleanGate) {
+                dispatch({ type: "engine-block", engineId: cesarEngineId, color, content: _cleanGate });
+                response = response + "\n\n" + _cleanGate;
+              }
+            }
+            _prevToolCount = _toolsUsed.length;
+            if (ctx.cesar) ctx.cesar.gateNudgedClaim = _doneClaimSignature(response);
+            continue;
+          }
+          break;
+        }
+        const wroteFiles = _toolsUsed.some((t) => isWriteToolName(t));
         const filePathRe = /(?:^|\s|`)((?:\.{1,2}\/|~\/|\/|(?:packages|src|tests|scripts|kern)\/)[\w./-]+\.(?:ts|tsx|kern|js|jsx|py|md|json|yaml|yml|toml|sh|css|scss|html))\b/g;
         const filesMentioned = Array.from(new Set(Array.from(response.matchAll(filePathRe), (m) => m[1]))).slice(0, 3);
         let nudge;
@@ -11514,7 +12765,7 @@ ${cleanFinalAnswer}` : cleanFinalAnswer;
           break;
         }
         dispatch({ type: "spinner-stop" });
-        const cleanCont = contResponse.replace(/<think>[\s\S]*?<\/think>\s*/gi, "").trim();
+        const cleanCont = emitLiveTodos(emitPreamble(contResponse.replace(/<think>[\s\S]*?<\/think>\s*/gi, "").trim()));
         if (_engineErrored) {
           const _reason = _engineErrorMsg || "no response";
           dispatch({ type: "warning", message: `Cesar (${cesarEngineId}) stopped \u2014 engine did not respond: ${_reason.slice(0, 160)}. Try again, /compact, or switch engine with /engine.` });
@@ -11535,12 +12786,13 @@ ${cleanFinalAnswer}` : cleanFinalAnswer;
                 async (message) => {
                   if (ctx.cesar.pendingDelegation) return "[Delegation pending]";
                   if (!session.alive || abort.signal.aborted) return "";
+                  const sendMessage = drainSteeringIntoSend(message, "auto");
                   dispatch({ type: "spinner-start", message: "Cesar executing\u2026", color });
                   _engineErrored = false;
                   _engineErrorMsg = "";
                   let nextResp = "";
                   const gen = session.send({
-                    message,
+                    message: sendMessage,
                     signal: abort.signal,
                     toolLoopBaseBudget: cesarFastPath ? fastPathBaseBudget : void 0,
                     toolLoopMaxBudget: cesarFastPath ? fastPathMaxBudget : void 0
@@ -11637,6 +12889,9 @@ ${cleanFinalAnswer}` : cleanFinalAnswer;
         message: _readHeavy ? `Cesar made ${_turnToolEvents} tool calls this turn (${_readToolEventCount} reads) \u2014 read-heavy, may be searching in circles. Consider /compact or a more specific instruction.` : `Cesar made ${_turnToolEvents} tool calls this turn \u2014 unusually high. If it felt stuck, /compact to shrink context or re-prompt more specifically.`
       });
     }
+    if (previewShown && !streaming) {
+      dispatch({ type: "streaming-end", engineId: cesarEngineId });
+    }
     if (!streaming && response && !ranToolLoop && !wasStreamed) {
       dispatch({ type: "spinner-stop" });
       dispatch({ type: "engine-block", engineId: cesarEngineId, color, content: response });
@@ -11655,7 +12910,7 @@ ${cleanFinalAnswer}` : cleanFinalAnswer;
           appendMessage(ctx.chatSession, { role: "engine", engineId: ch.engineId, content: ch.content, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
         }
       }
-      const tokenUsage = tracker.record(cesarEngineId, { prompt: input, response });
+      const tokenUsage = recordCesarTurn(ctx, cesarEngineId, input, response);
       try {
         const tracePath = join14(RUNS_DIR, "cesar-trace.jsonl");
         const taskClass = classifyTask(input);
@@ -11687,6 +12942,11 @@ ${cleanFinalAnswer}` : cleanFinalAnswer;
           confidenceToolUsed: toolTelemetry.confidenceToolUsed,
           hasNativeTools: toolTelemetry.hasNativeTools,
           delegated: false,
+          // Live-todo telemetry: emitted? + whether this was a multi-tool turn
+          // (toolCallTurns>1) — the later-gated metric is multi-tool turns that
+          // emitted ZERO todos, derivable from these two fields.
+          liveTodosEmitted: toolTelemetry.liveTodosEmitted,
+          multiToolTurn: toolTelemetry.toolCallTurns > 1,
           confidence: parsedConfidence,
           tokens: tokenUsage ? { prompt: tokenUsage.promptTokens, response: tokenUsage.responseTokens, cost: tokenUsage.costUsd } : void 0
         }) + "\n");
@@ -11802,6 +13062,7 @@ ${cleanFinalAnswer}` : cleanFinalAnswer;
       ctx.cesar.abortSignal = null;
       ctx.cesar.turnId = void 0;
       ctx.setActiveAbort(null);
+      releaseSteeringTurn(_turnId);
       const queued = ctx.cesar.queue;
       if (queued) {
         ctx.cesar.queue = null;
@@ -11833,6 +13094,7 @@ export {
   joinProblemInput,
   runThinkChain,
   runDelegate,
+  runPrText,
   goalDir,
   loadJournal,
   isTestFile,
@@ -11863,15 +13125,20 @@ export {
   clearPermissionQueue,
   clearThinkingBuffer,
   handleOutputEvent,
+  yieldToInk,
+  replayCesarHarnessLogs,
   parseConfidence,
   confidenceBadge,
   parseSuggestion,
-  yieldToInk,
-  replayCesarHarnessLogs,
+  onSteeringChange,
+  pushSteering,
+  peekSteeringCount,
+  drainLeftoverSteering,
+  clearSteering,
+  handleCesarBrain,
   buildCesarSystemPrompt,
   saveCesarConversationSnapshot,
   resolveCesarBackend,
-  ensureCesarSession,
-  handleCesarBrain
+  ensureCesarSession
 };
-//# sourceMappingURL=chunk-GMVFKWQA.js.map
+//# sourceMappingURL=chunk-24EWX243.js.map