@tangle-network/agent-eval 0.65.0 → 0.67.0

package/dist/{chunk-4ODZXQV2.js → chunk-NV2PF37Q.js}

@@ -1,6 +1,12 @@
+import {
+  runCampaign
+} from "./chunk-6XQIEUQ2.js";
 import {
   DEFAULT_REDACTION_RULES
 } from "./chunk-GGE4NNQT.js";
+import {
+  callLlm
+} from "./chunk-IHDHUN2X.js";
 import {
   ValidationError
 } from "./chunk-3BFEG2F6.js";
@@ -828,6 +834,630 @@ function parseReflectionResponse(raw, maxProposals) {
   return out;
 }
 
+// src/campaign/drivers/gepa.ts
+var REFLECTION_SYSTEM = 'You are an expert prompt engineer. Output ONLY a JSON object of shape {"proposals":[{"label":string,"rationale":string,"payload":string}]} where each `payload` is the FULL improved surface text. No prose outside the JSON.';
+var COMBINE_SYSTEM = 'You are an expert prompt engineer performing a GEPA "combine complementary lessons" merge. You are given several non-dominated versions of one surface; each is uniquely best on different scenarios. Produce ONE new version that keeps what makes each version strong on its winning scenarios and resolves conflicts in favor of the more general rule. Output ONLY a JSON object of shape {"proposals":[{"label":string,"rationale":string,"payload":string}]} with exactly one proposal whose `payload` is the FULL merged surface text. No prose outside the JSON.';
+function gepaDriver(opts) {
+  const evidenceK = opts.evidenceK ?? 3;
+  const combineParents = opts.combineParents ?? true;
+  const combineMaxParents = opts.combineMaxParents ?? 4;
+  if (combineParents && combineMaxParents < 1) {
+    throw new Error("gepaDriver: combineMaxParents must be >= 1 when combineParents is enabled");
+  }
+  return {
+    kind: "gepa",
+    async propose(ctx) {
+      const parent = typeof ctx.currentSurface === "string" ? ctx.currentSurface : JSON.stringify(ctx.currentSurface);
+      const constraints = opts.constraints;
+      const preserveSections = constraints?.preserveSections !== void 0 ? constraints.preserveSections.length === 0 ? extractH2Sections(parent) : constraints.preserveSections : null;
+      const maxEdits = constraints?.maxSentenceEdits;
+      const out = [];
+      const seen = /* @__PURE__ */ new Set();
+      const accept = (payload, label, rationale) => {
+        const text = typeof payload === "string" ? payload.trim() : "";
+        if (!text || text === parent || seen.has(text)) return;
+        if (preserveSections && !validatePreservedSections(text, preserveSections)) return;
+        if (maxEdits !== void 0 && countSentenceEdits(parent, text) > maxEdits * 2) return;
+        seen.add(text);
+        out.push({ surface: text, label, rationale });
+      };
+      const stringParents = (combineParents ? ctx.paretoParents ?? [] : []).filter((p) => typeof p.surface === "string").sort((a, b) => b.composite - a.composite).slice(0, combineMaxParents);
+      if (stringParents.length > 1) {
+        const combinePrompt = buildCombinePrompt({
+          target: opts.target,
+          parents: stringParents,
+          evidenceK
+        });
+        const combineResult = await callLlm(
+          {
+            model: opts.model,
+            messages: [
+              { role: "system", content: COMBINE_SYSTEM },
+              { role: "user", content: combinePrompt }
+            ],
+            jsonMode: true,
+            temperature: opts.temperature ?? 0.7,
+            maxTokens: opts.maxTokens ?? 6e3
+          },
+          opts.llm
+        );
+        const merged = parseReflectionResponse(combineResult.content, 1)[0];
+        if (merged) {
+          accept(
+            merged.payload,
+            merged.label || "pareto-combine",
+            merged.rationale || `combined ${stringParents.length} non-dominated parents (gen ${stringParents.map((p) => p.generation).join(",")})`
+          );
+        }
+      }
+      const reflectCount = Math.max(0, ctx.populationSize - out.length);
+      if (reflectCount > 0) {
+        const { top, bottom, target } = buildEvidence(ctx, evidenceK, opts.target);
+        const userPrompt = buildReflectionPrompt({
+          target,
+          parentPayload: parent,
+          topTrials: top,
+          bottomTrials: bottom,
+          childCount: reflectCount,
+          mutationPrimitives: opts.mutationPrimitives
+        });
+        const result = await callLlm(
+          {
+            model: opts.model,
+            messages: [
+              { role: "system", content: REFLECTION_SYSTEM },
+              { role: "user", content: userPrompt }
+            ],
+            jsonMode: true,
+            temperature: opts.temperature ?? 0.7,
+            maxTokens: opts.maxTokens ?? 6e3
+          },
+          opts.llm
+        );
+        for (const proposal of parseReflectionResponse(result.content, reflectCount)) {
+          accept(proposal.payload, proposal.label, proposal.rationale);
+        }
+      }
+      return out.slice(0, ctx.populationSize);
+    }
+  };
+}
+function buildCombinePrompt(args) {
+  const lines = [
+    `You are merging ${args.parents.length} versions of: ${args.target}.`,
+    "",
+    "Each version is on the Pareto frontier \u2014 none dominates the others; each",
+    "wins on different scenarios. Combine their complementary strengths into",
+    "ONE version. Below, each version lists the scenarios it scores highest on.",
+    ""
+  ];
+  args.parents.forEach((p, i) => {
+    const tag = String.fromCharCode(65 + i);
+    const best = Object.entries(p.objectives).sort((a, b) => b[1] - a[1]).slice(0, args.evidenceK).map(([id, score]) => `${id} (${score.toFixed(2)})`);
+    lines.push(
+      `### Version ${tag} (mean ${p.composite.toFixed(2)}; strongest on: ${best.join(", ") || "n/a"})`,
+      "```",
+      p.surface,
+      "```",
+      ""
+    );
+  });
+  lines.push(
+    "Return ONE merged version that would score well on the union of every",
+    "version's winning scenarios. Keep each version's specific winning rule;",
+    "where two rules conflict, prefer the more general one and note the choice",
+    "in your rationale."
+  );
+  return lines.join("\n");
+}
+function extractH2Sections(text) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    const match = /^##\s+(.+?)\s*$/.exec(line);
+    if (match) out.push(match[1]);
+  }
+  return out;
+}
+function countSentenceEdits(baseline, candidate) {
+  const norm = (s) => s.split(/(?<=[.!?])\s+|\n/g).map((p) => p.trim()).filter((p) => p.length > 0);
+  const a = new Set(norm(baseline));
+  const b = new Set(norm(candidate));
+  let edits = 0;
+  for (const s of a) if (!b.has(s)) edits++;
+  for (const s of b) if (!a.has(s)) edits++;
+  return edits;
+}
+function validatePreservedSections(candidate, required) {
+  if (required.length === 0) return true;
+  const have = new Set(extractH2Sections(candidate));
+  for (const section of required) {
+    if (!have.has(section)) return false;
+  }
+  return true;
+}
+function buildEvidence(ctx, evidenceK, baseTarget) {
+  const last = ctx.history.at(-1);
+  if (!last || last.candidates.length === 0) {
+    return { top: [], bottom: [], target: baseTarget };
+  }
+  const best = [...last.candidates].sort((a, b) => b.composite - a.composite)[0];
+  if (!best) return { top: [], bottom: [], target: baseTarget };
+  const byScore = [...best.scenarios].sort((a, b) => b.composite - a.composite);
+  const toTrace = (s) => ({
+    id: s.scenarioId,
+    score: s.composite
+  });
+  const top = byScore.slice(0, evidenceK).map(toTrace);
+  const bottom = byScore.slice(-evidenceK).reverse().map(toTrace);
+  const weakest = Object.entries(best.dimensions).sort((a, b) => a[1] - b[1]).slice(0, 3).map(([dim, value]) => `${dim} (${value.toFixed(2)})`);
+  const target = weakest.length > 0 ? `${baseTarget} \u2014 weakest dimensions: ${weakest.join(", ")}` : baseTarget;
+  return { top, bottom, target };
+}
+
+// src/campaign/gates/heldout-gate.ts
+function heldOutGate(options) {
+  const deltaThreshold = options.deltaThreshold ?? 0.5;
+  return {
+    name: "heldOutGate",
+    async decide(ctx) {
+      const scenarioIds = new Set(options.scenarios.map((s) => s.id));
+      const baseline = meanForScenarios(ctx.baselineJudgeScores ?? ctx.judgeScores, scenarioIds);
+      const candidate = meanForScenarios(ctx.judgeScores, scenarioIds);
+      const delta = candidate - baseline;
+      const passed = delta >= deltaThreshold;
+      return {
+        decision: passed ? "ship" : "hold",
+        reasons: passed ? [`held-out delta ${delta.toFixed(3)} \u2265 ${deltaThreshold}`] : [`held-out delta ${delta.toFixed(3)} < ${deltaThreshold}`],
+        contributingGates: [
+          { name: "heldOutGate", passed, detail: { baseline, candidate, delta, deltaThreshold } }
+        ],
+        delta
+      };
+    }
+  };
+}
+function meanForScenarios(judgeScoresByCell, scenarioIds) {
+  const composites = [];
+  for (const [cellId, scores] of judgeScoresByCell) {
+    const scenarioId = cellId.split(":")[0] ?? "";
+    if (!scenarioIds.has(scenarioId)) continue;
+    const vals = Object.values(scores).map((s) => s.composite);
+    if (vals.length > 0) composites.push(vals.reduce((a, b) => a + b, 0) / vals.length);
+  }
+  return composites.length === 0 ? 0 : composites.reduce((a, b) => a + b, 0) / composites.length;
+}
+
+// src/campaign/auto-pr.ts
+import { execSync } from "child_process";
+import { writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+function openAutoPr(options) {
+  if (options.gate.decision !== "ship") {
+    return {
+      opened: false,
+      dryRun: false,
+      reason: `gate verdict was "${options.gate.decision}" \u2014 refusing to open PR`
+    };
+  }
+  const dryRun = options.dryRun ?? !process.env.GH_AUTO_PR_TOKEN;
+  const branch = options.branch ?? `auto/${options.result.manifestHash.slice(0, 12)}`;
+  const title = options.title ?? `auto: campaign ${options.result.manifestHash.slice(0, 8)} promoted by gate`;
+  const body = renderPrBody(options.result, options.gate, options.promotedDiff);
+  const bodyPath = join(tmpdir(), `auto-pr-body-${Date.now()}.md`);
+  writeFileSync(bodyPath, body);
+  if (dryRun) {
+    return {
+      opened: false,
+      dryRun: true,
+      reason: `dry-run (GH_AUTO_PR_TOKEN not set). Would create PR on ${options.ghOwner}/${options.ghRepo} branch ${branch}. Body at ${bodyPath}.`
+    };
+  }
+  const ghExec = options.ghExec ?? defaultGhExec;
+  const result = ghExec([
+    "pr",
+    "create",
+    "--repo",
+    `${options.ghOwner}/${options.ghRepo}`,
+    "--head",
+    branch,
+    "--title",
+    title,
+    "--body-file",
+    bodyPath
+  ]);
+  if (result.status !== 0) {
+    return {
+      opened: false,
+      dryRun: false,
+      reason: `gh pr create failed (exit ${result.status}): ${result.stderr.slice(0, 400)}`
+    };
+  }
+  const prUrl = result.stdout.trim();
+  return { opened: true, prUrl, dryRun: false, reason: "PR opened" };
+}
+function renderPrBody(result, gate, diff) {
+  const lines = [];
+  lines.push(`## Automated promotion by \`runImprovementLoop\``);
+  lines.push("");
+  lines.push(`**Manifest**: \`${result.manifestHash}\``);
+  lines.push(`**Seed**: ${result.seed}`);
+  lines.push(`**Duration**: ${Math.round(result.durationMs / 1e3)}s`);
+  lines.push(
+    `**Cells**: executed ${result.aggregates.cellsExecuted}, cached ${result.aggregates.cellsCached}, skipped ${result.aggregates.cellsSkipped}, failed ${result.aggregates.cellsFailed}`
+  );
+  lines.push(`**Total spend**: $${result.aggregates.totalCostUsd.toFixed(2)}`);
+  lines.push("");
+  lines.push(`### Gate verdict: \`${gate.decision}\``);
+  lines.push("");
+  for (const reason of gate.reasons) lines.push(`- ${reason}`);
+  if (gate.delta !== void 0) lines.push(`- delta: ${gate.delta.toFixed(3)}`);
+  lines.push("");
+  lines.push("### Contributing gates");
+  lines.push("");
+  lines.push("| gate | passed | detail |");
+  lines.push("|---|---|---|");
+  for (const c of gate.contributingGates) {
+    const detail = typeof c.detail === "object" ? JSON.stringify(c.detail).slice(0, 80) : String(c.detail).slice(0, 80);
+    lines.push(`| ${c.name} | ${c.passed ? "\u2713" : "\u2717"} | ${detail} |`);
+  }
+  lines.push("");
+  lines.push("### Promoted surface");
+  lines.push("");
+  lines.push("```diff");
+  lines.push(diff.slice(0, 8e3));
+  lines.push("```");
+  lines.push("");
+  lines.push("### By-judge aggregates");
+  lines.push("");
+  lines.push("| judge | mean | ci95 | n |");
+  lines.push("|---|---|---|---|");
+  for (const [name, agg] of Object.entries(result.aggregates.byJudge)) {
+    lines.push(
+      `| ${name} | ${agg.mean.toFixed(3)} | [${agg.ci95[0].toFixed(3)}, ${agg.ci95[1].toFixed(3)}] | ${agg.n} |`
+    );
+  }
+  return lines.join("\n");
+}
+function defaultGhExec(args) {
+  try {
+    const stdout = execSync(`gh ${args.map(quoteArg).join(" ")}`, {
+      env: { ...process.env, GH_TOKEN: process.env.GH_AUTO_PR_TOKEN ?? process.env.GH_TOKEN ?? "" },
+      stdio: ["ignore", "pipe", "pipe"]
+    }).toString("utf8");
+    return { stdout, stderr: "", status: 0 };
+  } catch (err) {
+    const e = err;
+    return {
+      stdout: e.stdout?.toString("utf8") ?? "",
+      stderr: e.stderr?.toString("utf8") ?? "",
+      status: e.status ?? 1
+    };
+  }
+}
+function quoteArg(arg) {
+  if (/^[a-zA-Z0-9_/\-:.@]+$/.test(arg)) return arg;
+  return `"${arg.replace(/"/g, '\\"')}"`;
+}
+
+// src/campaign/score-utils.ts
+function campaignMeanComposite(campaign) {
+  const composites = [];
+  for (const cell of campaign.cells) {
+    const cellComposites = Object.values(cell.judgeScores).map((s) => s.composite);
+    if (cellComposites.length > 0) {
+      composites.push(cellComposites.reduce((a, b) => a + b, 0) / cellComposites.length);
+    }
+  }
+  return composites.length === 0 ? 0 : composites.reduce((a, b) => a + b, 0) / composites.length;
+}
+function campaignBreakdown(campaign) {
+  const dimSums = {};
+  const dimCounts = {};
+  const byScenario = /* @__PURE__ */ new Map();
+  for (const cell of campaign.cells) {
+    const judgeScores = Object.values(cell.judgeScores);
+    if (judgeScores.length === 0) continue;
+    const cellComposite = judgeScores.reduce((a, s) => a + s.composite, 0) / judgeScores.length;
+    const arr = byScenario.get(cell.scenarioId) ?? [];
+    arr.push(cellComposite);
+    byScenario.set(cell.scenarioId, arr);
+    for (const score of judgeScores) {
+      for (const [key, value] of Object.entries(score.dimensions)) {
+        dimSums[key] = (dimSums[key] ?? 0) + value;
+        dimCounts[key] = (dimCounts[key] ?? 0) + 1;
+      }
+    }
+  }
+  const dimensions = {};
+  for (const key of Object.keys(dimSums)) {
+    const count = dimCounts[key] ?? 0;
+    dimensions[key] = count > 0 ? (dimSums[key] ?? 0) / count : 0;
+  }
+  const scenarios = [...byScenario.entries()].map(([scenarioId, comps]) => ({
+    scenarioId,
+    composite: comps.reduce((a, b) => a + b, 0) / comps.length
+  }));
+  return { dimensions, scenarios };
+}
+
+// src/campaign/types.ts
+function isProposedCandidate(value) {
+  return typeof value === "object" && value !== null && "surface" in value && "label" in value && "rationale" in value;
+}
+var LABEL_TRUST_RANK = {
+  unverified: 0,
+  "verified-signal": 1,
+  "human-rated": 2
+};
+function labelTrustRank(trust) {
+  return LABEL_TRUST_RANK[trust ?? "unverified"];
+}
+
+// src/campaign/presets/run-optimization.ts
+import { createHash } from "crypto";
+async function runOptimization(opts) {
+  const promoteTopK = opts.promoteTopK ?? 2;
+  const baselineCampaign = await runCampaign({
+    ...opts,
+    dispatch: (scenario, ctx) => opts.dispatchWithSurface(opts.baselineSurface, scenario, ctx),
+    runDir: `${opts.runDir}/baseline`
+  });
+  const generations = [];
+  const history = [];
+  let currentSurfaces = [opts.baselineSurface];
+  let winnerSurface = opts.baselineSurface;
+  let winnerSurfaceHash = surfaceHash(opts.baselineSurface);
+  let winnerComposite = campaignMeanComposite(baselineCampaign);
+  let winnerLabel;
+  let winnerRationale;
+  const scored = [
+    toParetoParent(opts.baselineSurface, winnerSurfaceHash, baselineCampaign, -1)
+  ];
+  for (let gen = 0; gen < opts.maxGenerations; gen++) {
+    if (opts.driver.decide?.({ history }).stop) break;
+    const paretoParents = computeParetoFrontier(scored);
+    const proposed = await opts.driver.propose({
+      currentSurface: currentSurfaces[0] ?? opts.baselineSurface,
+      history,
+      findings: [],
+      populationSize: opts.populationSize,
+      generation: gen,
+      signal: new AbortController().signal,
+      report: opts.report,
+      dataset: opts.labeledStore && opts.labeledStore !== "off" ? opts.labeledStore : void 0,
+      maxImprovementShots: opts.maxImprovementShots,
+      paretoParents
+    });
+    const candidates = proposed.map(
+      (p) => isProposedCandidate(p) ? p : { surface: p, label: "", rationale: "" }
+    );
+    const surfaceResults = [];
+    for (let i = 0; i < candidates.length; i++) {
+      const { surface, label, rationale } = candidates[i];
+      const hash = surfaceHash(surface);
+      const campaign = await runCampaign({
+        ...opts,
+        dispatch: (scenario, ctx) => opts.dispatchWithSurface(surface, scenario, ctx),
+        runDir: `${opts.runDir}/gen-${gen}/candidate-${i}`
+      });
+      const composite = campaignMeanComposite(campaign);
+      surfaceResults.push({ surfaceHash: hash, surface, label, rationale, campaign, composite });
+      scored.push(
+        toParetoParent(surface, hash, campaign, gen, label || void 0, rationale || void 0)
+      );
+    }
+    surfaceResults.sort((a, b) => b.composite - a.composite);
+    const promoted = surfaceResults.slice(0, promoteTopK);
+    currentSurfaces = promoted.map((p) => p.surface);
+    const top = surfaceResults[0];
+    if (top && top.composite > winnerComposite) {
+      winnerSurface = top.surface;
+      winnerSurfaceHash = top.surfaceHash;
+      winnerComposite = top.composite;
+      winnerLabel = top.label || void 0;
+      winnerRationale = top.rationale || void 0;
+    }
+    const record = {
+      generationIndex: gen,
+      candidates: surfaceResults.map((s) => {
+        const breakdown = campaignBreakdown(s.campaign);
+        const candidate = {
+          surfaceHash: s.surfaceHash,
+          composite: s.composite,
+          ci95: [s.composite, s.composite],
+          dimensions: breakdown.dimensions,
+          scenarios: breakdown.scenarios
+        };
+        if (s.label) candidate.label = s.label;
+        if (s.rationale) candidate.rationale = s.rationale;
+        return candidate;
+      }),
+      promoted: promoted.map((p) => p.surfaceHash)
+    };
+    history.push(record);
+    generations.push({
+      record,
+      surfaces: surfaceResults.map((s) => ({
+        surfaceHash: s.surfaceHash,
+        surface: s.surface,
+        campaign: s.campaign
+      }))
+    });
+  }
+  return {
+    generations,
+    winnerSurface,
+    winnerSurfaceHash,
+    winnerLabel,
+    winnerRationale,
+    baselineCampaign,
+    paretoFrontier: computeParetoFrontier(scored)
+  };
+}
+function toParetoParent(surface, hash, campaign, generation, label, rationale) {
+  const objectives = {};
+  for (const { scenarioId, composite } of campaignBreakdown(campaign).scenarios) {
+    objectives[scenarioId] = composite;
+  }
+  const parent = {
+    surface,
+    surfaceHash: hash,
+    objectives,
+    composite: campaignMeanComposite(campaign),
+    generation
+  };
+  if (label) parent.label = label;
+  if (rationale) parent.rationale = rationale;
+  return parent;
+}
+function computeParetoFrontier(scored) {
+  if (scored.length <= 1) return [...scored];
+  const ids = /* @__PURE__ */ new Set();
+  for (const p of scored) for (const id of Object.keys(p.objectives)) ids.add(id);
+  if (ids.size === 0) return [...scored];
+  const floor = {};
+  for (const id of ids) {
+    let min = Number.POSITIVE_INFINITY;
+    for (const p of scored) {
+      const v = p.objectives[id];
+      if (typeof v === "number" && Number.isFinite(v) && v < min) min = v;
+    }
+    floor[id] = Number.isFinite(min) ? min : 0;
+  }
+  const objectives = [...ids].map((id) => ({
+    name: id,
+    direction: "maximize",
+    value: (p) => {
+      const v = p.objectives[id];
+      return typeof v === "number" && Number.isFinite(v) ? v : floor[id] ?? 0;
+    }
+  }));
+  return paretoFrontier(scored, objectives).frontier;
+}
+function surfaceHash(surface) {
+  const material = typeof surface === "string" ? surface : JSON.stringify({
+    kind: surface.kind,
+    worktreeRef: surface.worktreeRef,
+    baseRef: surface.baseRef ?? null
+  });
+  return createHash("sha256").update(material).digest("hex").slice(0, 16);
+}
+
+// src/campaign/presets/run-improvement-loop.ts
+var DEFAULT_DISPATCH_TIMEOUT_MS = 6e5;
+async function runImprovementLoop(opts) {
+  if (opts.autoOnPromote === "config") {
+    throw new Error(
+      "runImprovementLoop: autoOnPromote='config' is deferred to Pass B (requires shadow deploy + rollback + ensemble judges). Use 'pr' or 'none' in v0.40."
+    );
+  }
+  if (opts.tracing === "off" && opts.driver) {
+    throw new Error(
+      "runImprovementLoop: tracing='off' is forbidden when a driver is wired. The improvement loop without traces is unattributable; candidate surfaces cannot be cited back to spans and the optimization dataset goes unfed."
+    );
+  }
+  if (opts.autoOnPromote === "pr" && (!opts.ghOwner || !opts.ghRepo)) {
+    throw new Error("runImprovementLoop: autoOnPromote='pr' requires ghOwner + ghRepo.");
+  }
+  const dispatchTimeoutMs = opts.dispatchTimeoutMs ?? DEFAULT_DISPATCH_TIMEOUT_MS;
+  const optimization = await runOptimization({ ...opts, dispatchTimeoutMs });
+  const winnerIsBaseline = optimization.winnerSurfaceHash === surfaceHash(opts.baselineSurface);
+  const { runCampaign: runCampaign2 } = await import("./run-campaign-BVY3RGAZ.js");
+  const baselineOnHoldout = await runCampaign2({
+    ...opts,
+    dispatchTimeoutMs,
+    scenarios: opts.holdoutScenarios,
+    dispatch: (scenario, ctx) => opts.dispatchWithSurface(opts.baselineSurface, scenario, ctx),
+    runDir: `${opts.runDir}/holdout-baseline`
+  });
+  const winnerOnHoldout = winnerIsBaseline ? baselineOnHoldout : await runCampaign2({
+    ...opts,
+    dispatchTimeoutMs,
+    scenarios: opts.holdoutScenarios,
+    dispatch: (scenario, ctx) => opts.dispatchWithSurface(optimization.winnerSurface, scenario, ctx),
+    runDir: `${opts.runDir}/holdout-winner`
+  });
+  const scorable = (r) => r.cells.filter((c) => !c.error && c.artifact != null);
+  const baseScorable = scorable(baselineOnHoldout);
+  const winnerScorable = scorable(winnerOnHoldout);
+  if (baseScorable.length === 0 || winnerScorable.length === 0) {
+    const firstErr = (r) => r.cells.find((c) => c.error)?.error ?? "unknown";
+    throw new Error(
+      `runImprovementLoop: holdout produced no scorable cells (baseline ${baseScorable.length}/${baselineOnHoldout.cells.length}, winner ${winnerScorable.length}/${winnerOnHoldout.cells.length}) \u2014 every holdout dispatch or judge failed. Refusing to emit a gate decision over an empty holdout. First baseline error: "${firstErr(baselineOnHoldout)}"; first winner error: "${firstErr(winnerOnHoldout)}".`
+    );
+  }
+  const candidateArtifacts = /* @__PURE__ */ new Map();
+  const baselineArtifacts = /* @__PURE__ */ new Map();
+  const judgeScores = /* @__PURE__ */ new Map();
+  const baselineJudgeScores = /* @__PURE__ */ new Map();
+  for (const cell of winnerOnHoldout.cells) {
+    candidateArtifacts.set(cell.cellId, cell.artifact);
+    judgeScores.set(cell.cellId, cell.judgeScores);
+  }
+  for (const cell of baselineOnHoldout.cells) {
+    baselineArtifacts.set(cell.cellId, cell.artifact);
+    baselineJudgeScores.set(cell.cellId, cell.judgeScores);
+  }
+  const gateResult = winnerIsBaseline ? {
+    decision: "hold",
+    reasons: [
+      "no candidate beat the training baseline \u2014 winner == baseline (empty diff); nothing to promote"
+    ],
+    contributingGates: [
+      { name: "no-op-guard", passed: false, detail: { winnerIsBaseline: true } }
+    ],
+    delta: 0
+  } : await opts.gate.decide({
+    candidateArtifacts,
+    baselineArtifacts,
+    judgeScores,
+    baselineJudgeScores,
+    scenarios: opts.holdoutScenarios,
+    cost: {
+      candidate: winnerOnHoldout.aggregates.totalCostUsd,
+      baseline: baselineOnHoldout.aggregates.totalCostUsd
+    },
+    signal: new AbortController().signal
+  });
+  const render = opts.renderPromotedDiff ?? defaultRenderDiff;
+  const promotedDiff = optimization.winnerSurfaceHash === surfaceHash(opts.baselineSurface) ? "" : render(optimization.winnerSurface, opts.baselineSurface);
+  let prResult;
+  if (opts.autoOnPromote === "pr" && gateResult.decision === "ship") {
+    prResult = openAutoPr({
+      result: winnerOnHoldout,
+      gate: gateResult,
+      promotedDiff,
+      ghOwner: opts.ghOwner,
+      ghRepo: opts.ghRepo
+    });
+  }
+  return {
+    ...optimization,
+    baselineOnHoldout,
+    winnerOnHoldout,
+    gateResult,
+    promotedDiff,
+    prResult
+  };
+}
+function defaultRenderDiff(winnerSurface, baselineSurface) {
+  if (typeof winnerSurface !== "string" || typeof baselineSurface !== "string") {
+    const fmt = (s) => typeof s === "string" ? "(prompt surface)" : `worktree=${s.worktreeRef}${s.baseRef ? ` base=${s.baseRef}` : ""}${s.summary ? `
+${s.summary}` : ""}`;
+    return `--- baseline
+${fmt(baselineSurface)}
++++ winner
+${fmt(winnerSurface)}`;
+  }
+  const lines = [];
+  lines.push("--- baseline");
+  lines.push("+++ winner");
+  for (const l of baselineSurface.split("\n")) lines.push(`- ${l}`);
+  for (const l of winnerSurface.split("\n")) lines.push(`+ ${l}`);
+  return lines.join("\n");
+}
+
 export {
   dominates,
   paretoFrontier,
@@ -845,6 +1475,19 @@ export {
   runCanaries,
   DEFAULT_MUTATION_PRIMITIVES,
   buildReflectionPrompt,
-  parseReflectionResponse
+  parseReflectionResponse,
+  gepaDriver,
+  extractH2Sections,
+  countSentenceEdits,
+  heldOutGate,
+  openAutoPr,
+  campaignMeanComposite,
+  campaignBreakdown,
+  isProposedCandidate,
+  labelTrustRank,
+  runOptimization,
+  surfaceHash,
+  runImprovementLoop,
+  defaultRenderDiff
 };
-//# sourceMappingURL=chunk-4ODZXQV2.js.map
+//# sourceMappingURL=chunk-NV2PF37Q.js.map