@tangle-network/agent-eval 0.125.0 → 0.126.1

package/dist/chunk-NGUYT5CI.js

@@ -0,0 +1,4637 @@
+import {
+  JudgeParseError,
+  assertCodeSurfaceIdentity,
+  costReceiptFromTCloud,
+  labelTrustRank,
+  maximumChargeForTCloudRequest,
+  pairHoldout,
+  recoverTruncatedJson,
+  surfaceContentHash
+} from "./chunk-VMUENW6F.js";
+import {
+  SearchLedgerConflictError,
+  SearchLedgerError,
+  SearchLedgerIntegrityError,
+  appendSearchLedgerLine,
+  assertRealBackend,
+  contentHash,
+  planCampaignRun,
+  runCampaign,
+  summarizeBackendIntegrity,
+  withSearchLedgerFileLock
+} from "./chunk-UCLVDLCH.js";
+import {
+  Mutex
+} from "./chunk-WGXIEX7P.js";
+import {
+  eProcess,
+  mcnemar,
+  mulberry32,
+  pairedBootstrap,
+  pairedRiskDifference,
+  wilcoxonSignedRank
+} from "./chunk-PJQFMIOX.js";
+import {
+  CostLedger
+} from "./chunk-WS3NZZQQ.js";
+import {
+  analyzeTraces
+} from "./chunk-NUKSVU3W.js";
+import {
+  buildAgentProfileCell,
+  modelHasSnapshot,
+  validateRunRecord
+} from "./chunk-IILEIWGW.js";
+import {
+  canonicalize
+} from "./chunk-VSMTAMNK.js";
+import {
+  AgentEvalError,
+  ValidationError
+} from "./chunk-ONWEPEDO.js";
+
+// 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. 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/paired-arms.ts
+function pairArms(rows, opts) {
+  const { baselineArm, treatmentArm } = opts;
+  if (baselineArm === treatmentArm) {
+    throw new ValidationError(
+      `pairArms: baselineArm and treatmentArm are both '${baselineArm}' \u2014 an arm cannot be compared to itself`
+    );
+  }
+  const byArm = /* @__PURE__ */ new Map();
+  const armsSeen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    armsSeen.add(row.arm);
+    if (row.arm !== baselineArm && row.arm !== treatmentArm) continue;
+    const byKey = byArm.get(row.arm) ?? /* @__PURE__ */ new Map();
+    const group = byKey.get(row.pairKey) ?? [];
+    group.push(row);
+    byKey.set(row.pairKey, group);
+    byArm.set(row.arm, byKey);
+  }
+  for (const arm of [baselineArm, treatmentArm]) {
+    if (!byArm.has(arm)) {
+      const seen = [...armsSeen].sort().join(", ") || "<none>";
+      throw new ValidationError(`pairArms: no rows for arm '${arm}' (arms present: ${seen})`);
+    }
+  }
+  const baselineByKey = byArm.get(baselineArm);
+  const treatmentByKey = byArm.get(treatmentArm);
+  const allKeys = [.../* @__PURE__ */ new Set([...baselineByKey.keys(), ...treatmentByKey.keys()])].sort();
+  const pairs = [];
+  const unpairedBaseline = [];
+  const unpairedTreatment = [];
+  for (const pairKey of allKeys) {
+    const b = baselineByKey.get(pairKey) ?? [];
+    const t = treatmentByKey.get(pairKey) ?? [];
+    if (b.length <= 1 && t.length <= 1) {
+      if (b.length === 1 && t.length === 1) {
+        pairs.push({ pairKey, repIndex: 0, baseline: b[0], treatment: t[0] });
+      } else {
+        unpairedBaseline.push(...b);
+        unpairedTreatment.push(...t);
+      }
+      continue;
+    }
+    const bByRep = indexByRepKey(b, pairKey, baselineArm);
+    const tByRep = indexByRepKey(t, pairKey, treatmentArm);
+    const repKeys = [.../* @__PURE__ */ new Set([...bByRep.keys(), ...tByRep.keys()])].sort();
+    let repIndex = 0;
+    for (const repKey of repKeys) {
+      const baseline = bByRep.get(repKey);
+      const treatment = tByRep.get(repKey);
+      if (baseline !== void 0 && treatment !== void 0) {
+        pairs.push({ pairKey, repIndex: repIndex++, baseline, treatment });
+      } else if (baseline !== void 0) {
+        unpairedBaseline.push(baseline);
+      } else if (treatment !== void 0) {
+        unpairedTreatment.push(treatment);
+      }
+    }
+  }
+  return { pairs, unpairedBaseline, unpairedTreatment };
+}
+function indexByRepKey(group, pairKey, arm) {
+  const byRep = /* @__PURE__ */ new Map();
+  for (const row of group) {
+    if (row.repKey === void 0) {
+      throw new ValidationError(
+        `pairArms: pairKey '${pairKey}' has multiple reps in an arm, but a row in arm '${arm}' is missing repKey \u2014 multi-rep items require an explicit repKey on every row so reps pair by identity (pairing reps by outcome or by index would bias the paired statistics)`
+      );
+    }
+    if (byRep.has(row.repKey)) {
+      throw new ValidationError(
+        `pairArms: duplicate repKey '${row.repKey}' for pairKey '${pairKey}' in arm '${arm}' \u2014 (pairKey, repKey) must uniquely identify a rep within an arm`
+      );
+    }
+    byRep.set(row.repKey, row);
+  }
+  return byRep;
+}
+function comparePairedArms(rows, opts) {
+  const { pairs, unpairedBaseline, unpairedTreatment } = pairArms(rows, opts);
+  let correctness = null;
+  const baselinePass = [];
+  const treatmentPass = [];
+  for (const pair of pairs) {
+    if (pair.baseline.pass === void 0 || pair.treatment.pass === void 0) continue;
+    baselinePass.push(pair.baseline.pass ? 1 : 0);
+    treatmentPass.push(pair.treatment.pass ? 1 : 0);
+  }
+  if (baselinePass.length > 0) {
+    const mc = mcnemar(baselinePass, treatmentPass);
+    correctness = {
+      b10: mc.b,
+      b01: mc.c,
+      mcnemar: mc,
+      riskDifference: pairedRiskDifference(baselinePass, treatmentPass)
+    };
+  }
+  const metricNames = opts.metricNames ?? [
+    ...new Set(
+      pairs.flatMap((p) => [
+        ...Object.keys(p.baseline.metrics ?? {}),
+        ...Object.keys(p.treatment.metrics ?? {})
+      ])
+    )
+  ].sort();
+  const metricDeltas = metricNames.map((name) => {
+    const before = [];
+    const after = [];
+    let nMissing = 0;
+    for (const pair of pairs) {
+      const b = metricValue(pair.baseline, name);
+      const t = metricValue(pair.treatment, name);
+      if (b === void 0 || t === void 0) {
+        nMissing++;
+        continue;
+      }
+      before.push(b);
+      after.push(t);
+    }
+    const bootstrapCi = before.length === 0 ? null : pairedBootstrap(before, after, opts.bootstrap);
+    return {
+      name,
+      n: before.length,
+      nMissing,
+      medianDelta: bootstrapCi === null ? Number.NaN : bootstrapCi.median,
+      meanDelta: bootstrapCi === null ? Number.NaN : bootstrapCi.mean,
+      bootstrapCi,
+      wilcoxon: before.length === 0 ? null : wilcoxonSignedRank(before, after)
+    };
+  });
+  return {
+    nPairs: pairs.length,
+    nUnpairedBaseline: unpairedBaseline.length,
+    nUnpairedTreatment: unpairedTreatment.length,
+    correctness,
+    metricDeltas
+  };
+}
+function metricValue(row, name) {
+  const v = row.metrics?.[name];
+  if (v === void 0) return void 0;
+  if (!Number.isFinite(v)) {
+    throw new ValidationError(
+      `comparePairedArms: non-finite value for metric '${name}' on pairKey '${row.pairKey}' (arm '${row.arm}'): ${v}`
+    );
+  }
+  return v;
+}
+
+// src/campaign/cross-surface-context.ts
+function validateCrossSurfaceInput(input) {
+  assertNonEmptyUnique(input.taskOrder, "taskOrder");
+  assertNonEmptyUnique(input.componentOrder, "componentOrder");
+  if (input.componentOrder.length < 2) {
+    throw new ValidationError(
+      "analyzeCrossSurfaceInteractions: componentOrder must contain at least two surfaces"
+    );
+  }
+  assertNonEmptyUnique(input.candidateOrder, "candidateOrder");
+  assertNonEmptyUnique(input.costMetricOrder, "costMetricOrder");
+  if (input.costMetricOrder.includes("score")) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: costMetricOrder cannot contain reserved metric 'score'`
+    );
+  }
+  validateBootstrap(input);
+  validateSelection(input);
+  const componentById = indexUnique(
+    input.components,
+    (component) => component.componentId,
+    "component"
+  );
+  assertExactSet(input.componentOrder, componentById.keys(), "componentOrder", "components");
+  const surfaces = /* @__PURE__ */ new Set();
+  for (const component of componentById.values()) {
+    assertNonEmpty(component.componentId, "componentId");
+    assertNonEmpty(component.surfaceId, `surfaceId for component '${component.componentId}'`);
+    if (surfaces.has(component.surfaceId)) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: surfaceId '${component.surfaceId}' has more than one component; the interaction stage requires one independently selected finalist per surface`
+      );
+    }
+    surfaces.add(component.surfaceId);
+    if (typeof component.bestSingleEligible !== "boolean") {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: component '${component.componentId}' must declare bestSingleEligible`
+      );
+    }
+  }
+  const componentIndex = new Map(input.componentOrder.map((id, index) => [id, index]));
+  const candidateById = indexUnique(
+    input.candidates,
+    (candidate) => candidate.candidateId,
+    "candidate"
+  );
+  assertExactSet(input.candidateOrder, candidateById.keys(), "candidateOrder", "candidates");
+  if (!candidateById.has(input.baselineCandidateId)) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: unknown baselineCandidateId '${input.baselineCandidateId}'`
+    );
+  }
+  const candidateByComponents = /* @__PURE__ */ new Map();
+  const singleByComponent = /* @__PURE__ */ new Map();
+  for (const candidate of candidateById.values()) {
+    validateCandidate(candidate, componentById, componentIndex, input.baselineCandidateId);
+    const key = crossSurfaceComponentSetKey(candidate.componentIds);
+    const duplicate = candidateByComponents.get(key);
+    if (duplicate) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: candidates '${duplicate.candidateId}' and '${candidate.candidateId}' materialize the same component set`
+      );
+    }
+    candidateByComponents.set(key, candidate);
+    if (candidate.componentIds.length === 1) {
+      singleByComponent.set(candidate.componentIds[0], candidate);
+    }
+  }
+  const baseline = candidateById.get(input.baselineCandidateId);
+  if (baseline.componentIds.length !== 0) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: baseline '${baseline.candidateId}' must have zero components`
+    );
+  }
+  for (const componentId of input.componentOrder) {
+    if (!singleByComponent.has(componentId)) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: no single-surface candidate for component '${componentId}'`
+      );
+    }
+  }
+  for (let left = 0; left < input.componentOrder.length; left++) {
+    for (let right = left + 1; right < input.componentOrder.length; right++) {
+      const ids = [input.componentOrder[left], input.componentOrder[right]];
+      if (!candidateByComponents.has(crossSurfaceComponentSetKey(ids))) {
+        throw new ValidationError(
+          `analyzeCrossSurfaceInteractions: missing pair candidate for components [${ids.join(", ")}]`
+        );
+      }
+    }
+  }
+  const rowsByCandidate = /* @__PURE__ */ new Map();
+  const taskIds = new Set(input.taskOrder);
+  for (const row of input.rows) {
+    const candidate = candidateById.get(row.candidateId);
+    if (!candidate) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: row for task '${row.taskId}' names unknown candidate '${row.candidateId}'`
+      );
+    }
+    if (!taskIds.has(row.taskId)) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: row for candidate '${row.candidateId}' names task '${row.taskId}' outside the declared taskOrder`
+      );
+    }
+    validateRow(input, row, candidate);
+    const byTask = rowsByCandidate.get(row.candidateId) ?? /* @__PURE__ */ new Map();
+    if (byTask.has(row.taskId)) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: duplicate row for candidate '${row.candidateId}' and task '${row.taskId}'`
+      );
+    }
+    byTask.set(row.taskId, row);
+    rowsByCandidate.set(row.candidateId, byTask);
+  }
+  for (const candidateId of input.candidateOrder) {
+    const byTask = rowsByCandidate.get(candidateId);
+    const missing = input.taskOrder.filter((taskId) => !byTask?.has(taskId));
+    if (missing.length > 0) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: candidate '${candidateId}' is missing declared task row(s) [${missing.join(", ")}]; encode failed attempts explicitly instead of changing the task axis`
+      );
+    }
+  }
+  const expectedRows = input.candidateOrder.length * input.taskOrder.length;
+  if (input.rows.length !== expectedRows) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: expected exactly ${expectedRows} candidate \xD7 task rows, got ${input.rows.length}`
+    );
+  }
+  return {
+    input,
+    components: input.componentOrder.map((id) => componentById.get(id)),
+    candidates: input.candidateOrder.map((id) => candidateById.get(id)),
+    componentById,
+    candidateById,
+    candidateByComponents,
+    singleByComponent,
+    rowsByCandidate,
+    componentIndex,
+    candidateIndex: new Map(input.candidateOrder.map((id, index) => [id, index]))
+  };
+}
+function crossSurfaceRowsFor(context, candidateId) {
+  return context.input.taskOrder.map((taskId) => crossSurfaceRowFor(context, candidateId, taskId));
+}
+function crossSurfaceRowFor(context, candidateId, taskId) {
+  return context.rowsByCandidate.get(candidateId).get(taskId);
+}
+function canonicalCrossSurfaceComponents(context, componentIds) {
+  return [...componentIds].sort(
+    (left, right) => context.componentIndex.get(left) - context.componentIndex.get(right)
+  );
+}
+function crossSurfaceComponentSetKey(componentIds) {
+  return JSON.stringify(componentIds);
+}
+function validateBootstrap(input) {
+  const { seed, resamples, confidence } = input.bootstrap;
+  if (!Number.isInteger(seed)) {
+    throw new ValidationError(`analyzeCrossSurfaceInteractions: bootstrap.seed must be an integer`);
+  }
+  if (!Number.isInteger(resamples) || resamples <= 0) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: bootstrap.resamples must be a positive integer`
+    );
+  }
+  if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: bootstrap.confidence must be in (0,1)`
+    );
+  }
+}
+function validateSelection(input) {
+  const policy = input.selection;
+  for (const [name, value] of [
+    ["minimumFiringTasks", policy.minimumFiringTasks],
+    ["minimumEffectTasks", policy.minimumEffectTasks]
+  ]) {
+    if (!Number.isInteger(value) || value < 0 || value > input.taskOrder.length) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: selection.${name} must be an integer in [0,${input.taskOrder.length}]`
+      );
+    }
+  }
+  if (!Number.isInteger(policy.minimumBundleComponents) || policy.minimumBundleComponents < 2 || policy.minimumBundleComponents > input.componentOrder.length) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: selection.minimumBundleComponents must be an integer in [2,${input.componentOrder.length}]`
+    );
+  }
+  for (const [metric, limit] of Object.entries(policy.maximumMedianCostRatioToBaseline)) {
+    if (!input.costMetricOrder.includes(metric)) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: cost limit names undeclared metric '${metric}'`
+      );
+    }
+    if (!Number.isFinite(limit) || limit <= 0) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: cost ratio limit for '${metric}' must be positive and finite`
+      );
+    }
+  }
+}
+function validateCandidate(candidate, componentById, componentIndex, baselineCandidateId) {
+  assertNonEmpty(candidate.candidateId, "candidateId");
+  assertNonEmpty(candidate.contentHash, `contentHash for candidate '${candidate.candidateId}'`);
+  if (!Number.isInteger(candidate.artifactBytes) || candidate.artifactBytes < 0) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: artifactBytes for candidate '${candidate.candidateId}' must be a non-negative integer`
+    );
+  }
+  assertUnique(candidate.componentIds, `componentIds for candidate '${candidate.candidateId}'`);
+  for (const componentId of candidate.componentIds) {
+    if (!componentById.has(componentId)) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: candidate '${candidate.candidateId}' names unknown component '${componentId}'`
+      );
+    }
+  }
+  const canonical = [...candidate.componentIds].sort(
+    (left, right) => componentIndex.get(left) - componentIndex.get(right)
+  );
+  if (!arraysEqual(candidate.componentIds, canonical)) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: candidate '${candidate.candidateId}' components must follow componentOrder`
+    );
+  }
+  if (candidate.candidateId !== baselineCandidateId && candidate.componentIds.length === 0) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: only baseline '${baselineCandidateId}' may have zero components`
+    );
+  }
+}
+function validateRow(input, row, candidate) {
+  if (!arraysEqual(row.componentIds, candidate.componentIds)) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: row '${row.candidateId}/${row.taskId}' componentIds do not match its candidate`
+    );
+  }
+  if (!["complete", "missing", "invalid"].includes(row.completeness)) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: row '${row.candidateId}/${row.taskId}' has unknown completeness '${String(row.completeness)}'`
+    );
+  }
+  if (row.completeness === "complete") {
+    if (typeof row.pass !== "boolean" || !Number.isFinite(row.score)) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: complete row '${row.candidateId}/${row.taskId}' requires boolean pass and finite score`
+      );
+    }
+    if (row.rejectReason !== null) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: complete row '${row.candidateId}/${row.taskId}' cannot carry rejectReason`
+      );
+    }
+  } else {
+    if (row.pass !== null || row.score !== null) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: ${row.completeness} row '${row.candidateId}/${row.taskId}' must use null pass and score`
+      );
+    }
+    if (typeof row.rejectReason !== "string" || row.rejectReason.trim() === "") {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: ${row.completeness} row '${row.candidateId}/${row.taskId}' requires rejectReason`
+      );
+    }
+  }
+  assertExactSet(
+    input.costMetricOrder,
+    Object.keys(row.cost),
+    `cost keys for row '${row.candidateId}/${row.taskId}'`,
+    "costMetricOrder"
+  );
+  for (const metric of input.costMetricOrder) {
+    const value = row.cost[metric];
+    if (value === null || value === void 0 || !Number.isFinite(value) || value < 0) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: unknown or invalid cost '${metric}' on row '${row.candidateId}/${row.taskId}'; every attempt must report a non-negative finite value`
+      );
+    }
+  }
+  const evidenceByComponent = indexUnique(
+    row.componentEvidence,
+    (evidence) => evidence.componentId,
+    `componentEvidence on row '${row.candidateId}/${row.taskId}'`
+  );
+  assertExactSet(
+    candidate.componentIds,
+    evidenceByComponent.keys(),
+    `componentEvidence on row '${row.candidateId}/${row.taskId}'`,
+    "candidate components"
+  );
+  for (const evidence of evidenceByComponent.values()) {
+    assertTriState(evidence.fired, "fired", row);
+    assertTriState(evidence.effectObserved, "effectObserved", row);
+    if (evidence.effectObserved === true && evidence.fired !== true) {
+      throw new ValidationError(
+        `analyzeCrossSurfaceInteractions: effectObserved=true requires fired=true for component '${evidence.componentId}' on row '${row.candidateId}/${row.taskId}'`
+      );
+    }
+  }
+}
+function assertTriState(value, field, row) {
+  if (value !== true && value !== false && value !== null) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: ${field} on row '${row.candidateId}/${row.taskId}' must be boolean or null`
+    );
+  }
+}
+function indexUnique(items, id, label) {
+  const result = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = id(item);
+    assertNonEmpty(key, `${label} id`);
+    if (result.has(key)) {
+      throw new ValidationError(`analyzeCrossSurfaceInteractions: duplicate ${label} id '${key}'`);
+    }
+    result.set(key, item);
+  }
+  return result;
+}
+function assertNonEmptyUnique(values, label) {
+  if (values.length === 0) {
+    throw new ValidationError(`analyzeCrossSurfaceInteractions: ${label} is empty`);
+  }
+  assertUnique(values, label);
+  for (const value of values) assertNonEmpty(value, label);
+}
+function assertUnique(values, label) {
+  if (new Set(values).size !== values.length) {
+    throw new ValidationError(`analyzeCrossSurfaceInteractions: ${label} contains duplicates`);
+  }
+}
+function assertNonEmpty(value, label) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: ${label} must be a non-empty string`
+    );
+  }
+}
+function assertExactSet(expected, actualIterable, actualLabel, expectedLabel) {
+  const actual = [...actualIterable];
+  const expectedSet = new Set(expected);
+  const actualSet = new Set(actual);
+  const missing = expected.filter((value) => !actualSet.has(value));
+  const extra = actual.filter((value) => !expectedSet.has(value));
+  if (missing.length > 0 || extra.length > 0 || actual.length !== expected.length) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: ${actualLabel} does not match ${expectedLabel}; missing=[${missing.join(", ")}], extra=[${extra.join(", ")}]`
+    );
+  }
+}
+function arraysEqual(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+// src/campaign/cross-surface-interaction.ts
+function analyzeCrossSurfaceInteractions(input) {
+  const context = validateCrossSurfaceInput(input);
+  const baseline = context.candidateById.get(input.baselineCandidateId);
+  const preliminary = context.candidates.map(
+    (candidate) => summarizeCandidate(context, candidate, baseline)
+  );
+  const baselineSummary = preliminary.find(
+    (summary) => summary.candidate.candidateId === input.baselineCandidateId
+  );
+  const summaries = preliminary.map(
+    (summary) => summary.candidate.candidateId === input.baselineCandidateId ? summary : {
+      ...summary,
+      eligibility: candidateEligibility(context, summary, baselineSummary)
+    }
+  );
+  const summaryById = new Map(summaries.map((summary) => [summary.candidate.candidateId, summary]));
+  const eligibleSingles = rankedEligibleSingles(context, summaryById);
+  const interactionReadySingles = rankedInteractionReadySingles(context, summaryById);
+  const pairwise = buildPairwise(context, summaryById, interactionReadySingles, baselineSummary);
+  const selections = selectCandidates(
+    context,
+    summaryById,
+    eligibleSingles,
+    interactionReadySingles,
+    pairwise
+  );
+  const rows = context.candidates.flatMap(
+    (candidate) => input.taskOrder.map(
+      (taskId) => context.rowsByCandidate.get(candidate.candidateId).get(taskId)
+    )
+  );
+  return {
+    taskIds: [...input.taskOrder],
+    componentIds: [...input.componentOrder],
+    candidateIds: [...input.candidateOrder],
+    costMetrics: [...input.costMetricOrder],
+    rows,
+    missingAttempts: rows.filter((row) => row.completeness === "missing"),
+    invalidAttempts: rows.filter((row) => row.completeness === "invalid"),
+    candidates: summaries,
+    pairwise,
+    selections
+  };
+}
+function summarizeCandidate(context, candidate, baseline) {
+  const rows = crossSurfaceRowsFor(context, candidate.candidateId);
+  const baselineRows = crossSurfaceRowsFor(context, baseline.candidateId);
+  const outcome = summarizeOutcome(
+    context,
+    rows,
+    baselineRows,
+    candidate.candidateId === baseline.candidateId
+  );
+  const completeScores = rows.filter((row) => row.completeness === "complete").map((row) => row.score);
+  const costs = Object.fromEntries(
+    context.input.costMetricOrder.map((metric) => [
+      metric,
+      distribution(rows.map((row) => row.cost[metric]))
+    ])
+  );
+  return {
+    candidate,
+    outcome,
+    score: completeScores.length === 0 ? null : distribution(completeScores),
+    costs,
+    firing: summarizeCandidateEvidence(rows, candidate.componentIds, "fired"),
+    effect: summarizeCandidateEvidence(rows, candidate.componentIds, "effectObserved"),
+    comparisonToBaseline: candidate.candidateId === baseline.candidateId ? null : pairedComparison(context, baseline.candidateId, candidate.candidateId),
+    eligibility: null
+  };
+}
+function summarizeOutcome(context, rows, baselineRows, isBaseline) {
+  const resolvedTaskIds = [];
+  const failedTaskIds = [];
+  const missingTaskIds = [];
+  const invalidTaskIds = [];
+  const benefitTaskIds = [];
+  const regressionTaskIds = [];
+  const comparisonMissingTaskIds = [];
+  for (let index = 0; index < context.input.taskOrder.length; index++) {
+    const row = rows[index];
+    const baseline = baselineRows[index];
+    if (row.completeness === "missing") missingTaskIds.push(row.taskId);
+    else if (row.completeness === "invalid") invalidTaskIds.push(row.taskId);
+    else if (row.pass) resolvedTaskIds.push(row.taskId);
+    else failedTaskIds.push(row.taskId);
+    if (isBaseline) continue;
+    if (row.completeness !== "complete" || baseline.completeness !== "complete") {
+      comparisonMissingTaskIds.push(row.taskId);
+    } else if (row.pass && !baseline.pass) benefitTaskIds.push(row.taskId);
+    else if (!row.pass && baseline.pass) regressionTaskIds.push(row.taskId);
+  }
+  return {
+    resolvedTaskIds,
+    failedTaskIds,
+    missingTaskIds,
+    invalidTaskIds,
+    benefitTaskIds,
+    regressionTaskIds,
+    comparisonMissingTaskIds,
+    netBenefit: benefitTaskIds.length - regressionTaskIds.length
+  };
+}
+function summarizeCandidateEvidence(rows, componentIds, field) {
+  if (componentIds.length === 0) {
+    return {
+      byComponent: [],
+      allObservedTaskIds: [],
+      someObservedTaskIds: [],
+      noneObservedTaskIds: [],
+      unobservedTaskIds: []
+    };
+  }
+  const byComponent = componentIds.map((componentId) => {
+    const observedTaskIds = [];
+    const notObservedTaskIds = [];
+    const unobservedTaskIds2 = [];
+    for (const row of rows) {
+      const value = evidenceValue(row, componentId, field);
+      if (value === true) observedTaskIds.push(row.taskId);
+      else if (value === false) notObservedTaskIds.push(row.taskId);
+      else unobservedTaskIds2.push(row.taskId);
+    }
+    return { componentId, observedTaskIds, notObservedTaskIds, unobservedTaskIds: unobservedTaskIds2 };
+  });
+  const allObservedTaskIds = [];
+  const someObservedTaskIds = [];
+  const noneObservedTaskIds = [];
+  const unobservedTaskIds = [];
+  for (const row of rows) {
+    const values = componentIds.map((componentId) => evidenceValue(row, componentId, field));
+    if (values.some((value) => value === null)) unobservedTaskIds.push(row.taskId);
+    else if (values.every(Boolean)) allObservedTaskIds.push(row.taskId);
+    else if (values.some(Boolean)) someObservedTaskIds.push(row.taskId);
+    else noneObservedTaskIds.push(row.taskId);
+  }
+  return {
+    byComponent,
+    allObservedTaskIds,
+    someObservedTaskIds,
+    noneObservedTaskIds,
+    unobservedTaskIds
+  };
+}
+function candidateEligibility(context, summary, baseline) {
+  const reasons = [];
+  if (summary.outcome.missingTaskIds.length > 0) reasons.push("missing_attempt");
+  if (summary.outcome.invalidTaskIds.length > 0) reasons.push("invalid_attempt");
+  if (summary.outcome.comparisonMissingTaskIds.length > 0) reasons.push("baseline_outcome_missing");
+  if (summary.outcome.benefitTaskIds.length <= summary.outcome.regressionTaskIds.length) {
+    reasons.push("benefit_not_greater_than_regression");
+  }
+  appendEvidenceEligibilityReasons(
+    reasons,
+    summary.firing,
+    context.input.selection.minimumFiringTasks,
+    context.input.selection.requireObservedFiring,
+    "firing_below_minimum",
+    "firing_unobserved"
+  );
+  appendEvidenceEligibilityReasons(
+    reasons,
+    summary.effect,
+    context.input.selection.minimumEffectTasks,
+    context.input.selection.requireObservedEffect,
+    "effect_below_minimum",
+    "effect_unobserved"
+  );
+  if (!withinCostLimits(context, summary, baseline)) reasons.push("cost_limit_exceeded");
+  return { eligible: reasons.length === 0, reasons: unique(reasons) };
+}
+function appendEvidenceEligibilityReasons(reasons, evidence, minimum, requireObserved, belowReason, unobservedReason) {
+  if (evidence.byComponent.some((component) => component.observedTaskIds.length < minimum)) {
+    reasons.push(belowReason);
+  }
+  if (requireObserved && evidence.byComponent.some((component) => component.unobservedTaskIds.length > 0)) {
+    reasons.push(unobservedReason);
+  }
+}
+function rankedEligibleSingles(context, summaryById) {
+  return [...context.singleByComponent.values()].map((candidate) => summaryById.get(candidate.candidateId)).filter((summary) => summary.eligibility?.eligible).sort((left, right) => compareSingleSummaries(context, left, right));
+}
+function rankedInteractionReadySingles(context, summaryById) {
+  return [...context.singleByComponent.values()].map((candidate) => summaryById.get(candidate.candidateId)).filter(
+    (summary) => summary.outcome.regressionTaskIds.length === 0 && summary.eligibility?.reasons.every(
+      (reason) => reason === "benefit_not_greater_than_regression"
+    )
+  ).sort((left, right) => compareSingleSummaries(context, left, right));
+}
+function compareSingleSummaries(context, left, right) {
+  const byNetBenefit = right.outcome.netBenefit - left.outcome.netBenefit;
+  if (byNetBenefit !== 0) return byNetBenefit;
+  const byBenefit = right.outcome.benefitTaskIds.length - left.outcome.benefitTaskIds.length;
+  if (byBenefit !== 0) return byBenefit;
+  const byRegression = left.outcome.regressionTaskIds.length - right.outcome.regressionTaskIds.length;
+  if (byRegression !== 0) return byRegression;
+  for (const metric of context.input.costMetricOrder) {
+    const byCost = left.costs[metric].median - right.costs[metric].median;
+    if (byCost !== 0) return byCost;
+  }
+  const byBytes = left.candidate.artifactBytes - right.candidate.artifactBytes;
+  if (byBytes !== 0) return byBytes;
+  return context.candidateIndex.get(left.candidate.candidateId) - context.candidateIndex.get(right.candidate.candidateId);
+}
+function buildPairwise(context, summaryById, interactionReadySingles, baseline) {
+  const interactionReadyIds = new Set(
+    interactionReadySingles.map((summary) => summary.candidate.candidateId)
+  );
+  const entries = [];
+  for (let leftIndex = 0; leftIndex < context.components.length; leftIndex++) {
+    for (let rightIndex = leftIndex + 1; rightIndex < context.components.length; rightIndex++) {
+      const leftComponent = context.components[leftIndex];
+      const rightComponent = context.components[rightIndex];
+      const leftSingle = context.singleByComponent.get(leftComponent.componentId);
+      const rightSingle = context.singleByComponent.get(rightComponent.componentId);
+      const pair = context.candidateByComponents.get(
+        crossSurfaceComponentSetKey([leftComponent.componentId, rightComponent.componentId])
+      );
+      const pairSummary = summaryById.get(pair.candidateId);
+      const leftSummary = summaryById.get(leftSingle.candidateId);
+      const rightSummary = summaryById.get(rightSingle.candidateId);
+      const synergyTaskIds = [];
+      const interferenceTaskIds = [];
+      for (const taskId of context.input.taskOrder) {
+        const pairRow = crossSurfaceRowFor(context, pair.candidateId, taskId);
+        const leftRow = crossSurfaceRowFor(context, leftSingle.candidateId, taskId);
+        const rightRow = crossSurfaceRowFor(context, rightSingle.candidateId, taskId);
+        if (![pairRow, leftRow, rightRow].every((row) => row.completeness === "complete")) continue;
+        if (pairRow.pass && !leftRow.pass && !rightRow.pass) synergyTaskIds.push(taskId);
+        if (!pairRow.pass && (leftRow.pass || rightRow.pass)) interferenceTaskIds.push(taskId);
+      }
+      const incrementalVsConstituents = [
+        compareCandidates(context, summaryById, leftSingle.candidateId, pair.candidateId),
+        compareCandidates(context, summaryById, rightSingle.candidateId, pair.candidateId)
+      ];
+      const betterSingle = compareSingleSummaries(context, leftSummary, rightSummary) <= 0 ? leftSummary : rightSummary;
+      const firing = summarizePairEvidence(
+        crossSurfaceRowsFor(context, pair.candidateId),
+        leftComponent.componentId,
+        rightComponent.componentId,
+        "fired"
+      );
+      const effect = summarizePairEvidence(
+        crossSurfaceRowsFor(context, pair.candidateId),
+        leftComponent.componentId,
+        rightComponent.componentId,
+        "effectObserved"
+      );
+      const compatibility = pairCompatibility(
+        context,
+        pairSummary,
+        baseline,
+        betterSingle,
+        incrementalVsConstituents,
+        interactionReadyIds.has(leftSingle.candidateId) && interactionReadyIds.has(rightSingle.candidateId),
+        interferenceTaskIds,
+        firing,
+        effect
+      );
+      entries.push({
+        componentIds: [leftComponent.componentId, rightComponent.componentId],
+        singleCandidateIds: [leftSingle.candidateId, rightSingle.candidateId],
+        compositionCandidateId: pair.candidateId,
+        benefitTaskIds: [...pairSummary.outcome.benefitTaskIds],
+        regressionTaskIds: [...pairSummary.outcome.regressionTaskIds],
+        synergyTaskIds,
+        interferenceTaskIds,
+        incrementalVsConstituents,
+        relativeCostToBaseline: relativeCosts(context, pairSummary, baseline),
+        firing,
+        effect,
+        interaction: interactionEffect(
+          context,
+          baseline.candidate,
+          [leftSingle, rightSingle],
+          pair
+        ),
+        compatibility
+      });
+    }
+  }
+  return entries;
+}
+function pairCompatibility(context, pair, baseline, betterSingle, comparisons, constituentsReady, interferenceTaskIds, firing, effect) {
+  const reasons = [];
+  if (!constituentsReady) reasons.push("constituent_not_ready");
+  if (pair.outcome.missingTaskIds.length > 0 || pair.outcome.invalidTaskIds.length > 0 || pair.outcome.comparisonMissingTaskIds.length > 0) {
+    reasons.push("pair_incomplete");
+  }
+  if (pair.outcome.regressionTaskIds.length > 0) reasons.push("baseline_regression");
+  if (interferenceTaskIds.length > 0) reasons.push("interference");
+  const betterComparison = comparisons.find(
+    (comparison) => comparison.comparatorCandidateId === betterSingle.candidate.candidateId
+  );
+  if (betterComparison.winsTaskIds.length === 0) reasons.push("no_incremental_resolution");
+  appendPairEvidenceReasons(
+    reasons,
+    firing,
+    context.input.selection.minimumFiringTasks,
+    context.input.selection.requireObservedFiring,
+    "firing_below_minimum",
+    "firing_unobserved"
+  );
+  appendPairEvidenceReasons(
+    reasons,
+    effect,
+    context.input.selection.minimumEffectTasks,
+    context.input.selection.requireObservedEffect,
+    "effect_below_minimum",
+    "effect_unobserved"
+  );
+  if (!withinCostLimits(context, pair, baseline)) reasons.push("cost_limit_exceeded");
+  return {
+    compatible: reasons.length === 0,
+    reasons: unique(reasons),
+    betterSingleCandidateId: betterSingle.candidate.candidateId
+  };
+}
+function appendPairEvidenceReasons(reasons, evidence, minimum, requireObserved, belowReason, unobservedReason) {
+  const leftObserved = evidence.bothTaskIds.length + evidence.leftOnlyTaskIds.length;
+  const rightObserved = evidence.bothTaskIds.length + evidence.rightOnlyTaskIds.length;
+  if (leftObserved < minimum || rightObserved < minimum) reasons.push(belowReason);
+  if (requireObserved && evidence.unobservedTaskIds.length > 0) reasons.push(unobservedReason);
+}
+function interactionEffect(context, baseline, singles, composition) {
+  const perTask = context.input.taskOrder.map((taskId) => {
+    const baselineRow = crossSurfaceRowFor(context, baseline.candidateId, taskId);
+    const singleRows = singles.map((single) => crossSurfaceRowFor(context, single.candidateId, taskId));
+    const compositionRow = crossSurfaceRowFor(context, composition.candidateId, taskId);
+    const rows = [baselineRow, ...singleRows, compositionRow];
+    if (!rows.every((row) => row.completeness === "complete")) {
+      return { taskId, passInteraction: null, scoreInteraction: null };
+    }
+    const additivePass = singleRows.reduce((sum, row) => sum + Number(row.pass), 0) - (singles.length - 1) * Number(baselineRow.pass);
+    const additiveScore = singleRows.reduce((sum, row) => sum + row.score, 0) - (singles.length - 1) * baselineRow.score;
+    return {
+      taskId,
+      passInteraction: Number(compositionRow.pass) - additivePass,
+      scoreInteraction: compositionRow.score - additiveScore
+    };
+  });
+  const complete = perTask.filter(
+    (row) => row.passInteraction !== null && row.scoreInteraction !== null
+  );
+  const passInteractions = complete.map((row) => row.passInteraction);
+  const scoreInteractions = complete.map((row) => row.scoreInteraction);
+  return {
+    perTask,
+    n: complete.length,
+    nMissing: perTask.length - complete.length,
+    meanPassInteraction: meanOrNull(passInteractions),
+    meanScoreInteraction: meanOrNull(scoreInteractions),
+    passBootstrap: bootstrapInteraction(passInteractions, context),
+    scoreBootstrap: bootstrapInteraction(scoreInteractions, context)
+  };
+}
+function bootstrapInteraction(interactions, context) {
+  if (interactions.length === 0) return null;
+  return pairedBootstrap(new Array(interactions.length).fill(0), interactions, {
+    ...context.input.bootstrap,
+    statistic: "mean"
+  });
+}
+function selectCandidates(context, summaryById, eligibleSingles, interactionReadySingles, pairwise) {
+  const bestSingleRanking = eligibleSingles.filter((summary) => {
+    const componentId = summary.candidate.componentIds[0];
+    return context.componentById.get(componentId).bestSingleEligible;
+  });
+  const ranking = bestSingleRanking.map((summary, index) => ({
+    rank: index + 1,
+    candidateId: summary.candidate.candidateId,
+    componentId: summary.candidate.componentIds[0]
+  }));
+  const best = bestSingleRanking[0];
+  const bestSingle = best ? {
+    candidateId: best.candidate.candidateId,
+    componentId: best.candidate.componentIds[0],
+    ranking
+  } : null;
+  const naiveStack = selectNaiveStack(context, eligibleSingles);
+  const interactionAware = selectInteractionAware(
+    context,
+    summaryById,
+    interactionReadySingles,
+    pairwise
+  );
+  return { bestSingle, naiveStack, interactionAware };
+}
+function selectNaiveStack(context, eligibleSingles) {
+  if (eligibleSingles.length === 0) return null;
+  const componentIds = eligibleSingles.map((summary) => summary.candidate.componentIds[0]).sort((left, right) => context.componentIndex.get(left) - context.componentIndex.get(right));
+  const candidate = context.candidateByComponents.get(crossSurfaceComponentSetKey(componentIds));
+  if (!candidate) {
+    throw new ValidationError(
+      `analyzeCrossSurfaceInteractions: naive stack [${componentIds.join(", ")}] was not evaluated`
+    );
+  }
+  return { candidateId: candidate.candidateId, componentIds };
+}
+function selectInteractionAware(context, summaryById, interactionReadySingles, pairwise) {
+  const baseline = summaryById.get(context.input.baselineCandidateId);
+  const pairByComponents = new Map(
+    pairwise.map((entry) => [crossSurfaceComponentSetKey(entry.componentIds), entry])
+  );
+  const paths = pairwise.filter((entry) => entry.compatibility.compatible).map(
+    (entry) => growInteractionPath(
+      context,
+      summaryById,
+      interactionReadySingles,
+      pairByComponents,
+      baseline,
+      summaryById.get(entry.compositionCandidateId)
+    )
+  );
+  if (paths.length === 0) return null;
+  const qualified = paths.filter((path) => path.qualified).sort((left, right) => compareInteractionPaths(context, summaryById, left, right));
+  const winning = qualified[0] ?? [...paths].sort((left, right) => compareInteractionPaths(context, summaryById, left, right))[0];
+  return {
+    seedCandidateId: winning.seedCandidateId,
+    terminalCandidateId: winning.terminalCandidateId,
+    terminalComponentIds: [...winning.terminalComponentIds],
+    selectedCandidateId: qualified.length > 0 ? winning.terminalCandidateId : null,
+    qualified: qualified.length > 0,
+    evaluatedPaths: paths,
+    steps: winning.steps
+  };
+}
+function growInteractionPath(context, summaryById, interactionReadySingles, pairByComponents, baseline, seed) {
+  let current = seed;
+  let retained = [...seed.candidate.componentIds];
+  let remaining = interactionReadySingles.filter(
+    (summary) => !retained.includes(summary.candidate.componentIds[0])
+  );
+  const steps = [];
+  while (remaining.length > 0) {
+    const decisions = remaining.map(
+      (addition) => evaluateAddition(
+        context,
+        summaryById,
+        pairByComponents,
+        baseline,
+        current,
+        retained,
+        addition
+      )
+    );
+    const eligible = decisions.filter((decision) => decision.eligible).sort((left, right) => compareAdditionDecisions(context, summaryById, left, right));
+    const selected = eligible[0];
+    if (selected) selected.selected = true;
+    steps.push({
+      fromCandidateId: current.candidate.candidateId,
+      retainedComponentIds: [...retained],
+      considered: decisions.sort(
+        (left, right) => context.candidateIndex.get(left.additionCandidateId) - context.candidateIndex.get(right.additionCandidateId)
+      ),
+      selectedCandidateId: selected?.bundleCandidateId ?? null
+    });
+    if (!selected?.bundleCandidateId) break;
+    current = summaryById.get(selected.bundleCandidateId);
+    retained = [...current.candidate.componentIds];
+    remaining = remaining.filter(
+      (summary) => summary.candidate.candidateId !== selected.additionCandidateId
+    );
+  }
+  const qualified = retained.length >= context.input.selection.minimumBundleComponents;
+  return {
+    seedCandidateId: seed.candidate.candidateId,
+    terminalCandidateId: current.candidate.candidateId,
+    terminalComponentIds: retained,
+    qualified,
+    steps
+  };
+}
+function compareInteractionPaths(context, summaryById, left, right) {
+  const leftSummary = summaryById.get(left.terminalCandidateId);
+  const rightSummary = summaryById.get(right.terminalCandidateId);
+  const byNetBenefit = rightSummary.outcome.netBenefit - leftSummary.outcome.netBenefit;
+  if (byNetBenefit !== 0) return byNetBenefit;
+  const byBenefit = rightSummary.outcome.benefitTaskIds.length - leftSummary.outcome.benefitTaskIds.length;
+  if (byBenefit !== 0) return byBenefit;
+  const byRegression = leftSummary.outcome.regressionTaskIds.length - rightSummary.outcome.regressionTaskIds.length;
+  if (byRegression !== 0) return byRegression;
+  for (const metric of context.input.costMetricOrder) {
+    const byCost = leftSummary.costs[metric].median - rightSummary.costs[metric].median;
+    if (byCost !== 0) return byCost;
+  }
+  const byBytes = leftSummary.candidate.artifactBytes - rightSummary.candidate.artifactBytes;
+  if (byBytes !== 0) return byBytes;
+  const byCandidateOrder = context.candidateIndex.get(left.terminalCandidateId) - context.candidateIndex.get(right.terminalCandidateId);
+  if (byCandidateOrder !== 0) return byCandidateOrder;
+  return context.candidateIndex.get(left.seedCandidateId) - context.candidateIndex.get(right.seedCandidateId);
+}
+function evaluateAddition(context, summaryById, pairByComponents, baseline, current, retained, addition) {
+  const additionComponentId = addition.candidate.componentIds[0];
+  const reasons = [];
+  for (const retainedComponentId of retained) {
+    const pair = pairByComponents.get(
+      crossSurfaceComponentSetKey(canonicalCrossSurfaceComponents(context, [retainedComponentId, additionComponentId]))
+    );
+    if (!pair?.compatibility.compatible) reasons.push("pair_incompatible");
+  }
+  const bundleComponents = canonicalCrossSurfaceComponents(context, [...retained, additionComponentId]);
+  const bundle = context.candidateByComponents.get(crossSurfaceComponentSetKey(bundleComponents));
+  if (!bundle) {
+    reasons.push("full_bundle_not_evaluated");
+    return emptyAdditionDecision(addition, additionComponentId, reasons);
+  }
+  const bundleSummary = summaryById.get(bundle.candidateId);
+  if (bundleSummary.outcome.missingTaskIds.length > 0 || bundleSummary.outcome.invalidTaskIds.length > 0 || bundleSummary.outcome.comparisonMissingTaskIds.length > 0) {
+    reasons.push("bundle_incomplete");
+  }
+  if (bundleSummary.outcome.regressionTaskIds.length > 0) reasons.push("baseline_regression");
+  const comparison = compareCandidates(
+    context,
+    summaryById,
+    current.candidate.candidateId,
+    bundle.candidateId
+  );
+  if (comparison.winsTaskIds.length === 0) reasons.push("no_incremental_resolution");
+  if (comparison.regressionTaskIds.length > 0) reasons.push("incremental_regression");
+  appendBundleEvidenceReasons(
+    reasons,
+    bundleSummary.firing,
+    context.input.selection.minimumFiringTasks,
+    context.input.selection.requireObservedFiring,
+    "firing_below_minimum",
+    "firing_unobserved"
+  );
+  appendBundleEvidenceReasons(
+    reasons,
+    bundleSummary.effect,
+    context.input.selection.minimumEffectTasks,
+    context.input.selection.requireObservedEffect,
+    "effect_below_minimum",
+    "effect_unobserved"
+  );
+  if (!withinCostLimits(context, bundleSummary, baseline)) reasons.push("cost_limit_exceeded");
+  return {
+    additionCandidateId: addition.candidate.candidateId,
+    additionComponentId,
+    bundleCandidateId: bundle.candidateId,
+    incrementalResolutionTaskIds: comparison.winsTaskIds,
+    incrementalRegressionTaskIds: comparison.regressionTaskIds,
+    incrementalMedianCost: Object.fromEntries(
+      context.input.costMetricOrder.map((metric) => [
+        metric,
+        bundleSummary.costs[metric].median - current.costs[metric].median
+      ])
+    ),
+    eligible: reasons.length === 0,
+    selected: false,
+    reasons: unique(reasons)
+  };
+}
+function emptyAdditionDecision(addition, additionComponentId, reasons) {
+  return {
+    additionCandidateId: addition.candidate.candidateId,
+    additionComponentId,
+    bundleCandidateId: null,
+    incrementalResolutionTaskIds: [],
+    incrementalRegressionTaskIds: [],
+    incrementalMedianCost: null,
+    eligible: false,
+    selected: false,
+    reasons: unique(reasons)
+  };
+}
+function appendBundleEvidenceReasons(reasons, evidence, minimum, requireObserved, belowReason, unobservedReason) {
+  if (evidence.byComponent.some((component) => component.observedTaskIds.length < minimum)) {
+    reasons.push(belowReason);
+  }
+  if (requireObserved && evidence.byComponent.some((component) => component.unobservedTaskIds.length > 0)) {
+    reasons.push(unobservedReason);
+  }
+}
+function compareAdditionDecisions(context, summaryById, left, right) {
+  const byWins = right.incrementalResolutionTaskIds.length - left.incrementalResolutionTaskIds.length;
+  if (byWins !== 0) return byWins;
+  for (const metric of context.input.costMetricOrder) {
+    const byCost = left.incrementalMedianCost[metric] - right.incrementalMedianCost[metric];
+    if (byCost !== 0) return byCost;
+  }
+  const leftBytes = summaryById.get(left.additionCandidateId).candidate.artifactBytes;
+  const rightBytes = summaryById.get(right.additionCandidateId).candidate.artifactBytes;
+  const byBytes = leftBytes - rightBytes;
+  if (byBytes !== 0) return byBytes;
+  return context.candidateIndex.get(left.additionCandidateId) - context.candidateIndex.get(right.additionCandidateId);
+}
+function compareCandidates(context, summaryById, comparatorCandidateId, treatmentCandidateId) {
+  const winsTaskIds = [];
+  const regressionTaskIds = [];
+  const missingTaskIds = [];
+  for (const taskId of context.input.taskOrder) {
+    const comparator = crossSurfaceRowFor(context, comparatorCandidateId, taskId);
+    const treatment = crossSurfaceRowFor(context, treatmentCandidateId, taskId);
+    if (comparator.completeness !== "complete" || treatment.completeness !== "complete") {
+      missingTaskIds.push(taskId);
+    } else if (treatment.pass && !comparator.pass) winsTaskIds.push(taskId);
+    else if (!treatment.pass && comparator.pass) regressionTaskIds.push(taskId);
+  }
+  return {
+    comparatorCandidateId,
+    treatmentCandidateId,
+    winsTaskIds,
+    regressionTaskIds,
+    missingTaskIds,
+    paired: pairedComparison(context, comparatorCandidateId, treatmentCandidateId),
+    relativeCost: relativeCosts(
+      context,
+      summaryById.get(treatmentCandidateId),
+      summaryById.get(comparatorCandidateId)
+    )
+  };
+}
+function pairedComparison(context, comparatorCandidateId, treatmentCandidateId) {
+  const rows = [];
+  for (const taskId of context.input.taskOrder) {
+    rows.push(toPairedArmRow(context, crossSurfaceRowFor(context, comparatorCandidateId, taskId)));
+    rows.push(toPairedArmRow(context, crossSurfaceRowFor(context, treatmentCandidateId, taskId)));
+  }
+  return comparePairedArms(rows, {
+    baselineArm: comparatorCandidateId,
+    treatmentArm: treatmentCandidateId,
+    metricNames: ["score", ...context.input.costMetricOrder],
+    bootstrap: { ...context.input.bootstrap, statistic: "mean" }
+  });
+}
+function toPairedArmRow(context, row) {
+  const metrics = Object.fromEntries(
+    context.input.costMetricOrder.map((metric) => [metric, row.cost[metric]])
+  );
+  if (row.completeness === "complete") metrics.score = row.score;
+  return {
+    pairKey: row.taskId,
+    arm: row.candidateId,
+    ...row.completeness === "complete" ? { pass: row.pass } : {},
+    metrics
+  };
+}
+function summarizePairEvidence(rows, leftComponentId, rightComponentId, field) {
+  const bothTaskIds = [];
+  const leftOnlyTaskIds = [];
+  const rightOnlyTaskIds = [];
+  const neitherTaskIds = [];
+  const unobservedTaskIds = [];
+  for (const row of rows) {
+    const left = evidenceValue(row, leftComponentId, field);
+    const right = evidenceValue(row, rightComponentId, field);
+    if (left === null || right === null) unobservedTaskIds.push(row.taskId);
+    else if (left && right) bothTaskIds.push(row.taskId);
+    else if (left) leftOnlyTaskIds.push(row.taskId);
+    else if (right) rightOnlyTaskIds.push(row.taskId);
+    else neitherTaskIds.push(row.taskId);
+  }
+  return {
+    bothTaskIds,
+    leftOnlyTaskIds,
+    rightOnlyTaskIds,
+    neitherTaskIds,
+    unobservedTaskIds
+  };
+}
+function relativeCosts(context, treatment, comparator) {
+  return Object.fromEntries(
+    context.input.costMetricOrder.map((metric) => {
+      const treatmentMedian = treatment.costs[metric].median;
+      const comparatorMedian = comparator.costs[metric].median;
+      return [
+        metric,
+        {
+          treatmentMedian,
+          comparatorMedian,
+          medianDelta: treatmentMedian - comparatorMedian,
+          medianRatio: comparatorMedian === 0 ? treatmentMedian === 0 ? 1 : null : treatmentMedian / comparatorMedian
+        }
+      ];
+    })
+  );
+}
+function withinCostLimits(context, treatment, baseline) {
+  const relative3 = relativeCosts(context, treatment, baseline);
+  return Object.entries(context.input.selection.maximumMedianCostRatioToBaseline).every(
+    ([metric, limit]) => {
+      const ratio = relative3[metric].medianRatio;
+      return ratio !== null && ratio <= limit;
+    }
+  );
+}
+function distribution(values) {
+  const sorted = [...values].sort((left, right) => left - right);
+  const total = sorted.reduce((sum, value) => sum + value, 0);
+  const middle = Math.floor(sorted.length / 2);
+  const median = sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+  return {
+    n: sorted.length,
+    min: sorted[0],
+    median,
+    mean: total / sorted.length,
+    max: sorted[sorted.length - 1],
+    total
+  };
+}
+function evidenceValue(row, componentId, field) {
+  return row.componentEvidence.find((evidence) => evidence.componentId === componentId)[field];
+}
+function meanOrNull(values) {
+  return values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+
+// src/campaign/fixtures.ts
+import { createHash } 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: createHash("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 createHash2 } 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 = createHash2("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,
+        ...manifest ? { 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/grounded-reflection.ts
+function rolloutArgumentDiff(rollouts, opts = {}) {
+  const passThreshold = opts.passThreshold ?? 1;
+  const maxValues = opts.maxValuesPerField ?? 4;
+  const collect = (pass) => {
+    const byField = /* @__PURE__ */ new Map();
+    for (const r of rollouts) {
+      if (pass !== r.score >= passThreshold) continue;
+      for (const c of r.calls) {
+        for (const [k, v] of Object.entries(c.args)) {
+          const set = byField.get(k) ?? /* @__PURE__ */ new Set();
+          set.add(String(v));
+          byField.set(k, set);
+        }
+      }
+    }
+    return byField;
+  };
+  const passing = collect(true);
+  const failing = collect(false);
+  const lines = [];
+  for (const field of /* @__PURE__ */ new Set([...passing.keys(), ...failing.keys()])) {
+    const pv = [...passing.get(field) ?? []].slice(0, maxValues);
+    const fv = [...failing.get(field) ?? []].slice(0, maxValues);
+    const render = (vals) => vals.length ? JSON.stringify(vals) : "NOT SET (omitted)";
+    lines.push(`  ${field}: passing runs -> ${render(pv)} | failing runs -> ${render(fv)}`);
+  }
+  const lower = (m) => {
+    const out = /* @__PURE__ */ new Set();
+    for (const vals of m.values()) for (const v of vals) out.add(v.toLowerCase());
+    return out;
+  };
+  return {
+    text: lines.join("\n") || "  (no calls observed)",
+    passingValues: lower(passing),
+    failingValues: lower(failing)
+  };
+}
+function classifyUngroundedLiterals(text, diff) {
+  const ungrounded = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(/'([a-z][a-z_-]{1,19})'/gi)) {
+    const w = m[1].toLowerCase();
+    if (!diff.passingValues.has(w)) ungrounded.add(w);
+  }
+  const all = [...ungrounded];
+  return {
+    ungrounded: all,
+    harmful: all.filter((w) => diff.failingValues.has(w))
+  };
+}
+
+// src/campaign/labeled-store/fs-adapter.ts
+import { createHash as createHash3 } 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 createHash3("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/completion-verifier.ts
+import { randomUUID } from "crypto";
+function completionVerdict(input) {
+  if (input.requirements.length === 0) {
+    throw new Error(
+      `completionVerdict: task '${input.taskId}' has no requirement checks \u2014 nothing to derive a verdict from`
+    );
+  }
+  const measurable = input.requirements.filter((r) => !r.unmeasured);
+  const unmeasuredCount = input.requirements.length - measurable.length;
+  if (measurable.length === 0) {
+    throw new Error(
+      `completionVerdict: task '${input.taskId}' has no measurable requirements \u2014 all ${input.requirements.length} correctness checks failed (${input.requirements[0]?.unmeasuredReason ?? "unknown reason"})`
+    );
+  }
+  const satisfiedCount = measurable.filter((r) => r.satisfied).length;
+  const completionRate = satisfiedCount / measurable.length;
+  const fullyComplete = unmeasuredCount === 0 && satisfiedCount === measurable.length;
+  return {
+    taskId: input.taskId,
+    requirements: input.requirements,
+    completionRate,
+    fullyComplete,
+    unmeasuredCount,
+    valid: fullyComplete,
+    score: completionRate
+  };
+}
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "of",
+  "for",
+  "and",
+  "or",
+  "to",
+  "in",
+  "on",
+  "with",
+  "by"
+]);
+var REQUIREMENT_FORM_STOPWORDS = /* @__PURE__ */ new Set([
+  "generated",
+  "generate",
+  "view",
+  "render",
+  "rendered",
+  "persisted",
+  "persist",
+  "artifact",
+  "file",
+  "document",
+  "note",
+  "proposal",
+  "deliverable",
+  "output",
+  "created",
+  "create",
+  "produce",
+  "produced",
+  "flag"
+]);
+var MATCH_THRESHOLD = 0.5;
+var MIN_CONTENT_CHARS = 50;
+function tokens(s, extraStop) {
+  return new Set(
+    s.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 1 && !STOPWORDS.has(t) && !extraStop?.has(t))
+  );
+}
+function tokenRecall(requirementText, candidateText) {
+  const req = tokens(requirementText, REQUIREMENT_FORM_STOPWORDS);
+  if (req.size === 0) return 0;
+  const cand = tokens(candidateText);
+  let hit = 0;
+  for (const t of req) if (cand.has(t)) hit++;
+  return hit / req.size;
+}
+function artifactCandidates(req, reqIndex, artifacts) {
+  const reqText = `${req.title} ${req.category ?? ""}`;
+  const out = [];
+  artifacts.forEach((a, i) => {
+    if ((a.content ?? "").trim().length < MIN_CONTENT_CHARS) return;
+    let score = tokenRecall(
+      reqText,
+      `${a.path ?? ""} ${a.kind} ${(a.content ?? "").slice(0, 4e3)}`
+    );
+    if (req.category && a.kind && req.category.toLowerCase() === a.kind.toLowerCase()) {
+      score = Math.max(score, 1);
+    }
+    if (score < MATCH_THRESHOLD) return;
+    out.push({
+      reqIndex,
+      itemKey: `artifact:${i}`,
+      score,
+      evidence: `artifact '${a.path ?? a.kind}' matched (token recall ${score.toFixed(2)})`,
+      content: a.content ?? null
+    });
+  });
+  return out;
+}
+function proposalCandidates(req, reqIndex, proposals) {
+  const reqText = `${req.title} ${req.category ?? ""}`;
+  const out = [];
+  for (const p of proposals) {
+    if (p.status !== "approved") continue;
+    const body = (p.content ?? "").trim();
+    if (body.length < MIN_CONTENT_CHARS) continue;
+    const score = tokenRecall(reqText, `${p.title} ${body}`);
+    if (score < MATCH_THRESHOLD) continue;
+    out.push({
+      reqIndex,
+      itemKey: `proposal:${p.id}`,
+      score,
+      evidence: `approved proposal '${p.title}' matched (token recall ${score.toFixed(2)})`,
+      content: body
+    });
+  }
+  return out;
+}
+function toolCallCandidates(req, reqIndex, toolCalls) {
+  const out = [];
+  toolCalls.forEach((name, i) => {
+    const score = tokenRecall(req.title, name);
+    if (score < MATCH_THRESHOLD) return;
+    out.push({
+      reqIndex,
+      itemKey: `tool:${i}`,
+      score,
+      evidence: `tool call '${name}' matched (token recall ${score.toFixed(2)})`,
+      content: null
+    });
+  });
+  return out;
+}
+async function verifyCompletion(gold, state, checkCorrectness) {
+  if (gold.requirements.length === 0) {
+    throw new Error(
+      `verifyCompletion: task '${gold.taskId}' has no requirements \u2014 malformed gold spec`
+    );
+  }
+  const candidates = [];
+  gold.requirements.forEach((req, i) => {
+    const by = req.satisfiedBy ?? "any";
+    if (by === "artifact" || by === "any") {
+      candidates.push(...artifactCandidates(req, i, state.artifacts));
+    }
+    if (by === "proposal" || by === "any") {
+      candidates.push(...proposalCandidates(req, i, state.proposals));
+    }
+    if (by === "tool-call" || by === "any") {
+      candidates.push(...toolCallCandidates(req, i, state.toolCalls));
+    }
+  });
+  candidates.sort((a, b) => b.score - a.score);
+  const assigned = /* @__PURE__ */ new Map();
+  const itemTaken = /* @__PURE__ */ new Set();
+  for (const c of candidates) {
+    if (assigned.has(c.reqIndex) || itemTaken.has(c.itemKey)) continue;
+    assigned.set(c.reqIndex, c);
+    itemTaken.add(c.itemKey);
+  }
+  const requirements = [];
+  for (let i = 0; i < gold.requirements.length; i++) {
+    const req = gold.requirements[i];
+    const match = assigned.get(i);
+    const evidence = [];
+    let correct = null;
+    let unmeasuredReason;
+    if (match) {
+      evidence.push(match.evidence);
+      if (match.content !== null) {
+        try {
+          const r = await checkCorrectness(req, match.content);
+          correct = r.correct;
+          evidence.push(`correctness: ${r.correct ? "pass" : "fail"} \u2014 ${r.reason}`);
+        } catch (err) {
+          unmeasuredReason = err instanceof JudgeParseError ? `checker response unparseable after retry: ${err.raw.slice(0, 200)}` : `checker call failed: ${err instanceof Error ? err.message : String(err)}`;
+          evidence.push(`correctness: UNMEASURED \u2014 ${unmeasuredReason}`);
+        }
+      } else {
+        evidence.push("correctness: not assessed \u2014 matched item carries no content");
+      }
+    } else {
+      const by = req.satisfiedBy ?? "any";
+      const kind = by === "any" ? "artifact/proposal/tool-call" : by;
+      evidence.push(`no produced ${kind} matched this requirement`);
+    }
+    const structurallyPresent = match !== void 0;
+    const unmeasured = unmeasuredReason !== void 0;
+    const satisfied = structurallyPresent && !unmeasured && correct !== false;
+    requirements.push({
+      reqId: req.reqId,
+      title: req.title,
+      structurallyPresent,
+      correct,
+      satisfied,
+      ...unmeasured ? { unmeasured: true, unmeasuredReason } : {},
+      evidence
+    });
+  }
+  return completionVerdict({ taskId: gold.taskId, requirements });
+}
+function parseCorrectnessResponse(raw) {
+  const readVerdict = (candidate) => {
+    if (candidate === null || typeof candidate !== "object") return null;
+    const { correct, reason } = candidate;
+    if (typeof correct !== "boolean") return null;
+    return { correct, reason: typeof reason === "string" ? reason : "" };
+  };
+  const match = raw.match(/\{[\s\S]*\}/);
+  if (match) {
+    try {
+      const strict = readVerdict(JSON.parse(match[0]));
+      if (strict) return strict;
+    } catch {
+    }
+  }
+  const start = raw.indexOf("{");
+  if (start !== -1) {
+    const recovered = readVerdict(recoverTruncatedJson(raw.slice(start)));
+    if (recovered) return recovered;
+  }
+  throw new JudgeParseError("correctness-checker", raw);
+}
+function createLlmCorrectnessChecker(tc, opts = {}) {
+  const model = opts.model ?? "claude-sonnet-4-6";
+  const maxContentChars = opts.maxContentChars ?? 8e3;
+  const maxAttempts = opts.maxAttempts ?? 2;
+  const costLedger = opts.costLedger ?? new CostLedger();
+  const sink = opts.rawSink;
+  const record = async (event) => {
+    try {
+      await sink?.record(event);
+    } catch {
+    }
+  };
+  return async (requirement, content) => {
+    const request = {
+      model,
+      messages: [
+        {
+          role: "system",
+          content: 'You verify whether a produced work artifact actually fulfils a stated requirement. Judge fulfilment only \u2014 is the deliverable substantively present and on-point \u2014 not polish. A plan to do it later, a vague gesture, or a description of what should be done does NOT fulfil a requirement; the artifact must BE the deliverable. Respond with a single JSON object: {"correct": boolean, "reason": string (<= 30 words)}.'
+        },
+        {
+          role: "user",
+          content: `Requirement: ${requirement.title}
+${requirement.category ? `Category: ${requirement.category}
+` : ""}
+Produced artifact:
+${content.slice(0, maxContentChars)}`
+        }
+      ],
+      temperature: 0,
+      maxTokens: 200
+    };
+    let lastErr;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const started = Date.now();
+      await record({
+        eventId: randomUUID(),
+        provider: "correctness-checker",
+        model,
+        endpoint: "/chat",
+        baseUrl: "",
+        attemptIndex: attempt,
+        direction: "request",
+        timestamp: started,
+        requestBody: request,
+        redactedFields: []
+      });
+      try {
+        const paid = await costLedger.runPaidCall({
+          channel: "verifier",
+          phase: opts.costPhase ?? "completion.correctness",
+          actor: "correctness-checker",
+          model,
+          maximumCharge: maximumChargeForTCloudRequest(request, opts.tcloudMaximumAttempts),
+          tags: {
+            ...opts.costTags,
+            requirementId: requirement.reqId,
+            attempt: String(attempt)
+          },
+          signal: opts.signal,
+          execute: () => tc.chat(request),
+          receipt: (response) => costReceiptFromTCloud(response, model),
+          receiptFromError: (error) => opts.receiptFromError?.(error, attempt)
+        });
+        if (!paid.succeeded) throw paid.error;
+        const resp = paid.value;
+        const raw = resp.choices?.[0]?.message?.content ?? "";
+        await record({
+          eventId: randomUUID(),
+          provider: "correctness-checker",
+          model,
+          endpoint: "/chat",
+          baseUrl: "",
+          attemptIndex: attempt,
+          direction: "response",
+          timestamp: Date.now(),
+          durationMs: Date.now() - started,
+          responseBody: resp,
+          redactedFields: []
+        });
+        return parseCorrectnessResponse(raw);
+      } catch (err) {
+        lastErr = err;
+        await record({
+          eventId: randomUUID(),
+          provider: "correctness-checker",
+          model,
+          endpoint: "/chat",
+          baseUrl: "",
+          attemptIndex: attempt,
+          direction: "error",
+          timestamp: Date.now(),
+          durationMs: Date.now() - started,
+          errorMessage: err instanceof Error ? err.message : String(err),
+          redactedFields: []
+        });
+      }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+  };
+}
+var TITLE_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "for",
+  "to",
+  "of",
+  "in",
+  "on",
+  "with",
+  "review",
+  "update",
+  "new",
+  "proposed"
+]);
+function createTokenRecallChecker(opts = {}) {
+  const minRecall = opts.minRecall ?? 0.5;
+  const minLen = opts.minContentLength ?? 120;
+  return async (requirement, content) => {
+    const body = content.trim();
+    if (body.length < minLen)
+      return {
+        correct: false,
+        reason: `content too thin (${body.length} chars) to be the deliverable`
+      };
+    const titleTokens = requirement.title.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2 && !TITLE_STOPWORDS.has(t));
+    if (titleTokens.length === 0)
+      return {
+        correct: true,
+        reason: "requirement title has no significant tokens \u2014 structural match accepted"
+      };
+    const lower = body.toLowerCase();
+    const hits = titleTokens.filter((t) => lower.includes(t)).length;
+    const recall = hits / titleTokens.length;
+    return recall >= minRecall ? {
+      correct: true,
+      reason: `content recalls ${hits}/${titleTokens.length} requirement tokens`
+    } : {
+      correct: false,
+      reason: `content recalls only ${hits}/${titleTokens.length} requirement tokens`
+    };
+  };
+}
+
+// src/produced-state.ts
+function artifactKind(mimeType) {
+  if (!mimeType) return "file";
+  if (mimeType.includes("json")) return "json";
+  if (mimeType.startsWith("text/")) return "text";
+  return "file";
+}
+function extractProducedState(events) {
+  const artifacts = [];
+  const proposals = [];
+  const toolCalls = [];
+  const seenTools = /* @__PURE__ */ new Set();
+  for (const ev of events) {
+    if (ev.type === "tool_call") {
+      const name = ev.toolName;
+      if (name && !seenTools.has(name)) {
+        seenTools.add(name);
+        toolCalls.push(name);
+      }
+    } else if (ev.type === "artifact") {
+      const a = ev;
+      artifacts.push({
+        kind: artifactKind(a.mimeType),
+        path: a.name ?? a.uri ?? a.artifactId,
+        content: a.content ?? ""
+      });
+    } else if (ev.type === "proposal_created") {
+      const p = ev;
+      proposals.push({
+        id: p.proposalId,
+        title: p.title,
+        status: p.status ?? "pending",
+        ...p.content !== void 0 ? { content: p.content } : {}
+      });
+    }
+  }
+  return { artifacts, proposals, toolCalls };
+}
+
+// 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 truncate(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(truncate(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-profile-matrix.ts
+import { createHash as createHash5 } from "crypto";
+import { join as join3 } from "path";
+
+// src/agent-profile.ts
+import { createHash as createHash4 } from "crypto";
+import { harnessSupportsModel } from "@tangle-network/agent-interface";
+var CODING_HARNESSES = [
+  "opencode",
+  "claude-code",
+  "codex",
+  "kimi-code"
+];
+var HARNESS_NATIVE_MODEL = "default";
+function expandProfileAxes(spec) {
+  const harnesses = spec.harnesses ?? CODING_HARNESSES;
+  if (harnesses.length === 0) throw new ValidationError("expandProfileAxes: no harnesses to sweep");
+  const baseModel = spec.base.model?.default;
+  const models = spec.models ?? (baseModel ? [baseModel] : []);
+  if (models.length === 0) {
+    throw new ValidationError(
+      "expandProfileAxes: no models to sweep \u2014 base profile has no model.default and none were supplied"
+    );
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const harness of harnesses) {
+    const supported = spec.keepIncompatible ? models : models.filter((model) => harnessSupportsModel(harness, model));
+    const effective = supported.length > 0 ? supported : [HARNESS_NATIVE_MODEL];
+    for (const model of effective) {
+      const profile = {
+        ...spec.base,
+        name: `${spec.base.name ?? "agent"}/${harness}/${model}`,
+        model: { ...spec.base.model, default: model },
+        metadata: { ...spec.base.metadata ?? {}, harness, harnessModel: model }
+      };
+      const id = agentProfileId(profile);
+      if (seen.has(id)) continue;
+      seen.add(id);
+      out.push(profile);
+    }
+  }
+  if (out.length === 0) {
+    throw new ValidationError(
+      `expandProfileAxes: produced no profiles (harnesses=[${harnesses.join(", ")}], models=[${models.join(", ")}]).`
+    );
+  }
+  return out;
+}
+function harnessAxisOf(profile) {
+  const m = profile.metadata;
+  const harness = m?.harness;
+  const model = m?.harnessModel;
+  if (typeof harness === "string" && typeof model === "string") {
+    return { harness, model };
+  }
+  return void 0;
+}
+function agentProfileId(profile) {
+  const label = pathSafeProfileLabel(agentProfileDisplayLabel(profile)) ?? "profile";
+  return `${label}-${agentProfileHash(profile).slice(0, 16)}`;
+}
+function agentProfileModelId(profile) {
+  const model = profile.model?.default?.trim();
+  if (!model) {
+    const label = agentProfileDisplayLabel(profile) ?? "unnamed profile";
+    throw new ValidationError(
+      `AgentProfile "${label}" has no model.default \u2014 cannot record eval run`
+    );
+  }
+  return model;
+}
+function agentProfileDisplayLabel(profile) {
+  return profile.name?.trim() || profile.version?.trim() || void 0;
+}
+function pathSafeProfileLabel(label) {
+  const safe = label?.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return safe || void 0;
+}
+function compact(input) {
+  const out = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function agentProfileHash(profile) {
+  const model = agentProfileModelId(profile);
+  const behaviour = {
+    ...profile,
+    name: void 0,
+    description: void 0,
+    tags: profile.tags ? [...profile.tags].sort() : void 0,
+    model: compact({ ...profile.model, default: model })
+  };
+  return createHash4("sha256").update(JSON.stringify(canonicalize(behaviour))).digest("hex");
+}
+
+// src/campaign/presets/run-profile-matrix.ts
+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 mean2(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 : mean2(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 return it in the ctx.cost.runPaidCall receipt 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) in the paid-call receipt`
+    );
+  }
+  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] = mean2(values);
+  const costUsd = cell.costUsd;
+  raw.cost_usd = costUsd;
+  raw.cost_estimated = cell.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 totalCostUsd = campaign.aggregates.totalCostUsd;
+    campaigns[profileId] = campaign;
+    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: mean2(profileRecords.map(compositeOf)),
+      totalCostUsd,
+      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: mean2(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/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/search-ledger.ts
+import { createHash as createHash6 } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve2 } from "path";
+import { z } from "zod";
+var SEARCH_LEDGER_SCHEMA = "tangle.search-ledger.v1";
+var NON_EMPTY = z.string().min(1).refine((value) => value.trim() === value, "must not contain surrounding whitespace");
+var HASH = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+var LINEAGE_NODE_ID = z.string().regex(/^[a-f0-9]{16}$/);
+var IMMUTABLE_REVISION = z.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64}|sha256:[a-f0-9]{64}|sha512:[A-Za-z0-9+/=]+)$/);
+var ISO_TIMESTAMP = z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/).refine((value) => Number.isFinite(Date.parse(value)), "invalid timestamp");
+var NON_NEGATIVE_INT = z.number().int().nonnegative().safe();
+var FINITE_NUMBER = z.number().finite();
+var ArtifactRefSchema = z.object({
+  role: NON_EMPTY,
+  uri: NON_EMPTY,
+  sha256: HASH,
+  byteLength: NON_NEGATIVE_INT
+}).strict();
+var SourceRefSchema = z.object({
+  uri: NON_EMPTY,
+  revision: IMMUTABLE_REVISION
+}).strict();
+var FailureReasonSchema = z.object({
+  code: NON_EMPTY,
+  message: NON_EMPTY
+}).strict();
+var EventBaseShape = {
+  eventId: NON_EMPTY,
+  occurredAt: ISO_TIMESTAMP,
+  artifacts: z.array(ArtifactRefSchema).min(1)
+};
+var OperationKindSchema = z.enum([
+  "candidate-generation",
+  "analysis",
+  "selection",
+  "judge",
+  "other"
+]);
+var SearchPlannedSchema = z.object({
+  ...EventBaseShape,
+  kind: z.literal("search-planned"),
+  plan: z.object({
+    candidateSlots: z.array(
+      z.object({
+        slotId: NON_EMPTY,
+        generationOperationId: NON_EMPTY
+      }).strict()
+    ).min(1),
+    tasks: z.array(
+      z.object({
+        taskId: NON_EMPTY,
+        source: SourceRefSchema,
+        benchmark: SourceRefSchema,
+        maxAttempts: z.number().int().positive().safe()
+      }).strict()
+    ).min(1),
+    operations: z.array(
+      z.object({
+        operationId: NON_EMPTY,
+        kind: OperationKindSchema
+      }).strict()
+    ).min(1)
+  }).strict()
+}).strict();
+var CandidateRegisteredSchema = z.object({
+  ...EventBaseShape,
+  kind: z.literal("candidate-registered"),
+  slotId: NON_EMPTY,
+  generationOperationId: NON_EMPTY,
+  candidateId: NON_EMPTY,
+  lineage: z.object({
+    lineageNodeId: LINEAGE_NODE_ID,
+    parentCandidateIds: z.array(NON_EMPTY),
+    generation: NON_NEGATIVE_INT,
+    proposer: NON_EMPTY,
+    proposerSource: SourceRefSchema
+  }).strict(),
+  surfaces: z.array(
+    z.object({
+      surfaceId: NON_EMPTY,
+      kind: z.enum([
+        "prompt",
+        "tool-contract",
+        "runtime-config",
+        "memory",
+        "knowledge",
+        "agent-profile",
+        "code",
+        "deployment"
+      ]),
+      artifact: ArtifactRefSchema
+    }).strict()
+  ).min(1)
+}).strict();
+var CandidateSlotClosedSchema = z.object({
+  ...EventBaseShape,
+  kind: z.literal("candidate-slot-closed"),
+  slotId: NON_EMPTY,
+  generationOperationId: NON_EMPTY,
+  reason: FailureReasonSchema
+}).strict();
+var KnownTokensSchema = z.object({
+  status: z.literal("known"),
+  inputTokens: NON_NEGATIVE_INT,
+  outputTokens: NON_NEGATIVE_INT,
+  cachedTokens: NON_NEGATIVE_INT
+}).strict();
+var UnknownSchema = z.object({
+  status: z.literal("unknown"),
+  reason: NON_EMPTY
+}).strict();
+var KnownCostSchema = z.object({
+  status: z.literal("known"),
+  usd: z.number().finite().nonnegative(),
+  source: z.enum(["provider", "pricing-table", "free"])
+}).strict().superRefine((cost, ctx) => {
+  if (cost.source === "free" && cost.usd !== 0) {
+    ctx.addIssue({ code: "custom", message: "free cost source must have usd 0" });
+  }
+});
+var UnknownCostSchema = z.object({
+  status: z.literal("unknown"),
+  knownLowerBoundUsd: z.number().finite().nonnegative(),
+  reason: NON_EMPTY
+}).strict();
+var AccountingSchema = z.object({
+  tokens: z.discriminatedUnion("status", [KnownTokensSchema, UnknownSchema]),
+  cost: z.discriminatedUnion("status", [KnownCostSchema, UnknownCostSchema])
+}).strict();
+var MetricsSchema = z.record(NON_EMPTY, FINITE_NUMBER).superRefine((metrics, ctx) => {
+  for (const key of Object.keys(metrics)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      ctx.addIssue({ code: "custom", message: `unsafe metric key ${key}` });
+    }
+  }
+});
+var OutcomeSchema = z.discriminatedUnion("status", [
+  z.object({
+    status: z.literal("passed"),
+    score: FINITE_NUMBER,
+    metrics: MetricsSchema
+  }).strict(),
+  z.object({
+    status: z.literal("failed"),
+    score: FINITE_NUMBER,
+    metrics: MetricsSchema,
+    failure: FailureReasonSchema
+  }).strict(),
+  z.object({
+    status: z.literal("errored"),
+    metrics: MetricsSchema,
+    error: FailureReasonSchema.extend({ retryable: z.boolean() }).strict()
+  }).strict()
+]);
+var EffectSchema = z.discriminatedUnion("status", [
+  z.object({
+    status: z.literal("measured"),
+    metric: NON_EMPTY,
+    baselineValue: FINITE_NUMBER,
+    candidateValue: FINITE_NUMBER,
+    delta: FINITE_NUMBER
+  }).strict().superRefine((effect, ctx) => {
+    const expected = effect.candidateValue - effect.baselineValue;
+    const tolerance = Number.EPSILON * Math.max(1, Math.abs(expected), Math.abs(effect.delta)) * 8;
+    if (Math.abs(effect.delta - expected) > tolerance) {
+      ctx.addIssue({ code: "custom", message: "delta must equal candidateValue - baselineValue" });
+    }
+  }),
+  z.object({
+    status: z.literal("not-measured"),
+    reason: NON_EMPTY
+  }).strict()
+]);
+var SurfaceEvidenceSchema = z.object({
+  surfaceId: NON_EMPTY,
+  fired: z.boolean(),
+  firingCount: NON_NEGATIVE_INT,
+  effect: EffectSchema,
+  evidence: z.array(ArtifactRefSchema).min(1)
+}).strict().superRefine((evidence, ctx) => {
+  if (evidence.fired && evidence.firingCount === 0) {
+    ctx.addIssue({ code: "custom", message: "a fired surface must have firingCount >= 1" });
+  }
+  if (!evidence.fired && evidence.firingCount !== 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "a surface that did not fire must have firingCount 0"
+    });
+  }
+  if (!evidence.fired && evidence.effect.status === "measured" && evidence.effect.delta !== 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "a surface that did not fire cannot claim non-zero effect"
+    });
+  }
+});
+var TaskAttemptedSchema = z.object({
+  ...EventBaseShape,
+  kind: z.literal("task-attempted"),
+  candidateId: NON_EMPTY,
+  runId: NON_EMPTY,
+  attemptIndex: NON_NEGATIVE_INT,
+  task: z.object({ taskId: NON_EMPTY, source: SourceRefSchema }).strict(),
+  identity: z.object({
+    model: z.object({
+      provider: NON_EMPTY,
+      snapshot: NON_EMPTY.refine(
+        modelHasSnapshot,
+        "model must include an immutable snapshot"
+      )
+    }).strict(),
+    agent: SourceRefSchema,
+    benchmark: SourceRefSchema
+  }).strict(),
+  outcome: OutcomeSchema,
+  accounting: AccountingSchema,
+  surfaceEvidence: z.array(SurfaceEvidenceSchema).min(1)
+}).strict();
+var SearchOperationRecordedSchema = z.object({
+  ...EventBaseShape,
+  kind: z.literal("search-operation-recorded"),
+  operationId: NON_EMPTY,
+  operationKind: OperationKindSchema,
+  execution: z.discriminatedUnion("kind", [
+    z.object({
+      kind: z.literal("model"),
+      model: z.object({
+        provider: NON_EMPTY,
+        snapshot: NON_EMPTY.refine(
+          modelHasSnapshot,
+          "model must include an immutable snapshot"
+        )
+      }).strict(),
+      source: SourceRefSchema
+    }).strict(),
+    z.object({
+      kind: z.literal("deterministic"),
+      source: SourceRefSchema
+    }).strict()
+  ]),
+  outcome: z.discriminatedUnion("status", [
+    z.object({ status: z.literal("completed") }).strict(),
+    z.object({
+      status: z.literal("partial"),
+      failure: FailureReasonSchema
+    }).strict(),
+    z.object({
+      status: z.literal("failed"),
+      failure: FailureReasonSchema
+    }).strict()
+  ]),
+  accounting: AccountingSchema
+}).strict();
+var CandidateDecidedSchema = z.object({
+  ...EventBaseShape,
+  kind: z.literal("candidate-decided"),
+  candidateId: NON_EMPTY,
+  decision: z.discriminatedUnion("status", [
+    z.object({ status: z.literal("selected") }).strict(),
+    z.object({
+      status: z.literal("rejected"),
+      reason: FailureReasonSchema
+    }).strict()
+  ])
+}).strict();
+var SearchCompletedSchema = z.object({
+  ...EventBaseShape,
+  kind: z.literal("search-completed"),
+  result: z.discriminatedUnion("status", [
+    z.object({
+      status: z.literal("selected"),
+      candidateId: NON_EMPTY
+    }).strict(),
+    z.object({
+      status: z.literal("all-rejected"),
+      reason: FailureReasonSchema
+    }).strict()
+  ])
+}).strict();
+var EventSchema = z.discriminatedUnion("kind", [
+  SearchPlannedSchema,
+  CandidateRegisteredSchema,
+  CandidateSlotClosedSchema,
+  TaskAttemptedSchema,
+  SearchOperationRecordedSchema,
+  CandidateDecidedSchema,
+  SearchCompletedSchema
+]);
+var EntrySchema = z.object({
+  schema: z.literal(SEARCH_LEDGER_SCHEMA),
+  campaignId: NON_EMPTY,
+  sequence: NON_NEGATIVE_INT,
+  previousHash: z.union([HASH, z.null()]),
+  event: EventSchema,
+  entryHash: HASH
+}).strict();
+function validateSearchLedgerEvent(input) {
+  const parsed = EventSchema.safeParse(input);
+  if (!parsed.success) {
+    throw new SearchLedgerError(`invalid search ledger event: ${formatZodError(parsed.error)}`);
+  }
+  return normalizeEvent(parsed.data);
+}
+function openSearchLedger(options) {
+  if (options.path.trim().length === 0) throw new SearchLedgerError("ledger path is empty");
+  return new FileSearchLedger(options.path, options.campaignId);
+}
+var ledgerMutexes = /* @__PURE__ */ new Map();
+function mutexFor(path) {
+  const existing = ledgerMutexes.get(path);
+  if (existing) return existing;
+  const mutex = new Mutex();
+  ledgerMutexes.set(path, mutex);
+  return mutex;
+}
+var FileSearchLedger = class {
+  path;
+  campaignId;
+  mutex;
+  constructor(path, campaignId) {
+    if (path.trim().length === 0) throw new SearchLedgerError("ledger path is empty");
+    if (campaignId.length === 0) throw new SearchLedgerError("campaignId is empty");
+    if (campaignId.trim() !== campaignId) {
+      throw new SearchLedgerError("campaignId must not contain surrounding whitespace");
+    }
+    this.path = resolve2(path);
+    this.campaignId = campaignId;
+    this.mutex = mutexFor(this.path);
+  }
+  async replay() {
+    return this.mutex.runExclusive(
+      () => withSearchLedgerFileLock(this.path, () => replayFile(this.path, this.campaignId))
+    );
+  }
+  async append(input) {
+    const event = validateSearchLedgerEvent(input);
+    return this.mutex.runExclusive(
+      () => withSearchLedgerFileLock(this.path, () => {
+        const before = replayFile(this.path, this.campaignId);
+        const existing = before.entries.find((entry2) => entry2.event.eventId === event.eventId);
+        if (existing) {
+          if (canonicalString(existing.event) !== canonicalString(event)) {
+            throw new SearchLedgerConflictError(
+              `eventId ${event.eventId} already exists with different content`
+            );
+          }
+          return { entry: existing, appended: false, replay: before };
+        }
+        const previousHash = before.audit.headHash;
+        const material = {
+          schema: SEARCH_LEDGER_SCHEMA,
+          campaignId: this.campaignId,
+          sequence: before.entries.length,
+          previousHash,
+          event
+        };
+        const entry = {
+          ...material,
+          entryHash: hashCanonical(material)
+        };
+        const replay = replayEntries([...before.entries, entry], this.campaignId);
+        appendSearchLedgerLine(this.path, `${canonicalString(entry)}
+`);
+        return { entry, appended: true, replay };
+      })
+    );
+  }
+};
+function replayFile(path, campaignId) {
+  if (!existsSync3(path)) return replayEntries([], campaignId);
+  const text = readFileSync3(path, "utf8");
+  if (text.length === 0) return replayEntries([], campaignId);
+  if (!text.endsWith("\n")) {
+    throw new SearchLedgerIntegrityError(
+      `search ledger ${path} has a truncated final record (missing newline)`
+    );
+  }
+  const lines = text.slice(0, -1).split("\n");
+  const entries = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line.length === 0) {
+      throw new SearchLedgerIntegrityError(
+        `search ledger ${path} has a blank row at line ${index + 1}`
+      );
+    }
+    let raw;
+    try {
+      raw = JSON.parse(line);
+    } catch (error) {
+      throw new SearchLedgerIntegrityError(
+        `search ledger ${path} has invalid JSON at line ${index + 1}`,
+        { cause: error }
+      );
+    }
+    const parsed = EntrySchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new SearchLedgerIntegrityError(
+        `search ledger ${path} has a malformed entry at line ${index + 1}: ${formatZodError(parsed.error)}`
+      );
+    }
+    const entry = parsed.data;
+    const normalizedEvent = validateSearchLedgerEvent(entry.event);
+    if (canonicalString(normalizedEvent) !== canonicalString(entry.event)) {
+      throw new SearchLedgerIntegrityError(
+        `search ledger ${path} has non-canonical event ordering at line ${index + 1}`
+      );
+    }
+    if (line !== canonicalString(entry)) {
+      throw new SearchLedgerIntegrityError(
+        `search ledger ${path} has non-canonical bytes at line ${index + 1}`
+      );
+    }
+    entries.push(entry);
+  }
+  return replayEntries(entries, campaignId);
+}
+function replayEntries(entries, campaignId) {
+  const candidates = /* @__PURE__ */ new Map();
+  const candidateBySlot = /* @__PURE__ */ new Map();
+  const closedSlots = /* @__PURE__ */ new Map();
+  const lineageNodes = /* @__PURE__ */ new Map();
+  const eventIds = /* @__PURE__ */ new Set();
+  const runIds = /* @__PURE__ */ new Set();
+  const attemptKeys = /* @__PURE__ */ new Set();
+  const candidateEvents = [];
+  const closedSlotEvents = [];
+  const attempts = [];
+  const operationEvents = [];
+  const operationsById = /* @__PURE__ */ new Map();
+  const decisions = [];
+  let planEvent = null;
+  let completion = null;
+  let expectedPrevious = null;
+  let previousOccurredAt = Number.NEGATIVE_INFINITY;
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    if (entry.campaignId !== campaignId) {
+      throw new SearchLedgerIntegrityError(
+        `entry ${index} belongs to campaign ${entry.campaignId}, expected ${campaignId}`
+      );
+    }
+    if (entry.sequence !== index) {
+      throw new SearchLedgerIntegrityError(
+        `entry ${entry.event.eventId} has sequence ${entry.sequence}, expected ${index}`
+      );
+    }
+    if (entry.previousHash !== expectedPrevious) {
+      throw new SearchLedgerIntegrityError(
+        `entry ${entry.event.eventId} does not extend the previous hash`
+      );
+    }
+    const { entryHash: _entryHash, ...material } = entry;
+    const expectedHash = hashCanonical(material);
+    if (entry.entryHash !== expectedHash) {
+      throw new SearchLedgerIntegrityError(
+        `entry ${entry.event.eventId} hash mismatch: expected ${expectedHash}, got ${entry.entryHash}`
+      );
+    }
+    expectedPrevious = entry.entryHash;
+    const event = entry.event;
+    if (eventIds.has(event.eventId)) {
+      throw new SearchLedgerIntegrityError(`duplicate eventId ${event.eventId} in durable ledger`);
+    }
+    eventIds.add(event.eventId);
+    if (completion) {
+      throw new SearchLedgerIntegrityError(
+        `event ${event.eventId} appears after terminal event ${completion.eventId}`
+      );
+    }
+    const occurredAt = Date.parse(event.occurredAt);
+    if (occurredAt < previousOccurredAt) {
+      throw new SearchLedgerIntegrityError(
+        `event ${event.eventId} occurred before the preceding durable event`
+      );
+    }
+    previousOccurredAt = occurredAt;
+    assertUnique2(event.artifacts.map(artifactKey), "artifact receipt", event.eventId);
+    if (event.kind === "search-planned") {
+      if (index !== 0 || planEvent) {
+        throw new SearchLedgerIntegrityError("search plan must be the first and only plan event");
+      }
+      assertUnique2(
+        event.plan.candidateSlots.map((slot) => slot.slotId),
+        "candidate slot",
+        event.eventId
+      );
+      assertUnique2(
+        event.plan.tasks.map((task) => task.taskId),
+        "planned taskId",
+        event.eventId
+      );
+      assertUnique2(
+        event.plan.operations.map((operation) => operation.operationId),
+        "planned operationId",
+        event.eventId
+      );
+      for (const slot of event.plan.candidateSlots) {
+        const generationOperation = event.plan.operations.find(
+          (operation) => operation.operationId === slot.generationOperationId
+        );
+        if (!generationOperation || generationOperation.kind !== "candidate-generation") {
+          throw new SearchLedgerIntegrityError(
+            `candidate slot ${slot.slotId} references unplanned candidate-generation operation ${slot.generationOperationId}`
+          );
+        }
+      }
+      planEvent = event;
+      continue;
+    }
+    if (!planEvent) {
+      throw new SearchLedgerIntegrityError(
+        `event ${event.eventId} appears before the required search plan`
+      );
+    }
+    if (event.kind === "candidate-registered") {
+      if (candidates.has(event.candidateId)) {
+        throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} was registered twice`);
+      }
+      const plannedSlot = planEvent.plan.candidateSlots.find((slot) => slot.slotId === event.slotId);
+      if (!plannedSlot) {
+        throw new SearchLedgerIntegrityError(
+          `candidate ${event.candidateId} binds unknown slot ${event.slotId}`
+        );
+      }
+      if (candidateBySlot.has(event.slotId)) {
+        throw new SearchLedgerIntegrityError(`candidate slot ${event.slotId} was bound twice`);
+      }
+      if (closedSlots.has(event.slotId)) {
+        throw new SearchLedgerIntegrityError(`candidate slot ${event.slotId} was already closed`);
+      }
+      if (event.generationOperationId !== plannedSlot.generationOperationId) {
+        throw new SearchLedgerIntegrityError(
+          `candidate ${event.candidateId} generation operation ${event.generationOperationId} does not match slot ${event.slotId} plan ${plannedSlot.generationOperationId}`
+        );
+      }
+      const generationOperation = operationsById.get(event.generationOperationId);
+      if (!generationOperation) {
+        throw new SearchLedgerIntegrityError(
+          `candidate ${event.candidateId} precedes generation operation ${event.generationOperationId}`
+        );
+      }
+      if (generationOperation.outcome.status === "failed") {
+        throw new SearchLedgerIntegrityError(
+          `candidate ${event.candidateId} cannot bind failed generation operation ${event.generationOperationId}`
+        );
+      }
+      const previousCandidate = lineageNodes.get(event.lineage.lineageNodeId);
+      if (previousCandidate) {
+        throw new SearchLedgerIntegrityError(
+          `lineage node ${event.lineage.lineageNodeId} is already bound to ${previousCandidate}`
+        );
+      }
+      assertUnique2(event.lineage.parentCandidateIds, "parentCandidateId", event.eventId);
+      const parents = event.lineage.parentCandidateIds.map((id) => {
+        const parent = candidates.get(id);
+        if (!parent) {
+          throw new SearchLedgerIntegrityError(
+            `candidate ${event.candidateId} references unknown parent ${id}`
+          );
+        }
+        return parent;
+      });
+      const expectedGeneration = parents.length === 0 ? 0 : Math.max(...parents.map((parent) => parent.registered.lineage.generation)) + 1;
+      if (event.lineage.generation !== expectedGeneration) {
+        throw new SearchLedgerIntegrityError(
+          `candidate ${event.candidateId} generation ${event.lineage.generation} does not follow its parents (expected ${expectedGeneration})`
+        );
+      }
+      assertUnique2(
+        event.surfaces.map((surface) => surface.surfaceId),
+        "surfaceId",
+        event.eventId
+      );
+      candidates.set(event.candidateId, { registered: event, attempts: [], decision: null });
+      candidateBySlot.set(event.slotId, event.candidateId);
+      lineageNodes.set(event.lineage.lineageNodeId, event.candidateId);
+      candidateEvents.push(event);
+      continue;
+    }
+    if (event.kind === "task-attempted") {
+      const candidate = candidates.get(event.candidateId);
+      if (!candidate) {
+        throw new SearchLedgerIntegrityError(
+          `attempt ${event.eventId} references unknown candidate ${event.candidateId}`
+        );
+      }
+      if (candidate.decision) {
+        throw new SearchLedgerIntegrityError(
+          `attempt ${event.eventId} appears after candidate ${event.candidateId} was decided`
+        );
+      }
+      const plannedTask = planEvent.plan.tasks.find((task) => task.taskId === event.task.taskId);
+      if (!plannedTask) {
+        throw new SearchLedgerIntegrityError(
+          `attempt ${event.eventId} references unplanned task ${event.task.taskId}`
+        );
+      }
+      if (canonicalString(plannedTask.source) !== canonicalString(event.task.source) || canonicalString(plannedTask.benchmark) !== canonicalString(event.identity.benchmark)) {
+        throw new SearchLedgerIntegrityError(
+          `task ${event.task.taskId} does not match its planned source identity`
+        );
+      }
+      if (event.attemptIndex >= plannedTask.maxAttempts) {
+        throw new SearchLedgerIntegrityError(
+          `task ${event.task.taskId} attempt ${event.attemptIndex} exceeds planned maxAttempts ${plannedTask.maxAttempts}`
+        );
+      }
+      if (runIds.has(event.runId)) {
+        throw new SearchLedgerIntegrityError(`runId ${event.runId} was recorded twice`);
+      }
+      runIds.add(event.runId);
+      const attemptKey = canonicalString([event.candidateId, event.task.taskId, event.attemptIndex]);
+      if (attemptKeys.has(attemptKey)) {
+        throw new SearchLedgerIntegrityError(
+          `candidate ${event.candidateId} task ${event.task.taskId} attempt ${event.attemptIndex} was recorded twice`
+        );
+      }
+      const expectedAttemptIndex = candidate.attempts.filter(
+        (attempt) => attempt.task.taskId === event.task.taskId
+      ).length;
+      if (event.attemptIndex !== expectedAttemptIndex) {
+        throw new SearchLedgerIntegrityError(
+          `candidate ${event.candidateId} task ${event.task.taskId} attempt index ${event.attemptIndex} is not contiguous (expected ${expectedAttemptIndex})`
+        );
+      }
+      const previousAttempt = candidate.attempts.find(
+        (attempt) => attempt.task.taskId === event.task.taskId
+      );
+      if (previousAttempt?.outcome.status !== void 0 && previousAttempt.outcome.status !== "errored") {
+        throw new SearchLedgerIntegrityError(
+          `task ${event.task.taskId} was retried after a measured outcome`
+        );
+      }
+      if (previousAttempt && canonicalString({ task: previousAttempt.task, identity: previousAttempt.identity }) !== canonicalString({ task: event.task, identity: event.identity })) {
+        throw new SearchLedgerIntegrityError(
+          `candidate ${event.candidateId} task ${event.task.taskId} changed immutable execution identity between attempts`
+        );
+      }
+      attemptKeys.add(attemptKey);
+      const declared = candidate.registered.surfaces.map((surface) => surface.surfaceId).sort();
+      const observed = event.surfaceEvidence.map((surface) => surface.surfaceId).sort();
+      assertUnique2(observed, "surface evidence", event.eventId);
+      for (const evidence of event.surfaceEvidence) {
+        assertUnique2(evidence.evidence.map(artifactKey), "surface evidence receipt", event.eventId);
+      }
+      if (canonicalString(declared) !== canonicalString(observed)) {
+        throw new SearchLedgerIntegrityError(
+          `attempt ${event.eventId} surface evidence does not exactly cover candidate ${event.candidateId}`
+        );
+      }
+      candidate.attempts.push(event);
+      attempts.push(event);
+      continue;
+    }
+    if (event.kind === "search-operation-recorded") {
+      const plannedOperation = planEvent.plan.operations.find(
+        (operation) => operation.operationId === event.operationId
+      );
+      if (!plannedOperation) {
+        throw new SearchLedgerIntegrityError(
+          `operation ${event.operationId} was not declared in the search plan`
+        );
+      }
+      if (plannedOperation.kind !== event.operationKind) {
+        throw new SearchLedgerIntegrityError(
+          `operation ${event.operationId} kind ${event.operationKind} does not match planned ${plannedOperation.kind}`
+        );
+      }
+      if (operationsById.has(event.operationId)) {
+        throw new SearchLedgerIntegrityError(`operation ${event.operationId} was recorded twice`);
+      }
+      operationsById.set(event.operationId, event);
+      operationEvents.push(event);
+      continue;
+    }
+    if (event.kind === "candidate-slot-closed") {
+      const plannedSlot = planEvent.plan.candidateSlots.find((slot) => slot.slotId === event.slotId);
+      if (!plannedSlot) {
+        throw new SearchLedgerIntegrityError(
+          `candidate slot closure ${event.eventId} references unknown slot ${event.slotId}`
+        );
+      }
+      if (event.generationOperationId !== plannedSlot.generationOperationId) {
+        throw new SearchLedgerIntegrityError(
+          `candidate slot closure ${event.eventId} generation operation ${event.generationOperationId} does not match slot ${event.slotId} plan ${plannedSlot.generationOperationId}`
+        );
+      }
+      if (candidateBySlot.has(event.slotId)) {
+        throw new SearchLedgerIntegrityError(
+          `candidate slot ${event.slotId} was already bound to a candidate`
+        );
+      }
+      if (closedSlots.has(event.slotId)) {
+        throw new SearchLedgerIntegrityError(`candidate slot ${event.slotId} was closed twice`);
+      }
+      const operation = operationsById.get(event.generationOperationId);
+      if (!operation) {
+        throw new SearchLedgerIntegrityError(
+          `candidate slot closure ${event.eventId} precedes operation ${event.generationOperationId}`
+        );
+      }
+      if (operation.outcome.status === "completed") {
+        throw new SearchLedgerIntegrityError(
+          `candidate slot ${event.slotId} cannot close from completed operation ${event.generationOperationId}`
+        );
+      }
+      closedSlots.set(event.slotId, event);
+      closedSlotEvents.push(event);
+      continue;
+    }
+    if (event.kind === "candidate-decided") {
+      const candidate = candidates.get(event.candidateId);
+      if (!candidate) {
+        throw new SearchLedgerIntegrityError(
+          `decision ${event.eventId} references unknown candidate ${event.candidateId}`
+        );
+      }
+      if (candidate.decision) {
+        throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} was decided twice`);
+      }
+      if (event.decision.status === "selected") {
+        if (!candidate.attempts.some((attempt) => attempt.outcome.status !== "errored")) {
+          throw new SearchLedgerIntegrityError(
+            `candidate ${event.candidateId} cannot be selected without a measured task outcome`
+          );
+        }
+        if (decisions.some((decision) => decision.decision.status === "selected")) {
+          throw new SearchLedgerIntegrityError("more than one candidate was selected");
+        }
+      }
+      candidate.decision = event;
+      decisions.push(event);
+      continue;
+    }
+    const missingCandidateSlots2 = planEvent.plan.candidateSlots.filter((slot) => !candidateBySlot.has(slot.slotId) && !closedSlots.has(slot.slotId)).map((slot) => slot.slotId);
+    if (missingCandidateSlots2.length > 0) {
+      throw new SearchLedgerIntegrityError(
+        `search completed with missing candidate slots: ${missingCandidateSlots2.join(", ")}`
+      );
+    }
+    const missingTaskOutcomes2 = plannedTaskOutcomeKeys(planEvent, candidates);
+    if (missingTaskOutcomes2.length > 0) {
+      throw new SearchLedgerIntegrityError(
+        `search completed with missing task outcomes: ${missingTaskOutcomes2.join(", ")}`
+      );
+    }
+    const missingOperations2 = planEvent.plan.operations.filter((operation) => !operationsById.has(operation.operationId)).map((operation) => operation.operationId);
+    if (missingOperations2.length > 0) {
+      throw new SearchLedgerIntegrityError(
+        `search completed with missing search operations: ${missingOperations2.join(", ")}`
+      );
+    }
+    for (const operation of planEvent.plan.operations) {
+      if (operation.kind !== "candidate-generation") continue;
+      const generationOutcome = operationsById.get(operation.operationId).outcome.status;
+      const slots = planEvent.plan.candidateSlots.filter(
+        (slot) => slot.generationOperationId === operation.operationId
+      );
+      if (slots.length === 0) continue;
+      const registeredCount = slots.filter((slot) => candidateBySlot.has(slot.slotId)).length;
+      const closedCount = slots.filter((slot) => closedSlots.has(slot.slotId)).length;
+      if (generationOutcome === "completed" && closedCount > 0) {
+        throw new SearchLedgerIntegrityError(
+          `completed generation operation ${operation.operationId} contains ${closedCount} closed slot(s)`
+        );
+      }
+      if (generationOutcome === "failed" && registeredCount > 0) {
+        throw new SearchLedgerIntegrityError(
+          `failed generation operation ${operation.operationId} contains ${registeredCount} registered candidate(s)`
+        );
+      }
+      if (generationOutcome === "partial" && (registeredCount === 0 || closedCount === 0)) {
+        throw new SearchLedgerIntegrityError(
+          `partial generation operation ${operation.operationId} must contain both a registered candidate and a closed slot`
+        );
+      }
+    }
+    const pending = [...candidates.values()].filter((candidate) => candidate.decision === null);
+    if (pending.length > 0) {
+      throw new SearchLedgerIntegrityError(
+        `search completed with ${pending.length} candidate decision(s) missing`
+      );
+    }
+    const selected = decisions.filter((decision) => decision.decision.status === "selected");
+    if (event.result.status === "selected") {
+      if (selected.length !== 1 || selected[0].candidateId !== event.result.candidateId) {
+        throw new SearchLedgerIntegrityError(
+          `search completion winner ${event.result.candidateId} does not match candidate decisions`
+        );
+      }
+    } else if (selected.length !== 0) {
+      throw new SearchLedgerIntegrityError("all-rejected completion contains a selected candidate");
+    }
+    completion = event;
+  }
+  const selectedDecisions = decisions.filter((decision) => decision.decision.status === "selected");
+  const rejectedDecisions = decisions.filter((decision) => decision.decision.status === "rejected");
+  const outcomeCounts = { passed: 0, failed: 0, errored: 0 };
+  const operationOutcomeCounts = { completed: 0, partial: 0, failed: 0 };
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cachedTokens = 0;
+  let costUsd = 0;
+  const unknownTokenEventIds = [];
+  const unknownCostEventIds = [];
+  for (const attempt of attempts) {
+    outcomeCounts[attempt.outcome.status] += 1;
+  }
+  for (const operation of operationEvents) {
+    operationOutcomeCounts[operation.outcome.status] += 1;
+  }
+  for (const costedEvent of [...attempts, ...operationEvents]) {
+    if (costedEvent.accounting.tokens.status === "known") {
+      inputTokens += costedEvent.accounting.tokens.inputTokens;
+      outputTokens += costedEvent.accounting.tokens.outputTokens;
+      cachedTokens += costedEvent.accounting.tokens.cachedTokens;
+    } else {
+      unknownTokenEventIds.push(costedEvent.eventId);
+    }
+    if (costedEvent.accounting.cost.status === "known") {
+      costUsd += costedEvent.accounting.cost.usd;
+    } else {
+      costUsd += costedEvent.accounting.cost.knownLowerBoundUsd;
+      unknownCostEventIds.push(costedEvent.eventId);
+    }
+  }
+  const accounting = unknownTokenEventIds.length === 0 && unknownCostEventIds.length === 0 ? {
+    status: "known",
+    inputTokens,
+    outputTokens,
+    cachedTokens,
+    costUsd
+  } : {
+    status: "partial",
+    knownInputTokens: inputTokens,
+    knownOutputTokens: outputTokens,
+    knownCachedTokens: cachedTokens,
+    knownCostUsd: costUsd,
+    unknownTokenEventIds,
+    unknownCostEventIds
+  };
+  const selectedCandidateId = completion?.result.status === "selected" ? completion.result.candidateId : null;
+  const status = completion?.result.status === "selected" ? "selected" : completion?.result.status === "all-rejected" ? "all-rejected" : "in-progress";
+  const missingCandidateSlots = planEvent?.plan.candidateSlots.filter((slot) => !candidateBySlot.has(slot.slotId) && !closedSlots.has(slot.slotId)).map((slot) => slot.slotId) ?? [];
+  const missingTaskOutcomes = planEvent ? plannedTaskOutcomeKeys(planEvent, candidates) : [];
+  const missingOperations = planEvent?.plan.operations.filter((operation) => !operationsById.has(operation.operationId)).map((operation) => operation.operationId) ?? [];
+  return {
+    entries: [...entries],
+    plan: planEvent,
+    candidates: candidateEvents,
+    closedCandidateSlots: closedSlotEvents,
+    attempts,
+    operations: operationEvents,
+    decisions,
+    completion,
+    audit: {
+      campaignId,
+      eventCount: entries.length,
+      candidateCount: candidates.size,
+      closedCandidateSlotCount: closedSlots.size,
+      attemptCount: attempts.length,
+      operationCount: operationEvents.length,
+      outcomes: outcomeCounts,
+      operationOutcomes: operationOutcomeCounts,
+      decisions: {
+        selected: selectedDecisions.length,
+        rejected: rejectedDecisions.length,
+        pending: candidates.size - decisions.length
+      },
+      expected: {
+        candidateSlots: planEvent?.plan.candidateSlots.length ?? 0,
+        taskOutcomes: candidates.size * (planEvent?.plan.tasks.length ?? 0),
+        operations: planEvent?.plan.operations.length ?? 0,
+        missingCandidateSlots,
+        missingTaskOutcomes,
+        missingOperations
+      },
+      status,
+      selectedCandidateId,
+      accounting,
+      headHash: entries.at(-1)?.entryHash ?? null
+    }
+  };
+}
+function plannedTaskOutcomeKeys(planEvent, candidates) {
+  const missing = [];
+  const registeredCandidates = [...candidates.values()].sort(
+    (a, b) => compareStrings(a.registered.slotId, b.registered.slotId)
+  );
+  for (const candidate of registeredCandidates) {
+    const slotId = candidate.registered.slotId;
+    for (const task of planEvent.plan.tasks) {
+      const measured = candidate.attempts.some(
+        (attempt) => attempt.task.taskId === task.taskId && attempt.outcome.status !== "errored"
+      );
+      if (!measured) missing.push(`${slotId}/${task.taskId}`);
+    }
+  }
+  return missing;
+}
+function normalizeEvent(event) {
+  const artifacts = sortArtifacts(event.artifacts);
+  if (event.kind === "search-planned") {
+    return {
+      ...event,
+      artifacts,
+      plan: {
+        candidateSlots: [...event.plan.candidateSlots].sort(
+          (a, b) => compareStrings(a.slotId, b.slotId)
+        ),
+        tasks: [...event.plan.tasks].sort((a, b) => compareStrings(a.taskId, b.taskId)),
+        operations: [...event.plan.operations].sort(
+          (a, b) => compareStrings(a.operationId, b.operationId)
+        )
+      }
+    };
+  }
+  if (event.kind === "candidate-registered") {
+    return {
+      ...event,
+      artifacts,
+      lineage: {
+        ...event.lineage,
+        parentCandidateIds: sortedStrings(event.lineage.parentCandidateIds)
+      },
+      surfaces: [...event.surfaces].map((surface) => ({ ...surface, artifact: { ...surface.artifact } })).sort((a, b) => compareStrings(a.surfaceId, b.surfaceId))
+    };
+  }
+  if (event.kind === "task-attempted") {
+    return {
+      ...event,
+      artifacts,
+      surfaceEvidence: [...event.surfaceEvidence].map((evidence) => ({ ...evidence, evidence: sortArtifacts(evidence.evidence) })).sort((a, b) => compareStrings(a.surfaceId, b.surfaceId))
+    };
+  }
+  return { ...event, artifacts };
+}
+function sortArtifacts(artifacts) {
+  return [...artifacts].map((artifact) => ({ ...artifact })).sort((a, b) => compareStrings(artifactKey(a), artifactKey(b)));
+}
+function artifactKey(artifact) {
+  return canonicalString(artifact);
+}
+function compareStrings(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function sortedStrings(values) {
+  return [...values].sort();
+}
+function assertUnique2(values, label, eventId) {
+  if (new Set(values).size !== values.length) {
+    throw new SearchLedgerIntegrityError(`event ${eventId} contains duplicate ${label} values`);
+  }
+}
+function canonicalString(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function hashCanonical(value) {
+  return `sha256:${createHash6("sha256").update(canonicalString(value)).digest("hex")}`;
+}
+function formatZodError(error) {
+  return error.issues.map((issue) => `${issue.path.length > 0 ? issue.path.join(".") : "<root>"}: ${issue.message}`).join("; ");
+}
+
+// src/campaign/transient-failure.ts
+var BASE_TRANSIENT = /\b50[234]\b|no stream output|produced no stream|admission timed out|admission_rejected|queue_timeout|fetch failed|ECONNRESET|This operation was aborted/i;
+var TIMEOUT_PATTERN = /timeout after \d+ ?ms|cli-bridge timeout/i;
+function isTransientTransportFailure(message, opts = {}) {
+  if (!message) return false;
+  if (BASE_TRANSIENT.test(message)) return true;
+  if ((opts.retryFullDurationTimeouts ?? false) && TIMEOUT_PATTERN.test(message)) return true;
+  for (const p of opts.extraPatterns ?? []) if (p.test(message)) return true;
+  return false;
+}
+
+// src/campaign/worktree/index.ts
+import { execFileSync } from "child_process";
+import { createHash as createHash7 } from "crypto";
+import {
+  closeSync,
+  existsSync as existsSync4,
+  constants as fsConstants,
+  fstatSync,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  mkdtempSync,
+  openSync,
+  readlinkSync,
+  readSync,
+  realpathSync,
+  rmSync
+} from "fs";
+import { devNull, tmpdir } from "os";
+import { basename, dirname, isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve3, sep } from "path";
+var MAX_GIT_OUTPUT_BYTES = 256 * 1024 * 1024;
+var FILE_HASH_CHUNK_BYTES = 1024 * 1024;
+var GIT_REPOSITORY_ENV = /* @__PURE__ */ new Set([
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+  "GIT_COMMON_DIR",
+  "GIT_DIR",
+  "GIT_INDEX_FILE",
+  "GIT_NAMESPACE",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_PREFIX",
+  "GIT_QUARANTINE_PATH",
+  "GIT_WORK_TREE"
+]);
+var WorktreeAdapterError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "WorktreeAdapterError";
+  }
+  cause;
+};
+function defaultGit(args, cwd, overrides) {
+  try {
+    const env = { ...process.env };
+    for (const key of Object.keys(env)) {
+      if (GIT_REPOSITORY_ENV.has(key) || key === "GIT_CONFIG" || key.startsWith("GIT_CONFIG_") || key.startsWith("GIT_ATTR_") || key === "GIT_DIFF_OPTS" || key === "GIT_EXTERNAL_DIFF") {
+        delete env[key];
+      }
+    }
+    Object.assign(env, overrides);
+    env.GIT_NO_REPLACE_OBJECTS = "1";
+    env.LC_ALL = "C";
+    env.LANG = "C";
+    return execFileSync("git", args, { cwd, env, maxBuffer: MAX_GIT_OUTPUT_BYTES });
+  } 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 gitBytes(git, args, cwd, env) {
+  try {
+    const output = git(args, cwd, env);
+    return typeof output === "string" ? Buffer.from(output, "utf8") : Buffer.from(output);
+  } catch (err) {
+    if (err instanceof WorktreeAdapterError) throw err;
+    throw new WorktreeAdapterError(`git ${args.join(" ")} failed: ${String(err)}`, err);
+  }
+}
+function gitText(git, args, cwd, env) {
+  return gitBytes(git, args, cwd, env).toString("utf8").trim();
+}
+function hasRegisteredWorktree(git, repoRoot, path) {
+  const expected = Buffer.from(`worktree ${resolve3(path)}`, "utf8");
+  const records = gitBytes(git, ["worktree", "list", "--porcelain", "-z"], repoRoot);
+  let start = 0;
+  while (start < records.length) {
+    const end = records.indexOf(0, start);
+    if (end < 0) {
+      throw new WorktreeAdapterError("Git worktree list output was not NUL-terminated");
+    }
+    if (records.subarray(start, end).equals(expected)) return true;
+    start = end + 1;
+  }
+  return false;
+}
+function hasLocalBranch(git, repoRoot, branch) {
+  const ref = `refs/heads/${branch}`;
+  return gitText(git, ["for-each-ref", "--format=%(refname)", "--", ref], repoRoot).split("\n").some((candidate) => candidate === ref);
+}
+function reconcileAbsent(exists, remove) {
+  try {
+    if (!exists()) return void 0;
+  } catch (err) {
+    return err;
+  }
+  try {
+    remove();
+    return void 0;
+  } catch (removeError) {
+    try {
+      if (!exists()) return void 0;
+    } catch (recheckError) {
+      return new AggregateError(
+        [removeError, recheckError],
+        "Removal failed and the resulting resource state could not be checked"
+      );
+    }
+    return removeError;
+  }
+}
+function sha2562(bytes) {
+  return `sha256:${createHash7("sha256").update(bytes).digest("hex")}`;
+}
+var PATCH_ARGS = [
+  // Git binary patches embed a zlib stream. Pin no-compression at command
+  // scope so repository/global config and compressor heuristics cannot change
+  // the candidate identity for the same base and final tree.
+  "-c",
+  "core.compression=0",
+  "-c",
+  `core.attributesFile=${devNull}`,
+  "-c",
+  "core.quotePath=true",
+  "-c",
+  "diff.suppressBlankEmpty=false",
+  "diff",
+  "--unified=3",
+  "--inter-hunk-context=0",
+  `-O${devNull}`,
+  "--binary",
+  "--full-index",
+  "--no-color",
+  "--no-ext-diff",
+  "--no-textconv",
+  "--no-renames",
+  "--diff-algorithm=myers",
+  "--no-indent-heuristic",
+  "--src-prefix=a/",
+  "--dst-prefix=b/"
+];
+var CANONICAL_GIT_ENV = {
+  GIT_ATTR_GLOBAL: devNull,
+  GIT_ATTR_NOSYSTEM: "1",
+  GIT_CONFIG_GLOBAL: devNull,
+  GIT_CONFIG_NOSYSTEM: "1",
+  GIT_CONFIG_SYSTEM: devNull
+};
+function patchBytes(git, cwd, baseCommit, candidateCommit) {
+  const scratch = mkdtempSync(join4(tmpdir(), "agent-eval-patch-"));
+  const bareRepo = join4(scratch, "repo.git");
+  const emptyTemplate = join4(scratch, "empty-template");
+  mkdirSync2(emptyTemplate);
+  try {
+    const objectFormat = gitObjectHashAlgorithm(candidateCommit);
+    const sourceObjects = realpathSync(gitText(git, ["rev-parse", "--git-path", "objects"], cwd));
+    gitText(
+      git,
+      [
+        "init",
+        "--bare",
+        "--quiet",
+        ...objectFormat === "sha256" ? ["--object-format=sha256"] : [],
+        `--template=${emptyTemplate}`,
+        bareRepo
+      ],
+      scratch,
+      CANONICAL_GIT_ENV
+    );
+    return gitBytes(
+      git,
+      [`--git-dir=${bareRepo}`, ...PATCH_ARGS, baseCommit, candidateCommit, "--"],
+      scratch,
+      {
+        ...CANONICAL_GIT_ENV,
+        GIT_ALTERNATE_OBJECT_DIRECTORIES: sourceObjects
+      }
+    );
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+function resolveCommit(git, cwd, ref) {
+  return gitText(git, ["rev-parse", "--verify", `${ref}^{commit}`], cwd);
+}
+function unresolvedWorktreePath(surface, worktreeDir) {
+  if (isAbsolute2(surface.worktreeRef)) return surface.worktreeRef;
+  if (worktreeDir) return join4(worktreeDir, basename(surface.worktreeRef));
+  return surface.worktreeRef;
+}
+function displayGitPath(path) {
+  return JSON.stringify(path);
+}
+function parseGitTreeEntries(bytes) {
+  const input = Buffer.from(bytes);
+  const entries = [];
+  let start = 0;
+  while (start < input.length) {
+    const end = input.indexOf(0, start);
+    if (end < 0) throw new WorktreeAdapterError("Git tree output was not NUL-terminated");
+    const record = input.subarray(start, end);
+    start = end + 1;
+    if (record.length === 0) continue;
+    const tab = record.indexOf(9);
+    if (tab < 0) throw new WorktreeAdapterError("Git tree entry did not contain a path");
+    const metadata = record.subarray(0, tab).toString("ascii").split(" ");
+    if (metadata.length !== 3) throw new WorktreeAdapterError("Git tree entry was malformed");
+    const mode = metadata[0];
+    const type = metadata[1];
+    const objectId = metadata[2];
+    if (!mode || !type || !objectId) {
+      throw new WorktreeAdapterError("Git tree entry was malformed");
+    }
+    const pathBytes = record.subarray(tab + 1);
+    const path = pathBytes.toString("utf8");
+    if (!Buffer.from(path, "utf8").equals(pathBytes)) {
+      throw new WorktreeAdapterError("CodeSurface paths must be valid UTF-8");
+    }
+    if (type !== "blob" && type !== "commit") {
+      throw new WorktreeAdapterError(
+        `CodeSurface contains unsupported Git object type ${type} at ${displayGitPath(path)}`
+      );
+    }
+    entries.push({ mode, objectId, path });
+  }
+  return entries;
+}
+function parseGitPathList(bytes) {
+  const input = Buffer.from(bytes);
+  const paths = [];
+  let start = 0;
+  while (start < input.length) {
+    const end = input.indexOf(0, start);
+    if (end < 0) throw new WorktreeAdapterError("Git path output was not NUL-terminated");
+    const pathBytes = input.subarray(start, end);
+    start = end + 1;
+    if (pathBytes.length === 0) continue;
+    const path = pathBytes.toString("utf8");
+    if (!Buffer.from(path, "utf8").equals(pathBytes)) {
+      throw new WorktreeAdapterError("CodeSurface paths must be valid UTF-8");
+    }
+    paths.push(path);
+  }
+  return paths;
+}
+function isWithinRoot(root, candidate) {
+  const rel = relative2(root, candidate);
+  return rel === "" || !isAbsolute2(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
+}
+function assertSafeRelativePath(root, path) {
+  if (path.length === 0 || isAbsolute2(path)) {
+    throw new WorktreeAdapterError(`CodeSurface contains unsafe path ${displayGitPath(path)}`);
+  }
+  const absolutePath = resolve3(root, path);
+  if (!isWithinRoot(root, absolutePath) || absolutePath === root) {
+    throw new WorktreeAdapterError(`CodeSurface path escapes its worktree: ${displayGitPath(path)}`);
+  }
+  const segments = path.split(/[\\/]/u);
+  let parent = root;
+  for (const segment of segments.slice(0, -1)) {
+    if (segment.length === 0 || segment === "." || segment === "..") {
+      throw new WorktreeAdapterError(`CodeSurface contains unsafe path ${displayGitPath(path)}`);
+    }
+    parent = join4(parent, segment);
+    const stat = lstatSync(parent);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+      throw new WorktreeAdapterError(
+        `CodeSurface path traverses a non-directory or symbolic link: ${displayGitPath(path)}`
+      );
+    }
+  }
+  return absolutePath;
+}
+function gitObjectHashAlgorithm(objectId) {
+  if (/^[a-f0-9]{40}$/.test(objectId)) return "sha1";
+  if (/^[a-f0-9]{64}$/.test(objectId)) return "sha256";
+  throw new WorktreeAdapterError(`Unsupported Git object id: ${objectId}`);
+}
+function hashGitBlobBytes(bytes, objectId) {
+  const hash = createHash7(gitObjectHashAlgorithm(objectId));
+  hash.update(`blob ${bytes.byteLength}\0`);
+  hash.update(bytes);
+  return hash.digest("hex");
+}
+function hashGitBlobFile(path, objectId) {
+  const before = lstatSync(path);
+  if (!before.isFile() || before.isSymbolicLink()) {
+    throw new WorktreeAdapterError(`CodeSurface expected a regular file at ${displayGitPath(path)}`);
+  }
+  const noFollow = process.platform === "win32" ? 0 : fsConstants.O_NOFOLLOW;
+  const fd = openSync(path, fsConstants.O_RDONLY | noFollow);
+  try {
+    const opened = fstatSync(fd);
+    if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino || opened.size !== before.size) {
+      throw new WorktreeAdapterError(
+        `CodeSurface file changed while it was being verified: ${displayGitPath(path)}`
+      );
+    }
+    const hash = createHash7(gitObjectHashAlgorithm(objectId));
+    hash.update(`blob ${opened.size}\0`);
+    const chunk = Buffer.allocUnsafe(FILE_HASH_CHUNK_BYTES);
+    let total = 0;
+    while (true) {
+      const count = readSync(fd, chunk, 0, chunk.length, null);
+      if (count === 0) break;
+      total += count;
+      hash.update(chunk.subarray(0, count));
+    }
+    if (total !== opened.size) {
+      throw new WorktreeAdapterError(
+        `CodeSurface file changed while it was being verified: ${displayGitPath(path)}`
+      );
+    }
+    return { hash: hash.digest("hex"), executable: (opened.mode & 73) !== 0 };
+  } finally {
+    closeSync(fd);
+  }
+}
+function assertSymlinkTargetIsBound(root, linkPath, trackedPaths) {
+  const targetBytes = readlinkSync(linkPath, { encoding: "buffer" });
+  const target = targetBytes.toString("utf8");
+  if (!Buffer.from(target, "utf8").equals(targetBytes)) {
+    throw new WorktreeAdapterError(
+      `CodeSurface symbolic link has an unsafe target at ${displayGitPath(linkPath)}`
+    );
+  }
+  if (isAbsolute2(target)) {
+    throw new WorktreeAdapterError(
+      `CodeSurface symbolic link escapes its worktree at ${displayGitPath(linkPath)}`
+    );
+  }
+  const lexicalTarget = resolve3(dirname(linkPath), target);
+  if (!isWithinRoot(root, lexicalTarget)) {
+    throw new WorktreeAdapterError(
+      `CodeSurface symbolic link escapes its worktree at ${displayGitPath(linkPath)}`
+    );
+  }
+  let resolvedTarget;
+  try {
+    resolvedTarget = realpathSync(linkPath);
+  } catch (err) {
+    throw new WorktreeAdapterError(
+      `CodeSurface symbolic link target is missing or cyclic at ${displayGitPath(linkPath)}`,
+      err
+    );
+  }
+  if (!isWithinRoot(root, resolvedTarget)) {
+    throw new WorktreeAdapterError(
+      `CodeSurface symbolic link escapes its worktree at ${displayGitPath(linkPath)}`
+    );
+  }
+  const targetRelative = relative2(root, resolvedTarget).split(sep).join("/");
+  const targetIsTracked = trackedPaths.has(targetRelative) || [...trackedPaths].some((trackedPath) => trackedPath.startsWith(`${targetRelative}/`));
+  if (!targetIsTracked) {
+    throw new WorktreeAdapterError(
+      `CodeSurface symbolic link resolves to untracked content at ${displayGitPath(linkPath)}`
+    );
+  }
+}
+function assertRawTreeMatchesWorktree(git, root, candidateCommit) {
+  const entries = parseGitTreeEntries(
+    gitBytes(git, ["ls-tree", "-r", "-z", "--full-tree", candidateCommit], root)
+  );
+  const trackedPaths = new Set(entries.map((entry) => entry.path));
+  for (const entry of entries) {
+    const absolutePath = assertSafeRelativePath(root, entry.path);
+    if (entry.mode === "160000" || entry.mode === "040000") {
+      throw new WorktreeAdapterError(
+        `CodeSurface contains a Git submodule whose executable bytes are not bound: ${displayGitPath(entry.path)}`
+      );
+    }
+    if (entry.mode === "120000") {
+      const stat = lstatSync(absolutePath);
+      if (!stat.isSymbolicLink()) {
+        throw new WorktreeAdapterError(
+          `CodeSurface expected a symbolic link at ${displayGitPath(entry.path)}`
+        );
+      }
+      const targetBytes = readlinkSync(absolutePath, { encoding: "buffer" });
+      const actualObjectId = hashGitBlobBytes(targetBytes, entry.objectId);
+      if (actualObjectId !== entry.objectId) {
+        throw new WorktreeAdapterError(
+          `CodeSurface raw symbolic-link bytes differ from the candidate tree at ${displayGitPath(entry.path)}`
+        );
+      }
+      assertSymlinkTargetIsBound(root, absolutePath, trackedPaths);
+      continue;
+    }
+    if (entry.mode !== "100644" && entry.mode !== "100755") {
+      throw new WorktreeAdapterError(
+        `CodeSurface contains unsupported Git mode ${entry.mode} at ${displayGitPath(entry.path)}`
+      );
+    }
+    const actual = hashGitBlobFile(absolutePath, entry.objectId);
+    if (actual.hash !== entry.objectId) {
+      throw new WorktreeAdapterError(
+        `CodeSurface raw tracked bytes differ from the candidate tree because the worktree changed after finalization at ${displayGitPath(entry.path)}`
+      );
+    }
+    if (process.platform !== "win32" && actual.executable !== (entry.mode === "100755")) {
+      throw new WorktreeAdapterError(
+        `CodeSurface executable mode differs from the candidate tree at ${displayGitPath(entry.path)}`
+      );
+    }
+  }
+}
+function verifyCodeSurfaceWithGit(surface, path, git) {
+  assertCodeSurfaceIdentity(surface);
+  if (!existsSync4(path)) {
+    throw new WorktreeAdapterError(`CodeSurface worktree does not exist: ${path}`);
+  }
+  const lexicalRoot = resolve3(path);
+  const canonicalRoot = realpathSync(path);
+  if (lstatSync(lexicalRoot).isSymbolicLink() || process.platform !== "win32" && lexicalRoot !== canonicalRoot) {
+    throw new WorktreeAdapterError(
+      `CodeSurface worktree locator must not contain a symbolic link: ${path}`
+    );
+  }
+  const repoRoot = gitText(git, ["rev-parse", "--show-toplevel"], path);
+  const canonicalRepoRoot = realpathSync(repoRoot);
+  if (canonicalRepoRoot !== canonicalRoot) {
+    throw new WorktreeAdapterError(
+      `CodeSurface worktree locator is not the repository root: expected ${repoRoot}, got ${path}`
+    );
+  }
+  const indexFlags = gitText(git, ["ls-files", "-v"], path).split("\n").filter((line) => line.length > 0 && (line.startsWith("S ") || /^[a-z]/.test(line)));
+  if (indexFlags.length > 0) {
+    throw new WorktreeAdapterError(
+      `CodeSurface worktree uses hidden index entries that cannot be verified: ${path}
+${indexFlags.join("\n")}`
+    );
+  }
+  const extraPaths = [
+    ...parseGitPathList(gitBytes(git, ["ls-files", "--others", "--exclude-standard", "-z"], path)),
+    ...parseGitPathList(
+      gitBytes(git, ["ls-files", "--others", "--ignored", "--exclude-standard", "-z"], path)
+    )
+  ];
+  if (extraPaths.length > 0) {
+    throw new WorktreeAdapterError(
+      `CodeSurface worktree changed after finalization: ${path}
+${extraPaths.join("\n")}`
+    );
+  }
+  const candidateCommit = resolveCommit(git, path, "HEAD");
+  if (candidateCommit !== surface.candidateCommit) {
+    throw new WorktreeAdapterError(
+      `CodeSurface candidate commit mismatch: expected ${surface.candidateCommit}, got ${candidateCommit}`
+    );
+  }
+  const baseCommit = resolveCommit(git, path, surface.baseCommit);
+  if (baseCommit !== surface.baseCommit) {
+    throw new WorktreeAdapterError(
+      `CodeSurface base commit mismatch: expected ${surface.baseCommit}, got ${baseCommit}`
+    );
+  }
+  const baseTree = gitText(git, ["rev-parse", "--verify", `${surface.baseCommit}^{tree}`], path);
+  if (baseTree !== surface.baseTree) {
+    throw new WorktreeAdapterError(
+      `CodeSurface base tree mismatch: expected ${surface.baseTree}, got ${baseTree}`
+    );
+  }
+  const candidateTree = gitText(
+    git,
+    ["rev-parse", "--verify", `${surface.candidateCommit}^{tree}`],
+    path
+  );
+  if (candidateTree !== surface.candidateTree) {
+    throw new WorktreeAdapterError(
+      `CodeSurface tree mismatch: expected ${surface.candidateTree}, got ${candidateTree}`
+    );
+  }
+  try {
+    gitText(
+      git,
+      [
+        "diff-index",
+        "--cached",
+        "--quiet",
+        "--no-ext-diff",
+        "--no-textconv",
+        surface.candidateCommit,
+        "--"
+      ],
+      path
+    );
+  } catch (err) {
+    throw new WorktreeAdapterError(
+      `CodeSurface index differs from finalized candidate: ${path}`,
+      err
+    );
+  }
+  try {
+    assertRawTreeMatchesWorktree(git, canonicalRepoRoot, surface.candidateCommit);
+  } catch (err) {
+    if (err instanceof WorktreeAdapterError) throw err;
+    throw new WorktreeAdapterError(`CodeSurface raw tree verification failed: ${path}`, err);
+  }
+  const mergeBase = gitText(git, ["merge-base", surface.baseCommit, surface.candidateCommit], path);
+  if (mergeBase !== surface.baseCommit) {
+    throw new WorktreeAdapterError(
+      `CodeSurface candidate ${surface.candidateCommit} does not descend from base ${surface.baseCommit}`
+    );
+  }
+  const patch = patchBytes(git, path, surface.baseCommit, surface.candidateCommit);
+  const actualPatchHash = sha2562(patch);
+  if (actualPatchHash !== surface.patch.sha256 || patch.byteLength !== surface.patch.byteLength) {
+    throw new WorktreeAdapterError(
+      `CodeSurface patch mismatch: expected ${surface.patch.sha256}/${surface.patch.byteLength} bytes, got ${actualPatchHash}/${patch.byteLength} bytes`
+    );
+  }
+  return {
+    path,
+    repoRoot: canonicalRepoRoot,
+    contentHash: surfaceContentHash(surface),
+    patchBytes: new Uint8Array(patch)
+  };
+}
+function slug(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 ?? join4(opts.repoRoot, ".worktrees");
+  const branchPrefix = opts.branchPrefix ?? "improve";
+  return {
+    async create({ baseRef, label }) {
+      const id = `${slug(label)}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+      const branch = `${branchPrefix}/${id}`;
+      const path = join4(worktreeDir, id);
+      const baseCommit = resolveCommit(git, opts.repoRoot, baseRef);
+      const baseTree = gitText(
+        git,
+        ["rev-parse", "--verify", `${baseCommit}^{tree}`],
+        opts.repoRoot
+      );
+      gitText(git, ["worktree", "add", "-b", branch, path, baseCommit], opts.repoRoot);
+      return { path, branch, baseRef, baseCommit, baseTree };
+    },
+    async finalize(worktree, summary) {
+      const status = gitText(
+        git,
+        ["status", "--porcelain=v1", "--untracked-files=all"],
+        worktree.path
+      );
+      if (status.length > 0) {
+        gitText(git, ["add", "-A"], worktree.path);
+        gitText(git, ["commit", "-m", summary], worktree.path);
+      }
+      const candidateCommit = resolveCommit(git, worktree.path, "HEAD");
+      const candidateTree = gitText(
+        git,
+        ["rev-parse", "--verify", `${candidateCommit}^{tree}`],
+        worktree.path
+      );
+      const patch = patchBytes(git, worktree.path, worktree.baseCommit, candidateCommit);
+      const surface = {
+        kind: "code",
+        worktreeRef: worktree.path,
+        baseRef: worktree.baseRef,
+        baseCommit: worktree.baseCommit,
+        baseTree: worktree.baseTree,
+        candidateCommit,
+        candidateTree,
+        patch: {
+          format: "git-diff-binary",
+          sha256: sha2562(patch),
+          byteLength: patch.byteLength
+        },
+        summary
+      };
+      verifyCodeSurfaceWithGit(surface, worktree.path, git);
+      return surface;
+    },
+    async discard(worktree) {
+      const failures = [
+        reconcileAbsent(
+          () => hasRegisteredWorktree(git, opts.repoRoot, worktree.path),
+          () => gitText(git, ["worktree", "remove", "--force", "--", worktree.path], opts.repoRoot)
+        ),
+        reconcileAbsent(
+          () => hasLocalBranch(git, opts.repoRoot, worktree.branch),
+          () => gitText(git, ["branch", "-D", "--", worktree.branch], opts.repoRoot)
+        )
+      ].filter((failure) => failure !== void 0);
+      if (failures.length > 0) {
+        const cause = failures.length === 1 ? failures[0] : new AggregateError(failures, "Multiple Git resources could not be removed");
+        throw new WorktreeAdapterError(
+          `Failed to discard worktree ${worktree.path} and branch ${worktree.branch}`,
+          cause
+        );
+      }
+    }
+  };
+}
+function verifyCodeSurface(surface, worktreeDir) {
+  const path = unresolvedWorktreePath(surface, worktreeDir);
+  return verifyCodeSurfaceWithGit(surface, path, defaultGit);
+}
+function resolveWorktreePath(surface, worktreeDir) {
+  return verifyCodeSurface(surface, worktreeDir).path;
+}
+
+export {
+  pairArms,
+  comparePairedArms,
+  completionVerdict,
+  verifyCompletion,
+  parseCorrectnessResponse,
+  createLlmCorrectnessChecker,
+  createTokenRecallChecker,
+  extractProducedState,
+  CODING_HARNESSES,
+  HARNESS_NATIVE_MODEL,
+  expandProfileAxes,
+  harnessAxisOf,
+  agentProfileId,
+  agentProfileModelId,
+  agentProfileHash,
+  buildAnalystSurfaceDispatch,
+  failureModeRecallJudge,
+  analyzeCrossSurfaceInteractions,
+  discoverEvalFixtures,
+  loadEvalFixture,
+  loadEvalFixtureScenarios,
+  planEvalFixtureRun,
+  neutralizationGate,
+  sequentialPairedGate,
+  sequentialDecide,
+  rolloutArgumentDiff,
+  classifyUngroundedLiterals,
+  LabeledScenarioStoreError,
+  FsLabeledScenarioStore,
+  neutralizeText,
+  makePlaybackDispatch,
+  scoreUserStory,
+  userStoryScoreboard,
+  scoreboardSummary,
+  renderScoreboardMarkdown,
+  ProfileMatrixError,
+  runProfileMatrix,
+  scoreDiscrimination,
+  selectDiscriminative,
+  SEARCH_LEDGER_SCHEMA,
+  validateSearchLedgerEvent,
+  openSearchLedger,
+  FileSearchLedger,
+  isTransientTransportFailure,
+  WorktreeAdapterError,
+  gitWorktreeAdapter,
+  verifyCodeSurface,
+  resolveWorktreePath
+};
+//# sourceMappingURL=chunk-NGUYT5CI.js.map