@kernlang/agon 0.1.0

package/dist/chunk-YNZ4UHZI.js

@@ -0,0 +1,1593 @@
+#!/usr/bin/env node
+import {
+  ENGINE_COLORS,
+  confidenceBadge,
+  ensureCesarSession,
+  filterDefaultOrchestrationEngines,
+  parseConfidence,
+  runForge
+} from "./chunk-4HY7J7LY.js";
+import {
+  RUNS_DIR,
+  acquireApplyLock,
+  applyPatchWithUndo,
+  approvePlan,
+  branchChanged,
+  cancelPlan,
+  classifyTask,
+  createPlan,
+  currentBranch,
+  ensureAgonHome,
+  extractPatchFilePatterns,
+  failPlan,
+  getActiveWorkspace,
+  gitChangedFiles,
+  headChanged,
+  headSha,
+  loadOrCreateActiveThread,
+  mergeStepResult,
+  recordForgeJudgment,
+  releaseApplyLock,
+  resolveWorkingDir,
+  savePlan,
+  scanProjectContext,
+  snapshotWorkspace,
+  startPlan,
+  tracker
+} from "./chunk-GCXVT7RP.js";
+
+// src/generated/handlers/forge.ts
+import { join as join4 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync4 } from "fs";
+import { execFileSync } from "child_process";
+
+// src/generated/cesar/judge.ts
+import { join } from "path";
+import { readFileSync, writeFileSync } from "fs";
+function parseForgeJudgment(response, manifest) {
+  const stripped = parseConfidence(response).rest;
+  const lines = stripped.split("\n");
+  let winner = manifest.winner ?? "";
+  const strengths = [];
+  const convergencePlan = [];
+  let summary = "";
+  let shouldConverge = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const winnerMatch = trimmed.match(/^WINNER:\s*(.+)/i);
+    if (winnerMatch) {
+      winner = winnerMatch[1].trim();
+    }
+    const convergeMatch = trimmed.match(/^CONVERGE:\s*(yes|no)/i);
+    if (convergeMatch) {
+      shouldConverge = convergeMatch[1].toLowerCase() === "yes";
+    }
+    const summaryMatch = trimmed.match(/^SUMMARY:\s*(.+)/i);
+    if (summaryMatch) {
+      summary = summaryMatch[1].trim();
+    }
+    const strengthMatch = trimmed.match(/^-\s+(\w+):\s+(.+?)\s+[—–-]\s+(.+)/);
+    if (strengthMatch && !trimmed.startsWith("- file:")) {
+      strengths.push({ engineId: strengthMatch[1], category: strengthMatch[2], reason: strengthMatch[3] });
+    }
+    const convMatch = trimmed.match(/^-\s+file:(\S+)\s+fn:(\S+)\s+from:(\S+)\s+reason:(.+)/);
+    if (convMatch) {
+      convergencePlan.push({ file: convMatch[1], fn: convMatch[2], from: convMatch[3], reason: convMatch[4].trim() });
+    }
+  }
+  if (!winner) {
+    return null;
+  }
+  return { winner, strengths, convergencePlan, summary, shouldConverge };
+}
+async function cesarReviewForgeOutcome(manifest, dispatch, ctx) {
+  let session;
+  try {
+    session = await ensureCesarSession(ctx);
+  } catch {
+    return;
+  }
+  if (!session.alive) return;
+  const cesarEngineId = ctx.config.cesarEngine ?? ctx.config.forgeFixedStarter ?? "claude";
+  const color = ENGINE_COLORS[cesarEngineId] ?? 124;
+  if (manifest.error) {
+    const skippedDetail = manifest.engines.length > 0 ? `Engines configured: ${manifest.engines.join(", ")}.` : "No engines were dispatched.";
+    const errorPrompt = `The forge run failed before producing a winner.
+
+TASK: ${manifest.task}
+FITNESS COMMAND: ${manifest.fitnessCmd}
+ERROR: ${manifest.error}
+${skippedDetail}
+
+In 2-3 sentences, explain to the user what went wrong and the most likely fix (refresh API keys, install a CLI, check git state, etc.). Be specific and actionable. Do not pad. End with a confidence percentage on whatever fix you suggest.`;
+    dispatch({ type: "spinner-start", message: "Cesar reading forge failure\u2026", color });
+    let response = "";
+    try {
+      const gen = session.send({ message: errorPrompt, signal: void 0 });
+      for await (const chunk of gen) {
+        if (chunk.type === "text") response += chunk.content;
+        if (chunk.type === "done" || chunk.type === "error") break;
+      }
+    } catch {
+    }
+    dispatch({ type: "spinner-stop" });
+    if (response.trim()) {
+      dispatch({ type: "header", title: "Cesar \u2014 Forge Failure" });
+      dispatch({ type: "engine-block", engineId: cesarEngineId, color, content: response.trim() });
+    }
+    return;
+  }
+  if (manifest.alreadySatisfied) {
+    const satisfiedPrompt = `The forge baseline check passed before any engine ran. The task says: ${manifest.task}. The fitness command "${manifest.fitnessCmd}" already passes on a clean checkout. In 1-2 sentences, confirm to the user that the task appears already done and suggest next steps (verify, move on, or re-check if the fitness command is too lenient). End with a confidence percentage.`;
+    dispatch({ type: "spinner-start", message: "Cesar confirming task state\u2026", color });
+    let response = "";
+    try {
+      const gen = session.send({ message: satisfiedPrompt, signal: void 0 });
+      for await (const chunk of gen) {
+        if (chunk.type === "text") response += chunk.content;
+        if (chunk.type === "done" || chunk.type === "error") break;
+      }
+    } catch {
+    }
+    dispatch({ type: "spinner-stop" });
+    if (response.trim()) {
+      dispatch({ type: "header", title: "Cesar \u2014 Already Satisfied" });
+      dispatch({ type: "engine-block", engineId: cesarEngineId, color, content: response.trim() });
+    }
+    return;
+  }
+  if (manifest.singleSurvivor && manifest.winner) {
+    const winnerId = manifest.winner;
+    const winnerResult = manifest.results[winnerId];
+    let winnerPatch = "";
+    const winnerPatchPath = manifest.patches[winnerId];
+    if (winnerPatchPath) {
+      try {
+        const fullPatch = readFileSync(winnerPatchPath, "utf-8");
+        const lines = fullPatch.split("\n");
+        winnerPatch = lines.slice(0, 200).join("\n");
+        if (lines.length > 200) winnerPatch += `
+... (${lines.length - 200} more lines)`;
+      } catch {
+        winnerPatch = "(patch file unreadable)";
+      }
+    }
+    const failedList = Object.entries(manifest.results).filter(([id, r]) => id !== winnerId && !r.pass).map(([id, r]) => `- ${id}: ${r.durationSec}s, ${r.diffLines ?? 0} lines, ${r.pass ? "passed" : "failed"}`).join("\n");
+    const survivorPrompt = `Forge produced exactly one passing result. The other engines failed.
+
+  TASK: ${manifest.task}
+  FITNESS COMMAND: ${manifest.fitnessCmd}
+  SOLE SURVIVOR: ${winnerId} (score: ${winnerResult?.score ?? 0})
+  OTHER ENGINES:
+  ${failedList || "(none reported)"}
+
+  ## SURVIVING PATCH (first 200 lines)
+
+  \`\`\`diff
+  ${winnerPatch}
+  \`\`\`
+
+  Read the patch carefully. Tell the user:
+  1. **Quality verdict** \u2014 does this look like a competent solution to the task? Note specific concerns or strengths.
+  2. **Recommendation** \u2014 accept this patch, or run /forge again hoping for more engines? Be specific about why.
+  3. **Apply hint** \u2014 if accept-worthy, give the exact path: ${winnerPatchPath ?? "(no patch path)"}
+
+  End with a confidence percentage. Don't pad.`;
+    dispatch({ type: "spinner-start", message: `Cesar reviewing ${winnerId}'s solo solution\u2026`, color });
+    let response = "";
+    try {
+      const gen = session.send({ message: survivorPrompt, signal: void 0 });
+      for await (const chunk of gen) {
+        if (chunk.type === "text") response += chunk.content;
+        if (chunk.type === "done" || chunk.type === "error") break;
+      }
+    } catch {
+    }
+    dispatch({ type: "spinner-stop" });
+    if (response.trim()) {
+      dispatch({ type: "header", title: `Cesar \u2014 Single Survivor (${winnerId})` });
+      dispatch({ type: "engine-block", engineId: cesarEngineId, color, content: response.trim() });
+    }
+    return;
+  }
+  if (!manifest.winner) {
+    const noWinnerPrompt = `Forge dispatched ${manifest.enginesDispatched} engine(s) and none produced a passing result for: ${manifest.task}
+
+Fitness command: ${manifest.fitnessCmd}
+
+Engine outcomes:
+${Object.entries(manifest.results).map(([id, r]) => `- ${id}: pass=${r.pass}, score=${r.score}, ${r.diffLines ?? 0} lines`).join("\n")}
+
+In 2-3 sentences, tell the user the most likely root cause (task too vague, fitness too strict, engines lacking context, etc.) and one concrete next move. End with a confidence percentage.`;
+    dispatch({ type: "spinner-start", message: "Cesar diagnosing forge failure\u2026", color });
+    let response = "";
+    try {
+      const gen = session.send({ message: noWinnerPrompt, signal: void 0 });
+      for await (const chunk of gen) {
+        if (chunk.type === "text") response += chunk.content;
+        if (chunk.type === "done" || chunk.type === "error") break;
+      }
+    } catch {
+    }
+    dispatch({ type: "spinner-stop" });
+    if (response.trim()) {
+      dispatch({ type: "header", title: "Cesar \u2014 No Winner" });
+      dispatch({ type: "engine-block", engineId: cesarEngineId, color, content: response.trim() });
+    }
+    return;
+  }
+}
+async function cesarJudgeForge(manifest, dispatch, ctx) {
+  let session;
+  try {
+    session = await ensureCesarSession(ctx);
+  } catch {
+    return null;
+  }
+  if (!session.alive) return null;
+  const cesarEngineId = ctx.config.cesarEngine ?? ctx.config.forgeFixedStarter ?? "claude";
+  const color = ENGINE_COLORS[cesarEngineId] ?? 124;
+  const engineSummaries = [];
+  const patchTexts = [];
+  for (const [id, result] of Object.entries(manifest.results)) {
+    let patchSummary = "(no patch)";
+    const patchPath = manifest.patches[id];
+    if (patchPath) {
+      try {
+        const patch = readFileSync(patchPath, "utf-8");
+        patchTexts.push(patch);
+        const lines = patch.split("\n");
+        patchSummary = lines.slice(0, 150).join("\n");
+        if (lines.length > 150) patchSummary += `
+... (${lines.length - 150} more lines)`;
+      } catch {
+        patchSummary = "(patch unreadable)";
+      }
+    }
+    engineSummaries.push(
+      `### ${id}
+- Score: ${result.score} | Pass: ${result.pass} | Diff: ${result.diffLines} lines | Files: ${result.filesChanged} | Time: ${result.durationSec}s
+\`\`\`diff
+${patchSummary}
+\`\`\``
+    );
+  }
+  const judgePrompt = `You are judging forge results. Multiple engines competed on this task.
+
+  TASK: ${manifest.task}
+  FITNESS COMMAND: ${manifest.fitnessCmd}
+  AUTOMATIC WINNER: ${manifest.winner ?? "none"}
+
+  ## ENGINE RESULTS
+
+  ${engineSummaries.join("\n\n")}
+
+  ## YOUR JOB
+
+  Evaluate each engine's code. Identify:
+  1. **Overall winner** \u2014 who produced the best result and why
+  2. **Per-engine strengths** \u2014 where each engine did something BETTER than others (architecture, error handling, tests, edge cases, code style, performance)
+  3. **Convergence plan** \u2014 if multiple engines have complementary strengths, list which parts from which engine should be merged. Only suggest convergence if it would genuinely improve the result.
+
+  Respond in this EXACT format:
+
+  WINNER: {engineId}
+  STRENGTHS:
+  - {engineId}: {category} \u2014 {reason}
+  - {engineId}: {category} \u2014 {reason}
+  CONVERGE: {yes|no}
+  CONVERGENCE:
+  - file:{path} fn:{name} from:{engineId} reason:{why}
+  SUMMARY: {your read \u2014 as long or as short as it actually deserves}`;
+  dispatch({ type: "spinner-start", message: "Cesar judging forge results\u2026", color });
+  let judgeResponse = "";
+  try {
+    const gen = session.send({ message: judgePrompt, signal: void 0 });
+    for await (const chunk of gen) {
+      if (chunk.type === "text") judgeResponse += chunk.content;
+      if (chunk.type === "done" || chunk.type === "error") break;
+    }
+  } catch {
+    dispatch({ type: "spinner-stop" });
+    return null;
+  }
+  dispatch({ type: "spinner-stop" });
+  const judgment = parseForgeJudgment(judgeResponse, manifest);
+  const conf = parseConfidence(judgeResponse);
+  if (conf.value !== null) {
+    dispatch({ type: "info", message: confidenceBadge(conf.value) + " Cesar (judge)" });
+  }
+  if (judgment) {
+    try {
+      recordForgeJudgment(
+        judgment.winner,
+        manifest.winner ?? null,
+        Object.keys(manifest.results),
+        classifyTask(manifest.task),
+        manifest.forgeId,
+        judgment.summary,
+        judgment.strengths,
+        extractPatchFilePatterns(patchTexts.join("\n"))
+      );
+    } catch (err) {
+      console.warn(`[agon] failed to record Cesar forge judgment: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    dispatch({ type: "header", title: "Cesar's Judgment" });
+    dispatch({ type: "success", message: `Winner: ${judgment.winner}` });
+    if (judgment.strengths.length > 0) {
+      dispatch({ type: "info", message: "Per-engine strengths:" });
+      for (const s of judgment.strengths) {
+        const sColor = ENGINE_COLORS[s.engineId] ?? 124;
+        dispatch({ type: "engine-block", engineId: s.engineId, color: sColor, content: `${s.category} \u2014 ${s.reason}` });
+      }
+    }
+    dispatch({ type: "info", message: judgment.summary });
+    if (judgment.shouldConverge && judgment.convergencePlan.length > 0) {
+      dispatch({ type: "header", title: "Convergence Plan" });
+      for (const entry of judgment.convergencePlan) {
+        const eColor = ENGINE_COLORS[entry.from] ?? 124;
+        dispatch({ type: "engine-block", engineId: entry.from, color: eColor, content: `${entry.file}:${entry.fn} \u2014 ${entry.reason}` });
+      }
+    }
+  }
+  return judgment;
+}
+async function cesarConvergeForge(manifest, judgment, dispatch, ctx) {
+  let session;
+  try {
+    session = await ensureCesarSession(ctx);
+  } catch {
+    return null;
+  }
+  if (!session.alive) return null;
+  const cesarEngineId = ctx.config.cesarEngine ?? ctx.config.forgeFixedStarter ?? "claude";
+  const color = ENGINE_COLORS[cesarEngineId] ?? 124;
+  const patchContents = {};
+  if (judgment.winner && manifest.patches[judgment.winner]) {
+    try {
+      patchContents[judgment.winner] = readFileSync(manifest.patches[judgment.winner], "utf-8");
+    } catch {
+    }
+  }
+  for (const entry of judgment.convergencePlan) {
+    if (!patchContents[entry.from] && manifest.patches[entry.from]) {
+      try {
+        patchContents[entry.from] = readFileSync(manifest.patches[entry.from], "utf-8");
+      } catch {
+      }
+    }
+  }
+  const patchSections = Object.entries(patchContents).map(([id, content]) => {
+    const lines = content.split("\n");
+    const summary = lines.slice(0, 200).join("\n");
+    return `### ${id}'s patch
+\`\`\`diff
+${summary}
+\`\`\``;
+  }).join("\n\n");
+  const planLines = judgment.convergencePlan.map(
+    (e) => `- Take ${e.fn} from ${e.from} (${e.file}) \u2014 ${e.reason}`
+  ).join("\n");
+  const convergePrompt = `You are synthesizing a converged patch from multiple forge competitors.
+
+  TASK: ${manifest.task}
+  WINNER: ${judgment.winner}
+
+  ## CONVERGENCE PLAN
+  ${planLines}
+
+  ## PATCHES TO MERGE
+  ${patchSections}
+
+  ## INSTRUCTIONS
+  Create a single unified diff that takes the best parts from each engine according to the convergence plan above.
+  - Start from the winner's patch as the base
+  - Replace specific functions/sections with the better versions from other engines
+  - Ensure the merged result is coherent \u2014 no duplicate functions, no conflicts
+  - Output ONLY the unified diff, nothing else. Start with --- and +++ lines.`;
+  dispatch({ type: "spinner-start", message: "Cesar synthesizing converged patch\u2026", color });
+  let convergedPatch = "";
+  try {
+    const gen = session.send({ message: convergePrompt, signal: void 0 });
+    for await (const chunk of gen) {
+      if (chunk.type === "text") convergedPatch += chunk.content;
+      if (chunk.type === "done" || chunk.type === "error") break;
+    }
+  } catch {
+    dispatch({ type: "spinner-stop" });
+    return null;
+  }
+  dispatch({ type: "spinner-stop" });
+  let patch = convergedPatch.trim();
+  const fenceMatch = patch.match(/```(?:diff)?\n([\s\S]*?)```/);
+  if (fenceMatch) patch = fenceMatch[1].trim();
+  if (!patch || !patch.includes("---")) {
+    dispatch({ type: "warning", message: "Cesar could not produce a valid converged patch" });
+    return null;
+  }
+  const convergePath = join(manifest.forgeDir, "convergence-patch.diff");
+  writeFileSync(convergePath, patch, "utf-8");
+  return convergePath;
+}
+
+// src/generated/models/session-results.ts
+var SessionResultStore = class {
+  results = [];
+  add(result) {
+    this.results.push(result);
+  }
+  getResults() {
+    return [...this.results];
+  }
+  hasResults() {
+    return this.results.length > 0;
+  }
+  getLatest() {
+    return this.results.length > 0 ? this.results[this.results.length - 1] : null;
+  }
+  clear() {
+    this.results = [];
+  }
+};
+var sessionResultStore = new SessionResultStore();
+
+// src/generated/cesar/scoreboard.ts
+function createScoreboard(runId, mode, engineIds) {
+  const now = Date.now();
+  return { runId, mode, startedAt: now, entries: engineIds.map((id) => Object.assign({}, { engineId: id, state: "waiting", progress: 0 })), overallState: "running" };
+}
+function scoreboardFind(board, engineId) {
+  return board.entries.find((e) => e.engineId === engineId);
+}
+function scoreboardUpdateProgress(board, engineId, progress) {
+  const entry = scoreboardFind(board, engineId);
+  if (!entry) {
+    return board;
+  }
+  entry.progress = Math.max(0, Math.min(100, Math.floor(progress)));
+  return board;
+}
+function scoreboardFinishEngine(board, engineId, opts) {
+  const entry = scoreboardFind(board, engineId);
+  if (!entry) {
+    return board;
+  }
+  entry.state = "done";
+  entry.finishedAt = Date.now();
+  entry.progress = 100;
+  if (opts?.score !== void 0) {
+    entry.score = opts.score;
+  }
+  if (opts?.result !== void 0) {
+    entry.result = opts.result;
+  }
+  scoreboardRecomputeOverall(board);
+  return board;
+}
+function scoreboardFailEngine(board, engineId, error) {
+  const entry = scoreboardFind(board, engineId);
+  if (!entry) {
+    return board;
+  }
+  entry.state = "failed";
+  entry.finishedAt = Date.now();
+  entry.error = error;
+  scoreboardRecomputeOverall(board);
+  return board;
+}
+function scoreboardRecomputeOverall(board) {
+  if (board.entries.every((e) => e.state === "done")) {
+    board.overallState = "done";
+  } else if (board.entries.every((e) => e.state === "failed")) {
+    board.overallState = "failed";
+  } else if (board.entries.every((e) => e.state === "done" || e.state === "failed" || e.state === "cancelled")) {
+    board.overallState = "done";
+  } else if (board.entries.some((e) => e.state === "running")) {
+    board.overallState = "running";
+  }
+}
+function formatScoreboardLine(entry) {
+  const iconMap = {
+    waiting: "\u25C7",
+    running: "\u25D0",
+    done: "\u2714",
+    failed: "\u2718",
+    cancelled: "\u25C7"
+  };
+  const color = ENGINE_COLORS[entry.engineId] ?? 245;
+  const icon = iconMap[entry.state];
+  const bar = entry.state === "running" ? `${entry.progress}%` : entry.state === "done" && entry.score != null ? `score ${entry.score}` : "";
+  const result = entry.result ? ` \u2014 ${entry.result}` : "";
+  const error = entry.error ? ` [${entry.error}]` : "";
+  return `\x1B[38;5;${color}m${icon} ${entry.engineId}${bar ? ` ${bar}` : ""}${result}${error}\x1B[0m`;
+}
+function renderScoreboard(board) {
+  const lines = board.entries.map((e) => formatScoreboardLine(e));
+  return lines.join("\n");
+}
+
+// src/generated/cesar/checkpoint.ts
+import { join as join2 } from "path";
+import { mkdirSync, appendFileSync, existsSync, readFileSync as readFileSync2 } from "fs";
+function createCheckpointId() {
+  return `chk-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+}
+function buildCheckpoint(runId, phase, mode, engineIds, metadata) {
+  const cwd = resolveWorkingDir();
+  let branch = "";
+  let changedFiles = [];
+  try {
+    branch = currentBranch(cwd);
+  } catch {
+  }
+  try {
+    changedFiles = gitChangedFiles(cwd);
+  } catch {
+  }
+  return {
+    id: createCheckpointId(),
+    runId,
+    phase,
+    ts: Date.now(),
+    cwd,
+    branch,
+    changedFiles,
+    mode,
+    engineIds,
+    metadata
+  };
+}
+function recordCheckpoint(cp, runsDir) {
+  try {
+    const dir = runsDir ?? RUNS_DIR;
+    mkdirSync(dir, { recursive: true });
+    appendFileSync(join2(dir, "checkpoints.jsonl"), JSON.stringify(cp) + "\n");
+  } catch {
+  }
+}
+
+// src/telemetry/index.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3, resolve } from "path";
+import { homedir } from "os";
+var DEFAULT_WINDOW = 50;
+function getAgonHome() {
+  const override = process.env.AGON_HOME?.trim();
+  return override ? resolve(override) : join3(homedir(), ".agon");
+}
+function telemetryPath() {
+  return join3(getAgonHome(), "telemetry.json");
+}
+function classifyTaskType(mode, intent) {
+  const m = mode.toLowerCase();
+  const text = (intent ?? "").toLowerCase();
+  if (m === "review") return "review";
+  if (text.length > 0) {
+    if (/\b(fix|bug|patch|hotfix|debug|regression|crash|error|issue)\b/.test(text)) return "bugfix";
+    if (/\b(add|implement|create|new|feature|support|enable)\b/.test(text)) return "feature";
+    if (/\b(refactor|cleanup|clean.?up|restructure|rename|move|extract|simplify|consolidate)\b/.test(text)) return "refactor";
+    if (/\b(spec|design|plan|proposal|architect)\b/.test(text)) return "spec";
+    if (/\b(question|explain|how|what|why|help|understand|clarify)\b/.test(text)) return "question";
+  }
+  if (m === "build" || m === "agent" || m === "team-agent" || m === "agent-solo") return "build";
+  if (m === "pipeline") return "pipeline";
+  if (m === "brainstorm" || m === "team-brainstorm") return "question";
+  if (m === "tribunal" || m === "team-tribunal") return "spec";
+  if (m === "campfire") return "question";
+  if (m === "forge" || m === "team-forge" || m === "speculate") return "feature";
+  return "unknown";
+}
+var TelemetryLedger = class {
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath ?? telemetryPath();
+  }
+  /** Read the entire ledger file, returning an empty structure if missing/malformed. */
+  read() {
+    try {
+      const raw = readFileSync3(this.filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && Array.isArray(parsed.runs)) return parsed;
+    } catch {
+    }
+    return { version: 1, runs: [] };
+  }
+  /** Persist the ledger to disk atomically. */
+  write(data) {
+    const dir = join3(this.filePath, "..");
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync2(this.filePath, JSON.stringify(data, null, 2));
+  }
+  /** Append a single run record. */
+  append(record) {
+    const data = this.read();
+    this.write({ ...data, runs: [...data.runs, record] });
+  }
+  /** Return the last N runs, optionally filtered by mode. */
+  recentRuns(limit = DEFAULT_WINDOW, mode) {
+    const data = this.read();
+    let runs = data.runs;
+    if (mode) runs = runs.filter((r) => r.mode === mode);
+    return runs.slice(-limit);
+  }
+  /**
+   * Compute rolling win rate over the last `window` runs.
+   * Returns entries per mode found in the window, plus an overall entry.
+   */
+  winRates(window = DEFAULT_WINDOW) {
+    const runs = this.recentRuns(window);
+    const byMode = /* @__PURE__ */ new Map();
+    for (const r of runs) {
+      const entry = byMode.get(r.mode) ?? { total: 0, wins: 0 };
+      entry.total += 1;
+      if (r.success) entry.wins += 1;
+      byMode.set(r.mode, entry);
+    }
+    const entries = [];
+    for (const [mode, { total, wins }] of byMode) {
+      entries.push({ mode, total, wins, rate: total > 0 ? wins / total : 0 });
+    }
+    const overallTotal = runs.length;
+    const overallWins = runs.filter((r) => r.success).length;
+    entries.push({
+      mode: "__overall__",
+      total: overallTotal,
+      wins: overallWins,
+      rate: overallTotal > 0 ? overallWins / overallTotal : 0
+    });
+    return entries;
+  }
+};
+var defaultLedger = new TelemetryLedger();
+function recordRun(result) {
+  const stats = typeof tracker?.getStats === "function" ? tracker.getStats() : null;
+  const record = {
+    id: `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    timestamp: Date.now(),
+    mode: result.mode,
+    taskType: classifyTaskType(result.mode, result.intent),
+    winner: result.winner,
+    success: result.success,
+    durationMs: result.durationMs,
+    engineIds: result.engineIds ?? [],
+    completionState: result.completionState,
+    costEstimateUsd: stats?.totalCostUsd ?? void 0
+  };
+  defaultLedger.append(record);
+  return record;
+}
+function formatRunSummary(record) {
+  const mode = record.mode;
+  const winner = record.winner ?? "\u2014";
+  const cost = record.costEstimateUsd && record.costEstimateUsd > 0 ? `~${record.costEstimateUsd.toFixed(2)}` : "";
+  const mins = Math.floor(record.durationMs / 6e4);
+  const secs = Math.floor(record.durationMs % 6e4 / 1e3);
+  const time = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+  const costText = cost ? ` \xB7 ${cost}` : "";
+  return `${mode} complete \u2192 ${winner} won${costText} \xB7 ${time}`;
+}
+
+// src/generated/handlers/forge.ts
+function handleForgeEvent(event, plan, engineStatus, dispatch, ctx) {
+  if (ctx.currentPlan?.state === "cancelled") return plan;
+  const id = event.engineId ?? "";
+  switch (event.type) {
+    case "baseline:start":
+      plan = mergeStepResult(plan, "baseline", { state: "running", attempts: [{ startedAt: (/* @__PURE__ */ new Date()).toISOString() }] });
+      break;
+    case "baseline:done":
+      plan = mergeStepResult(plan, "baseline", { state: "completed" });
+      if (event.data?.passes) {
+        dispatch({ type: "warning", message: "Baseline passes \u2014 fitness may be non-discriminating. Add a failing regression test, use forge validate mode, or allow no-diff validation." });
+      }
+      break;
+    case "stage1:dispatch":
+      plan = mergeStepResult(plan, "dispatch", { state: "running", attempts: [{ startedAt: (/* @__PURE__ */ new Date()).toISOString() }] });
+      engineStatus[id] = "building";
+      break;
+    case "stage2:dispatch":
+      engineStatus[id] = "building";
+      break;
+    case "engine:worktree": {
+      if (id) {
+        engineStatus[id] = "building";
+        const worktreePath = String(event.data?.worktreePath ?? "");
+        if (worktreePath && engineStatus[`${id}:worktree`] !== worktreePath) {
+          engineStatus[`${id}:worktree`] = worktreePath;
+          dispatch({ type: "info", message: `Forge worktree ${id}: ${worktreePath}` });
+        }
+      }
+      break;
+    }
+    case "engine:pid":
+      dispatch({ type: "engine-pid", engineId: id, pid: Number(event.data?.pid ?? 0), phase: event.data?.phase });
+      break;
+    case "engine:pid-clear":
+      dispatch({ type: "engine-pid-clear", engineId: id });
+      break;
+    case "engine:fallback":
+      engineStatus[String(event.data?.to ?? "")] = "fallback";
+      dispatch({ type: "warning", message: `${String(event.data?.from ?? id)} failed during ${String(event.data?.phase ?? "forge")} \u2014 retrying on ${String(event.data?.to ?? "fallback")}` });
+      break;
+    case "engine:failed": {
+      engineStatus[id] = "failed";
+      engineStatus[`${id}:score`] = "0";
+      const errMsg = String(event.data?.error ?? "failed");
+      engineStatus[`${id}:error`] = errMsg;
+      const snippet = errMsg.length > 120 ? errMsg.slice(0, 120) + "\u2026" : errMsg;
+      dispatch({ type: "warning", message: `${id} failed: ${snippet}` });
+      dispatch({ type: "engine-pid-clear", engineId: id });
+      break;
+    }
+    case "stage1:accepted":
+      engineStatus[id] = "done";
+      engineStatus[`${id}:score`] = String(event.data?.score ?? "?");
+      break;
+    case "stage1:score":
+    case "stage2:score": {
+      if (id) {
+        const passed = event.data?.pass !== false;
+        engineStatus[id] = passed ? "done" : "failed";
+        engineStatus[`${id}:score`] = String(event.data?.score ?? "?");
+        if (!passed) engineStatus[`${id}:error`] = Number(event.data?.score ?? 0) === 0 ? "no candidate changes or fitness failed" : "fitness failed";
+      }
+      const scoreStep = plan.steps.find((s) => s.id === "score");
+      if (scoreStep && scoreStep.result.state === "pending") {
+        plan = mergeStepResult(plan, "score", { state: "running", attempts: [{ startedAt: (/* @__PURE__ */ new Date()).toISOString() }] });
+      }
+      break;
+    }
+    case "winner:determined": {
+      plan = mergeStepResult(plan, "dispatch", { state: "completed" });
+      plan = mergeStepResult(plan, "score", { state: "completed" });
+      plan = mergeStepResult(plan, "winner", { state: "completed" });
+      if (event.data?.winner) {
+        const winnerId = String(event.data.winner);
+        engineStatus[winnerId] = "done";
+        engineStatus[`${winnerId}:score`] = String(event.data.bestScore ?? "?");
+        engineStatus["__winner"] = winnerId;
+      }
+      break;
+    }
+    case "forge:no-candidate-diff": {
+      const count = Number(event.data?.count ?? 0);
+      const toolLoopLimit = Number(event.data?.toolLoopLimit ?? 0);
+      if (toolLoopLimit > 0) {
+        dispatch({ type: "warning", message: `Forge produced no candidate diff: ${toolLoopLimit}/${count} engine(s) hit the tool-loop limit before producing a patch.` });
+      } else {
+        dispatch({ type: "warning", message: `Forge produced no candidate diff from ${count} engine(s).` });
+      }
+      break;
+    }
+    case "synthesis:start": {
+      plan = mergeStepResult(plan, "synthesis", { state: "running", attempts: [{ startedAt: (/* @__PURE__ */ new Date()).toISOString() }] });
+      const winnerId = id || engineStatus["__winner"] || "";
+      if (winnerId) engineStatus[winnerId] = "synthesizing";
+      break;
+    }
+    case "synthesis:done": {
+      plan = mergeStepResult(plan, "synthesis", { state: "completed" });
+      const winnerId = id || engineStatus["__winner"] || "";
+      if (winnerId && engineStatus[winnerId] === "synthesizing") engineStatus[winnerId] = "done";
+      break;
+    }
+  }
+  ctx.setCurrentPlan(plan);
+  return plan;
+}
+function applyForgePatchToWorkspace(winnerId, patchContent, dispatch, baseSha, baseBranch) {
+  if (!patchContent.trim()) {
+    dispatch({ type: "info", message: `Winner ${winnerId} produced an empty patch.` });
+    return true;
+  }
+  const cwd = resolveWorkingDir();
+  const movedHead = headChanged(cwd, baseSha ?? null);
+  if (movedHead.changed) {
+    dispatch({ type: "warning", message: `HEAD moved (${(baseSha ?? "?").slice(0, 8)} \u2192 ${(movedHead.current ?? "?").slice(0, 8)}) since this run started \u2014 not auto-applying. Review with /apply.` });
+    return false;
+  }
+  const movedBranch = branchChanged(cwd, baseBranch ?? null);
+  if (movedBranch.changed) {
+    dispatch({ type: "warning", message: `Branch changed (${baseBranch} \u2192 ${movedBranch.current ?? "?"}) since this run started \u2014 not auto-applying. Review with /apply.` });
+    return false;
+  }
+  const lock = acquireApplyLock(cwd, `forge-apply ${winnerId}`);
+  if (!lock.acquired) {
+    const who = lock.heldBy ? ` (pid ${lock.heldBy.pid}: ${lock.heldBy.action})` : "";
+    dispatch({ type: "warning", message: `Another apply is in progress in this checkout${who} \u2014 not auto-applying. Review with /apply once it finishes.` });
+    return false;
+  }
+  try {
+    const result = applyPatchWithUndo(cwd, patchContent);
+    if (result.ok) {
+      dispatch({ type: "success", message: `Applied winner patch from ${winnerId}` });
+      if (result.undoToken) dispatch({ type: "info", message: "Undo available: /undo" });
+      return true;
+    }
+    dispatch({ type: "warning", message: `Winner patch not applied automatically: ${result.error ?? "unknown error"}` });
+    return false;
+  } finally {
+    if (lock.sessionUUID) releaseApplyLock(cwd, lock.sessionUUID);
+  }
+}
+function extractFitnessCommandFromCesarOutput(output) {
+  let text = String(output ?? "").trim();
+  if (!text) return null;
+  text = text.replace(/^```(?:json|bash|sh)?\s*/i, "").replace(/\s*```$/i, "").trim();
+  let candidate = null;
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (jsonMatch) {
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (parsed && typeof parsed.fitnessCmd === "string") candidate = parsed.fitnessCmd;
+      else if (parsed && typeof parsed.command === "string") candidate = parsed.command;
+    } catch {
+    }
+  }
+  if (!candidate) {
+    candidate = text.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0 && !/^(```|fitnessCmd\s*:|command\s*:)/i.test(line)) ?? null;
+  }
+  if (!candidate) return null;
+  candidate = candidate.replace(/^`|`$/g, "").trim();
+  candidate = candidate.replace(/^(fitnessCmd|command)\s*:\s*/i, "").trim();
+  if (!candidate || candidate.length > 500 || /[\r\n\0]/.test(candidate)) return null;
+  return candidate;
+}
+function extractGithubLiterals(text) {
+  return [...new Set((String(text ?? "").match(/(?:https?:\/\/)?github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+/g) ?? []).map((m) => m.replace(/^https?:\/\//, "").replace(/[).,;:'"`\]]+$/g, "")))];
+}
+function repairFitnessCommandTaskLiterals(task, command) {
+  const taskUrls = extractGithubLiterals(task);
+  if (taskUrls.length === 0) return command;
+  const taskUrlSet = new Set(taskUrls);
+  let repaired = command;
+  for (const cmdUrl of extractGithubLiterals(command)) {
+    if (taskUrlSet.has(cmdUrl)) continue;
+    const cmdParts = cmdUrl.split("/");
+    const replacement = taskUrls.length === 1 ? taskUrls[0] : taskUrls.find((url) => {
+      const parts = url.split("/");
+      return parts[2]?.toLowerCase() === cmdParts[2]?.toLowerCase();
+    });
+    if (replacement) {
+      repaired = repaired.split(cmdUrl).join(replacement);
+    }
+  }
+  return repaired;
+}
+function normalizeGithubRemoteLiteral(remote) {
+  const raw = String(remote ?? "").trim();
+  if (!raw) {
+    return null;
+  }
+  const cleaned = raw.replace(/\.git$/, "");
+  const ssh = cleaned.match(/^git@github\.com:([^/]+)\/(.+)$/);
+  if (ssh) {
+    return `github.com/${ssh[1]}/${ssh[2]}`;
+  }
+  const https = cleaned.match(/^https?:\/\/github\.com\/([^/]+)\/(.+)$/);
+  if (https) {
+    return `github.com/${https[1]}/${https[2]}`;
+  }
+  return null;
+}
+function detectGithubRemoteLiteral(cwd) {
+  try {
+    const remote = execFileSync("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }).trim();
+    return normalizeGithubRemoteLiteral(remote);
+  } catch (e) {
+    return null;
+  }
+}
+function repairFitnessCommandRepositoryLiteral(command, repoLiteral) {
+  if (!repoLiteral) {
+    return command;
+  }
+  let repaired = command;
+  for (const cmdUrl of extractGithubLiterals(command)) {
+    if (cmdUrl === repoLiteral) {
+      continue;
+    }
+    repaired = repaired.split(cmdUrl).join(repoLiteral);
+  }
+  return repaired;
+}
+function taskExplicitlyMentionsLiteral(task, literal) {
+  const taskLower = String(task ?? "").toLowerCase();
+  const literalLower = String(literal ?? "").toLowerCase();
+  if (!literalLower) {
+    return false;
+  }
+  if (taskLower.includes(literalLower)) {
+    return true;
+  }
+  const escaped = literalLower.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\b(?:no|avoid|without|forbid|exclude|do not mention)\\s+${escaped}\\b`, "i").test(taskLower);
+}
+function taskWantsRepositoryLinkCheck(task) {
+  const t = String(task ?? "").toLowerCase();
+  if (/github\.com\/[a-z0-9_.-]+\/[a-z0-9_.-]+/i.test(t)) {
+    return true;
+  }
+  return /\b(?:github|repo(?:sitory)?\s+(?:url|link)|project\s+(?:url|link)|source\s+(?:url|link)|footer\s+(?:with|containing|link)|public\s+(?:repo|repository|link|url))\b/i.test(t);
+}
+function repairOverbroadForbiddenLiterals(task, command, repoLiteral) {
+  const forbidden = extractFitnessStringArray(command, "forbidden");
+  if (forbidden.length === 0 || !repoLiteral) return command;
+  const parts = repoLiteral.split("/");
+  const protectedLiterals = /* @__PURE__ */ new Set();
+  if (parts[1]) protectedLiterals.add(parts[1]);
+  if (parts[2]) protectedLiterals.add(parts[2]);
+  protectedLiterals.add(repoLiteral);
+  protectedLiterals.add(`https://${repoLiteral}`);
+  const kept = forbidden.filter((f) => {
+    const isProtected = [...protectedLiterals].some((p) => p.toLowerCase() === f.toLowerCase());
+    if (!isProtected) return true;
+    return taskExplicitlyMentionsLiteral(task, f);
+  });
+  if (kept.length === forbidden.length) return command;
+  const serialized = kept.map((v) => `'${v.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`).join(",");
+  return command.replace(/forbidden\s*=\s*\[[^\]]*\]/, `forbidden=[${serialized}]`);
+}
+function extractFitnessStringArray(command, name) {
+  const re = new RegExp(`${name}\\s*=\\s*\\[([^\\]]*)\\]`);
+  const match = String(command ?? "").match(re);
+  if (!match) return [];
+  const values = [];
+  const body = match[1];
+  const stringRe = /(['"])((?:\\.|(?!\1).)*)\1/g;
+  let m;
+  while ((m = stringRe.exec(body)) !== null) {
+    values.push(m[2].replace(/\\(['"\\])/g, "$1"));
+  }
+  return values;
+}
+function repairContradictoryFitnessLiterals(command) {
+  const required = extractFitnessStringArray(command, "required");
+  const forbidden = extractFitnessStringArray(command, "forbidden");
+  if (required.length === 0 || forbidden.length === 0) return command;
+  const kept = forbidden.filter((f) => {
+    const lower = f.toLowerCase();
+    return !required.some((r) => {
+      const req = r.toLowerCase();
+      return req.includes(lower) || lower.includes(req);
+    });
+  });
+  if (kept.length === forbidden.length) return command;
+  const serialized = kept.map((v) => `'${v.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`).join(",");
+  return command.replace(/forbidden\s*=\s*\[[^\]]*\]/, `forbidden=[${serialized}]`);
+}
+function validateFitnessCommandIntent(task, command, repoLiteral) {
+  const cmd = String(command ?? "");
+  if (!cmd.trim()) {
+    return { ok: false, reason: "empty fitness command" };
+  }
+  const githubLiterals = extractGithubLiterals(cmd);
+  if (githubLiterals.length > 0 && !taskWantsRepositoryLinkCheck(task)) {
+    return { ok: false, reason: `fitness added repository URL check without repo-link intent: ${githubLiterals.join(", ")}` };
+  }
+  const required = extractFitnessStringArray(cmd, "required");
+  const forbidden = extractFitnessStringArray(cmd, "forbidden");
+  for (const r of required) {
+    const req = r.toLowerCase();
+    for (const f of forbidden) {
+      const forb = f.toLowerCase();
+      if (req.includes(forb) || forb.includes(req)) {
+        return { ok: false, reason: `fitness requires and forbids overlapping literal "${f}"` };
+      }
+    }
+  }
+  if (repoLiteral) {
+    const owner = repoLiteral.split("/")[1] ?? "";
+    if (owner) {
+      const overbroad = forbidden.find((f) => f.toLowerCase() === owner.toLowerCase() && !taskExplicitlyMentionsLiteral(task, f));
+      if (overbroad) {
+        return { ok: false, reason: `fitness forbids local repo identity "${overbroad}" without explicit task intent` };
+      }
+    }
+  }
+  return { ok: true };
+}
+function repairForgeTaskRepositoryLiteral(task, cwd) {
+  const repoLiteral = detectGithubRemoteLiteral(cwd);
+  return repairFitnessCommandRepositoryLiteral(task, repoLiteral);
+}
+function describeProjectFitnessOptions(cwd) {
+  const lines = [];
+  const packageJsonPath = join4(cwd, "package.json");
+  if (existsSync2(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
+      const scripts = pkg && typeof pkg === "object" && pkg.scripts && typeof pkg.scripts === "object" ? Object.keys(pkg.scripts).sort() : [];
+      if (scripts.length > 0) {
+        lines.push(`package.json scripts: ${scripts.join(", ")}`);
+      }
+    } catch (e) {
+      lines.push("package.json exists but could not be parsed");
+    }
+  }
+  if (existsSync2(join4(cwd, "Cargo.toml"))) {
+    lines.push("Cargo.toml present");
+  }
+  if (existsSync2(join4(cwd, "go.mod"))) {
+    lines.push("go.mod present");
+  }
+  if (existsSync2(join4(cwd, "pyproject.toml"))) {
+    lines.push("pyproject.toml present");
+  }
+  if (existsSync2(join4(cwd, "README.md"))) {
+    lines.push("README.md present");
+  }
+  const repoLiteral = detectGithubRemoteLiteral(cwd);
+  if (repoLiteral) {
+    lines.push(`git origin: ${repoLiteral}`);
+  }
+  return lines.length > 0 ? lines.join("\n") : "No common project test metadata found.";
+}
+async function prepareForgeFitnessCommand(task, dispatch, ctx) {
+  const config = ctx.config;
+  const cwd = resolveWorkingDir();
+  const cesarEngineId = String(config.cesarEngine ?? config.forgeFixedStarter ?? ctx.activeEngines()[0] ?? "").trim();
+  if (!cesarEngineId) return null;
+  let engine = null;
+  try {
+    engine = ctx.registry.get(cesarEngineId);
+  } catch {
+    return null;
+  }
+  if (!engine) return null;
+  const outputDir = join4(RUNS_DIR, `fitness-${Date.now()}`);
+  mkdirSync3(outputDir, { recursive: true });
+  dispatch({ type: "info", message: `Cesar preparing fitness check with ${cesarEngineId}\u2026` });
+  const prompt = [
+    "Prepare one shell fitness command for a forge run.",
+    "",
+    'Return strict JSON only: {"fitnessCmd":"<command>","reason":"<short reason>"}',
+    "",
+    "Rules:",
+    "- The command must be non-interactive and suitable to run from the repository root.",
+    "- Interpret the task semantically. Do not convert every phrase into a literal grep.",
+    "- The command should verify the task requirements as specifically as possible using local files and local project facts.",
+    "- Do not add GitHub/repository URL checks unless the task explicitly asks for a public repo link, GitHub URL, or footer/source link.",
+    "- If a repo link is needed, use the git origin shown in Project signals as the source of truth.",
+    "- Preserve exact literals only when the task actually requires those literals. Do not correct or invent spellings.",
+    '- Do not turn broad wording like "avoid internal build details" into forbidding local identity names such as the GitHub owner or repo name.',
+    "- Prefer existing project scripts when they fit; otherwise write a small shell/node/python check.",
+    "- Do not include markdown, prose, or multiple commands outside the JSON string.",
+    "",
+    `Task:
+${task}`,
+    "",
+    `Project signals:
+${describeProjectFitnessOptions(cwd)}`
+  ].join("\n");
+  try {
+    const result = await ctx.adapter.dispatch({
+      engine,
+      prompt,
+      cwd,
+      mode: "exec",
+      timeout: Math.min(config.timeout ?? 90, 90),
+      outputDir
+    });
+    const cmd = extractFitnessCommandFromCesarOutput(String(result.stdout ?? ""));
+    if (cmd) {
+      const repoLiteral = detectGithubRemoteLiteral(cwd);
+      const taskRepaired = repairFitnessCommandTaskLiterals(task, cmd);
+      const repoRepaired = repairFitnessCommandRepositoryLiteral(taskRepaired, repoLiteral);
+      const forbiddenRepaired = repairOverbroadForbiddenLiterals(task, repoRepaired, repoLiteral);
+      const repaired = repairContradictoryFitnessLiterals(forbiddenRepaired);
+      const validation = validateFitnessCommandIntent(task, repaired, repoLiteral);
+      if (!validation.ok) {
+        dispatch({ type: "warning", message: `Rejected Cesar fitness check: ${validation.reason}` });
+        return null;
+      }
+      if (repaired !== cmd) {
+        dispatch({ type: "warning", message: `Repaired Cesar fitness literal: ${cmd} -> ${repaired}` });
+      }
+      dispatch({ type: "info", message: `Cesar fitness check: ${repaired}` });
+      return repaired;
+    }
+  } catch (err) {
+    dispatch({ type: "warning", message: `Cesar could not prepare a fitness check: ${err instanceof Error ? err.message : String(err)}` });
+  }
+  return null;
+}
+function inferProjectFitnessCommand(cwd) {
+  const packageJsonPath = join4(cwd, "package.json");
+  if (existsSync2(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
+      const scripts = pkg && typeof pkg === "object" && pkg.scripts && typeof pkg.scripts === "object" ? pkg.scripts : {};
+      const hasScript = (name) => typeof scripts[name] === "string" && String(scripts[name]).trim().length > 0;
+      if (hasScript("test:ts")) return "npm run test:ts";
+      if (hasScript("test")) return "npm test";
+      if (hasScript("typecheck")) return "npm run typecheck";
+      if (hasScript("build")) return "npm run build";
+    } catch {
+    }
+  }
+  if (existsSync2(join4(cwd, "Cargo.toml"))) return "cargo test";
+  if (existsSync2(join4(cwd, "go.mod"))) return "go test ./...";
+  if (existsSync2(join4(cwd, "pyproject.toml"))) return "python -m pytest";
+  return "git diff --check";
+}
+async function handleForge(task, fitnessCmd, dispatch, ctx, existingPlan, hardened, skipPlanApproval) {
+  const forgeAbort = new AbortController();
+  try {
+    ensureAgonHome();
+    if (!task) {
+      dispatch({ type: "warning", message: 'No task provided. Usage: "fix the auth bug, test with npm test"' });
+      return null;
+    }
+    const forgeCwd = resolveWorkingDir();
+    const preflightHead = (() => {
+      try {
+        return headSha(forgeCwd);
+      } catch {
+        return null;
+      }
+    })();
+    const preflightBranch = (() => {
+      try {
+        return currentBranch(forgeCwd);
+      } catch {
+        return null;
+      }
+    })();
+    const originalTask = task;
+    task = repairForgeTaskRepositoryLiteral(task, forgeCwd);
+    if (task !== originalTask) {
+      dispatch({ type: "warning", message: "Repaired forge task repository link to match git origin." });
+    }
+    let fitness = fitnessCmd;
+    if (!fitness) {
+      fitness = await prepareForgeFitnessCommand(task, dispatch, ctx);
+    }
+    if (!fitness) {
+      fitness = inferProjectFitnessCommand(resolveWorkingDir());
+      dispatch({ type: "warning", message: `Cesar did not provide a fitness check; falling back to: ${fitness}` });
+    }
+    const allEngines = ctx.activeEngines();
+    const engines = filterDefaultOrchestrationEngines(allEngines);
+    const excluded = allEngines.filter((id) => !engines.includes(id));
+    if (excluded.length > 0) dispatch({ type: "info", message: `Skipping disabled orchestration engines: ${excluded.join(", ")}` });
+    if (engines.length === 0) {
+      dispatch({ type: "error", message: "No engines available. Install at least one AI CLI tool." });
+      return null;
+    }
+    const config = ctx.config;
+    let plan;
+    if (existingPlan) {
+      plan = startPlan(existingPlan);
+      ctx.setCurrentPlan(plan);
+      savePlan(plan);
+    } else {
+      const ws = getActiveWorkspace();
+      const snapshot = ws ? snapshotWorkspace(ws) : { id: "cwd", path: forgeCwd, headSha: "unknown", branch: "unknown", dirty: false };
+      const forgeSteps = [
+        { id: "baseline", kind: "fitness", label: "Baseline fitness check", effects: ["exec"] },
+        { id: "dispatch", kind: "dispatch", label: `Dispatch engines: ${engines.join(", ")}`, effects: ["exec", "write", "network"] },
+        { id: "score", kind: "fitness", label: "Score engine results", effects: ["exec", "read"] },
+        { id: "winner", kind: "dispatch", label: "Determine winner", effects: ["read"] }
+      ];
+      if (config.forgeEnableSynthesis) {
+        forgeSteps.push({ id: "synthesis", kind: "synthesis", label: "Critique & synthesize", effects: ["exec", "write", "network"] });
+      }
+      plan = createPlan(
+        { type: "forge", task, fitnessCmd: fitness, engines, hardened: hardened ?? false },
+        snapshot,
+        forgeSteps
+      );
+      ctx.setCurrentPlan(plan);
+      dispatch({ type: "plan", plan });
+      const approvalLevel = config.approvalLevel ?? "plan";
+      if (!skipPlanApproval && approvalLevel !== "auto") {
+        const answer = await ctx.askQuestion("Approve plan? [Y/n]");
+        if (answer.trim().toLowerCase() === "n") {
+          plan = cancelPlan(plan);
+          ctx.setCurrentPlan(plan);
+          savePlan(plan);
+          dispatch({ type: "info", message: "Plan cancelled." });
+          return null;
+        }
+      }
+      plan = approvePlan(plan);
+      plan = startPlan(plan);
+      ctx.setCurrentPlan(plan);
+      savePlan(plan);
+    }
+    const forgeDir = join4(RUNS_DIR, `forge-${Date.now()}`);
+    mkdirSync3(forgeDir, { recursive: true });
+    dispatch({ type: "info", message: `Forge run dir: ${forgeDir}` });
+    const projectCtx = scanProjectContext(forgeCwd, config.projectContext || void 0, config.contextFormat);
+    const engineStatus = {};
+    const startTime = Date.now();
+    const runId = `forge-${Date.now()}`;
+    const scoreboard = createScoreboard(runId, "forge", engines);
+    const preCp = buildCheckpoint(runId, "pre-dispatch", "forge", engines, { task, fitnessCmd: fitness, hardened: hardened ?? false });
+    recordCheckpoint(preCp);
+    const agentEngineIds = /* @__PURE__ */ new Set();
+    for (const id of engines) {
+      try {
+        const eng = ctx.registry.get(id);
+        if (eng.agent || eng.api) agentEngineIds.add(id);
+      } catch {
+      }
+    }
+    let _lastProgressSig = "";
+    const progressInterval = setInterval(() => {
+      const elapsed = Math.floor((Date.now() - startTime) / 1e3);
+      const progress = engines.map((id) => {
+        const status = engineStatus[id] ?? "preparing";
+        return {
+          id,
+          status: status === "done" ? `done (${engineStatus[`${id}:score`] ?? "?"})` : status,
+          elapsed,
+          done: status === "done",
+          failed: status === "failed",
+          score: engineStatus[`${id}:score`],
+          isAgent: agentEngineIds.has(id)
+        };
+      });
+      const sig = progress.map((p) => `${p.id}:${p.status}:${p.score ?? ""}`).join("|") + `@${elapsed}`;
+      if (sig !== _lastProgressSig) {
+        _lastProgressSig = sig;
+        dispatch({ type: "progress-update", engines: progress });
+      }
+      for (const id of engines) {
+        const s = engineStatus[id] ?? "waiting";
+        if (s === "building") scoreboardUpdateProgress(scoreboard, id, Math.min(95, elapsed * 2));
+        else if (s === "done") scoreboardFinishEngine(scoreboard, id, { score: Number(engineStatus[`${id}:score`]) || void 0 });
+        else if (s === "failed") scoreboardFailEngine(scoreboard, id, engineStatus[`${id}:error`] ?? "failed");
+      }
+    }, 250);
+    ctx.setActiveAbort(forgeAbort);
+    let manifest;
+    try {
+      manifest = await runForge(
+        {
+          task,
+          fitnessCmd: fitness,
+          cwd: forgeCwd,
+          forgeDir,
+          engines,
+          context: projectCtx,
+          hardened: hardened ?? false,
+          // Interactive forge: Cesar synthesizes the best-of-all result (only
+          // active when config.forgeEnableSynthesis is on). Falls back to the
+          // winner engine if cesarEngine is unset/unknown.
+          synthEngine: String(ctx.config.cesarEngine ?? "").trim() || void 0,
+          synthesize: "always",
+          signal: forgeAbort.signal
+        },
+        ctx.registry,
+        ctx.adapter,
+        (event) => {
+          plan = handleForgeEvent(event, plan, engineStatus, dispatch, ctx);
+        }
+      );
+    } catch (err) {
+      clearInterval(progressInterval);
+      dispatch({ type: "progress-clear" });
+      ctx.setActiveAbort(null);
+      if (ctx.currentPlan?.state !== "cancelled") {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        plan = failPlan(plan, errorMsg);
+        ctx.setCurrentPlan(plan);
+        savePlan(plan);
+      }
+      throw err;
+    }
+    clearInterval(progressInterval);
+    dispatch({ type: "progress-clear" });
+    if (manifest.error) {
+      dispatch({ type: "warning", message: `Forge failed: ${manifest.error}` });
+      try {
+        await cesarReviewForgeOutcome(manifest, dispatch, ctx);
+      } catch (err) {
+        console.warn(`[agon] Cesar review (error path) failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      if (ctx.currentPlan?.state !== "cancelled") {
+        plan = failPlan(plan, manifest.error);
+        ctx.setCurrentPlan(plan);
+        savePlan(plan);
+      }
+      recordRun({
+        mode: "forge",
+        intent: task,
+        winner: void 0,
+        success: false,
+        durationMs: Date.now() - startTime,
+        engineIds: engines,
+        fitnessCmd: fitness ?? void 0,
+        completionState: "crashed",
+        error: manifest.error
+      });
+      ctx.setActiveAbort(null);
+      return null;
+    }
+    if (manifest.alreadySatisfied) {
+      dispatch({ type: "info", message: "Forge: task already satisfied \u2014 fitness command passes on baseline, no engines dispatched." });
+      try {
+        await cesarReviewForgeOutcome(manifest, dispatch, ctx);
+      } catch (err) {
+        console.warn(`[agon] Cesar review (already-satisfied path) failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      recordRun({
+        mode: "forge",
+        intent: task,
+        winner: void 0,
+        success: true,
+        durationMs: Date.now() - startTime,
+        engineIds: engines,
+        fitnessCmd: fitness ?? void 0,
+        completionState: "completed"
+      });
+      ctx.setActiveAbort(null);
+      return { winner: null, patchPath: null, manifestPath: `${forgeDir}/manifest.json`, task, fitnessCmd: fitness };
+    }
+    if (manifest.singleSurvivor && manifest.winner) {
+      const winner = manifest.winner;
+      const score = manifest.results[winner]?.score ?? 0;
+      dispatch({ type: "warning", message: `Only ${winner} produced a passing result (score ${score}). Other engines failed.` });
+      try {
+        await cesarReviewForgeOutcome(manifest, dispatch, ctx);
+      } catch (err) {
+        console.warn(`[agon] Cesar review (single-survivor path) failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    for (const id of engines) {
+      const s = engineStatus[id] ?? "waiting";
+      if (s === "done") scoreboardFinishEngine(scoreboard, id, { score: Number(engineStatus[`${id}:score`]) || void 0 });
+      else if (s === "failed") scoreboardFailEngine(scoreboard, id, engineStatus[`${id}:error`] ?? "failed");
+    }
+    dispatch({ type: "info", message: renderScoreboard(scoreboard) });
+    const postCp = buildCheckpoint(runId, "post-dispatch", "forge", engines, { winner: manifest.winner ?? null, task });
+    recordCheckpoint(postCp);
+    const engineIds = Object.keys(manifest.results);
+    const results = Object.values(manifest.results);
+    dispatch({
+      type: "scoreboard",
+      title: "Forge Scoreboard",
+      engineIds,
+      winner: manifest.winner ?? void 0,
+      metrics: [
+        { label: "Fitness", values: results.map((r) => r.pass ? `PASS (${r.score})` : "FAIL") },
+        { label: "Score", values: results.map((r) => String(r.score)) },
+        { label: "Diff size", values: results.map((r) => `${r.diffLines} lines`) },
+        { label: "Files changed", values: results.map((r) => String(r.filesChanged)) },
+        { label: "Time", values: results.map((r) => `${r.durationSec}s`) }
+      ]
+    });
+    let judgment = null;
+    const passingEngines = Object.values(manifest.results).filter((r) => r.pass).length;
+    if (passingEngines >= 2 && ctx.cesarSession) {
+      try {
+        judgment = await cesarJudgeForge(manifest, dispatch, ctx);
+      } catch (err) {
+        console.warn(`[agon] Cesar judge failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    } else if (passingEngines === 0 && !manifest.alreadySatisfied && ctx.cesarSession) {
+      try {
+        await cesarReviewForgeOutcome(manifest, dispatch, ctx);
+      } catch (err) {
+        console.warn(`[agon] Cesar review (no-winner path) failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    const finalWinner = judgment?.winner ?? manifest.winner;
+    if (judgment?.shouldConverge && judgment.convergencePlan.length > 0 && finalWinner) {
+      dispatch({ type: "info", message: "Cesar recommends convergence \u2014 synthesizing best-of-breed\u2026" });
+      const answer = await ctx.askQuestion("Converge best parts from all engines? [Y/n]");
+      if (answer.trim().toLowerCase() !== "n") {
+        try {
+          const convergedPath = await cesarConvergeForge(manifest, judgment, dispatch, ctx);
+          if (convergedPath) {
+            dispatch({ type: "success", message: "Convergence complete \u2014 merged patch ready" });
+            const convergedContent = readFileSync4(convergedPath, "utf-8");
+            const applied = applyForgePatchToWorkspace("convergence", convergedContent, dispatch, preflightHead, preflightBranch);
+            if (!applied) dispatch({ type: "patch-review", winnerId: "convergence", patchPath: convergedPath, patchContent: convergedContent });
+            if (ctx.config.sessionContinuity === true) {
+              try {
+                const convergeThread = loadOrCreateActiveThread(resolveWorkingDir());
+                const capped = convergedContent.length > 9e4 ? convergedContent.slice(0, 9e4) + `
+
+[... ${convergedContent.length - 9e4} more chars truncated \u2014 full patch at ${convergedPath}]` : convergedContent;
+                convergeThread.append({
+                  role: "assistant",
+                  content: `[forge-convergence-diff] winner: convergence (best-of-breed)
+patch path: ${convergedPath}
+
+${capped}`
+                });
+                await convergeThread.save();
+              } catch (threadErr) {
+                dispatch({ type: "warning", message: `Convergence diff NOT persisted to thread: ${threadErr instanceof Error ? threadErr.message : String(threadErr)}` });
+              }
+            }
+            dispatch({ type: "info", message: `Manifest: ${forgeDir}/manifest.json` });
+            dispatch({ type: "info", message: `Result bundle: ${manifest.resultBundlePath ?? `${forgeDir}/result.json`}` });
+            for (const step of plan.steps) {
+              if (step.result.state === "pending" || step.result.state === "running") {
+                plan = mergeStepResult(plan, step.id, { state: "completed" });
+              }
+            }
+            const winnerArtifacts2 = [
+              { type: "manifest", path: `${forgeDir}/manifest.json` },
+              { type: "patch", path: convergedPath, engineId: "convergence" }
+            ];
+            plan = mergeStepResult(plan, "winner", { state: "completed", artifacts: winnerArtifacts2 });
+            ctx.setCurrentPlan(plan);
+            savePlan(plan);
+            dispatch({ type: "info", message: `Plan: ${plan.id}` });
+            sessionResultStore.add({
+              type: "forge",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              question: task,
+              engines: engineIds,
+              winner: "convergence",
+              data: {
+                scoreboard: engineIds.map((id) => {
+                  const r = manifest.results[id];
+                  return { engineId: id, pass: r.pass, score: r.score, diffLines: r.diffLines, filesChanged: r.filesChanged, durationSec: r.durationSec };
+                }),
+                winner: "convergence",
+                synthesis: manifest.synthesis ?? void 0
+              }
+            });
+            for (const [id, r] of Object.entries(manifest.results)) {
+              tracker.record(id, { prompt: task, response: `score:${r.score} diff:${r.diffLines}` });
+            }
+            recordRun({
+              mode: "forge",
+              intent: task,
+              winner: "convergence",
+              success: true,
+              durationMs: Date.now() - startTime,
+              engineIds,
+              fitnessCmd: fitness ?? void 0,
+              completionState: "completed"
+            });
+            return {
+              winner: "convergence",
+              patchPath: convergedPath,
+              manifestPath: `${forgeDir}/manifest.json`,
+              task,
+              fitnessCmd: fitness
+            };
+          }
+        } catch (err) {
+          dispatch({ type: "warning", message: `Convergence failed: ${err instanceof Error ? err.message : String(err)}. Falling back to winner.` });
+        }
+      }
+    }
+    if (finalWinner) {
+      if (!judgment) dispatch({ type: "success", message: `Winner: ${finalWinner}` });
+      const patchPath = manifest.patches[finalWinner];
+      dispatch({ type: "info", message: `Patch: ${patchPath}` });
+      if (patchPath) {
+        try {
+          const patchContent = readFileSync4(patchPath, "utf-8");
+          const applied = applyForgePatchToWorkspace(finalWinner, patchContent, dispatch, preflightHead, preflightBranch);
+          if (!applied) dispatch({ type: "patch-review", winnerId: finalWinner, patchPath, patchContent });
+          if (ctx.config.sessionContinuity === true) {
+            try {
+              const cwd = resolveWorkingDir();
+              const forgeThread = loadOrCreateActiveThread(cwd);
+              const capped = patchContent.length > 9e4 ? patchContent.slice(0, 9e4) + `
+
+[... ${patchContent.length - 9e4} more chars truncated \u2014 full patch at ${patchPath}]` : patchContent;
+              forgeThread.append({
+                role: "assistant",
+                content: `[forge-diff] winner: ${finalWinner}
+patch path: ${patchPath}
+
+${capped}`
+              });
+              await forgeThread.save();
+            } catch (threadErr) {
+              dispatch({ type: "warning", message: `Winner diff NOT persisted to thread: ${threadErr instanceof Error ? threadErr.message : String(threadErr)}` });
+            }
+          }
+        } catch (err) {
+          console.warn(`[agon] failed to read winning patch ${patchPath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    } else {
+      if (manifest.noDiffSummary) {
+        const summary = manifest.noDiffSummary;
+        if (Number(summary.toolLoopLimit ?? 0) > 0) {
+          dispatch({ type: "error", message: `No candidate diff \u2014 ${summary.toolLoopLimit}/${summary.count} engine(s) hit the tool-loop limit before producing a patch.` });
+        } else {
+          dispatch({ type: "warning", message: "No candidate diff \u2014 engines produced no patch. Use validate/improve mode or a more discriminating fitness command for already-passing work." });
+        }
+      } else {
+        dispatch({ type: "error", message: "No winner \u2014 all engines failed" });
+      }
+    }
+    dispatch({ type: "info", message: `Manifest: ${forgeDir}/manifest.json` });
+    dispatch({ type: "info", message: `Result bundle: ${manifest.resultBundlePath ?? `${forgeDir}/result.json`}` });
+    for (const step of plan.steps) {
+      if (step.result.state === "pending" || step.result.state === "running") {
+        plan = mergeStepResult(plan, step.id, { state: "completed" });
+      }
+    }
+    const anyPassed = Object.values(manifest.results).some((r) => r.pass);
+    const winnerForPlan = finalWinner ?? manifest.winner;
+    const winnerArtifacts = [
+      { type: "manifest", path: `${forgeDir}/manifest.json` },
+      ...winnerForPlan && manifest.patches[winnerForPlan] ? [{ type: "patch", path: manifest.patches[winnerForPlan], engineId: winnerForPlan }] : []
+    ];
+    plan = mergeStepResult(plan, "winner", { state: "completed", artifacts: winnerArtifacts });
+    if (!anyPassed) {
+      plan = { ...plan, state: "failed", currentStepId: null, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+    ctx.setCurrentPlan(plan);
+    savePlan(plan);
+    dispatch({ type: "info", message: `Plan: ${plan.id}` });
+    sessionResultStore.add({
+      type: "forge",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      question: task,
+      engines: engineIds,
+      winner: finalWinner ?? null,
+      data: {
+        scoreboard: engineIds.map((id, i) => {
+          const r = results[i];
+          return { engineId: id, pass: r.pass, score: r.score, diffLines: r.diffLines, filesChanged: r.filesChanged, durationSec: r.durationSec };
+        }),
+        winner: finalWinner ?? null,
+        synthesis: manifest.synthesis ?? void 0
+      }
+    });
+    for (const [id, r] of Object.entries(manifest.results)) {
+      tracker.record(id, { prompt: task, response: `score:${r.score} diff:${r.diffLines}` });
+    }
+    const runRecord = recordRun({
+      mode: "forge",
+      intent: task,
+      winner: finalWinner ?? void 0,
+      success: anyPassed,
+      durationMs: Date.now() - startTime,
+      engineIds,
+      fitnessCmd: fitness ?? void 0,
+      completionState: "completed"
+    });
+    if (!process.env.AGON_NO_SUMMARY) {
+      dispatch({ type: "info", message: formatRunSummary(runRecord) });
+    }
+    return {
+      winner: finalWinner ?? null,
+      patchPath: finalWinner && manifest.patches[finalWinner] ? manifest.patches[finalWinner] : null,
+      manifestPath: `${forgeDir}/manifest.json`,
+      task,
+      fitnessCmd: fitness
+    };
+  } finally {
+    ctx.setActiveAbort(null);
+  }
+}
+
+export {
+  sessionResultStore,
+  createScoreboard,
+  scoreboardFinishEngine,
+  scoreboardFailEngine,
+  renderScoreboard,
+  buildCheckpoint,
+  recordCheckpoint,
+  recordRun,
+  formatRunSummary,
+  extractFitnessCommandFromCesarOutput,
+  repairFitnessCommandTaskLiterals,
+  normalizeGithubRemoteLiteral,
+  repairFitnessCommandRepositoryLiteral,
+  taskWantsRepositoryLinkCheck,
+  repairOverbroadForbiddenLiterals,
+  repairContradictoryFitnessLiterals,
+  validateFitnessCommandIntent,
+  repairForgeTaskRepositoryLiteral,
+  prepareForgeFitnessCommand,
+  inferProjectFitnessCommand,
+  handleForge
+};
+//# sourceMappingURL=chunk-YNZ4UHZI.js.map