@tangle-network/agent-eval 0.128.2 → 0.130.0

package/dist/chunk-UB2LOJ6Q.js

@@ -1,4461 +0,0 @@
-import {
-  JudgeParseError,
-  assertCodeSurfaceIdentity,
-  costReceiptFromTCloud,
-  labelTrustRank,
-  maximumChargeForTCloudRequest,
-  pairHoldout,
-  recoverTruncatedJson,
-  surfaceContentHash
-} from "./chunk-NKAGIDE2.js";
-import {
-  SearchLedgerConflictError,
-  SearchLedgerError,
-  SearchLedgerIntegrityError,
-  appendSearchLedgerLine,
-  assertRealBackend,
-  contentHash,
-  planCampaignRun,
-  runCampaign,
-  summarizeBackendIntegrity,
-  withSearchLedgerFileLock
-} from "./chunk-EZJEIH2R.js";
-import {
-  Mutex
-} from "./chunk-WGXIEX7P.js";
-import {
-  campaignCellToRunRecord
-} from "./chunk-2MKQIFS4.js";
-import {
-  comparePairedArms
-} from "./chunk-DPUHNQLN.js";
-import {
-  eProcess,
-  mulberry32,
-  pairedBootstrap
-} from "./chunk-MHELPNRP.js";
-import {
-  CostLedger
-} from "./chunk-WS3NZZQQ.js";
-import {
-  analyzeTraces
-} from "./chunk-5DTSBUL2.js";
-import {
-  buildAgentProfileCell,
-  canonicalize,
-  modelHasSnapshot,
-  runTaskScore,
-  validateRunRecord
-} from "./chunk-2JX3CFMB.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/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",
-              status: "fail",
-              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",
-            status: passed ? "pass" : "fail",
-            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, status: "not_evaluated", detail }]
-        };
-      }
-      const decision = last.decision === "promote" ? "ship" : last.decision === "continue" ? "need_more_work" : "hold";
-      return {
-        decision,
-        reasons: [`${name}: ${last.reason}`],
-        contributingGates: [
-          {
-            name,
-            status: decision === "ship" ? "pass" : decision === "need_more_work" ? "not_evaluated" : "fail",
-            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, candidate) => {
-      if (best.composite === null) return candidate;
-      if (candidate.composite === null) return best;
-      return candidate.composite > best.composite ? candidate : 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 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 record = campaignCellToRunRecord(cell, {
-    runId: `${matrixId}:${profileId}:${cell.cellId}`,
-    experimentId,
-    candidateId: profileId,
-    model,
-    promptHash: profileHash,
-    configHash,
-    commitSha,
-    splitTag,
-    agentProfile: args.agentProfileCell
-  });
-  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: null,
-        costProvenance: { kind: "uncaptured", usd: null },
-        tokenUsage: { input: 0, output: 0 },
-        terminalOutcome: "succeeded",
-        outcome: { raw: { execution_error_count: 0 } },
-        splitTag,
-        scenarioId: "recordability-probe"
-      });
-    } 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: meanOrNull2(
-        profileRecords.map(scoreOf).filter((score) => score !== void 0)
-      ),
-      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 scoreOf(r) {
-  return runTaskScore(r);
-}
-function meanOrNull2(values) {
-  return values.length === 0 ? null : mean2(values);
-}
-function rollup(records, keyOf) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const r of records) {
-    const key = keyOf(r);
-    if (key === void 0) continue;
-    const score = scoreOf(r);
-    if (score === void 0) continue;
-    const arr = groups.get(key) ?? [];
-    arr.push(score);
-    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?.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 {
-  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-UB2LOJ6Q.js.map