@tangle-network/agent-eval 0.107.0 → 0.108.1

package/dist/campaign/index.js

@@ -1,32 +1,70 @@
 import {
-  buildEvidenceVector,
-  composeGate,
-  defaultProductionGate,
-  evolutionaryProposer,
-  paretoPolicy,
-  paretoSignificanceGate,
-  powerPreflight,
-  runEval
-} from "../chunk-V75NN2ZR.js";
-import {
-  HARNESS_NATIVE_MODEL,
-  agentProfileHash,
-  agentProfileId,
-  agentProfileModelId,
-  extractProducedState,
-  harnessAxisOf,
+  FsLabeledScenarioStore,
+  LabeledScenarioStoreError,
+  Lineage,
+  ProfileMatrixError,
+  SkillPatchParseError,
+  WorktreeAdapterError,
+  aceProposer,
+  applySkillPatch,
+  buildAnalystSurfaceDispatch,
+  callbackGovernor,
+  compareProposers,
+  discoverEvalFixtures,
+  extractFapoAttributionSignals,
+  failureModeRecallJudge,
+  fapoEscalationEntry,
+  fapoProposer,
+  fsLineageStore,
+  gepaParetoEntry,
+  gepaReflectionEntry,
+  gitWorktreeAdapter,
+  haloProposer,
+  heuristicGovernor,
+  lineageNodeId,
   llmJudge,
-  verifyCompletion
-} from "../chunk-6PF6LXRY.js";
+  loadEvalFixture,
+  loadEvalFixtureScenarios,
+  makePlaybackDispatch,
+  memLineageStore,
+  memoryCurationProposer,
+  neutralizationGate,
+  neutralizeText,
+  parameterSweepProposer,
+  parseSkillPatchResponse,
+  patchEditCount,
+  planEvalFixtureRun,
+  policyEditProposer,
+  renderScoreboardMarkdown,
+  resolveWorktreePath,
+  runLineage,
+  runLineageLoop,
+  runProfileMatrix,
+  runSkillOpt,
+  scoreDiscrimination,
+  scoreUserStory,
+  scoreboardSummary,
+  selectDiscriminative,
+  sequentialDecide,
+  sequentialPairedGate,
+  skillOptEntry,
+  skillOptProposer,
+  traceAnalystProposer,
+  userStoryScoreboard
+} from "../chunk-6SKVFBTR.js";
 import {
+  buildEvidenceVector,
   buildLoopProvenanceRecord,
   campaignBreakdown,
   campaignMeanComposite,
+  composeGate,
   countSentenceEdits,
+  defaultProductionGate,
   defaultRenderDiff,
   detectScale,
   dimensionRegressions,
   emitLoopProvenance,
+  evolutionaryProposer,
   extractH2Sections,
   gepaProposer,
   heldOutGate,
@@ -36,3414 +74,41 @@ import {
   loopProvenanceSpans,
   openAutoPr,
   pairHoldout,
+  paretoPolicy,
+  paretoSignificanceGate,
+  powerPreflight,
   provenanceRecordPath,
   provenanceSpansPath,
-  renderAnalystEvidence,
+  runEval,
   runImprovementLoop,
   runOptimization,
   surfaceContentHash,
   surfaceHash
-} from "../chunk-G4DLZAV5.js";
+} from "../chunk-OVPVM4JC.js";
 import {
-  assertRealBackend,
-  contentHash,
   fsCampaignStorage,
   inMemoryCampaignStorage,
   planCampaignRun,
   resolveRunDir,
   runCampaign,
-  summarizeBackendIntegrity,
   tangleTracesRoot
 } from "../chunk-3PFZBGMR.js";
-import {
-  estimateCost,
-  isModelPriced
-} from "../chunk-VI2UW6B6.js";
-import {
-  admitPolicyEdit,
-  applyPolicyEditToSurface,
-  isPolicyEdit,
-  policyEditsFromFindings
-} from "../chunk-LOJ2QVCE.js";
-import {
-  AnalystRegistry,
-  DEFAULT_TRACE_ANALYST_KINDS,
-  createTraceAnalystKind
-} from "../chunk-2OGPXHOB.js";
+import "../chunk-VI2UW6B6.js";
+import "../chunk-LOJ2QVCE.js";
+import "../chunk-2OGPXHOB.js";
 import "../chunk-N22ZO7FV.js";
-import {
-  callLlm
-} from "../chunk-FUCQVFMU.js";
+import "../chunk-FUCQVFMU.js";
 import "../chunk-45EEMHTC.js";
-import {
-  eProcess,
-  mulberry32,
-  pairedBootstrap
-} from "../chunk-XMSYF4A7.js";
-import {
-  analyzeTraces
-} from "../chunk-RPDDVKI7.js";
+import "../chunk-XMSYF4A7.js";
+import "../chunk-RPDDVKI7.js";
 import "../chunk-GGE4NNQT.js";
-import {
-  OtlpFileTraceStore
-} from "../chunk-LNQEP766.js";
+import "../chunk-LNQEP766.js";
 import "../chunk-PC4UYEBM.js";
-import {
-  modelHasSnapshot,
-  validateRunRecord
-} from "../chunk-VK6HBGAE.js";
-import {
-  buildAgentProfileCell
-} from "../chunk-XJYR7XFV.js";
-import {
-  canonicalize
-} from "../chunk-VSMTAMNK.js";
-import {
-  AgentEvalError
-} from "../chunk-ONWEPEDO.js";
+import "../chunk-VK6HBGAE.js";
+import "../chunk-XJYR7XFV.js";
+import "../chunk-VSMTAMNK.js";
+import "../chunk-ONWEPEDO.js";
 import "../chunk-PZ5AY32C.js";
-
-// src/campaign/lineage.ts
-import { createHash } from "crypto";
-import { appendFile, mkdir, readFile, writeFile } from "fs/promises";
-import { dirname } from "path";
-function lineageNodeId(input) {
-  const parents = [...input.parentIds].sort().join(",");
-  const payload = `${parents}|${input.track}|${input.surface}|${input.proposer}`;
-  return createHash("sha256").update(payload).digest("hex").slice(0, 16);
-}
-var Lineage = class _Lineage {
-  byId = /* @__PURE__ */ new Map();
-  childIds = /* @__PURE__ */ new Map();
-  nextSeq = 0;
-  constructor(nodes) {
-    if (!nodes) return;
-    for (const node of [...nodes].sort((a, b) => a.seq - b.seq)) {
-      this.index(node);
-      this.nextSeq = Math.max(this.nextSeq, node.seq + 1);
-    }
-  }
-  /** Append a node. Derives `id` (via {@link lineageNodeId}), assigns the next
-   *  `seq`, and derives `generation` as `max(parent.generation) + 1` (root = 0)
-   *  when omitted. Throws on an unknown parent. Idempotent: re-adding an identical
-   *  node returns the existing one.
-   *
-   *  Acyclicity is guaranteed by construction, not by a runtime check: every
-   *  parent must already exist (a child can never point at a not-yet-added node),
-   *  ids are immutable content hashes (an existing node can never gain new
-   *  parents), and the store is append-only — so no back-edge can form. (Traversal
-   *  is still cycle-safe against hand-corrupted deserialized input via visited
-   *  sets in {@link ancestors}/{@link descendants}.) */
-  addNode(input) {
-    for (const parentId of input.parentIds) {
-      if (!this.byId.has(parentId)) {
-        throw new Error(`Lineage.addNode: unknown parent '${parentId}'`);
-      }
-    }
-    const id = lineageNodeId({
-      parentIds: input.parentIds,
-      track: input.track,
-      surface: input.surface,
-      proposer: input.proposer
-    });
-    const existing = this.byId.get(id);
-    if (existing) return existing;
-    const generation = input.generation ?? (input.parentIds.length === 0 ? 0 : Math.max(...input.parentIds.map((p) => this.byId.get(p).generation)) + 1);
-    const node = {
-      id,
-      parentIds: [...input.parentIds],
-      track: input.track,
-      surface: input.surface,
-      score: input.score,
-      proposer: input.proposer,
-      generation,
-      seq: this.nextSeq++,
-      ...input.vision !== void 0 ? { vision: input.vision } : {},
-      ...input.scoreVector !== void 0 ? { scoreVector: [...input.scoreVector] } : {},
-      ...input.rationale !== void 0 ? { rationale: input.rationale } : {},
-      ...input.gate !== void 0 ? { gate: input.gate } : {}
-    };
-    this.index(node);
-    return node;
-  }
-  /** Collapse 2+ parents into a single node (a merge/"collapse"). A merge is an
-   *  ordinary multi-parent node; this is a guarded convenience. */
-  merge(input) {
-    if (input.parentIds.length < 2) {
-      throw new Error(`Lineage.merge: a merge needs >= 2 parents, got ${input.parentIds.length}`);
-    }
-    return this.addNode({ ...input, proposer: input.proposer ?? "merge" });
-  }
-  get(id) {
-    return this.byId.get(id);
-  }
-  has(id) {
-    return this.byId.has(id);
-  }
-  /** All nodes, in insertion (`seq`) order. */
-  all() {
-    return [...this.byId.values()].sort(bySeq);
-  }
-  roots() {
-    return this.all().filter((n) => n.parentIds.length === 0);
-  }
-  parents(id) {
-    const node = this.byId.get(id);
-    if (!node) return [];
-    return node.parentIds.map((p) => this.byId.get(p)).filter((n) => n !== void 0).sort(bySeq);
-  }
-  children(id) {
-    return (this.childIds.get(id) ?? []).map((c) => this.byId.get(c)).sort(bySeq);
-  }
-  /** Transitive ancestors (excludes `id`). */
-  ancestors(id) {
-    const out = /* @__PURE__ */ new Set();
-    const stack = [...this.byId.get(id)?.parentIds ?? []];
-    while (stack.length > 0) {
-      const cur = stack.pop();
-      if (out.has(cur)) continue;
-      out.add(cur);
-      const node = this.byId.get(cur);
-      if (node) stack.push(...node.parentIds);
-    }
-    return out;
-  }
-  /** Transitive descendants (excludes `id`). */
-  descendants(id) {
-    const out = /* @__PURE__ */ new Set();
-    const stack = [...this.childIds.get(id) ?? []];
-    while (stack.length > 0) {
-      const cur = stack.pop();
-      if (out.has(cur)) continue;
-      out.add(cur);
-      stack.push(...this.childIds.get(cur) ?? []);
-    }
-    return out;
-  }
-  /** Nodes with no children (leaf/branch tips). */
-  tips() {
-    return this.all().filter((n) => (this.childIds.get(n.id) ?? []).length === 0);
-  }
-  /** Distinct track ids, in first-seen (`seq`) order. */
-  tracks() {
-    const seen = /* @__PURE__ */ new Set();
-    const out = [];
-    for (const node of this.all()) {
-      if (!seen.has(node.track)) {
-        seen.add(node.track);
-        out.push(node.track);
-      }
-    }
-    return out;
-  }
-  trackNodes(track) {
-    return this.all().filter((n) => n.track === track);
-  }
-  /** The highest-`score` tip of a track (ties broken by lowest `seq`). */
-  trackTip(track) {
-    return pickBest(this.tips().filter((n) => n.track === track));
-  }
-  /** The highest-`score` node overall (ties broken by lowest `seq`). */
-  best() {
-    return pickBest(this.all());
-  }
-  /** The Pareto-non-dominated set among TIPS. Uses `scoreVector` when every
-   *  compared tip carries one, else the scalar `score`. A dominates B iff A is
-   *  >= B on every component and > B on at least one. */
-  frontier() {
-    const tips = this.tips();
-    const useVector = tips.length > 0 && tips.every((n) => n.scoreVector !== void 0);
-    const vecOf = (n) => useVector ? n.scoreVector : [n.score];
-    return tips.filter((a) => !tips.some((b) => b.id !== a.id && dominates(vecOf(b), vecOf(a)))).sort(bySeq);
-  }
-  toGraph() {
-    const nodes = this.all();
-    const edges = [];
-    for (const node of nodes) {
-      for (const parentId of node.parentIds) {
-        edges.push({ from: parentId, to: node.id });
-      }
-    }
-    return { nodes, edges };
-  }
-  /** One JSON node per line, in `seq` order. */
-  toJSONL() {
-    return this.all().map((n) => JSON.stringify(n)).join("\n");
-  }
-  static fromJSONL(text) {
-    const nodes = text.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => JSON.parse(line));
-    return new _Lineage(nodes);
-  }
-  index(node) {
-    this.byId.set(node.id, node);
-    for (const parentId of node.parentIds) {
-      const list = this.childIds.get(parentId);
-      if (list) {
-        if (!list.includes(node.id)) list.push(node.id);
-      } else {
-        this.childIds.set(parentId, [node.id]);
-      }
-    }
-  }
-};
-function bySeq(a, b) {
-  return a.seq - b.seq;
-}
-function pickBest(nodes) {
-  let best;
-  for (const node of nodes) {
-    if (!best || node.score > best.score || node.score === best.score && node.seq < best.seq) {
-      best = node;
-    }
-  }
-  return best;
-}
-function dominates(a, b) {
-  if (a.length !== b.length) return false;
-  let strictlyBetter = false;
-  for (let i = 0; i < a.length; i += 1) {
-    if (a[i] < b[i]) return false;
-    if (a[i] > b[i]) strictlyBetter = true;
-  }
-  return strictlyBetter;
-}
-function fsLineageStore(path) {
-  const ensureDir = () => mkdir(dirname(path), { recursive: true });
-  return {
-    async load() {
-      try {
-        return Lineage.fromJSONL(await readFile(path, "utf8"));
-      } catch (err) {
-        if (err.code === "ENOENT") return new Lineage();
-        throw err;
-      }
-    },
-    async append(node) {
-      await ensureDir();
-      await appendFile(path, `${JSON.stringify(node)}
-`, "utf8");
-    },
-    async save(lineage) {
-      await ensureDir();
-      const jsonl = lineage.toJSONL();
-      await writeFile(path, jsonl.length > 0 ? `${jsonl}
-` : "", "utf8");
-    }
-  };
-}
-function memLineageStore() {
-  const nodes = [];
-  return {
-    async load() {
-      return new Lineage(nodes);
-    },
-    async append(node) {
-      nodes.push(node);
-    },
-    async save(lineage) {
-      nodes.length = 0;
-      nodes.push(...lineage.all());
-    }
-  };
-}
-function heuristicGovernor(opts = {}) {
-  const maxTracks = opts.maxTracks ?? 3;
-  const plateauSteps = opts.plateauSteps ?? 2;
-  const mergeFrontierAt = opts.mergeFrontierAt ?? 2;
-  return {
-    decide(ctx) {
-      const { lineage } = ctx;
-      if (ctx.budgetRemaining <= 0) return { op: "stop" };
-      const pruned = new Set(ctx.prunedTracks);
-      const liveTracks = lineage.tracks().filter((t) => !pruned.has(t));
-      if (liveTracks.length === 0) return { op: "stop" };
-      const frontierByTrack = /* @__PURE__ */ new Map();
-      for (const tip of lineage.frontier()) {
-        if (pruned.has(tip.track)) continue;
-        if (!frontierByTrack.has(tip.track)) frontierByTrack.set(tip.track, tip);
-      }
-      if (frontierByTrack.size >= mergeFrontierAt) {
-        const tips = [...frontierByTrack.values()].sort(bySeq);
-        const target = pickBest(tips);
-        return { op: "merge", parentIds: tips.map((t) => t.id), track: target.track };
-      }
-      for (const track of liveTracks) {
-        if (isPlateaued(lineage.trackNodes(track), plateauSteps)) {
-          if (liveTracks.length > 1 || liveTracks.length < maxTracks) {
-            return { op: "prune", track };
-          }
-        }
-      }
-      const leader = pickBest(liveTracks.map((t) => lineage.trackTip(t)).filter(Boolean));
-      if (leader && liveTracks.length < maxTracks && isPlateaued(lineage.trackNodes(leader.track), plateauSteps)) {
-        return {
-          op: "branch",
-          fromNodeId: leader.id,
-          track: `${leader.track}+${lineage.tracks().length}`,
-          proposer: "gepa"
-        };
-      }
-      if (leader) return { op: "extend", track: leader.track };
-      return { op: "stop" };
-    }
-  };
-}
-function callbackGovernor(decide) {
-  return { decide };
-}
-function isPlateaued(trackNodes, window) {
-  if (trackNodes.length <= window) return false;
-  const ordered = [...trackNodes].sort(bySeq);
-  const head = ordered.slice(0, ordered.length - window);
-  const tail = ordered.slice(ordered.length - window);
-  const bestBefore = Math.max(...head.map((n) => n.score));
-  const bestRecent = Math.max(...tail.map((n) => n.score));
-  return bestRecent <= bestBefore;
-}
-async function runLineage(opts) {
-  const store = opts.store ?? memLineageStore();
-  const lineage = await store.load();
-  const log = opts.log ?? (() => {
-  });
-  const pruned = /* @__PURE__ */ new Set();
-  const trackProposer = /* @__PURE__ */ new Map();
-  const persist = async (node) => {
-    await store.append(node);
-  };
-  for (const seed of opts.seeds) {
-    const node = lineage.addNode({
-      parentIds: [],
-      track: seed.track,
-      surface: seed.surface,
-      score: seed.score,
-      proposer: seed.proposer,
-      ...seed.vision !== void 0 ? { vision: seed.vision } : {},
-      ...seed.scoreVector !== void 0 ? { scoreVector: seed.scoreVector } : {}
-    });
-    trackProposer.set(seed.track, seed.proposer);
-    await persist(node);
-  }
-  let steps = 0;
-  while (steps < opts.budget.maxSteps) {
-    const op = await opts.governor.decide({
-      lineage,
-      step: steps,
-      budgetRemaining: opts.budget.maxSteps - steps,
-      prunedTracks: [...pruned]
-    });
-    if (op.op === "stop") {
-      log("lineage: governor stop", { steps });
-      break;
-    }
-    if (op.op === "prune") {
-      pruned.add(op.track);
-      log("lineage: prune", { track: op.track });
-      steps += 1;
-      continue;
-    }
-    if (op.op === "merge") {
-      const parents = op.parentIds.map((id) => lineage.get(id)).filter((n) => n !== void 0);
-      if (parents.length < 2) {
-        log("lineage: merge skipped (fewer than 2 known parents)", { op });
-        steps += 1;
-        continue;
-      }
-      const result2 = await opts.merge({ parents, track: op.track });
-      const node2 = lineage.merge({
-        parentIds: parents.map((p) => p.id),
-        track: op.track,
-        surface: result2.surface,
-        score: result2.score,
-        ...parents[0].vision !== void 0 ? { vision: parents[0].vision } : {},
-        ...result2.scoreVector !== void 0 ? { scoreVector: result2.scoreVector } : {},
-        ...result2.rationale !== void 0 ? { rationale: result2.rationale } : {}
-      });
-      await persist(node2);
-      steps += 1;
-      continue;
-    }
-    if (op.op === "branch") {
-      if (pruned.has(op.track)) {
-        log("lineage: branch skipped (target track pruned)", { track: op.track });
-        steps += 1;
-        continue;
-      }
-      const from = lineage.get(op.fromNodeId);
-      if (!from) {
-        log("lineage: branch skipped (unknown fromNodeId)", { op });
-        steps += 1;
-        continue;
-      }
-      trackProposer.set(op.track, op.proposer);
-      const result2 = await opts.step({ track: op.track, proposer: op.proposer, tip: from });
-      const node2 = lineage.addNode({
-        parentIds: [from.id],
-        track: op.track,
-        surface: result2.surface,
-        score: result2.score,
-        proposer: op.proposer,
-        ...op.vision !== void 0 ? { vision: op.vision } : {},
-        ...result2.scoreVector !== void 0 ? { scoreVector: result2.scoreVector } : {},
-        ...result2.rationale !== void 0 ? { rationale: result2.rationale } : {},
-        ...result2.gate !== void 0 ? { gate: result2.gate } : {}
-      });
-      await persist(node2);
-      steps += 1;
-      continue;
-    }
-    if (pruned.has(op.track)) {
-      log("lineage: extend skipped (track pruned)", { track: op.track });
-      steps += 1;
-      continue;
-    }
-    const tip = lineage.trackTip(op.track);
-    if (!tip) {
-      log("lineage: extend skipped (no tip for track)", { track: op.track });
-      steps += 1;
-      continue;
-    }
-    const proposer = trackProposer.get(op.track) ?? tip.proposer;
-    const result = await opts.step({ track: op.track, proposer, tip });
-    const node = lineage.addNode({
-      parentIds: [tip.id],
-      track: op.track,
-      surface: result.surface,
-      score: result.score,
-      proposer,
-      ...tip.vision !== void 0 ? { vision: tip.vision } : {},
-      ...result.scoreVector !== void 0 ? { scoreVector: result.scoreVector } : {},
-      ...result.rationale !== void 0 ? { rationale: result.rationale } : {},
-      ...result.gate !== void 0 ? { gate: result.gate } : {}
-    });
-    await persist(node);
-    steps += 1;
-  }
-  return { lineage, best: lineage.best(), steps };
-}
-
-// src/campaign/analyst-surface.ts
-function surfaceToText(surface) {
-  if (typeof surface === "string") return surface;
-  throw new Error(
-    `buildAnalystSurfaceDispatch: the analyst surface must be a string actorDescription, got a ${surface.kind}-tier surface (${surface.worktreeRef}). The analyst prompt is prompt-tier.`
-  );
-}
-function buildAnalystSurfaceDispatch(opts) {
-  const analyze = opts.analyze ?? analyzeTraces;
-  return async (surface, scenario, _ctx) => {
-    const actorDescription = surfaceToText(surface);
-    const res = await analyze(
-      { question: scenario.question },
-      { ...opts.analystOptions, actorDescription, source: scenario.source }
-    );
-    return {
-      answer: res.answer,
-      findings: res.findings,
-      actorPromptVersion: res.actorPromptVersion
-    };
-  };
-}
-function failureModeRecallJudge(opts = {}) {
-  const recallWeight = opts.recallWeight ?? 0.5;
-  return {
-    name: "failure-mode-recall",
-    dimensions: [
-      { key: "recall", description: "fraction of ground-truth failure modes the analyst surfaced" },
-      {
-        key: "precision",
-        description: "1 \u2212 share of findings that named a failure/tool/error absent from this corpus"
-      }
-    ],
-    appliesTo: (s) => s.kind === "analyst-surface",
-    score({ artifact, scenario }) {
-      const modes = scenario.expectedFailureModes;
-      if (modes.length === 0) {
-        throw new Error(
-          `failureModeRecallJudge: scenario '${scenario.id}' has no expectedFailureModes \u2014 refusing to score (a vacuous 1.0 would corrupt the comparison)`
-        );
-      }
-      const hay = artifact.findings.join("\n").toLowerCase();
-      const matched = modes.filter((m) => m.cues.some((c) => hay.includes(c.toLowerCase())));
-      const recall = matched.length / modes.length;
-      const forbidden = (scenario.forbiddenCues ?? []).map((c) => c.toLowerCase());
-      let precision = 1;
-      let hallucinated = 0;
-      if (forbidden.length > 0) {
-        const denom = Math.max(1, artifact.findings.length);
-        hallucinated = artifact.findings.filter(
-          (f) => forbidden.some((c) => f.toLowerCase().includes(c))
-        ).length;
-        precision = 1 - hallucinated / denom;
-      }
-      const composite = forbidden.length > 0 ? recallWeight * recall + (1 - recallWeight) * precision : recall;
-      const missed = modes.filter((m) => !matched.includes(m)).map((m) => m.id);
-      const notes = `matched ${matched.length}/${modes.length} failure modes` + (missed.length ? `; missed [${missed.join(", ")}]` : "") + (hallucinated ? `; ${hallucinated} out-of-corpus finding(s)` : "");
-      return { dimensions: { recall, precision }, composite, notes };
-    }
-  };
-}
-
-// src/campaign/fixtures.ts
-import { createHash as createHash2 } from "crypto";
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import { isAbsolute, join, relative, resolve } from "path";
-function discoverEvalFixtures(evalsDir) {
-  const root = resolve(evalsDir);
-  if (!existsSync(root)) throw new Error(`discoverEvalFixtures: evalsDir not found: ${root}`);
-  const fixtures = [];
-  const walk = (dir, base = "") => {
-    for (const entry of readdirSync(dir).sort()) {
-      if (entry.startsWith(".") || entry === "node_modules") continue;
-      const fullPath = join(dir, entry);
-      if (!statSync(fullPath).isDirectory()) continue;
-      const name = base ? `${base}/${entry}` : entry;
-      if (existsWithExactCase(fullPath, "PROMPT.md")) {
-        fixtures.push(name);
-      } else {
-        walk(fullPath, name);
-      }
-    }
-  };
-  walk(root);
-  return fixtures;
-}
-function loadEvalFixture(evalsDir, name, options = {}) {
-  const validation = options.validation ?? "vitest";
-  const root = resolve(evalsDir);
-  const fixturePath = resolve(root, name);
-  assertInside(root, fixturePath, name);
-  if (!existsSync(fixturePath) || !statSync(fixturePath).isDirectory()) {
-    throw new Error(`loadEvalFixture: fixture not found: ${name}`);
-  }
-  if (!existsWithExactCase(fixturePath, "PROMPT.md")) {
-    throw new Error(`loadEvalFixture: ${name} is missing exact-case PROMPT.md`);
-  }
-  const promptPath = join(fixturePath, "PROMPT.md");
-  const evalPath = resolveEvalPath(fixturePath);
-  const packageJsonPath = existsWithExactCase(fixturePath, "package.json") ? join(fixturePath, "package.json") : void 0;
-  if (validation !== "none") {
-    if (!evalPath)
-      throw new Error(`loadEvalFixture: ${name} is missing exact-case EVAL.ts or EVAL.tsx`);
-    if (!packageJsonPath)
-      throw new Error(`loadEvalFixture: ${name} is missing exact-case package.json`);
-    assertModulePackage(packageJsonPath, name);
-  }
-  const files = collectFixtureFiles(fixturePath);
-  return {
-    name,
-    path: fixturePath,
-    promptPath,
-    evalPath,
-    packageJsonPath,
-    prompt: readFileSync(promptPath, "utf8"),
-    files,
-    fingerprint: contentHash({
-      files,
-      config: options.fingerprintConfig ?? null
-    })
-  };
-}
-function loadEvalFixtureScenarios(evalsDir, options = {}) {
-  const names = options.names ?? discoverEvalFixtures(evalsDir);
-  return names.map((name) => {
-    const fixture = loadEvalFixture(evalsDir, name, options);
-    return {
-      id: fixture.name,
-      kind: "eval-fixture",
-      tags: ["eval-fixture"],
-      fixtureName: fixture.name,
-      fixturePath: fixture.path,
-      promptPath: fixture.promptPath,
-      evalPath: fixture.evalPath,
-      packageJsonPath: fixture.packageJsonPath,
-      prompt: fixture.prompt,
-      fingerprint: fixture.fingerprint
-    };
-  });
-}
-function planEvalFixtureRun(options) {
-  const scenarios = loadEvalFixtureScenarios(options.evalsDir, {
-    names: options.names,
-    validation: options.validation,
-    fingerprintConfig: options.fingerprintConfig
-  });
-  const plan = planCampaignRun({
-    scenarios,
-    dispatchRef: options.dispatchRef ?? "eval-fixture-dispatch",
-    judges: options.judges,
-    seed: options.seed,
-    reps: options.reps,
-    resumable: options.resumable,
-    runDir: options.runDir,
-    storage: options.storage
-  });
-  return {
-    ...plan,
-    fixtures: scenarios.map((scenario) => ({
-      fixtureName: scenario.fixtureName,
-      fixturePath: scenario.fixturePath,
-      fingerprint: scenario.fingerprint
-    }))
-  };
-}
-function existsWithExactCase(dirPath, fileName) {
-  try {
-    return readdirSync(dirPath).includes(fileName);
-  } catch {
-    return false;
-  }
-}
-function resolveEvalPath(fixturePath) {
-  if (existsWithExactCase(fixturePath, "EVAL.ts")) return join(fixturePath, "EVAL.ts");
-  if (existsWithExactCase(fixturePath, "EVAL.tsx")) return join(fixturePath, "EVAL.tsx");
-  return void 0;
-}
-function assertModulePackage(packageJsonPath, name) {
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-  } catch (err) {
-    throw new Error(
-      `loadEvalFixture: ${name} package.json is invalid JSON: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  if (typeof parsed !== "object" || parsed === null || parsed.type !== "module") {
-    throw new Error(`loadEvalFixture: ${name} package.json must set "type": "module"`);
-  }
-}
-function collectFixtureFiles(fixturePath, base = "") {
-  const files = [];
-  for (const entry of readdirSync(join(fixturePath, base)).sort()) {
-    if (entry === "node_modules" || entry === ".git") continue;
-    const relativePath = base ? `${base}/${entry}` : entry;
-    const fullPath = join(fixturePath, relativePath);
-    const stat = statSync(fullPath);
-    if (stat.isDirectory()) {
-      files.push(...collectFixtureFiles(fixturePath, relativePath));
-      continue;
-    }
-    const bytes = readFileSync(fullPath);
-    files.push({
-      path: relativePath,
-      sha256: createHash2("sha256").update(bytes).digest("hex"),
-      bytes: bytes.byteLength
-    });
-  }
-  return files;
-}
-function assertInside(root, target, label) {
-  const rel = relative(root, target);
-  if (rel === "" || !rel.startsWith("..") && !isAbsolute(rel)) return;
-  throw new Error(`loadEvalFixture: fixture path escapes evalsDir: ${label}`);
-}
-
-// src/campaign/gates/neutralization-gate.ts
-function mean(xs) {
-  return xs.length === 0 ? 0 : xs.reduce((a, b) => a + b, 0) / xs.length;
-}
-function pairedLift(arm, baseline, scenarioIds) {
-  const paired = pairHoldout(arm, baseline, scenarioIds, (s) => s.composite);
-  const deltas = paired.after.map((a, i) => a - (paired.before[i] ?? 0));
-  return { lift: mean(deltas), n: deltas.length };
-}
-function neutralizationGate(options) {
-  const maxDecorativeFraction = options.maxDecorativeFraction ?? 0.5;
-  return {
-    name: "neutralizationGate",
-    async decide(ctx) {
-      if (!ctx.baselineJudgeScores) {
-        throw new Error(
-          "neutralizationGate: ctx.baselineJudgeScores is required \u2014 the placebo control measures lift OVER baseline."
-        );
-      }
-      if (!ctx.neutralizedJudgeScores) {
-        throw new Error(
-          "neutralizationGate: ctx.neutralizedJudgeScores is required. It is populated by runImprovementLoop only when a `neutralize` function is supplied \u2014 composing this gate without that wiring would pass an unproven candidate."
-        );
-      }
-      const scenarioIds = new Set(options.scenarios.map((s) => s.id));
-      const cand = pairedLift(
-        ctx.judgeScores,
-        ctx.baselineJudgeScores,
-        scenarioIds
-      );
-      const neut = pairedLift(
-        ctx.neutralizedJudgeScores,
-        ctx.baselineJudgeScores,
-        scenarioIds
-      );
-      if (cand.lift <= 0) {
-        return {
-          decision: "hold",
-          reasons: [
-            `neutralization: candidate held-out lift ${cand.lift.toFixed(3)} \u2264 0 \u2014 no positive lift to attribute to content`
-          ],
-          contributingGates: [
-            {
-              name: "neutralizationGate",
-              passed: false,
-              detail: { candidateLift: cand.lift, neutralizedLift: neut.lift, n: cand.n }
-            }
-          ],
-          delta: cand.lift
-        };
-      }
-      const decorativeFraction = neut.lift / cand.lift;
-      const passed = decorativeFraction < maxDecorativeFraction;
-      const pct = (decorativeFraction * 100).toFixed(0);
-      return {
-        decision: passed ? "ship" : "hold",
-        reasons: passed ? [
-          `neutralization: content is causal \u2014 blanked variant reproduces ${pct}% of the lift (< ${(maxDecorativeFraction * 100).toFixed(0)}%); candidate \u0394 ${cand.lift.toFixed(3)}, neutralized \u0394 ${neut.lift.toFixed(3)}`
-        ] : [
-          `neutralization: lift is DECORATIVE \u2014 blanking the content (footprint-matched) reproduces ${pct}% of the lift (\u2265 ${(maxDecorativeFraction * 100).toFixed(0)}%); candidate \u0394 ${cand.lift.toFixed(3)}, neutralized \u0394 ${neut.lift.toFixed(3)}`
-        ],
-        contributingGates: [
-          {
-            name: "neutralizationGate",
-            passed,
-            detail: {
-              candidateLift: cand.lift,
-              neutralizedLift: neut.lift,
-              decorativeFraction,
-              maxDecorativeFraction,
-              n: cand.n
-            }
-          }
-        ],
-        delta: cand.lift
-      };
-    }
-  };
-}
-
-// src/campaign/gates/sequential.ts
-import { createHash as createHash3 } from "crypto";
-function verifyManifestSync(m) {
-  if (m.algo !== void 0 && m.algo !== "sha256-content") {
-    throw new Error(`sequentialPairedGate: unrecognized manifest hash algo '${m.algo}'`);
-  }
-  const { contentHash: contentHash2, algo: _algo, ...rest } = m;
-  void _algo;
-  const bytes = JSON.stringify(canonicalize(rest));
-  const hash = createHash3("sha256").update(bytes, "utf8").digest("hex");
-  return hash === contentHash2;
-}
-function resolveConfig(opts) {
-  const m = opts.preRegistration;
-  let alpha;
-  let maxN;
-  let direction;
-  let minEffect;
-  if (m) {
-    if (!verifyManifestSync(m)) {
-      throw new Error(
-        `sequentialPairedGate: pre-registration manifest '${m.id}' content hash mismatch (tampered)`
-      );
-    }
-    if (opts.alpha !== void 0 && opts.alpha !== m.alpha) {
-      throw new Error(
-        `sequentialPairedGate: alpha ${opts.alpha} conflicts with pre-registered alpha ${m.alpha} \u2014 the registered statistic is the only one anytime validity covers`
-      );
-    }
-    if (opts.maxN !== void 0 && opts.maxN !== m.preRegisteredN) {
-      throw new Error(
-        `sequentialPairedGate: maxN ${opts.maxN} conflicts with pre-registered N ${m.preRegisteredN}`
-      );
-    }
-    alpha = m.alpha;
-    maxN = m.preRegisteredN;
-    direction = m.direction;
-    minEffect = m.minEffect;
-  } else {
-    alpha = opts.alpha ?? 0.05;
-    if (opts.maxN === void 0) {
-      throw new Error(
-        "sequentialPairedGate: maxN is required (or bind a preRegistration manifest whose preRegisteredN is the budget) \u2014 an unbounded stream has no pre-registered budget"
-      );
-    }
-    maxN = opts.maxN;
-    direction = "increase";
-    minEffect = 0;
-  }
-  const scale = opts.scale ?? 1;
-  if (!Number.isFinite(scale) || scale <= 0) {
-    throw new Error(`sequentialPairedGate: scale must be > 0, got ${scale}`);
-  }
-  if (!Number.isInteger(maxN) || maxN < 1) {
-    throw new Error(`sequentialPairedGate: maxN must be a positive integer, got ${maxN}`);
-  }
-  const minN = opts.minN ?? 5;
-  if (!Number.isInteger(minN) || minN < 1 || minN > maxN) {
-    throw new Error(
-      `sequentialPairedGate: minN must be an integer in [1, maxN=${maxN}], got ${minN}`
-    );
-  }
-  if (!Number.isFinite(minEffect) || minEffect < 0 || minEffect >= scale) {
-    throw new Error(
-      `sequentialPairedGate: minEffect must be in [0, scale=${scale}), got ${minEffect}`
-    );
-  }
-  const nullMean = 0.5 + minEffect / (2 * scale);
-  return {
-    alpha,
-    minN,
-    maxN,
-    maxBet: opts.maxBet ?? 0.5,
-    scale,
-    shuffleSeed: opts.shuffleSeed ?? 1337,
-    direction,
-    nullMean,
-    minEffect
-  };
-}
-function makeStream(cfg) {
-  const proc = eProcess({ alpha: cfg.alpha, maxBet: cfg.maxBet, nullMean: cfg.nullMean });
-  const threshold = 1 / cfg.alpha;
-  let terminal;
-  return {
-    observe(delta) {
-      if (terminal === "undecided-at-maxN") {
-        throw new Error(
-          `sequentialPairedGate: pre-registered maxN=${cfg.maxN} exhausted \u2014 extending the stream after seeing the result reopens optional stopping; start a NEW pre-registered test`
-        );
-      }
-      if (!Number.isFinite(delta) || Math.abs(delta) > cfg.scale) {
-        throw new Error(
-          `sequentialPairedGate: delta ${delta} outside \xB1scale=${cfg.scale} \u2014 pass the judge's native scale explicitly (detectScale helps pick 1 vs 100)`
-        );
-      }
-      const d = cfg.direction === "decrease" ? -delta : delta;
-      const step = proc.update((d / cfg.scale + 1) / 2);
-      if (terminal === void 0 && step.n >= cfg.minN && step.wealth >= threshold) {
-        terminal = "promote";
-      }
-      if (terminal === "promote") {
-        return {
-          decision: "promote",
-          eValue: step.wealth,
-          n: step.n,
-          reason: `e-value ${step.wealth.toFixed(2)} \u2265 1/\u03B1=${threshold.toFixed(2)} at n=${step.n} (minN=${cfg.minN}): the paired improvement exceeds ${cfg.minEffect} at anytime-valid level \u03B1=${cfg.alpha}`
-        };
-      }
-      if (step.n >= cfg.maxN) {
-        terminal = "undecided-at-maxN";
-        return {
-          decision: "undecided-at-maxN",
-          eValue: step.wealth,
-          n: step.n,
-          reason: `undecided at pre-registered maxN=${cfg.maxN} (e-value ${step.wealth.toFixed(2)} < 1/\u03B1=${threshold.toFixed(2)}). This is NOT evidence of no effect \u2014 the effect may be real but smaller than this budget can detect; re-register with a larger N to test that`
-        };
-      }
-      return {
-        decision: "continue",
-        eValue: step.wealth,
-        n: step.n,
-        reason: `e-value ${step.wealth.toFixed(2)} < 1/\u03B1=${threshold.toFixed(2)} at n=${step.n}/${cfg.maxN} \u2014 keep observing`
-      };
-    },
-    state() {
-      return { ...proc.state(), decision: terminal ?? "continue" };
-    }
-  };
-}
-function seededShuffle(items, seed) {
-  const rng = mulberry32(seed);
-  for (let i = items.length - 1; i > 0; i--) {
-    const j = Math.floor(rng() * (i + 1));
-    const tmp = items[i];
-    items[i] = items[j];
-    items[j] = tmp;
-  }
-  return items;
-}
-function sequentialPairedGate(options) {
-  const cfg = resolveConfig(options);
-  const name = options.name ?? "sequentialPairedGate";
-  const manifest = options.preRegistration;
-  const observeStream = makeStream(cfg);
-  return {
-    name,
-    observe(delta) {
-      return observeStream.observe(delta);
-    },
-    state() {
-      return observeStream.state();
-    },
-    async decide(ctx) {
-      if (!ctx.baselineJudgeScores) {
-        throw new Error(
-          `${name}: ctx.baselineJudgeScores is required \u2014 falling back to the candidate's own scores would compare the candidate against itself (delta 0, silent no-op)`
-        );
-      }
-      const scenarioIds = new Set(ctx.scenarios.map((s) => s.id));
-      const paired = pairHoldout(
-        ctx.judgeScores,
-        ctx.baselineJudgeScores,
-        scenarioIds,
-        (s) => s.composite
-      );
-      const deltas = paired.after.map((a, i) => a - paired.before[i]);
-      seededShuffle(deltas, cfg.shuffleSeed);
-      const stream = makeStream(cfg);
-      let last;
-      for (const d of deltas) {
-        last = stream.observe(d);
-        if (last.decision !== "continue") break;
-      }
-      const detail = {
-        ...stream.state(),
-        minN: cfg.minN,
-        maxN: cfg.maxN,
-        scale: cfg.scale,
-        shuffleSeed: cfg.shuffleSeed,
-        direction: cfg.direction,
-        minEffect: cfg.minEffect,
-        pairedN: deltas.length,
-        preRegisteredId: manifest?.id,
-        metric: manifest?.metric
-      };
-      const meanDelta = deltas.length === 0 ? void 0 : deltas.reduce((s, d) => s + d, 0) / deltas.length;
-      if (last === void 0) {
-        return {
-          decision: "need_more_work",
-          reasons: [`${name}: no paired holdout observations \u2014 nothing to test`],
-          contributingGates: [{ name, passed: false, detail }]
-        };
-      }
-      const decision = last.decision === "promote" ? "ship" : last.decision === "continue" ? "need_more_work" : "hold";
-      return {
-        decision,
-        reasons: [`${name}: ${last.reason}`],
-        contributingGates: [{ name, passed: decision === "ship", detail }],
-        delta: meanDelta
-      };
-    }
-  };
-}
-function sequentialDecide(options = {}) {
-  const alpha = options.alpha ?? 0.05;
-  const minN = options.minN ?? 5;
-  const scale = options.scale ?? 1;
-  if (!Number.isFinite(scale) || scale <= 0) {
-    throw new Error(`sequentialDecide: scale must be > 0, got ${scale}`);
-  }
-  const proc = eProcess({ alpha, maxBet: options.maxBet ?? 0.5, nullMean: 0.5 });
-  const threshold = 1 / alpha;
-  let processedGenerations = 0;
-  let reference;
-  let stopped;
-  const topCandidate = (record) => {
-    if (record.candidates.length === 0) {
-      throw new Error(
-        `sequentialDecide: generation ${record.generationIndex} has no candidates \u2014 cannot extract a top candidate`
-      );
-    }
-    return record.candidates.reduce((best, c) => c.composite > best.composite ? c : best);
-  };
-  const decide = ({ history }) => {
-    if (stopped) return stopped;
-    if (history.length === 0) return { stop: false };
-    if (reference === void 0) {
-      reference = new Map(
-        topCandidate(history[0]).scenarios.map((s) => [s.scenarioId, s.composite])
-      );
-    }
-    for (let g = Math.max(1, processedGenerations); g < history.length; g++) {
-      const top = topCandidate(history[g]);
-      const byScenario = new Map(top.scenarios.map((s) => [s.scenarioId, s.composite]));
-      for (const [scenarioId, refComposite] of reference) {
-        const candComposite = byScenario.get(scenarioId);
-        if (candComposite === void 0) {
-          throw new Error(
-            `sequentialDecide: generation ${history[g].generationIndex} top candidate is missing scenario '${scenarioId}' \u2014 generations must score the same scenario set to pair`
-          );
-        }
-        const delta = candComposite - refComposite;
-        if (!Number.isFinite(delta) || Math.abs(delta) > scale) {
-          throw new Error(
-            `sequentialDecide: paired delta ${delta} outside \xB1scale=${scale} on scenario '${scenarioId}' \u2014 pass the composite scale explicitly`
-          );
-        }
-        const step = proc.update((delta / scale + 1) / 2);
-        if (step.n >= minN && step.wealth >= threshold) {
-          stopped = {
-            stop: true,
-            reason: `sequential e-process decided at generation ${history[g].generationIndex}: e-value ${step.wealth.toFixed(2)} \u2265 1/\u03B1=${threshold.toFixed(2)} after n=${step.n} paired deltas vs the generation-0 incumbent \u2014 the improvement is real at \u03B1=${alpha}; stop exploring and promote via the gate`
-          };
-          processedGenerations = history.length;
-          return stopped;
-        }
-      }
-    }
-    processedGenerations = history.length;
-    return { stop: false };
-  };
-  decide.state = () => proc.state();
-  return decide;
-}
-
-// src/campaign/labeled-store/fs-adapter.ts
-import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { join as join2 } from "path";
-var LabeledScenarioStoreError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "LabeledScenarioStoreError";
-  }
-  code;
-};
-var FsLabeledScenarioStore = class {
-  constructor(options) {
-    this.options = options;
-    if (!existsSync2(options.root)) mkdirSync(options.root, { recursive: true });
-    this.now = options.now ?? Date.now;
-  }
-  options;
-  now;
-  rateLimits = /* @__PURE__ */ new Map();
-  async observe(write) {
-    this.assertProvenance(write);
-    this.assertRateLimit(write);
-    const record = this.toRecord(write);
-    const path = this.pathForSource(write.source);
-    const line = `${JSON.stringify(record)}
-`;
-    appendLine(path, line);
-  }
-  async sample(args) {
-    if (!args.split) {
-      throw new LabeledScenarioStoreError(
-        "split_required",
-        "sample() requires an explicit `split` (train | test) \u2014 substrate refuses ambiguous reads"
-      );
-    }
-    if (!args.capturedBefore) {
-      throw new LabeledScenarioStoreError(
-        "capturedBefore_required",
-        "sample() requires an explicit `capturedBefore` timestamp for temporal-split discipline"
-      );
-    }
-    const all = [];
-    for (const source of ALL_SOURCES) {
-      if (args.split === "train" && source === "production-trace") {
-        const explicit = sourceFilterContains(args.filter?.source, "production-trace");
-        if (!explicit) continue;
-      }
-      const path = this.pathForSource(source);
-      if (!existsSync2(path)) continue;
-      const lines = readFileSync2(path, "utf8").split("\n").filter(Boolean);
-      for (const line of lines) {
-        let record;
-        try {
-          record = JSON.parse(line);
-        } catch {
-          continue;
-        }
-        if (!matchesFilter(record, args, source)) continue;
-        all.push(record);
-      }
-    }
-    all.sort((a, b) => {
-      if (a.capturedAt !== b.capturedAt) return a.capturedAt.localeCompare(b.capturedAt);
-      return a.recordHash.localeCompare(b.recordHash);
-    });
-    return all.slice(0, args.count);
-  }
-  async size() {
-    const bySource = {};
-    const byTrust = {
-      unverified: 0,
-      "verified-signal": 0,
-      "human-rated": 0
-    };
-    let total = 0;
-    for (const source of ALL_SOURCES) {
-      const path = this.pathForSource(source);
-      if (!existsSync2(path)) {
-        bySource[source] = 0;
-        continue;
-      }
-      const lines = readFileSync2(path, "utf8").split("\n").filter(Boolean);
-      bySource[source] = lines.length;
-      total += lines.length;
-      for (const line of lines) {
-        let trust = "unverified";
-        try {
-          trust = JSON.parse(line).labelTrust ?? "unverified";
-        } catch {
-        }
-        byTrust[trust] += 1;
-      }
-    }
-    return { train: total, test: total, bySource, byTrust };
-  }
-  assertProvenance(write) {
-    if (!write.source) {
-      throw new LabeledScenarioStoreError(
-        "missing_source",
-        "LabeledScenarioWrite requires `source`"
-      );
-    }
-    if (!write.sourceVersionHash || write.sourceVersionHash.length === 0) {
-      throw new LabeledScenarioStoreError(
-        "missing_source_version",
-        "LabeledScenarioWrite requires `sourceVersionHash` (git sha or substrate version)"
-      );
-    }
-    if (!write.capturedAt) {
-      throw new LabeledScenarioStoreError(
-        "missing_captured_at",
-        "LabeledScenarioWrite requires `capturedAt` ISO timestamp"
-      );
-    }
-    if (!write.redactionStatus) {
-      throw new LabeledScenarioStoreError(
-        "missing_redaction_status",
-        "LabeledScenarioWrite requires explicit `redactionStatus` \u2014 raw / redacted-pii / redacted-secrets / fully-redacted"
-      );
-    }
-    if (!ALL_SOURCES.includes(write.source)) {
-      throw new LabeledScenarioStoreError(
-        "unknown_source",
-        `LabeledScenarioWrite.source must be one of: ${ALL_SOURCES.join(", ")}`
-      );
-    }
-  }
-  assertRateLimit(write) {
-    const cap = this.options.maxWritesPerMinutePerBucket;
-    if (!cap || !write.rateLimitBucket) return;
-    const now = this.now();
-    const windowMs = 6e4;
-    let state = this.rateLimits.get(write.rateLimitBucket);
-    if (!state || now - state.windowStartMs >= windowMs) {
-      state = { bucket: write.rateLimitBucket, windowStartMs: now, count: 0 };
-      this.rateLimits.set(write.rateLimitBucket, state);
-    }
-    if (state.count >= cap) {
-      throw new LabeledScenarioStoreError(
-        "rate_limit_exceeded",
-        `LabeledScenarioStore: bucket ${write.rateLimitBucket} exceeded ${cap} writes/min`
-      );
-    }
-    state.count += 1;
-  }
-  toRecord(write) {
-    const recordHash = sha256(
-      JSON.stringify({
-        id: write.scenario.id,
-        src: write.source,
-        at: write.capturedAt,
-        ver: write.sourceVersionHash
-      })
-    );
-    return {
-      ...write,
-      recordHash,
-      split: "train"
-    };
-  }
-  pathForSource(source) {
-    return join2(this.options.root, `${source}.jsonl`);
-  }
-};
-var ALL_SOURCES = [
-  "production-trace",
-  "eval-run",
-  "manual",
-  "red-team",
-  "synthetic"
-];
-function sourceFilterContains(filter, needle) {
-  if (!filter) return false;
-  if (Array.isArray(filter)) return filter.includes(needle);
-  return filter === needle;
-}
-function matchesFilter(record, args, source) {
-  if (args.split === "train" && record.capturedAt >= args.capturedBefore) return false;
-  if (args.split === "test" && record.capturedAt < args.capturedBefore) return false;
-  const f = args.filter;
-  if (!f) return true;
-  if (f.kind && record.scenario.kind !== f.kind) return false;
-  if (f.source) {
-    const sources = Array.isArray(f.source) ? f.source : [f.source];
-    if (!sources.includes(source)) return false;
-  }
-  if (f.minComposite !== void 0 || f.maxComposite !== void 0) {
-    const composites = Object.values(record.judgeScores).map((s) => s.composite);
-    const max = composites.length === 0 ? 0 : Math.max(...composites);
-    if (f.minComposite !== void 0 && max < f.minComposite) return false;
-    if (f.maxComposite !== void 0 && max > f.maxComposite) return false;
-  }
-  if (f.minTrust !== void 0 && labelTrustRank(record.labelTrust) < labelTrustRank(f.minTrust)) {
-    return false;
-  }
-  return true;
-}
-function sha256(input) {
-  return createHash4("sha256").update(input).digest("hex").slice(0, 16);
-}
-function appendLine(path, line) {
-  if (existsSync2(path)) {
-    const existing = readFileSync2(path, "utf8");
-    writeFileSync(path, existing + line);
-  } else {
-    writeFileSync(path, line);
-  }
-}
-
-// src/campaign/neutralize.ts
-var FILLER = "#";
-function neutralizeText(content) {
-  return content.replace(/\S/g, FILLER);
-}
-
-// src/campaign/proposers/fapo.ts
-var FAPO_LEVELS = ["prompt", "parameter", "structural"];
-var MAX_FINDING_DEPTH = 16;
-var UNSAFE_JSON_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
-function fapoProposer(opts) {
-  const proposers = levelProposers(opts);
-  const allowed = allowedLevels(opts, proposers);
-  const plateauWindow = opts.plateauWindow ?? 3;
-  const minDistinctStrategies = opts.minDistinctStrategies ?? 3;
-  const minImprovement = opts.minImprovement ?? 0;
-  const proposalsPerCycle = opts.proposalsPerCycle ?? 1;
-  if (allowed.length === 0) {
-    throw new Error("fapoProposer: at least one allowed level must have a proposer");
-  }
-  if (plateauWindow < 1) throw new Error("fapoProposer: plateauWindow must be >= 1");
-  if (minDistinctStrategies < 1) {
-    throw new Error("fapoProposer: minDistinctStrategies must be >= 1");
-  }
-  if (proposalsPerCycle < 1) throw new Error("fapoProposer: proposalsPerCycle must be >= 1");
-  return {
-    kind: "fapo",
-    async propose(ctx) {
-      const state = policyState(ctx.history, ctx.findings, {
-        plateauWindow,
-        minDistinctStrategies,
-        minImprovement
-      });
-      const decision = chooseLevel({
-        allowed,
-        available: allowed.filter((level) => !state.exhausted[level]),
-        proposers,
-        state,
-        promptFirst: opts.promptFirst ?? true,
-        parameterBeforeStructural: opts.parameterBeforeStructural ?? true
-      });
-      if (!decision) return [];
-      const proposer = proposers[decision.level];
-      if (!proposer) {
-        throw new Error(`fapoProposer: selected ${decision.level} but no proposer is configured`);
-      }
-      const requested = Math.min(ctx.populationSize, proposalsPerCycle);
-      const raw = await proposer.propose({ ...ctx, populationSize: requested });
-      const wrapped = raw.map((candidate) => normalizeProposal(candidate)).map((candidate) => wrapProposal(candidate, decision.level, decision.reason));
-      const reviewed = [];
-      for (const candidate of wrapped) {
-        const review = opts.reviewCandidate ? await opts.reviewCandidate({
-          level: decision.level,
-          candidate,
-          context: ctx,
-          reason: decision.reason
-        }) : { verdict: "pass" };
-        if (review.verdict === "fail") continue;
-        const warn = review.verdict === "warn" ? renderReviewWarnings(review) : "";
-        reviewed.push(
-          warn ? { ...candidate, rationale: `${candidate.rationale}
-${warn}` } : candidate
-        );
-      }
-      if (wrapped.length > 0 && reviewed.length === 0) {
-        throw new Error(
-          `fapoProposer: reviewer blocked every ${decision.level} candidate; refusing to evaluate an unreviewed variant`
-        );
-      }
-      return reviewed;
-    },
-    decide({ history }) {
-      const last = history[history.length - 1];
-      if (last && last.candidates.length === 0) {
-        return { stop: true, reason: "FAPO produced no scoped candidate in the prior generation" };
-      }
-      const state = policyState(history, [], {
-        plateauWindow,
-        minDistinctStrategies,
-        minImprovement
-      });
-      const everyAllowedLevelExhausted = allowed.every((level) => state.exhausted[level]);
-      return everyAllowedLevelExhausted ? { stop: true, reason: `all FAPO levels exhausted (${allowed.join(", ")})` } : { stop: false };
-    }
-  };
-}
-function levelProposers(opts) {
-  return {
-    ...opts.proposers ?? {},
-    ...opts.promptProposer ? { prompt: opts.promptProposer } : {},
-    ...opts.parameterProposer ? { parameter: opts.parameterProposer } : {},
-    ...opts.structuralProposer ? { structural: opts.structuralProposer } : {}
-  };
-}
-function allowedLevels(opts, proposers) {
-  const explicit = opts.scope?.allowedLevels;
-  const forbidden = new Set(opts.scope?.forbiddenLevels ?? []);
-  return FAPO_LEVELS.filter((level) => {
-    if (!proposers[level]) return false;
-    if (forbidden.has(level)) return false;
-    return explicit ? explicit.includes(level) : true;
-  });
-}
-function policyState(history, findings, opts) {
-  const attempts = extractAttempts(history);
-  return {
-    attempts,
-    exhausted: {
-      prompt: isLevelExhausted("prompt", attempts, opts),
-      parameter: isLevelExhausted("parameter", attempts, opts),
-      structural: isLevelExhausted("structural", attempts, opts)
-    },
-    signals: extractFapoAttributionSignals(findings)
-  };
-}
-function extractAttempts(history) {
-  const attempts = [];
-  for (const generation of history) {
-    for (const candidate of generation.candidates) {
-      const level = candidateLevel(candidate);
-      if (!level) continue;
-      attempts.push({
-        level,
-        composite: candidate.composite,
-        strategy: candidateStrategy(candidate)
-      });
-    }
-  }
-  return attempts;
-}
-function candidateLevel(candidate) {
-  const label = candidate.label ?? "";
-  const rationale = candidate.rationale ?? "";
-  return parseLevel(label) ?? parseLevel(rationale);
-}
-function parseLevel(text) {
-  const match = /\bfapo:(prompt|parameter|structural)\b/.exec(text);
-  return match ? match[1] : null;
-}
-function candidateStrategy(candidate) {
-  const label = candidate.label ?? candidate.rationale ?? candidate.surfaceHash;
-  return label.replace(/\bfapo:(prompt|parameter|structural):?/g, "").trim() || candidate.surfaceHash;
-}
-function isLevelExhausted(level, attempts, opts) {
-  const own = attempts.filter((attempt) => attempt.level === level);
-  if (own.length < opts.plateauWindow) return false;
-  const distinctStrategies = new Set(own.map((attempt) => attempt.strategy)).size;
-  if (distinctStrategies < opts.minDistinctStrategies) return false;
-  let best = Number.NEGATIVE_INFINITY;
-  let nonImproving = 0;
-  for (const attempt of own) {
-    if (attempt.composite > best + opts.minImprovement) {
-      best = attempt.composite;
-      nonImproving = 0;
-    } else {
-      nonImproving += 1;
-    }
-  }
-  return nonImproving >= opts.plateauWindow;
-}
-function chooseLevel(args) {
-  const { available, state } = args;
-  if (available.length === 0) return null;
-  const triedPrompt = state.attempts.some((attempt) => attempt.level === "prompt");
-  if (args.promptFirst && available.includes("prompt") && !triedPrompt) {
-    return {
-      level: "prompt",
-      reason: "prompt-first policy: no prompt-level variant has been tried yet"
-    };
-  }
-  const supported = available.filter((level) => state.signals.counts[level] > 0);
-  if (supported.includes("prompt")) {
-    return {
-      level: "prompt",
-      reason: `attribution has ${state.signals.counts.prompt} prompt-addressable failure(s)`
-    };
-  }
-  const strongest = supported.sort(
-    (a, b) => state.signals.counts[b] - state.signals.counts[a] || levelRank(a) - levelRank(b)
-  )[0];
-  if (strongest) {
-    if (strongest === "structural" && args.parameterBeforeStructural && available.includes("parameter") && args.proposers.parameter) {
-      return {
-        level: "parameter",
-        reason: "attribution indicates a non-prompt bottleneck; trying parameter/config edits before structural edits"
-      };
-    }
-    return {
-      level: strongest,
-      reason: `attribution has ${state.signals.counts[strongest]} ${strongest}-addressable failure(s)`
-    };
-  }
-  if (state.attempts.length === 0) {
-    const first = available.slice().sort((a, b) => levelRank(a) - levelRank(b))[0];
-    return { level: first, reason: "no attribution yet; starting at the cheapest allowed level" };
-  }
-  return null;
-}
-function levelRank(level) {
-  return level === "prompt" ? 0 : level === "parameter" ? 1 : 2;
-}
-function normalizeProposal(value) {
-  return isProposedCandidate(value) ? value : { surface: value, label: "candidate", rationale: "bare candidate from level proposer" };
-}
-function wrapProposal(candidate, level, reason) {
-  const label = candidate.label ? `fapo:${level}:${candidate.label}` : `fapo:${level}`;
-  return {
-    ...candidate,
-    label,
-    rationale: [
-      `fapo:${level} selected by reviewed escalation policy`,
-      `Reason: ${reason}`,
-      candidate.rationale ? `Level proposer rationale: ${candidate.rationale}` : ""
-    ].filter(Boolean).join("\n")
-  };
-}
-function renderReviewWarnings(review) {
-  const issues = review.issues?.filter((issue) => issue.severity === "warn") ?? [];
-  if (issues.length === 0) return "";
-  return `Reviewer warnings:
-${issues.map((issue) => `- ${issue.checkName}: ${issue.description}`).join("\n")}`;
-}
-function extractFapoAttributionSignals(findings) {
-  const signals = {
-    counts: { prompt: 0, parameter: 0, structural: 0 },
-    clusters: []
-  };
-  const seen = /* @__PURE__ */ new WeakSet();
-  for (const finding of findings) {
-    collectFinding(signals, finding, seen, 0);
-  }
-  return signals;
-}
-function collectFinding(signals, finding, seen, depth) {
-  if (depth > MAX_FINDING_DEPTH) return;
-  if (!finding) return;
-  if (typeof finding === "string") {
-    const level = inferLevelFromText(finding);
-    if (level) addCluster(signals, { label: finding, level, count: 1 });
-    return;
-  }
-  if (Array.isArray(finding)) {
-    if (seen.has(finding)) return;
-    seen.add(finding);
-    for (const item of finding) collectFinding(signals, item, seen, depth + 1);
-    return;
-  }
-  if (typeof finding !== "object") return;
-  if (seen.has(finding)) return;
-  seen.add(finding);
-  const obj = finding;
-  collectLevelPartition(signals, obj.level_partition ?? obj.levelPartition, seen, depth + 1);
-  collectCounts(signals, obj);
-  collectClusters(signals, obj.clusters, true, seen, depth + 1);
-  const explicit = parseFindingLevel(obj.level ?? obj.optimization_level ?? obj.optimizationLevel);
-  const text = textFields(obj);
-  const inferred = explicit ?? inferLevelFromText(text);
-  if (inferred) {
-    addCluster(signals, {
-      label: text || inferred,
-      level: inferred,
-      count: numberField(obj.count) ?? 1,
-      confidence: confidenceField(obj.confidence),
-      suggestedFix: stringField(obj.suggested_fix ?? obj.suggestedFix ?? obj.recommended_action),
-      caseIds: stringArrayField(obj.case_ids ?? obj.caseIds)
-    });
-  }
-}
-function collectLevelPartition(signals, raw, seen, depth) {
-  if (!raw || typeof raw !== "object") return;
-  if (seen.has(raw)) return;
-  seen.add(raw);
-  const partition = raw;
-  for (const level of FAPO_LEVELS) {
-    const bucket = partition[level];
-    if (!bucket || typeof bucket !== "object") continue;
-    const obj = bucket;
-    const count = numberField(obj.count) ?? 0;
-    if (count > 0) signals.counts[level] += count;
-    collectClusters(signals, obj.clusters, false, seen, depth + 1);
-  }
-}
-function collectCounts(signals, obj) {
-  const prompt = numberField(obj.prompt_addressable ?? obj.promptAddressable);
-  const structural = numberField(obj.structural_addressable ?? obj.structuralAddressable);
-  const tool = numberField(obj.tool_addressable ?? obj.toolAddressable);
-  if (prompt) signals.counts.prompt += prompt;
-  if (structural) signals.counts.structural += structural;
-  if (tool) signals.counts.structural += tool;
-}
-function collectClusters(signals, raw, countClusters, seen, depth) {
-  if (!Array.isArray(raw)) return;
-  if (seen.has(raw)) return;
-  seen.add(raw);
-  for (const item of raw) {
-    if (countClusters) {
-      collectFinding(signals, item, seen, depth + 1);
-      continue;
-    }
-    const cluster = parseCluster(item);
-    if (cluster) signals.clusters.push(cluster);
-  }
-}
-function addCluster(signals, cluster) {
-  signals.counts[cluster.level] += Math.max(1, cluster.count);
-  signals.clusters.push(cluster);
-}
-function parseCluster(raw) {
-  if (!raw || typeof raw !== "object") return null;
-  const obj = raw;
-  const text = textFields(obj);
-  const level = parseFindingLevel(obj.level ?? obj.optimization_level ?? obj.optimizationLevel) ?? inferLevelFromText(text);
-  if (!level) return null;
-  return {
-    label: text || level,
-    level,
-    count: numberField(obj.count) ?? 1,
-    confidence: confidenceField(obj.confidence),
-    suggestedFix: stringField(obj.suggested_fix ?? obj.suggestedFix ?? obj.recommended_action),
-    caseIds: stringArrayField(obj.case_ids ?? obj.caseIds)
-  };
-}
-function parseFindingLevel(raw) {
-  if (typeof raw !== "string") return null;
-  const lower = raw.toLowerCase();
-  if (lower === "prompt" || lower === "parameter" || lower === "structural") return lower;
-  if (lower === "chain" || lower === "tool" || lower === "code") return "structural";
-  if (lower === "config" || lower === "params") return "parameter";
-  return null;
-}
-function inferLevelFromText(text) {
-  const lower = text.toLowerCase();
-  if (/\b(retrieval_k|temperature|top_p|max_tokens|max_completion_tokens|reasoning_effort|config|parameter)\b/.test(
-    lower
-  )) {
-    return "parameter";
-  }
-  if (/\b(retriev\w*|search\w*|bm25|hop|evidence|cascade|tool|node|chain|state|structur\w*|topology|import)\b/.test(
-    lower
-  )) {
-    return "structural";
-  }
-  if (/\b(format\w*|verbose|brevity|abstain\w*|reasoning|instruction|prompt|output|answer)\b/.test(
-    lower
-  )) {
-    return "prompt";
-  }
-  return null;
-}
-function textFields(obj) {
-  return [
-    obj.label,
-    obj.claim,
-    obj.recommended_action,
-    obj.suggested_fix,
-    obj.suggestedFix,
-    obj.message,
-    obj.text,
-    obj.heuristic,
-    obj.area
-  ].filter((value) => typeof value === "string" && value.trim().length > 0).join(" ");
-}
-function numberField(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function stringField(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-function confidenceField(value) {
-  return value === "high" || value === "medium" || value === "low" ? value : void 0;
-}
-function stringArrayField(value) {
-  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : void 0;
-}
-function parameterSweepProposer(opts) {
-  if (opts.candidates.length === 0) {
-    throw new Error("parameterSweepProposer: candidates must not be empty");
-  }
-  return {
-    kind: "parameter-sweep",
-    async propose(ctx) {
-      if (typeof ctx.currentSurface !== "string") {
-        throw new Error(
-          "parameterSweepProposer: currentSurface must be a JSON string config surface"
-        );
-      }
-      const parse = opts.parse ?? parseJsonObject;
-      const stringify = opts.stringify ?? ((config) => JSON.stringify(config, null, 2));
-      const current = parse(ctx.currentSurface);
-      const currentCanonical = canonicalJson(current);
-      const tried = triedLabels(ctx.history);
-      const out = [];
-      for (const candidate of opts.candidates) {
-        if (tried.has(candidate.label)) continue;
-        const next = applyParameterCandidate(current, candidate);
-        const surface = stringify(next);
-        if (surface === ctx.currentSurface || canonicalJson(next) === currentCanonical) continue;
-        out.push({ surface, label: candidate.label, rationale: candidate.rationale });
-        if (out.length >= ctx.populationSize) break;
-      }
-      return out;
-    }
-  };
-}
-function parseJsonObject(surface) {
-  let parsed;
-  try {
-    parsed = JSON.parse(surface);
-  } catch (error) {
-    throw new Error(
-      `parameterSweepProposer: currentSurface must be valid JSON object config (${error instanceof Error ? error.message : String(error)})`
-    );
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("parameterSweepProposer: JSON surface must parse to an object");
-  }
-  return parsed;
-}
-function triedLabels(history) {
-  const tried = /* @__PURE__ */ new Set();
-  for (const generation of history) {
-    for (const candidate of generation.candidates) {
-      if (!candidate.label) continue;
-      tried.add(candidate.label);
-      tried.add(candidateStrategy(candidate));
-    }
-  }
-  return tried;
-}
-function applyParameterCandidate(current, candidate) {
-  const next = cloneJsonObject(current);
-  if (candidate.patch) deepMerge(next, candidate.patch);
-  for (const change of candidate.changes ?? []) {
-    setPath(
-      next,
-      typeof change.path === "string" ? change.path.split(".") : [...change.path],
-      change.value
-    );
-  }
-  return next;
-}
-function cloneJsonObject(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-function deepMerge(target, patch) {
-  for (const [key, value] of Object.entries(patch)) {
-    assertSafeJsonKey(key);
-    if (isPlainObject(value) && isPlainObject(target[key])) {
-      deepMerge(target[key], value);
-    } else {
-      target[key] = value;
-    }
-  }
-}
-function setPath(target, path, value) {
-  if (path.length === 0) throw new Error("parameterSweepProposer: change path must not be empty");
-  for (const part of path) assertSafeJsonKey(part);
-  let cursor = target;
-  for (const part of path.slice(0, -1)) {
-    const existing = cursor[part];
-    if (!isPlainObject(existing)) {
-      cursor[part] = {};
-    }
-    cursor = cursor[part];
-  }
-  cursor[path[path.length - 1]] = value;
-}
-function assertSafeJsonKey(key) {
-  if (!key.trim()) throw new Error("parameterSweepProposer: change path contains an empty key");
-  if (UNSAFE_JSON_KEYS.has(key)) {
-    throw new Error(`parameterSweepProposer: unsafe JSON key "${key}" is not allowed`);
-  }
-}
-function canonicalJson(value) {
-  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
-  if (isPlainObject(value)) {
-    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-function isPlainObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-
-// src/campaign/skill-patch.ts
-function applySkillPatch(surface, patch) {
-  let lines = surface.split("\n");
-  let applied = 0;
-  const rejected = [];
-  const findLine = (anchor) => lines.findIndex((l) => l.includes(anchor));
-  for (const op of patch.ops) {
-    if (op.op === "add") {
-      if (typeof op.text !== "string" || op.text.trim() === "") {
-        rejected.push({ op, reason: "empty add text" });
-        continue;
-      }
-      const insert = op.text.split("\n");
-      if (op.after === void 0 || op.after === "") {
-        lines = [...lines, ...insert];
-        applied++;
-        continue;
-      }
-      const idx = findLine(op.after);
-      if (idx === -1) {
-        rejected.push({ op, reason: `add anchor not found: ${truncate(op.after)}` });
-        continue;
-      }
-      lines = [...lines.slice(0, idx + 1), ...insert, ...lines.slice(idx + 1)];
-      applied++;
-    } else if (op.op === "delete") {
-      const idx = findLine(op.anchor);
-      if (idx === -1) {
-        rejected.push({ op, reason: `delete anchor not found: ${truncate(op.anchor)}` });
-        continue;
-      }
-      lines = [...lines.slice(0, idx), ...lines.slice(idx + 1)];
-      applied++;
-    } else {
-      const idx = findLine(op.anchor);
-      if (idx === -1) {
-        rejected.push({ op, reason: `replace anchor not found: ${truncate(op.anchor)}` });
-        continue;
-      }
-      if (typeof op.text !== "string") {
-        rejected.push({ op, reason: "replace text missing" });
-        continue;
-      }
-      lines = [...lines.slice(0, idx), ...op.text.split("\n"), ...lines.slice(idx + 1)];
-      applied++;
-    }
-  }
-  return { surface: lines.join("\n"), applied, rejected };
-}
-function patchEditCount(patch) {
-  return patch.ops.length;
-}
-function truncate(s, max = 48) {
-  return s.length <= max ? s : `${s.slice(0, max)}\u2026`;
-}
-
-// src/campaign/proposers/skill-opt.ts
-var SKILLOPT_SYSTEM = 'You are a SkillOpt optimizer. You improve ONE skill document by proposing BOUNDED, anchored edits \u2014 never a full rewrite. Output ONLY a JSON object of shape {"patches":[{"label":string,"rationale":string,"ops":[op,...]}]} where each op is one of: {"op":"add","after":<exact substring of an existing line, or omit to append>,"text":<new line(s)>}, {"op":"delete","anchor":<exact substring of the line to remove>}, {"op":"replace","anchor":<exact substring of the line to replace>,"text":<replacement line(s)>}. Anchors MUST be verbatim substrings of lines that exist in the document. No prose outside JSON.';
-function skillOptProposer(opts) {
-  const evidenceK = opts.evidenceK ?? 3;
-  const defaultBudget = opts.editBudget ?? 3;
-  async function proposePatches(args) {
-    const userPrompt = buildPatchPrompt({
-      target: opts.target,
-      surface: args.surface,
-      evidence: args.evidence,
-      editBudget: args.editBudget,
-      rejectedBuffer: args.rejectedBuffer,
-      metaNote: args.metaNote,
-      findingsNote: args.findingsNote,
-      count: args.count
-    });
-    const result = await callLlm(
-      {
-        model: opts.model,
-        messages: [
-          { role: "system", content: SKILLOPT_SYSTEM },
-          { role: "user", content: userPrompt }
-        ],
-        jsonMode: true,
-        temperature: opts.temperature ?? 0.6,
-        maxTokens: opts.maxTokens ?? 4e3
-      },
-      opts.llm
-    );
-    return parseSkillPatchResponse(result.content, args.count, args.editBudget);
-  }
-  return {
-    kind: "skill-opt",
-    proposePatches,
-    async propose(ctx) {
-      if (typeof ctx.currentSurface !== "string") {
-        throw new Error(
-          "skillOptProposer: surface must be a string skill document (got a CodeSurface). SkillOpt patches text."
-        );
-      }
-      const surface = ctx.currentSurface;
-      const patches = await proposePatches({
-        surface,
-        evidence: evidenceFromHistory(ctx, evidenceK),
-        editBudget: defaultBudget,
-        rejectedBuffer: [],
-        findingsNote: renderAnalystEvidence(ctx.findings, ctx.report) ?? void 0,
-        count: ctx.populationSize,
-        signal: ctx.signal
-      });
-      const out = [];
-      const seen = /* @__PURE__ */ new Set();
-      for (const patch of patches) {
-        const { surface: candidate, applied } = applySkillPatch(surface, patch);
-        if (applied === 0 || candidate === surface || seen.has(candidate)) continue;
-        seen.add(candidate);
-        out.push({ surface: candidate, label: patch.label, rationale: patch.rationale });
-        if (out.length >= ctx.populationSize) break;
-      }
-      return out;
-    }
-  };
-}
-function evidenceFromHistory(ctx, k) {
-  const last = ctx.history.at(-1);
-  if (!last || last.candidates.length === 0) return { weakScenarios: [], weakDimensions: [] };
-  const best = [...last.candidates].sort((a, b) => b.composite - a.composite)[0];
-  if (!best) return { weakScenarios: [], weakDimensions: [] };
-  const weakScenarios = [...best.scenarios].sort((a, b) => a.composite - b.composite).slice(0, k);
-  const weakDimensions = Object.entries(best.dimensions).sort((a, b) => a[1] - b[1]).slice(0, k).map(([dimension, score]) => ({ dimension, score }));
-  return { weakScenarios, weakDimensions };
-}
-function buildPatchPrompt(args) {
-  const lines = [
-    `Skill document governs: ${args.target}.`,
-    "",
-    "Current skill document:",
-    "```",
-    args.surface,
-    "```",
-    "",
-    `Propose ${args.count} candidate patch(es). Each patch is a SMALL bundle of`,
-    `at most ${args.editBudget} op(s). Anchors must be verbatim substrings of`,
-    "existing lines. Prefer adding a specific missing rule or sharpening a vague",
-    "one over deleting; never rewrite the whole document."
-  ];
-  if (args.evidence.weakScenarios.length > 0) {
-    lines.push(
-      "",
-      "Weakest scenarios (patch to fix these):",
-      ...args.evidence.weakScenarios.map((s) => `- ${s.scenarioId} (${s.composite.toFixed(2)})`)
-    );
-  }
-  if (args.evidence.weakDimensions.length > 0) {
-    lines.push(
-      "",
-      "Weakest dimensions (what to improve):",
-      ...args.evidence.weakDimensions.map((d) => `- ${d.dimension} (${d.score.toFixed(2)})`)
-    );
-  }
-  if (args.rejectedBuffer.length > 0) {
-    lines.push(
-      "",
-      "Already tried and REJECTED (do not repeat or restate these edits):",
-      ...args.rejectedBuffer.map((e) => `- ${e.label}: ${e.rationale} \u2014 ${e.reason}`)
-    );
-  }
-  if (args.findingsNote) {
-    lines.push("", args.findingsNote);
-  }
-  if (args.metaNote) {
-    lines.push("", `Strategy note from prior epochs: ${args.metaNote}`);
-  }
-  return lines.join("\n");
-}
-var SkillPatchParseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SkillPatchParseError";
-  }
-};
-function parseSkillPatchResponse(raw, maxPatches, editBudget) {
-  let text = raw.trim();
-  if (text.startsWith("```")) text = text.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
-  const start = text.indexOf("{");
-  const end = text.lastIndexOf("}");
-  if (start < 0 || end <= start) {
-    throw new SkillPatchParseError(
-      `parseSkillPatchResponse: response was not valid JSON (no object found): ${snippet(raw)}`
-    );
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(text.slice(start, end + 1));
-  } catch (err) {
-    throw new SkillPatchParseError(
-      `parseSkillPatchResponse: response was not valid JSON (${err instanceof Error ? err.message : String(err)}): ${snippet(raw)}`
-    );
-  }
-  const rawPatches = Array.isArray(parsed.patches) ? parsed.patches : [];
-  const out = [];
-  for (const rp of rawPatches) {
-    if (typeof rp !== "object" || rp === null) continue;
-    const obj = rp;
-    const ops = Array.isArray(obj.ops) ? obj.ops.map(normalizeOp).filter(isOp) : [];
-    if (ops.length === 0) continue;
-    out.push({
-      label: typeof obj.label === "string" ? obj.label : "patch",
-      rationale: typeof obj.rationale === "string" ? obj.rationale : "",
-      ops: ops.slice(0, editBudget)
-    });
-    if (out.length >= maxPatches) break;
-  }
-  return out;
-}
-function normalizeOp(raw) {
-  if (typeof raw !== "object" || raw === null) return null;
-  const o = raw;
-  if (o.op === "add") {
-    if (typeof o.text !== "string") return null;
-    const op = { op: "add", text: o.text };
-    if (typeof o.after === "string") op.after = o.after;
-    return op;
-  }
-  if (o.op === "delete") {
-    if (typeof o.anchor !== "string") return null;
-    return { op: "delete", anchor: o.anchor };
-  }
-  if (o.op === "replace") {
-    if (typeof o.anchor !== "string" || typeof o.text !== "string") return null;
-    return { op: "replace", anchor: o.anchor, text: o.text };
-  }
-  return null;
-}
-function isOp(op) {
-  return op !== null;
-}
-function snippet(s, max = 120) {
-  const t = s.trim().replace(/\s+/g, " ");
-  return t.length <= max ? t : `${t.slice(0, max)}\u2026`;
-}
-
-// src/campaign/presets/run-skill-opt.ts
-async function runSkillOpt(opts) {
-  if (opts.trainScenarios.length === 0) throw new Error("runSkillOpt: trainScenarios is empty");
-  if (opts.holdoutScenarios.length === 0) throw new Error("runSkillOpt: holdoutScenarios is empty");
-  if (!opts.judges || opts.judges.length === 0) {
-    throw new Error(
-      "runSkillOpt: at least one judge is required \u2014 scoring (and therefore acceptance) is meaningless without one, and would report a silent zero lift."
-    );
-  }
-  const holdoutIds = new Set(opts.holdoutScenarios.map((s) => s.id));
-  const overlap = opts.trainScenarios.filter((s) => holdoutIds.has(s.id)).map((s) => s.id);
-  if (overlap.length > 0) {
-    throw new Error(
-      `runSkillOpt: trainScenarios and holdoutScenarios must be disjoint (overlap: [${overlap.join(
-        ", "
-      )}]) \u2014 a shared scenario leaks the held-out acceptance axis into the proposal evidence.`
-    );
-  }
-  const patchesPerEpoch = opts.patchesPerEpoch ?? 2;
-  const initialBudget = opts.editBudget ?? 3;
-  const minImprovement = opts.minImprovement ?? 0;
-  if (minImprovement < 0) {
-    throw new Error(
-      "runSkillOpt: minImprovement must be >= 0 \u2014 a negative threshold would accept held-out regressions, breaking the monotonic-lift contract."
-    );
-  }
-  const patience = opts.patience ?? opts.maxEpochs;
-  const budgetAnneal = opts.budgetAnneal ?? true;
-  const rejectedBufferSize = opts.rejectedBufferSize ?? 12;
-  const slowMetaEvery = opts.slowMetaEvery ?? 2;
-  let totalCostUsd = 0;
-  const scoreHoldout = async (surface, tag) => {
-    const campaign = await runScoringCampaign(opts, opts.holdoutScenarios, surface, tag);
-    totalCostUsd += campaign.aggregates.totalCostUsd;
-    return campaignMeanComposite(campaign);
-  };
-  const evidenceK = opts.evidenceK ?? 3;
-  const trainEvidence = async (surface, tag) => {
-    const campaign = await runScoringCampaign(opts, opts.trainScenarios, surface, tag);
-    totalCostUsd += campaign.aggregates.totalCostUsd;
-    return toEvidence(campaign, evidenceK);
-  };
-  let current = opts.baselineSurface;
-  let currentEvidence = await trainEvidence(current, "baseline-train");
-  const baselineHoldout = await scoreHoldout(current, "baseline-holdout");
-  let currentHoldout = baselineHoldout;
-  const buffer = [];
-  const acceptedEdits = [];
-  const rejectedAll = [];
-  const history = [];
-  let budget = initialBudget;
-  let sinceAccept = 0;
-  let metaNote;
-  let epochsRun = 0;
-  for (let epoch = 0; epoch < opts.maxEpochs; epoch++) {
-    epochsRun++;
-    const patches = await opts.proposer.proposePatches({
-      surface: current,
-      evidence: currentEvidence,
-      editBudget: budget,
-      rejectedBuffer: buffer,
-      metaNote,
-      count: patchesPerEpoch,
-      signal: opts.signal ?? new AbortController().signal
-    });
-    let accepted = null;
-    const rejectedThisEpoch = [];
-    for (let i = 0; i < patches.length; i++) {
-      const patch = patches[i];
-      const { surface: candidate, applied } = applySkillPatch(current, patch);
-      if (applied === 0 || candidate === current) {
-        rejectedThisEpoch.push({
-          label: patch.label,
-          rationale: patch.rationale,
-          reason: "no-op (unanchored or zero-change)"
-        });
-        continue;
-      }
-      const candidateHoldout = await scoreHoldout(candidate, `epoch-${epoch}-cand-${i}-holdout`);
-      if (candidateHoldout > currentHoldout + minImprovement) {
-        accepted = {
-          epoch,
-          label: patch.label,
-          rationale: patch.rationale,
-          holdoutDelta: candidateHoldout - currentHoldout
-        };
-        current = candidate;
-        currentHoldout = candidateHoldout;
-        currentEvidence = await trainEvidence(current, `epoch-${epoch}-train`);
-        break;
-      }
-      rejectedThisEpoch.push({
-        label: patch.label,
-        rationale: patch.rationale,
-        reason: `held-out ${candidateHoldout.toFixed(3)} \u2264 current ${currentHoldout.toFixed(3)}`
-      });
-    }
-    if (accepted) {
-      acceptedEdits.push(accepted);
-      sinceAccept = 0;
-    } else {
-      sinceAccept++;
-      if (budgetAnneal && sinceAccept >= 2 && budget > 1) budget--;
-    }
-    for (const r of rejectedThisEpoch) {
-      buffer.push(r);
-      rejectedAll.push(r);
-    }
-    while (buffer.length > rejectedBufferSize) buffer.shift();
-    if (slowMetaEvery > 0 && (epoch + 1) % slowMetaEvery === 0) {
-      metaNote = buildMetaNote(acceptedEdits, buffer);
-    }
-    history.push({
-      epoch,
-      editBudget: budget,
-      proposed: patches.length,
-      accepted,
-      rejected: rejectedThisEpoch,
-      holdoutComposite: currentHoldout
-    });
-    if (sinceAccept >= patience) break;
-  }
-  return {
-    winnerSurface: current,
-    baselineHoldoutComposite: baselineHoldout,
-    winnerHoldoutComposite: currentHoldout,
-    lift: currentHoldout - baselineHoldout,
-    acceptedEdits,
-    rejectedEdits: rejectedAll,
-    epochsRun,
-    history,
-    totalCostUsd
-  };
-}
-function runScoringCampaign(opts, scenarios, surface, tag) {
-  return runCampaign({
-    ...opts,
-    scenarios,
-    dispatch: (scenario, ctx) => opts.dispatchWithSurface(surface, scenario, ctx),
-    runDir: `${opts.runDir}/${tag}`
-  });
-}
-function toEvidence(campaign, k) {
-  const { dimensions, scenarios } = campaignBreakdown(campaign);
-  const weakScenarios = [...scenarios].sort((a, b) => a.composite - b.composite).slice(0, k);
-  const weakDimensions = Object.entries(dimensions).sort((a, b) => a[1] - b[1]).slice(0, k).map(([dimension, score]) => ({ dimension, score }));
-  return { weakScenarios, weakDimensions };
-}
-function buildMetaNote(accepted, rejected) {
-  const parts = [];
-  if (accepted.length > 0) {
-    parts.push(
-      `Edits that improved held-out so far: ${accepted.map((a) => `"${a.label}" (+${a.holdoutDelta.toFixed(3)})`).join("; ")}. Build on these.`
-    );
-  }
-  if (rejected.length > 0) {
-    const labels = [...new Set(rejected.map((r) => r.label))].slice(0, 5);
-    parts.push(`Dead ends to avoid: ${labels.join(", ")}. Try a different anchor or rule.`);
-  }
-  parts.push("Keep edits small and anchored to existing lines.");
-  return parts.join(" ");
-}
-
-// src/campaign/presets/compare-proposers.ts
-async function compareProposers(opts) {
-  return compareProposerEntries(opts);
-}
-async function compareProposerEntries(opts) {
-  if (opts.proposers.length === 0) throw new Error("compareProposers: no proposers to compare");
-  const seed = opts.seed ?? 42;
-  const resamples = opts.resamples ?? 2e3;
-  const confidence = opts.confidence ?? 0.95;
-  const scoreOnHoldout = async (surface, tag) => {
-    const campaign = await runCampaign({
-      ...opts,
-      scenarios: opts.holdoutScenarios,
-      dispatch: (scenario, ctx) => opts.dispatchWithSurface(surface, scenario, ctx),
-      runDir: `${opts.runDir}/${tag}`
-    });
-    const byScenario = {};
-    for (const { scenarioId, composite } of campaignBreakdown(campaign).scenarios) {
-      byScenario[scenarioId] = composite;
-    }
-    return byScenario;
-  };
-  const scenarioIds = [...new Set(opts.holdoutScenarios.map((s) => s.id))].sort();
-  if (scenarioIds.length === 0) throw new Error("compareProposers: holdoutScenarios is empty");
-  const align = (byScenario, label) => {
-    const missing = scenarioIds.filter((id) => !(id in byScenario));
-    if (missing.length > 0) {
-      throw new Error(
-        `compareProposers: ${label} produced no held-out score for scenario(s) [${missing.join(
-          ", "
-        )}] \u2014 a cell errored or its judges returned nothing. Refusing to fabricate a 0 (it would corrupt the lift comparison). Fix the dispatch/judge or drop the scenario.`
-      );
-    }
-    return scenarioIds.map((id) => byScenario[id]);
-  };
-  const baselineArr = align(
-    await scoreOnHoldout(opts.baselineSurface, "compare-baseline"),
-    "baseline"
-  );
-  const winners = [];
-  for (const proposer of opts.proposers) {
-    const out = await proposer.optimize();
-    const byScenario = await scoreOnHoldout(out.winnerSurface, `compare-${slug(proposer.name)}`);
-    winners.push({
-      name: proposer.name,
-      winnerSurface: out.winnerSurface,
-      costUsd: out.costUsd,
-      durationMs: out.durationMs,
-      arr: align(byScenario, `proposer "${proposer.name}"`)
-    });
-  }
-  const scores = winners.map((w) => {
-    const boot = pairedBootstrap(baselineArr, w.arr, {
-      seed,
-      resamples,
-      confidence,
-      statistic: "mean"
-    });
-    const score = {
-      name: w.name,
-      baselineComposite: mean2(baselineArr),
-      winnerComposite: mean2(w.arr),
-      lift: boot.mean,
-      liftCi: { low: boot.low, high: boot.high },
-      costUsd: w.costUsd,
-      winnerSurface: w.winnerSurface,
-      rank: 0
-    };
-    if (w.durationMs !== void 0) score.durationMs = w.durationMs;
-    return score;
-  });
-  scores.sort((a, b) => b.lift - a.lift || a.costUsd - b.costUsd);
-  scores.forEach((s, i) => {
-    s.rank = i + 1;
-  });
-  const best = scores[0];
-  const byName = new Map(winners.map((w) => [w.name, w]));
-  const bestArr = byName.get(best.name).arr;
-  const pairwise = scores.slice(1).map((other) => {
-    const otherArr = byName.get(other.name).arr;
-    const boot = pairedBootstrap(otherArr, bestArr, {
-      seed,
-      resamples,
-      confidence,
-      statistic: "mean"
-    });
-    const favored = boot.low > 0 ? best.name : boot.high < 0 ? other.name : "tie";
-    return {
-      a: best.name,
-      b: other.name,
-      deltaMean: boot.mean,
-      low: boot.low,
-      high: boot.high,
-      favored
-    };
-  });
-  return { scores, best, pairwise, holdoutScenarioIds: scenarioIds };
-}
-function mean2(xs) {
-  return xs.length === 0 ? 0 : xs.reduce((a, b) => a + b, 0) / xs.length;
-}
-function slug(name) {
-  return name.replace(/[^a-z0-9]+/gi, "-").toLowerCase();
-}
-function gepaReflectionEntry(config, name = "gepa-reflection") {
-  return gepaEntry(config, false, name);
-}
-function gepaParetoEntry(config, name = "gepa-pareto") {
-  return gepaEntry(config, true, name);
-}
-function gepaEntry(config, combineParents, name) {
-  return {
-    name,
-    async optimize() {
-      const started = Date.now();
-      const proposer = gepaProposer({
-        llm: config.llm,
-        model: config.model,
-        target: config.target,
-        combineParents,
-        ...config.mutationPrimitives ? { mutationPrimitives: config.mutationPrimitives } : {}
-      });
-      const result = await runImprovementLoop({
-        scenarios: config.trainScenarios,
-        holdoutScenarios: config.holdoutScenarios,
-        baselineSurface: config.baselineSurface,
-        dispatchWithSurface: config.dispatchWithSurface,
-        judges: config.judges,
-        proposer,
-        populationSize: config.populationSize ?? 2,
-        maxGenerations: config.maxGenerations ?? 3,
-        gate: defaultProductionGate({
-          holdoutScenarios: config.holdoutScenarios,
-          deltaThreshold: 0
-        }),
-        autoOnPromote: "none",
-        runDir: `${config.runDir}/${slug(name)}-loop`,
-        ...config.seed !== void 0 ? { seed: config.seed } : {},
-        // Flow findings to the proposer's propose(). These reach runOptimization
-        // unchanged (runImprovementLoop extends RunOptimizationOptions and
-        // forwards {...opts}); ctx.findings/report/analyzeGeneration are consumed there.
-        ...config.findings !== void 0 ? { findings: config.findings } : {},
-        ...config.analyzeGeneration ? { analyzeGeneration: config.analyzeGeneration } : {},
-        ...config.report !== void 0 ? { report: config.report } : {}
-      });
-      const costUsd = result.baselineCampaign.aggregates.totalCostUsd + result.generations.reduce(
-        (sum, g) => sum + g.surfaces.reduce((s, sf) => s + sf.campaign.aggregates.totalCostUsd, 0),
-        0
-      );
-      return { winnerSurface: result.winnerSurface, costUsd, durationMs: Date.now() - started };
-    }
-  };
-}
-function skillOptEntry(config, name = "skill-opt") {
-  return {
-    name,
-    async optimize() {
-      const started = Date.now();
-      const proposer = skillOptProposer({
-        llm: config.llm,
-        model: config.model,
-        target: config.target
-      });
-      const result = await runSkillOpt({
-        baselineSurface: config.baselineSurface,
-        dispatchWithSurface: config.dispatchWithSurface,
-        judges: config.judges,
-        proposer,
-        trainScenarios: config.trainScenarios,
-        holdoutScenarios: config.holdoutScenarios,
-        maxEpochs: config.maxEpochs ?? 6,
-        runDir: `${config.runDir}/${slug(name)}-loop`,
-        ...config.seed !== void 0 ? { seed: config.seed } : {}
-      });
-      return {
-        winnerSurface: result.winnerSurface,
-        costUsd: result.totalCostUsd,
-        durationMs: Date.now() - started
-      };
-    }
-  };
-}
-function fapoEscalationEntry(config, name = "fapo-escalation") {
-  return {
-    name,
-    async optimize() {
-      const started = Date.now();
-      const promptProposer = config.promptProposer ?? gepaProposer({
-        llm: config.llm,
-        model: config.model,
-        target: config.target,
-        combineParents: true,
-        ...config.mutationPrimitives ? { mutationPrimitives: config.mutationPrimitives } : {}
-      });
-      const parameterProposer = config.parameterProposer ?? (config.parameterCandidates ? parameterSweepProposer({ candidates: config.parameterCandidates }) : void 0);
-      const structuralProposer = config.structuralProposer;
-      const proposer = fapoProposer({
-        ...config.fapo ?? {},
-        promptProposer,
-        ...parameterProposer ? { parameterProposer } : {},
-        ...structuralProposer ? { structuralProposer } : {}
-      });
-      const result = await runImprovementLoop({
-        scenarios: config.trainScenarios,
-        holdoutScenarios: config.holdoutScenarios,
-        baselineSurface: config.baselineSurface,
-        dispatchWithSurface: config.dispatchWithSurface,
-        judges: config.judges,
-        proposer,
-        populationSize: config.populationSize ?? 2,
-        maxGenerations: config.maxGenerations ?? 3,
-        gate: defaultProductionGate({
-          holdoutScenarios: config.holdoutScenarios,
-          deltaThreshold: 0
-        }),
-        autoOnPromote: "none",
-        runDir: `${config.runDir}/${slug(name)}-loop`,
-        ...config.seed !== void 0 ? { seed: config.seed } : {},
-        ...config.findings !== void 0 ? { findings: config.findings } : {},
-        ...config.analyzeGeneration ? { analyzeGeneration: config.analyzeGeneration } : {},
-        ...config.report !== void 0 ? { report: config.report } : {}
-      });
-      const costUsd = result.baselineCampaign.aggregates.totalCostUsd + result.generations.reduce(
-        (sum, g) => sum + g.surfaces.reduce((s, sf) => s + sf.campaign.aggregates.totalCostUsd, 0),
-        0
-      );
-      return { winnerSurface: result.winnerSurface, costUsd, durationMs: Date.now() - started };
-    }
-  };
-}
-
-// src/campaign/presets/playback.ts
-function makePlaybackDispatch(driver) {
-  return async (profile, scenario, ctx) => {
-    const events = await driver.run(scenario, { ...ctx, profile });
-    return extractProducedState(events);
-  };
-}
-async function scoreUserStory(story, state, checkCorrectness) {
-  const verdict = await verifyCompletion(
-    { taskId: story.id, requirements: story.requirements },
-    state,
-    checkCorrectness
-  );
-  return { ...verdict, title: story.title };
-}
-function userStoryScoreboard(verdicts) {
-  const rows = [];
-  for (const v of verdicts) {
-    for (const r of v.requirements) {
-      rows.push({
-        storyId: v.taskId,
-        storyTitle: v.title,
-        reqId: r.reqId,
-        reqTitle: r.title,
-        status: r.satisfied ? "PASS" : "FAIL",
-        evidence: r.evidence
-      });
-    }
-  }
-  return rows;
-}
-function scoreboardSummary(rows) {
-  const byStory = /* @__PURE__ */ new Map();
-  let passed = 0;
-  for (const r of rows) {
-    const s = byStory.get(r.storyId) ?? { total: 0, passed: 0 };
-    s.total++;
-    if (r.status === "PASS") {
-      s.passed++;
-      passed++;
-    }
-    byStory.set(r.storyId, s);
-  }
-  let storiesFullyComplete = 0;
-  for (const s of byStory.values()) if (s.total > 0 && s.passed === s.total) storiesFullyComplete++;
-  return {
-    stories: byStory.size,
-    storiesFullyComplete,
-    requirements: rows.length,
-    passed,
-    failed: rows.length - passed,
-    passRate: rows.length === 0 ? 0 : passed / rows.length
-  };
-}
-function escapeCell(s) {
-  return s.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
-}
-function truncate2(s, max) {
-  return s.length <= max ? s : `${s.slice(0, Math.max(0, max - 1))}\u2026`;
-}
-function renderScoreboardMarkdown(rows, opts = {}) {
-  const maxEv = opts.maxEvidenceChars ?? 160;
-  const sum = scoreboardSummary(rows);
-  const pct = (n) => `${Math.round(n * 100)}%`;
-  const ev = (e) => escapeCell(truncate2(e.join("; "), maxEv)) || "\u2014";
-  const out = [`# ${opts.title ?? "Product-flow playback scoreboard"}`, ""];
-  if (opts.meta) {
-    for (const [k, v] of Object.entries(opts.meta)) out.push(`- **${k}:** ${v}`);
-    out.push("");
-  }
-  out.push(
-    `**${sum.storiesFullyComplete}/${sum.stories}** user stories fully shipped \xB7 **${sum.passed}/${sum.requirements}** requirements passing (${pct(sum.passRate)}) \xB7 **${sum.failed}** open`,
-    ""
-  );
-  const fails = rows.filter((r) => r.status === "FAIL");
-  if (fails.length > 0) {
-    out.push("## Open tickets", "", "| Story | Requirement | Evidence |", "| --- | --- | --- |");
-    for (const r of fails) {
-      out.push(`| ${escapeCell(r.storyTitle)} | ${escapeCell(r.reqTitle)} | ${ev(r.evidence)} |`);
-    }
-    out.push("");
-  } else {
-    out.push("_All requirements passing \u2014 no open tickets._", "");
-  }
-  out.push("## Per-story tick-off", "");
-  for (const storyId of [...new Set(rows.map((r) => r.storyId))]) {
-    const storyRows = rows.filter((r) => r.storyId === storyId);
-    const passed = storyRows.filter((r) => r.status === "PASS").length;
-    const mark = passed === storyRows.length ? "\u2705" : "\u26A0\uFE0F";
-    out.push(
-      `### ${escapeCell(storyRows[0].storyTitle)} \u2014 ${passed}/${storyRows.length} ${mark}`,
-      "",
-      "| Requirement | Status | Evidence |",
-      "| --- | --- | --- |"
-    );
-    for (const r of storyRows) {
-      out.push(
-        `| ${escapeCell(r.reqTitle)} | ${r.status === "PASS" ? "\u2705 PASS" : "\u274C FAIL"} | ${ev(r.evidence)} |`
-      );
-    }
-    out.push("");
-  }
-  return out.join("\n");
-}
-
-// src/campaign/presets/run-lineage-loop.ts
-function toCandidate(p) {
-  return isProposedCandidate(p) ? { surface: p.surface, ...p.rationale ? { rationale: p.rationale } : {} } : { surface: p };
-}
-async function runLineageLoop(opts) {
-  const governor = opts.governor ?? heuristicGovernor();
-  const populationSize = opts.populationSize ?? 4;
-  if (populationSize < 1) {
-    throw new Error("runLineageLoop: populationSize must be >= 1");
-  }
-  let proposer = opts.proposer;
-  if (!proposer) {
-    if (!opts.llm || !opts.model) {
-      throw new Error(
-        "runLineageLoop: a proposer is required \u2014 either inject `proposer`, or provide `llm` + `model` for the default gepaProposer."
-      );
-    }
-    proposer = gepaProposer({
-      llm: opts.llm,
-      model: opts.model,
-      target: opts.target ?? "agent surface",
-      // GEPA combine-complementary-lessons is what the `merge` seam relies on.
-      combineParents: true
-    });
-  }
-  const scoringScenarios = opts.holdoutScenarios ?? opts.scenarios;
-  let scoreSurface = opts.scoreSurface;
-  if (!scoreSurface) {
-    const dispatchWithSurface = opts.dispatchWithSurface;
-    const runDir = opts.runDir;
-    if (!dispatchWithSurface || !runDir) {
-      throw new Error(
-        "runLineageLoop: scoring is required \u2014 either inject `scoreSurface`, or provide `dispatchWithSurface` (the agent) + `runDir` for the default runCampaign scorer."
-      );
-    }
-    if (scoringScenarios.length === 0) {
-      throw new Error(
-        "runLineageLoop: the default scorer needs at least one scenario (holdoutScenarios ?? scenarios is empty)."
-      );
-    }
-    scoreSurface = async (surface) => {
-      const campaign = await runCampaign({
-        scenarios: scoringScenarios,
-        dispatch: (scenario, ctx) => dispatchWithSurface(surface, scenario, ctx),
-        dispatchRef: `lineage-loop:${surfaceHash(surface)}`,
-        runDir: `${runDir}/score/${surfaceHash(surface)}`,
-        ...opts.judges ? { judges: opts.judges } : {},
-        ...opts.seed !== void 0 ? { seed: opts.seed } : {},
-        ...opts.reps !== void 0 ? { reps: opts.reps } : {},
-        ...opts.storage ? { storage: opts.storage } : {},
-        ...opts.tracing ? { tracing: opts.tracing } : {},
-        ...opts.expectUsage ? { expectUsage: opts.expectUsage } : {},
-        ...opts.maxConcurrency !== void 0 ? { maxConcurrency: opts.maxConcurrency } : {},
-        ...opts.dispatchTimeoutMs !== void 0 ? { dispatchTimeoutMs: opts.dispatchTimeoutMs } : {},
-        ...opts.now ? { now: opts.now } : {}
-      });
-      const score = campaignMeanComposite(campaign);
-      const byId = new Map(
-        campaignBreakdown(campaign).scenarios.map((s) => [s.scenarioId, s.composite])
-      );
-      const scoreVector = scoringScenarios.map((s) => byId.get(s.id) ?? 0);
-      return { score, scoreVector };
-    };
-  }
-  const objectivesOf = (node) => {
-    const objectives = {};
-    if (node.scoreVector && node.scoreVector.length > 0) {
-      scoringScenarios.forEach((s, i) => {
-        objectives[s.id] = node.scoreVector[i] ?? 0;
-      });
-      if (Object.keys(objectives).length > 0) return objectives;
-    }
-    objectives.composite = node.score;
-    return objectives;
-  };
-  const scoredSeeds = [];
-  for (const seed of opts.seeds) {
-    const measured = await scoreSurface(seed.surface);
-    scoredSeeds.push({
-      surface: seed.surface,
-      track: seed.track,
-      proposer: seed.proposer,
-      score: measured.score,
-      ...seed.vision !== void 0 ? { vision: seed.vision } : {},
-      ...measured.scoreVector !== void 0 ? { scoreVector: measured.scoreVector } : {}
-    });
-  }
-  const step = async (args) => {
-    const proposed = await proposer.propose({
-      currentSurface: args.tip.surface,
-      history: [],
-      findings: [],
-      populationSize,
-      generation: 0,
-      signal: new AbortController().signal,
-      paretoParents: []
-    });
-    const pool = [
-      {
-        surface: args.tip.surface,
-        score: args.tip.score,
-        ...args.tip.scoreVector !== void 0 ? { scoreVector: args.tip.scoreVector } : {},
-        ...args.tip.rationale !== void 0 ? { rationale: args.tip.rationale } : {}
-      }
-    ];
-    for (const p of proposed) {
-      const { surface, rationale } = toCandidate(p);
-      const measured = await scoreSurface(surface);
-      pool.push({
-        surface,
-        score: measured.score,
-        ...measured.scoreVector !== void 0 ? { scoreVector: measured.scoreVector } : {},
-        ...rationale !== void 0 ? { rationale } : {}
-      });
-    }
-    let best = pool[0];
-    for (const entry of pool) {
-      if (entry.score > best.score) best = entry;
-    }
-    return {
-      surface: best.surface,
-      score: best.score,
-      ...best.scoreVector !== void 0 ? { scoreVector: best.scoreVector } : {},
-      ...best.rationale !== void 0 ? { rationale: best.rationale } : {}
-    };
-  };
-  const merge = async (args) => {
-    const ordered = [...args.parents].sort((a, b) => b.score - a.score);
-    const paretoParents = ordered.map((node) => ({
-      surface: node.surface,
-      surfaceHash: surfaceHash(node.surface),
-      objectives: objectivesOf(node),
-      composite: node.score,
-      generation: node.generation
-    }));
-    const proposed = await proposer.propose({
-      currentSurface: ordered[0].surface,
-      history: [],
-      findings: [],
-      // A merge is a single crossover; combineParents fires because
-      // paretoParents has > 1 string member.
-      populationSize: 1,
-      // generation >= 1 keeps the combine slot semantically a "merge" step.
-      generation: 1,
-      signal: new AbortController().signal,
-      paretoParents
-    });
-    const first = proposed[0];
-    const merged = first ? toCandidate(first) : { surface: ordered[0].surface };
-    const measured = await scoreSurface(merged.surface);
-    return {
-      surface: merged.surface,
-      score: measured.score,
-      ...measured.scoreVector !== void 0 ? { scoreVector: measured.scoreVector } : {},
-      ...merged.rationale !== void 0 ? { rationale: merged.rationale } : {}
-    };
-  };
-  const result = await runLineage({
-    seeds: scoredSeeds,
-    step,
-    merge,
-    governor,
-    budget: opts.budget,
-    ...opts.store ? { store: opts.store } : {},
-    ...opts.log ? { log: opts.log } : {}
-  });
-  return { lineage: result.lineage, best: result.best, steps: result.steps };
-}
-
-// src/campaign/presets/run-profile-matrix.ts
-import { createHash as createHash5 } from "crypto";
-import { join as join3 } from "path";
-var ProfileMatrixError = class extends AgentEvalError {
-  constructor(message) {
-    super("profile_matrix", message);
-  }
-};
-function sanitize(id) {
-  return id.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-function sha(input) {
-  return createHash5("sha256").update(JSON.stringify(input)).digest("hex");
-}
-function mean3(xs) {
-  return xs.length === 0 ? 0 : xs.reduce((a, b) => a + b, 0) / xs.length;
-}
-function cellComposite(cell) {
-  const composites = Object.values(cell.judgeScores).map((s) => s.composite);
-  return composites.length === 0 ? 0 : mean3(composites);
-}
-function requireResolvedModel(cell, profileId) {
-  const resolved = cell.resolvedModel?.trim();
-  if (!resolved) {
-    throw new ProfileMatrixError(
-      `profile '${profileId}' declared the '${HARNESS_NATIVE_MODEL}' runtime-resolved model but its dispatch reported no resolved model for cell '${cell.cellId}' \u2014 report it via ctx.cost.observeModel(<id>) so the RunRecord pins the real model (never records '${HARNESS_NATIVE_MODEL}')`
-    );
-  }
-  if (!modelHasSnapshot(resolved)) {
-    throw new ProfileMatrixError(
-      `profile '${profileId}' resolved to model '${resolved}' for cell '${cell.cellId}', which lacks a snapshot version \u2014 pin it (name@YYYY-MM-DD or name-YYYYMMDD) before reporting it via ctx.cost.observeModel`
-    );
-  }
-  return resolved;
-}
-function buildRunRecord(args) {
-  const { cell, profile, profileHash, configHash, experimentId, splitTag, commitSha, matrixId } = args;
-  const profileId = agentProfileId(profile);
-  const declaredModel = agentProfileModelId(profile);
-  const model = declaredModel === HARNESS_NATIVE_MODEL ? requireResolvedModel(cell, profileId) : declaredModel;
-  const composite = cellComposite(cell);
-  const raw = { composite };
-  const perJudge = {};
-  const dimAccum = {};
-  const notes = [];
-  for (const [judgeName, js] of Object.entries(cell.judgeScores)) {
-    perJudge[judgeName] = { ...js.dimensions };
-    for (const [dim, value] of Object.entries(js.dimensions)) {
-      raw[`${judgeName}.${dim}`] = value;
-      dimAccum[dim] ??= [];
-      dimAccum[dim].push(value);
-    }
-    if (js.notes) notes.push(`${judgeName}: ${js.notes}`);
-  }
-  const perDimMean = {};
-  for (const [dim, values] of Object.entries(dimAccum)) perDimMean[dim] = mean3(values);
-  let costUsd = cell.costUsd;
-  let costEstimated = false;
-  if (costUsd === 0 && cell.tokenUsage.output > 0 && isModelPriced(model)) {
-    costUsd = estimateCost(cell.tokenUsage.input, cell.tokenUsage.output, model);
-    costEstimated = costUsd > 0;
-  }
-  raw.cost_usd = costUsd;
-  raw.cost_estimated = costEstimated ? 1 : 0;
-  raw.tokens_input = cell.tokenUsage.input;
-  raw.tokens_output = cell.tokenUsage.output;
-  if (typeof cell.tokenUsage.cached === "number") raw.tokens_cached = cell.tokenUsage.cached;
-  raw.latency_ms = cell.durationMs;
-  if (costUsd > 0) {
-    raw.tokens_per_dollar = (cell.tokenUsage.input + cell.tokenUsage.output) / costUsd;
-  }
-  if (composite > 0.01) raw.cost_per_quality = costUsd / composite;
-  const outcome = splitTag === "holdout" ? { holdoutScore: composite, raw } : { searchScore: composite, raw };
-  if (Object.keys(perJudge).length > 0) {
-    outcome.judgeScores = {
-      perJudge,
-      perDimMean,
-      composite,
-      ...notes.length > 0 ? { notes: notes.join(" | ") } : {}
-    };
-  }
-  const record = {
-    runId: `${matrixId}:${profileId}:${cell.cellId}`,
-    experimentId,
-    candidateId: profileId,
-    seed: cell.seed,
-    model,
-    promptHash: profileHash,
-    configHash,
-    commitSha,
-    wallMs: cell.durationMs,
-    costUsd,
-    tokenUsage: cell.tokenUsage,
-    outcome,
-    splitTag,
-    scenarioId: cell.scenarioId,
-    ...args.agentProfileCell ? { agentProfile: args.agentProfileCell } : {},
-    ...cell.error ? { failureMode: cell.error } : {}
-  };
-  if (args.corpusText && args.scenario) {
-    try {
-      const text = args.corpusText(cell.artifact, args.scenario);
-      if (text && typeof text.prompt === "string" && typeof text.completion === "string") {
-        record.prompt = text.prompt;
-        record.completion = text.completion;
-      }
-    } catch {
-    }
-  }
-  return record;
-}
-async function runProfileMatrix(opts) {
-  if (opts.profiles.length === 0) throw new ProfileMatrixError("profiles must not be empty");
-  if (opts.scenarios.length === 0) throw new ProfileMatrixError("scenarios must not be empty");
-  const splitTag = opts.splitTag ?? "search";
-  const seed = opts.seed ?? 42;
-  const validate = opts.validate ?? true;
-  const integrityMode = opts.integrity ?? "assert";
-  const profileIds = opts.profiles.map(agentProfileId);
-  const experimentId = opts.experimentId ?? `pm_${sha({ profileIds, scenarios: opts.scenarios.map((s) => s.id) }).slice(0, 16)}`;
-  const matrixId = `mtx_${sha({ experimentId, profileIds, seed, splitTag }).slice(0, 16)}`;
-  const scenarioById = new Map(opts.scenarios.map((s) => [s.id, s]));
-  for (const profile of opts.profiles) {
-    const profileHash = agentProfileHash(profile);
-    const profileId = agentProfileId(profile);
-    const declaredModel = agentProfileModelId(profile);
-    const model = declaredModel === HARNESS_NATIVE_MODEL ? `${HARNESS_NATIVE_MODEL}@runtime-resolved` : declaredModel;
-    try {
-      validateRunRecord({
-        runId: `${matrixId}:${profileId}:probe`,
-        experimentId,
-        candidateId: profileId,
-        seed,
-        model,
-        promptHash: profileHash,
-        configHash: profileHash,
-        commitSha: opts.commitSha,
-        wallMs: 0,
-        costUsd: 0,
-        tokenUsage: { input: 0, output: 0 },
-        outcome: splitTag === "holdout" ? { holdoutScore: 0, raw: {} } : { searchScore: 0, raw: {} },
-        splitTag
-      });
-    } catch (err) {
-      throw new ProfileMatrixError(
-        `profile '${profileId}' is not recordable: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  const records = [];
-  const campaigns = {};
-  const byProfile = {};
-  for (const profile of opts.profiles) {
-    const profileHash = agentProfileHash(profile);
-    const profileId = agentProfileId(profile);
-    const declaredModel = agentProfileModelId(profile);
-    const configHash = sha({
-      profile: profileHash,
-      judges: (opts.judges ?? []).map((j) => j.name),
-      seed,
-      splitTag
-    });
-    const dispatch = (scenario, ctx) => opts.dispatch(profile, scenario, ctx);
-    Object.defineProperty(dispatch, "name", { value: `profile_${sanitize(profileId)}` });
-    const campaign = await runCampaign({
-      scenarios: opts.scenarios,
-      dispatch,
-      judges: opts.judges,
-      seed,
-      reps: opts.reps,
-      maxConcurrency: opts.maxConcurrency,
-      costCeiling: opts.costCeiling,
-      labeledStore: opts.labeledStore,
-      captureSource: opts.captureSource,
-      storage: opts.storage,
-      now: opts.now,
-      runDir: join3(opts.runDir, sanitize(profileId))
-    });
-    const axis = harnessAxisOf(profile);
-    const buildCellIdentity = (cellModel) => buildAgentProfileCell({
-      profileId,
-      sourceProfile: { kind: "agent-interface-profile", hash: profileHash },
-      model: cellModel,
-      ...axis ? { harness: { id: axis.harness } } : {}
-    });
-    const sharedCellIdentity = declaredModel === HARNESS_NATIVE_MODEL ? void 0 : await buildCellIdentity(declaredModel);
-    const profileRecords = [];
-    for (const cell of campaign.cells) {
-      const agentProfileCell = sharedCellIdentity ?? await buildCellIdentity(requireResolvedModel(cell, profileId));
-      const record = buildRunRecord({
-        cell,
-        profile,
-        profileHash,
-        configHash,
-        experimentId,
-        splitTag,
-        commitSha: opts.commitSha,
-        matrixId,
-        agentProfileCell,
-        scenario: scenarioById.get(cell.scenarioId),
-        corpusText: opts.corpusText
-      });
-      if (validate) validateRunRecord(record);
-      profileRecords.push(record);
-      records.push(record);
-    }
-    const pricedTotalCostUsd = profileRecords.reduce((a, r) => a + r.costUsd, 0);
-    campaigns[profileId] = {
-      ...campaign,
-      aggregates: { ...campaign.aggregates, totalCostUsd: pricedTotalCostUsd }
-    };
-    byProfile[profileId] = {
-      profileId,
-      profileHash,
-      // The declared model, unless it snapped to the sentinel — then the
-      // resolved model the cells actually ran on (all cells of a profile share
-      // one harness, so the first record's model is representative).
-      model: declaredModel === HARNESS_NATIVE_MODEL ? profileRecords[0]?.model ?? declaredModel : declaredModel,
-      records: profileRecords.length,
-      meanComposite: mean3(profileRecords.map(compositeOf)),
-      totalCostUsd: pricedTotalCostUsd,
-      integrity: summarizeBackendIntegrity(profileRecords)
-    };
-  }
-  const integrity = summarizeBackendIntegrity(records);
-  if (integrityMode === "assert") {
-    assertRealBackend(records, { allowMixed: opts.allowMixed ?? true });
-  } else if (integrityMode === "warn" && integrity.verdict !== "real") {
-    console.warn(
-      `[runProfileMatrix] backend integrity: ${integrity.verdict} \u2014 ${integrity.diagnosis}`
-    );
-  }
-  const byScenario = rollup(records, (r) => r.scenarioId);
-  const byPersona = opts.personaOf ? rollupByPersona(records, opts.scenarios, opts.personaOf) : void 0;
-  return { matrixId, experimentId, records, byProfile, byScenario, byPersona, integrity, campaigns };
-}
-function compositeOf(r) {
-  return r.outcome.holdoutScore ?? r.outcome.searchScore ?? 0;
-}
-function rollup(records, keyOf) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const r of records) {
-    const key = keyOf(r);
-    if (key === void 0) continue;
-    const arr = groups.get(key) ?? [];
-    arr.push(compositeOf(r));
-    groups.set(key, arr);
-  }
-  const out = {};
-  for (const [key, xs] of groups) out[key] = { meanComposite: mean3(xs), n: xs.length };
-  return out;
-}
-function rollupByPersona(records, scenarios, personaOf) {
-  const personaByScenarioId = /* @__PURE__ */ new Map();
-  for (const s of scenarios) personaByScenarioId.set(s.id, personaOf(s));
-  return rollup(records, (r) => r.scenarioId ? personaByScenarioId.get(r.scenarioId) : void 0);
-}
-
-// src/campaign/proposers/_findings-text.ts
-function findingToLesson(f) {
-  if (typeof f === "string") return f.trim() || null;
-  if (f && typeof f === "object") {
-    const o = f;
-    const cand = o.recommended_action ?? o.claim ?? o.lesson ?? o.text ?? o.message;
-    if (typeof cand === "string" && cand.trim()) return cand.trim();
-  }
-  return null;
-}
-function normKey(s) {
-  return s.toLowerCase().replace(/\s+/g, " ").replace(/[.;:!?\s]+$/, "").trim();
-}
-function surfaceToText2(surface) {
-  if (typeof surface === "string") return surface;
-  throw new Error(
-    `curator proposer: surface must be a string prompt, got a ${surface.kind}-tier surface (${surface.worktreeRef}) \u2014 curation is prompt-tier`
-  );
-}
-function extractBlockBody(text, startMarker, endMarker) {
-  const start = text.indexOf(startMarker);
-  const end = text.indexOf(endMarker);
-  if (start === -1 || end === -1 || end < start) return "";
-  return text.slice(start + startMarker.length, end);
-}
-function stripBlock(text, startMarker, endMarker) {
-  const start = text.indexOf(startMarker);
-  const end = text.indexOf(endMarker);
-  if (start === -1 || end === -1 || end < start) return text.trimEnd();
-  return (text.slice(0, start) + text.slice(end + endMarker.length)).trimEnd();
-}
-
-// src/campaign/proposers/ace.ts
-var BLOCK_START = "<!-- BEGIN ace-playbook (auto-managed by aceProposer) -->";
-var BLOCK_END = "<!-- END ace-playbook -->";
-var DEFAULT_HEADING = "## Playbook (accumulated lessons \u2014 append-only)";
-function parsePlaybook(surface) {
-  const body = extractBlockBody(surface, BLOCK_START, BLOCK_END);
-  const out = [];
-  for (const raw of body.split("\n")) {
-    const line = raw.trim();
-    if (!line.startsWith("- ")) continue;
-    const item = line.slice(2).trim();
-    const tag = /^\[g(-?\d+)\]\s*(.*)$/.exec(item);
-    if (tag) out.push({ gen: Number(tag[1]), text: tag[2].trim() });
-    else out.push({ gen: -1, text: item });
-  }
-  return out;
-}
-function aceProposer(opts = {}) {
-  const maxEntries = opts.maxEntries ?? 50;
-  if (maxEntries < 1) throw new Error("aceProposer: maxEntries must be >= 1");
-  const heading = opts.sectionHeading ?? DEFAULT_HEADING;
-  return {
-    kind: "ace",
-    async propose(ctx) {
-      const parent = surfaceToText2(ctx.currentSurface);
-      const existing = parsePlaybook(parent);
-      const seen = new Set(existing.map((b) => normKey(b.text)));
-      const fresh = [];
-      for (const f of ctx.findings ?? []) {
-        const lesson = findingToLesson(f);
-        if (!lesson) continue;
-        const k = normKey(lesson);
-        if (!k || seen.has(k)) continue;
-        seen.add(k);
-        fresh.push({ gen: ctx.generation, text: lesson });
-      }
-      if (fresh.length === 0) return [];
-      const all = [...existing, ...fresh].slice(-maxEntries);
-      const block = [
-        BLOCK_START,
-        heading,
-        ...all.map((b) => `- [g${b.gen}] ${b.text}`),
-        BLOCK_END
-      ].join("\n");
-      const base = stripBlock(parent, BLOCK_START, BLOCK_END);
-      const surface = base ? `${base}
-
-${block}` : block;
-      return [
-        {
-          surface,
-          label: `ace-playbook +${fresh.length}`,
-          rationale: `appended ${fresh.length} new lesson(s) from gen ${ctx.generation} findings (playbook now ${all.length} bullet(s), append-only)`
-        }
-      ];
-    }
-  };
-}
-
-// src/campaign/proposers/halo.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-
-// src/campaign/proposers/analysis-edit.ts
-import { mkdtempSync, writeFileSync as writeFileSync2 } from "fs";
-import { tmpdir } from "os";
-import { join as join4 } from "path";
-var APPLY_SYSTEM = "You apply a trace-analysis report to an agent instruction prompt. Output ONLY the full revised prompt \u2014 no preamble, no commentary, no code fences. Make the minimal edits that address the report findings; preserve everything else verbatim.";
-function surfaceToPromptText(surface) {
-  return typeof surface === "string" ? surface : JSON.stringify(surface);
-}
-function analysisEditProposer(opts) {
-  return {
-    kind: opts.kind,
-    async propose(ctx) {
-      const parent = surfaceToPromptText(ctx.currentSurface);
-      const traces = await opts.resolveTraces(ctx) ?? "";
-      if (!traces.trim()) throw new Error(opts.noTracesError);
-      const dir = mkdtempSync(join4(tmpdir(), `${opts.kind}-proposer-`));
-      const tracePath = join4(dir, "traces.jsonl");
-      writeFileSync2(tracePath, traces.endsWith("\n") ? traces : `${traces}
-`);
-      const report = await opts.analyze(tracePath, ctx);
-      const applied = await callLlm(
-        {
-          model: opts.applyModel,
-          messages: [
-            { role: "system", content: APPLY_SYSTEM },
-            {
-              role: "user",
-              content: `CURRENT PROMPT:
-${parent}
-
-TRACE-ANALYSIS REPORT:
-${report}
-
-Return the full revised prompt.`
-            }
-          ]
-        },
-        { baseUrl: opts.baseUrl, apiKey: opts.apiKey, fetch: opts.fetchImpl }
-      );
-      const text = applied.content.trim();
-      if (!text || text === parent) return [];
-      return [{ surface: text, label: opts.label, rationale: opts.rationale(report) }];
-    }
-  };
-}
-
-// src/campaign/proposers/halo.ts
-var execFileAsync = promisify(execFile);
-var DEFAULT_ANALYSIS_PROMPT = "Diagnose the failures in these agent execution traces \u2014 hallucinated tool calls, redundant tool arguments, refusal loops, and semantic-correctness errors \u2014 and suggest concrete, generalizable fixes to the agent instructions.";
-function haloProposer(opts) {
-  const haloBin = opts.haloBin ?? "halo";
-  const model = opts.model ?? "gpt-5.4-mini";
-  return analysisEditProposer({
-    kind: "halo",
-    label: "halo",
-    baseUrl: opts.baseUrl,
-    apiKey: opts.apiKey,
-    applyModel: opts.applyModel ?? model,
-    fetchImpl: opts.fetchImpl,
-    resolveTraces: opts.resolveTraces,
-    noTracesError: "haloProposer: resolveTraces returned no OTLP traces \u2014 the halo engine has nothing to analyze",
-    // HALO's real findings are preserved verbatim in the rationale (attribution).
-    rationale: (findings) => `halo-engine findings:
-${findings.slice(0, 800)}`,
-    analyze: async (tracePath, ctx) => {
-      const args = [
-        tracePath,
-        "-p",
-        opts.analysisPrompt ?? DEFAULT_ANALYSIS_PROMPT,
-        "-m",
-        model,
-        ...opts.maxDepth !== void 0 ? ["--max-depth", String(opts.maxDepth)] : [],
-        ...opts.maxTurns !== void 0 ? ["--max-turns", String(opts.maxTurns)] : []
-      ];
-      let findings;
-      try {
-        const { stdout } = await execFileAsync(haloBin, args, {
-          maxBuffer: 64 * 1024 * 1024,
-          signal: ctx.signal,
-          env: {
-            ...process.env,
-            ...opts.apiKey ? { OPENAI_API_KEY: opts.apiKey } : {},
-            OPENAI_BASE_URL: opts.baseUrl
-          }
-        });
-        findings = stdout.trim();
-      } catch (e) {
-        throw new Error(
-          `haloProposer: halo-engine ('${haloBin}') failed \u2014 ${e instanceof Error ? e.message : String(e)}`
-        );
-      }
-      if (!findings) throw new Error("haloProposer: halo-engine produced no findings");
-      return findings;
-    }
-  });
-}
-
-// src/campaign/proposers/memory.ts
-var BLOCK_START2 = "<!-- BEGIN curated-memory (auto-managed by memoryCurationProposer) -->";
-var BLOCK_END2 = "<!-- END curated-memory -->";
-var DEFAULT_HEADING2 = "## Learned from prior runs (curated memory)";
-var DISTILL_SYSTEM = 'You compress raw trace-analysis findings into crisp, generalizable agent guidance. Output ONLY a JSON array of strings, each one imperative lesson the agent should follow (e.g. "Always fetch a resource before mutating it"). No prose outside the JSON. Deduplicate; keep the most actionable and general; drop case-specific noise.';
-function extractExistingLessons(text) {
-  return extractBlockBody(text, BLOCK_START2, BLOCK_END2).split("\n").map((l) => l.replace(/^\s*-\s+/, "").trim()).filter((l) => l && !l.startsWith("#"));
-}
-async function distillLessons(raw, distill) {
-  const res = await callLlm(
-    {
-      model: distill.model,
-      messages: [
-        { role: "system", content: DISTILL_SYSTEM },
-        { role: "user", content: `Findings:
-${raw.map((r) => `- ${r}`).join("\n")}` }
-      ]
-    },
-    { baseUrl: distill.baseUrl, apiKey: distill.apiKey, fetch: distill.fetchImpl }
-  );
-  try {
-    const parsed = JSON.parse(res.content.trim());
-    if (Array.isArray(parsed)) {
-      const lessons = parsed.filter(
-        (x) => typeof x === "string" && x.trim().length > 0
-      );
-      if (lessons.length > 0) return lessons;
-    }
-  } catch {
-  }
-  return raw;
-}
-function memoryCurationProposer(opts = {}) {
-  const maxEntries = opts.maxEntries ?? 12;
-  const heading = opts.sectionHeading ?? DEFAULT_HEADING2;
-  return {
-    kind: "memory-curation",
-    async propose(ctx) {
-      const parent = surfaceToText2(ctx.currentSurface);
-      const fresh = [];
-      for (const f of ctx.findings ?? []) {
-        const l = findingToLesson(f);
-        if (l) fresh.push(l);
-      }
-      const carried = extractExistingLessons(parent);
-      if (fresh.length === 0 && carried.length === 0) return [];
-      const distilled = opts.distill && fresh.length > 0 ? await distillLessons(fresh, opts.distill) : fresh;
-      const byKey = /* @__PURE__ */ new Map();
-      for (const l of carried) {
-        const k = normKey(l);
-        if (k) byKey.set(k, { text: l, count: 1 });
-      }
-      for (const l of distilled) {
-        const k = normKey(l);
-        if (!k) continue;
-        const e = byKey.get(k);
-        if (e) e.count += 1;
-        else byKey.set(k, { text: l, count: 1 });
-      }
-      const ranked = [...byKey.values()].sort((a, b) => b.count - a.count || a.text.localeCompare(b.text)).slice(0, maxEntries);
-      if (ranked.length === 0) return [];
-      const block = [BLOCK_START2, heading, ...ranked.map((e) => `- ${e.text}`), BLOCK_END2].join(
-        "\n"
-      );
-      const next = `${stripBlock(parent, BLOCK_START2, BLOCK_END2)}
-
-${block}
-`;
-      if (next === parent) return [];
-      return [
-        {
-          surface: next,
-          label: "memory-curation",
-          rationale: `curated ${ranked.length} lessons (from ${fresh.length} new finding(s) + ${carried.length} carried)`
-        }
-      ];
-    }
-  };
-}
-
-// src/campaign/proposers/policy-edit.ts
-function policyEditProposer(opts = {}) {
-  return {
-    kind: "policy-edit",
-    async propose(ctx) {
-      const edits = materializePolicyEdits(opts.edits ?? ctx.findings, opts.findingOptions);
-      const limit = Math.max(
-        0,
-        Math.min(opts.maxCandidates ?? ctx.populationSize, ctx.populationSize)
-      );
-      const out = [];
-      if (limit === 0) return out;
-      for (const edit of edits) {
-        const admission = admitPolicyEdit(edit, opts.admission);
-        opts.onAdmission?.(admission);
-        if (admission.decision !== "admit") continue;
-        const surface = coerceCandidateSurface(applyPolicyEditToSurface(ctx.currentSurface, edit));
-        if (sameSurface(ctx.currentSurface, surface)) continue;
-        out.push({
-          surface,
-          label: `policy-edit:${edit.axis}`,
-          rationale: `${edit.editId} expected ${edit.expectedGain.direction} ${edit.expectedGain.metric} by ${edit.expectedGain.amount}; source findings [${edit.source.findingIds.join(", ")}]`
-        });
-        if (out.length >= limit) break;
-      }
-      return out;
-    }
-  };
-}
-function materializePolicyEdits(inputs, findingOptions) {
-  const edits = [];
-  const findings = [];
-  for (const input of inputs) {
-    if (isPolicyEdit(input)) {
-      edits.push(input);
-    } else if (isAnalystFindingLike(input)) {
-      findings.push(input);
-    }
-  }
-  if (findings.length > 0) edits.push(...policyEditsFromFindings(findings, findingOptions));
-  return edits;
-}
-function isAnalystFindingLike(input) {
-  if (!input || typeof input !== "object") return false;
-  const obj = input;
-  return typeof obj.finding_id === "string" && typeof obj.analyst_id === "string" && typeof obj.claim === "string" && Array.isArray(obj.evidence_refs);
-}
-function coerceCandidateSurface(surface) {
-  if (typeof surface === "string") return surface;
-  if (surface && typeof surface === "object") {
-    const obj = surface;
-    if (obj.kind === "code" && typeof obj.worktreeRef === "string") {
-      return surface;
-    }
-    return JSON.stringify(surface, null, 2);
-  }
-  throw new Error("policyEditProposer: policy edit produced an unsupported surface");
-}
-function sameSurface(a, b) {
-  return JSON.stringify(a) === JSON.stringify(b);
-}
-
-// src/campaign/proposers/trace-analyst.ts
-import { ai } from "@ax-llm/ax";
-function renderFindings(findings) {
-  return findings.map((f, i) => {
-    const action = f.recommended_action ? `
-   FIX: ${f.recommended_action}` : "";
-    const subject = f.subject ? ` (${f.subject})` : "";
-    return `${i + 1}. [${f.severity}/${f.area}]${subject} ${f.claim}${action}`;
-  }).join("\n");
-}
-function traceAnalystProposer(opts) {
-  if (!opts.apiKey) throw new Error("traceAnalystProposer: apiKey is required");
-  if (!opts.model) throw new Error("traceAnalystProposer: model is required");
-  const kinds = opts.kinds ?? DEFAULT_TRACE_ANALYST_KINDS;
-  const produceFindings = opts.analyze ?? (async (path, c) => {
-    const aiService = ai({
-      name: opts.provider ?? "openai",
-      apiKey: opts.apiKey,
-      apiURL: opts.baseUrl,
-      config: { model: opts.model }
-    });
-    const registry = new AnalystRegistry();
-    for (const spec of kinds) {
-      registry.register(createTraceAnalystKind(spec, { ai: aiService, model: opts.model }));
-    }
-    const result = await registry.run(
-      `trace-analyst-gen-${c.generation}`,
-      { traceStore: new OtlpFileTraceStore({ path }) },
-      { signal: c.signal }
-    );
-    return result.findings;
-  });
-  return analysisEditProposer({
-    kind: "trace-analyst",
-    label: "trace-analyst",
-    baseUrl: opts.baseUrl,
-    apiKey: opts.apiKey,
-    applyModel: opts.applyModel ?? opts.model,
-    fetchImpl: opts.fetchImpl,
-    resolveTraces: opts.resolveTraces,
-    noTracesError: "traceAnalystProposer: resolveTraces returned no OTLP traces \u2014 the analyst has nothing to read",
-    rationale: (report) => `trace-analyst findings:
-${report.slice(0, 800)}`,
-    analyze: async (tracePath, ctx) => {
-      let findings;
-      try {
-        findings = await produceFindings(tracePath, ctx);
-      } catch (e) {
-        throw new Error(
-          `traceAnalystProposer: analyst engine failed \u2014 ${e instanceof Error ? e.message : String(e)}`
-        );
-      }
-      if (findings.length === 0) {
-        throw new Error("traceAnalystProposer: analyst engine produced no findings");
-      }
-      return renderFindings(findings);
-    }
-  });
-}
-
-// src/campaign/scenario-selection.ts
-var DEFAULT_SATURATION_CEILING = 0.999;
-var VARIANCE_EPSILON = 1e-9;
-function moments(scores) {
-  const n = scores.length;
-  if (n === 0) return { meanScore: 0, variance: 0 };
-  let sum = 0;
-  for (const s of scores) sum += s;
-  const meanScore = sum / n;
-  let sqDev = 0;
-  for (const s of scores) {
-    const d = s - meanScore;
-    sqDev += d * d;
-  }
-  return { meanScore, variance: sqDev / n };
-}
-function compareDiscrimination(a, b) {
-  if (b.discrimination !== a.discrimination) return b.discrimination - a.discrimination;
-  if (a.meanScore !== b.meanScore) return a.meanScore - b.meanScore;
-  return a.scenarioId < b.scenarioId ? -1 : a.scenarioId > b.scenarioId ? 1 : 0;
-}
-function scoreDiscrimination(signals, opts) {
-  const saturationCeiling = opts?.saturationCeiling ?? DEFAULT_SATURATION_CEILING;
-  const scored = signals.map((signal) => {
-    const { meanScore, variance } = moments(signal.scores);
-    const tied = variance < VARIANCE_EPSILON && meanScore >= saturationCeiling;
-    return {
-      scenarioId: signal.scenarioId,
-      discrimination: variance,
-      meanScore,
-      variance,
-      tied
-    };
-  });
-  return scored.sort(compareDiscrimination);
-}
-function selectDiscriminative(signals, k, opts) {
-  if (k < 1) throw new Error(`selectDiscriminative: k must be >= 1 (got ${k})`);
-  const ranked = scoreDiscrimination(signals, opts);
-  if (ranked.length <= k) return ranked.map((s) => s.scenarioId);
-  const nonTied = ranked.filter((s) => !s.tied);
-  if (nonTied.length >= k) return nonTied.slice(0, k).map((s) => s.scenarioId);
-  const tied = ranked.filter((s) => s.tied);
-  const fill = tied.slice(0, k - nonTied.length);
-  return [...nonTied, ...fill].map((s) => s.scenarioId);
-}
-
-// src/campaign/worktree/index.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync3 } from "fs";
-import { basename, isAbsolute as isAbsolute2, join as join5 } from "path";
-var WorktreeAdapterError = class extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.name = "WorktreeAdapterError";
-  }
-  cause;
-};
-function defaultGit(args, cwd) {
-  try {
-    return execFileSync("git", args, { cwd, encoding: "utf8" }).trim();
-  } catch (err) {
-    const stderr = err && typeof err === "object" && "stderr" in err ? String(err.stderr) : "";
-    throw new WorktreeAdapterError(`git ${args.join(" ")} failed: ${stderr || String(err)}`, err);
-  }
-}
-function slug2(label) {
-  return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "candidate";
-}
-function gitWorktreeAdapter(opts) {
-  const git = opts.git ?? defaultGit;
-  const worktreeDir = opts.worktreeDir ?? join5(opts.repoRoot, ".worktrees");
-  const branchPrefix = opts.branchPrefix ?? "improve";
-  return {
-    async create({ baseRef, label }) {
-      const id = `${slug2(label)}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
-      const branch = `${branchPrefix}/${id}`;
-      const path = join5(worktreeDir, id);
-      git(["worktree", "add", "-b", branch, path, baseRef], opts.repoRoot);
-      return { path, branch, baseRef };
-    },
-    async finalize(worktree, summary) {
-      const status = git(["status", "--porcelain"], worktree.path);
-      if (status.length > 0) {
-        git(["add", "-A"], worktree.path);
-        git(["commit", "-m", summary], worktree.path);
-      }
-      return {
-        kind: "code",
-        worktreeRef: worktree.path,
-        baseRef: worktree.baseRef,
-        summary
-      };
-    },
-    async discard(worktree) {
-      git(["worktree", "remove", "--force", worktree.path], opts.repoRoot);
-      git(["branch", "-D", worktree.branch], opts.repoRoot);
-    }
-  };
-}
-function resolveWorktreePath(surface, worktreeDir) {
-  if (isAbsolute2(surface.worktreeRef) && existsSync3(surface.worktreeRef)) return surface.worktreeRef;
-  if (worktreeDir) return join5(worktreeDir, basename(surface.worktreeRef));
-  return surface.worktreeRef;
-}
 export {
   FsLabeledScenarioStore,
   LabeledScenarioStoreError,