@tangle-network/agent-eval 0.173.3 → 0.175.0

package/dist/index-CFDffsKz.d.ts

@@ -1,1135 +0,0 @@
-import { c as ValidationError, t as AgentEvalError } from "./errors-DEE6u6ot.js";
-import { T as RunPaidCallInput, p as CostProvenance } from "./cost-ledger-DbQdN3nO.js";
-import { a as RunRecord, s as RunSplitTag } from "./run-record-DTv1MdjK.js";
-import { f as AnalystUsageReceipt, i as AnalystFinding, l as AnalystRunResult, w as TraceAnalysisStore } from "./types-DN2WdT5S.js";
-import { _ as PairedArmsComparison } from "./pre-registration-BoI4ucR3.js";
-import { d as PairedBootstrapResult } from "./paired-promotion-decision-CGzg0cI_.js";
-import { A as LabeledScenarioWrite, D as LabeledScenarioSampleArgs, E as LabeledScenarioRecord, O as LabeledScenarioSource, R as Scenario, S as JudgeConfig, T as LabelTrust, a as CampaignResult, d as DispatchContext, j as MutableSurface, k as LabeledScenarioStore, l as CodeSurface, p as Gate, u as ComponentSurface } from "./types-Ba5UQyVD.js";
-import "./heldout-gate-Df5hsqmm.js";
-import { In as CampaignRunPlan, Kn as CampaignStorage, Rn as PlanCampaignRunOptions } from "./provenance-CRY67X50.js";
-import "./promotion-policy-CvMda3kU.js";
-import { d as CompletionVerdict, f as CorrectnessChecker, h as ProducedState, n as BackendIntegrityReport, s as RuntimeEventLike, u as CompletionRequirement } from "./backend-integrity-CeuTgqsd.js";
-import { _ as AnalystIssueExpectation, a as AnalystBenchmarkLabelState, t as AnalystBenchmarkCase } from "./benchmark-BjLGkfnN.js";
-import { t as AgentProfile$1 } from "./agent-profile-B9_GGsG8.js";
-import "./statistical-heldout-DTyB_6-1.js";
-import { AgentProfile } from "@tangle-network/agent-interface";
-//#region src/campaign/search-ledger-errors.d.ts
-/** Base error for invalid search-ledger input or operations. */
-declare class SearchLedgerError extends ValidationError {}
-/** Error raised when durable search-ledger data fails an integrity check. */
-declare class SearchLedgerIntegrityError extends SearchLedgerError {}
-/** Error raised when an event identifier is reused with different content. */
-declare class SearchLedgerConflictError extends SearchLedgerError {}
-//#endregion
-//#region src/campaign/analyst-surface.d.ts
-interface TraceAnalystScenario extends Scenario {
-  kind: 'trace-analyst';
-  traceStore: TraceAnalysisStore;
-  labelState: AnalystBenchmarkLabelState;
-  expectedIssues: readonly AnalystIssueExpectation[];
-  labeledEvidence?: AnalystBenchmarkCase['labeledEvidence'];
-}
-interface TraceAnalystArtifact {
-  findings: readonly AnalystFinding[];
-  usage?: AnalystUsageReceipt;
-  run?: AnalystRunResult;
-}
-interface BuildTraceAnalystSurfaceDispatchOptions {
-  analyze(input: {
-    instructions: string;
-    traceStore: TraceAnalysisStore;
-    runId: string;
-    signal: AbortSignal;
-  }): Promise<TraceAnalystArtifact>;
-}
-declare function buildTraceAnalystSurfaceDispatch(options: BuildTraceAnalystSurfaceDispatchOptions): (surface: MutableSurface, scenario: TraceAnalystScenario, context: DispatchContext) => Promise<TraceAnalystArtifact>;
-declare function traceAnalystQualityJudge(): JudgeConfig<TraceAnalystArtifact, TraceAnalystScenario>;
-//#endregion
-//#region src/campaign/cross-surface-types.d.ts
-/** Whether one candidate attempt produced a usable executable outcome. */
-type CrossSurfaceAttemptCompleteness = 'complete' | 'missing' | 'invalid';
-/** One independently proposed change on one caller-defined surface. */
-interface CrossSurfaceComponent {
-  componentId: string;
-  surfaceId: string;
-  /** Explicitly controls whether this component may anchor the best-single arm. */
-  bestSingleEligible: boolean;
-}
-/** Immutable identity for a single candidate or a materialized composition. */
-interface CrossSurfaceCandidate {
-  candidateId: string;
-  componentIds: string[];
-  contentHash: string;
-  artifactBytes: number;
-}
-/** Per-component trace evidence captured during one task attempt. */
-interface CrossSurfaceComponentEvidence {
-  componentId: string;
-  /** null means the trace could not establish whether the component fired. */
-  fired: boolean | null;
-  /** null means the trace could not establish whether the component changed behavior. */
-  effectObserved: boolean | null;
-}
-/**
- * Canonical per-task input row. Consumers may extend this interface with
- * receipt, trace, retry, or failure details; the report preserves the original
- * row object rather than projecting those details away.
- */
-interface CrossSurfaceTaskRow {
-  taskId: string;
-  candidateId: string;
-  /** Repeated here so every persisted row remains self-describing. */
-  componentIds: string[];
-  completeness: CrossSurfaceAttemptCompleteness;
-  pass: boolean | null;
-  score: number | null;
-  /**
-   * Per-attempt deployment measurements. Every declared metric must have a
-   * known, non-negative value. Proposal, analysis, and selection spend belongs
-   * in the search ledger rather than being spread across task cells.
-   */
-  cost: Record<string, number | null>;
-  componentEvidence: CrossSurfaceComponentEvidence[];
-  /** Required for missing or invalid attempts; forbidden for complete attempts. */
-  rejectReason: string | null;
-}
-interface CrossSurfaceBootstrapPolicy {
-  seed: number;
-  resamples: number;
-  confidence: number;
-}
-/** Predeclared candidate eligibility and composition policy. */
-interface CrossSurfaceSelectionPolicy {
-  minimumFiringTasks: number;
-  minimumEffectTasks: number;
-  requireObservedFiring: boolean;
-  requireObservedEffect: boolean;
-  /** Only named metrics are constrained; all declared metrics are still reported. */
-  maximumMedianCostRatioToBaseline: Record<string, number>;
-  /** A smaller terminal bundle is reported but cannot become the selected arm. */
-  minimumBundleComponents: number;
-}
-interface AnalyzeCrossSurfaceInteractionsInput<TRow extends CrossSurfaceTaskRow = CrossSurfaceTaskRow> {
-  components: readonly CrossSurfaceComponent[];
-  candidates: readonly CrossSurfaceCandidate[];
-  rows: readonly TRow[];
-  baselineCandidateId: string;
-  /** Exact shared task axis and its canonical output order. */
-  taskOrder: readonly string[];
-  /** Canonical materialization order for component sets and the naive stack. */
-  componentOrder: readonly string[];
-  /** Final deterministic tie-break; lower index wins. */
-  candidateOrder: readonly string[];
-  /** Declares every cost key and the order used for cost tie-breaks. */
-  costMetricOrder: readonly string[];
-  bootstrap: CrossSurfaceBootstrapPolicy;
-  selection: CrossSurfaceSelectionPolicy;
-}
-interface CrossSurfaceDistribution {
-  n: number;
-  min: number;
-  median: number;
-  mean: number;
-  max: number;
-  total: number;
-}
-interface CrossSurfaceEvidenceBreakdown {
-  componentId: string;
-  observedTaskIds: string[];
-  notObservedTaskIds: string[];
-  unobservedTaskIds: string[];
-}
-interface CrossSurfaceCandidateEvidence {
-  byComponent: CrossSurfaceEvidenceBreakdown[];
-  allObservedTaskIds: string[];
-  someObservedTaskIds: string[];
-  noneObservedTaskIds: string[];
-  unobservedTaskIds: string[];
-}
-type CrossSurfaceIneligibilityReason = 'missing_attempt' | 'invalid_attempt' | 'baseline_outcome_missing' | 'benefit_not_greater_than_regression' | 'firing_below_minimum' | 'firing_unobserved' | 'effect_below_minimum' | 'effect_unobserved' | 'cost_limit_exceeded';
-interface CrossSurfaceEligibility {
-  eligible: boolean;
-  reasons: CrossSurfaceIneligibilityReason[];
-}
-interface CrossSurfaceCandidateOutcome {
-  resolvedTaskIds: string[];
-  failedTaskIds: string[];
-  missingTaskIds: string[];
-  invalidTaskIds: string[];
-  benefitTaskIds: string[];
-  regressionTaskIds: string[];
-  comparisonMissingTaskIds: string[];
-  netBenefit: number;
-}
-interface CrossSurfaceCandidateSummary {
-  candidate: CrossSurfaceCandidate;
-  outcome: CrossSurfaceCandidateOutcome;
-  score: CrossSurfaceDistribution | null;
-  costs: Record<string, CrossSurfaceDistribution>;
-  firing: CrossSurfaceCandidateEvidence;
-  effect: CrossSurfaceCandidateEvidence;
-  /** Reuses the package's paired McNemar/risk-difference/bootstrap statistics. */
-  comparisonToBaseline: PairedArmsComparison | null;
-  /** null only for the fixed baseline. */
-  eligibility: CrossSurfaceEligibility | null;
-}
-interface CrossSurfaceRelativeCost {
-  treatmentMedian: number;
-  comparatorMedian: number;
-  medianDelta: number;
-  /** null when the comparator median is zero but the treatment median is not. */
-  medianRatio: number | null;
-}
-interface CrossSurfaceCandidateComparison {
-  comparatorCandidateId: string;
-  treatmentCandidateId: string;
-  winsTaskIds: string[];
-  regressionTaskIds: string[];
-  missingTaskIds: string[];
-  paired: PairedArmsComparison;
-  relativeCost: Record<string, CrossSurfaceRelativeCost>;
-}
-interface CrossSurfacePairEvidence {
-  bothTaskIds: string[];
-  leftOnlyTaskIds: string[];
-  rightOnlyTaskIds: string[];
-  neitherTaskIds: string[];
-  unobservedTaskIds: string[];
-}
-interface CrossSurfaceInteractionTask {
-  taskId: string;
-  /** Composition minus the additive expectation from the baseline and singles. */
-  passInteraction: number | null;
-  scoreInteraction: number | null;
-}
-interface CrossSurfaceInteractionEffect {
-  perTask: CrossSurfaceInteractionTask[];
-  n: number;
-  nMissing: number;
-  meanPassInteraction: number | null;
-  meanScoreInteraction: number | null;
-  passBootstrap: PairedBootstrapResult | null;
-  scoreBootstrap: PairedBootstrapResult | null;
-}
-type CrossSurfacePairIncompatibilityReason = 'constituent_not_ready' | 'pair_incomplete' | 'baseline_regression' | 'interference' | 'no_incremental_resolution' | 'firing_below_minimum' | 'firing_unobserved' | 'effect_below_minimum' | 'effect_unobserved' | 'cost_limit_exceeded';
-interface CrossSurfacePairCompatibility {
-  compatible: boolean;
-  reasons: CrossSurfacePairIncompatibilityReason[];
-  betterSingleCandidateId: string;
-}
-interface CrossSurfacePairwiseEntry {
-  componentIds: [string, string];
-  singleCandidateIds: [string, string];
-  compositionCandidateId: string;
-  benefitTaskIds: string[];
-  regressionTaskIds: string[];
-  synergyTaskIds: string[];
-  interferenceTaskIds: string[];
-  incrementalVsConstituents: [CrossSurfaceCandidateComparison, CrossSurfaceCandidateComparison];
-  relativeCostToBaseline: Record<string, CrossSurfaceRelativeCost>;
-  firing: CrossSurfacePairEvidence;
-  effect: CrossSurfacePairEvidence;
-  interaction: CrossSurfaceInteractionEffect;
-  compatibility: CrossSurfacePairCompatibility;
-}
-interface CrossSurfaceRankedSingle {
-  rank: number;
-  candidateId: string;
-  componentId: string;
-}
-interface CrossSurfaceBestSingleSelection {
-  candidateId: string;
-  componentId: string;
-  ranking: CrossSurfaceRankedSingle[];
-}
-interface CrossSurfaceNaiveStackSelection {
-  /** Every individually eligible single, stacked in canonical component order. */
-  candidateId: string;
-  componentIds: string[];
-}
-type CrossSurfaceAdditionRejectionReason = 'pair_incompatible' | 'full_bundle_not_evaluated' | 'bundle_incomplete' | 'baseline_regression' | 'no_incremental_resolution' | 'incremental_regression' | 'firing_below_minimum' | 'firing_unobserved' | 'effect_below_minimum' | 'effect_unobserved' | 'cost_limit_exceeded';
-interface CrossSurfaceAdditionDecision {
-  additionCandidateId: string;
-  additionComponentId: string;
-  bundleCandidateId: string | null;
-  incrementalResolutionTaskIds: string[];
-  incrementalRegressionTaskIds: string[];
-  incrementalMedianCost: Record<string, number> | null;
-  eligible: boolean;
-  selected: boolean;
-  reasons: CrossSurfaceAdditionRejectionReason[];
-}
-interface CrossSurfaceCompositionStep {
-  fromCandidateId: string;
-  retainedComponentIds: string[];
-  considered: CrossSurfaceAdditionDecision[];
-  selectedCandidateId: string | null;
-}
-/** One deterministic growth path starting from a compatible two-surface seed. */
-interface CrossSurfaceInteractionPath {
-  seedCandidateId: string;
-  terminalCandidateId: string;
-  terminalComponentIds: string[];
-  qualified: boolean;
-  steps: CrossSurfaceCompositionStep[];
-}
-interface CrossSurfaceInteractionAwareSelection {
-  /** Compatible pair that seeded the selected deterministic growth path. */
-  seedCandidateId: string;
-  /** Candidate reached by the winning path, even if the minimum size is not met. */
-  terminalCandidateId: string;
-  terminalComponentIds: string[];
-  /** null when no path produced a qualifying multi-component bundle. */
-  selectedCandidateId: string | null;
-  qualified: boolean;
-  /** Every compatible pair seed is retained so seed choice cannot hide an interaction. */
-  evaluatedPaths: CrossSurfaceInteractionPath[];
-  /** Convenience alias for the winning path's steps. */
-  steps: CrossSurfaceCompositionStep[];
-}
-interface CrossSurfaceSelections {
-  bestSingle: CrossSurfaceBestSingleSelection | null;
-  naiveStack: CrossSurfaceNaiveStackSelection | null;
-  interactionAware: CrossSurfaceInteractionAwareSelection | null;
-}
-interface CrossSurfaceInteractionReport<TRow extends CrossSurfaceTaskRow = CrossSurfaceTaskRow> {
-  taskIds: string[];
-  componentIds: string[];
-  candidateIds: string[];
-  costMetrics: string[];
-  /** Canonical candidate × task order; no input row is dropped. */
-  rows: TRow[];
-  missingAttempts: TRow[];
-  invalidAttempts: TRow[];
-  candidates: CrossSurfaceCandidateSummary[];
-  pairwise: CrossSurfacePairwiseEntry[];
-  selections: CrossSurfaceSelections;
-}
-//#endregion
-//#region src/campaign/cross-surface-interaction.d.ts
-/**
- * Build the complete cross-surface evidence matrix and derive all three frozen
- * candidates. The task/candidate/component orders are part of the input so
- * neither insertion order nor an after-the-fact tie-break can change a result.
- */
-declare function analyzeCrossSurfaceInteractions<TRow extends CrossSurfaceTaskRow>(input: AnalyzeCrossSurfaceInteractionsInput<TRow>): CrossSurfaceInteractionReport<TRow>;
-//#endregion
-//#region src/campaign/fixtures.d.ts
-type EvalFixtureValidationMode = 'vitest' | 'none';
-interface EvalFixtureFile {
-  path: string;
-  sha256: string;
-  bytes: number;
-}
-interface EvalFixture {
-  name: string;
-  path: string;
-  promptPath: string;
-  evalPath?: string;
-  packageJsonPath?: string;
-  prompt: string;
-  files: EvalFixtureFile[];
-  fingerprint: string;
-}
-interface EvalFixtureScenario extends Scenario {
-  kind: 'eval-fixture';
-  fixtureName: string;
-  fixturePath: string;
-  promptPath: string;
-  evalPath?: string;
-  packageJsonPath?: string;
-  prompt: string;
-  fingerprint: string;
-}
-interface EvalFixtureLoadOptions {
-  /** `vitest` requires EVAL.ts/EVAL.tsx and package.json type=module. `none` only requires PROMPT.md. */
-  validation?: EvalFixtureValidationMode;
-  /** Extra caller-owned knobs that affect fixture behavior, folded into the fingerprint. */
-  fingerprintConfig?: unknown;
-}
-interface LoadEvalFixtureScenariosOptions extends EvalFixtureLoadOptions {
-  names?: string[];
-}
-interface PlanEvalFixtureRunOptions<TArtifact = unknown> extends Pick<PlanCampaignRunOptions<EvalFixtureScenario, TArtifact>, 'dispatchRef' | 'judges' | 'seed' | 'reps' | 'resumable' | 'runDir'> {
-  evalsDir: string;
-  validation?: EvalFixtureValidationMode;
-  fingerprintConfig?: unknown;
-  names?: string[];
-  storage?: CampaignStorage;
-}
-type EvalFixtureRunPlan = CampaignRunPlan & {
-  fixtures: Array<Pick<EvalFixtureScenario, 'fixtureName' | 'fixturePath' | 'fingerprint'>>;
-};
-/** Walk `evalsDir` and return the relative name of every fixture directory (one containing an exact-case `PROMPT.md`). */
-declare function discoverEvalFixtures(evalsDir: string): string[];
-/**
- * Load ONE fixture by name: reads `PROMPT.md` (plus `EVAL.ts`/`EVAL.tsx` and `package.json` under
- * `vitest` validation) and content-fingerprints the full file set for cache identity.
- */
-declare function loadEvalFixture(evalsDir: string, name: string, options?: EvalFixtureLoadOptions): EvalFixture;
-/** Load fixtures (all discovered, or just `names`) as campaign `Scenario`s tagged `eval-fixture`. */
-declare function loadEvalFixtureScenarios(evalsDir: string, options?: LoadEvalFixtureScenariosOptions): EvalFixtureScenario[];
-/**
- * Dry-run planner for a fixture campaign: loads the scenarios, delegates to `planCampaignRun`,
- * and returns the plan plus each fixture's name/path/fingerprint.
- */
-declare function planEvalFixtureRun<TArtifact = unknown>(options: PlanEvalFixtureRunOptions<TArtifact>): EvalFixtureRunPlan;
-//#endregion
-//#region src/campaign/gates/neutralization-gate.d.ts
-interface NeutralizationGateOptions<TScenario extends Scenario = Scenario> {
-  scenarios: TScenario[];
-  /** Reject when the neutralized (content-blanked, footprint-matched) variant
-   *  reproduces at least this fraction of the candidate's held-out lift. Default
-   *  0.5 — if blanking the content keeps half the lift, the content is decorative.
-   *  Equality rejects: a neutralized lift == threshold·candidateLift is decorative. */
-  maxDecorativeFraction?: number;
-}
-/**
- * Composable placebo gate: ships only when the candidate's held-out lift is NOT
- * mostly reproduced by a footprint-matched neutralized variant.
- */
-declare function neutralizationGate<TArtifact, TScenario extends Scenario>(options: NeutralizationGateOptions<TScenario>): Gate<TArtifact, TScenario>;
-//#endregion
-//#region src/campaign/grounded-reflection.d.ts
-/**
- * Evidence grounding for reflective optimizers (GEPA-style revise loops).
- *
- * Two failure modes recur when an LLM revises an artifact from raw rollout
- * traces (first measured in agent-lab R358, where naive reflection REGRESSED
- * the score 0.375 -> 0.125 before these helpers fixed it):
- *
- * 1. The environment often hides WHY a rollout failed - a tool call can
- *    succeed while an invisible downstream check fails - so the reviser
- *    cannot see the cause in the transcript. The only reliable signal is the
- *    field-level difference between what passing and failing rollouts did.
- *    `rolloutArgumentDiff` computes that difference deterministically so the
- *    reviser is handed the diff instead of being trusted to derive it.
- *
- * 2. Revisers invent plausible-but-wrong literal values ("use 'new'",
- *    "use 'sent'") that no passing rollout ever used, turning every rollout
- *    into a failure. `classifyUngroundedLiterals` mechanically detects them,
- *    separating HARMFUL literals (ones failing rollouts actually used -
- *    proven damage) from benign illustrations (e.g. a name example like
- *    'Doe'), so callers can hard-reject the former and merely log the latter.
- *    Rejecting every ungrounded quoted word is too blunt: it killed a run
- *    over a surname illustration before the severity split existed.
- *
- * Pure data in, data out: no LLM calls, no filesystem, no domain knowledge.
- */
-/** One tool/action call observed in a rollout: a name plus its arguments. */
-interface RolloutCall {
-  readonly name: string;
-  readonly args: Readonly<Record<string, unknown>>;
-}
-/** A scored rollout: its calls plus the scalar outcome used to split pass/fail. */
-interface ScoredRollout {
-  /** Caller-meaningful identifier (task id, cell id) used only for reporting. */
-  readonly id: string;
-  /** Scalar outcome in [0, 1]; `passThreshold` splits passing from failing. */
-  readonly score: number;
-  readonly calls: readonly RolloutCall[];
-}
-interface RolloutArgumentDiffOptions {
-  /** Rollouts with `score >= passThreshold` count as passing. Default 1. */
-  readonly passThreshold?: number;
-  /** Max distinct values listed per field per side in the rendered text. Default 4. */
-  readonly maxValuesPerField?: number;
-}
-interface RolloutArgumentDiff {
-  /** Human/LLM-readable per-field diff, one line per field. */
-  readonly text: string;
-  /** Lowercased stringified argument values seen in passing rollouts. */
-  readonly passingValues: ReadonlySet<string>;
-  /** Lowercased stringified argument values seen in failing rollouts. */
-  readonly failingValues: ReadonlySet<string>;
-}
-/**
- * Deterministic per-field diff of call arguments between passing and failing
- * rollouts. A field set by failing rollouts but left unset by passing ones is
- * the classic poison-input signature; a field whose values differ across the
- * split points at the correct value. Feed `text` to the reviser verbatim.
- */
-declare function rolloutArgumentDiff(rollouts: readonly ScoredRollout[], opts?: RolloutArgumentDiffOptions): RolloutArgumentDiff;
-interface UngroundedLiteralReport {
-  /** Quoted single-word literals in the text that no passing rollout used. */
-  readonly ungrounded: readonly string[];
-  /** The subset failing rollouts actually used - prescribing these is proven harmful. */
-  readonly harmful: readonly string[];
-}
-/**
- * Scan revised artifact text for single-quoted single-word literals (the
- * "use exactly 'new'" pattern) that appear in no passing rollout's argument
- * values. Multi-word quotes pass (they are prose, not prescriptions).
- * Callers should reject on `harmful` (with a bounded retry) and at most log
- * `ungrounded` - see the module header for why the severities differ.
- */
-declare function classifyUngroundedLiterals(text: string, diff: Pick<RolloutArgumentDiff, 'passingValues' | 'failingValues'>): UngroundedLiteralReport;
-//#endregion
-//#region src/campaign/labeled-store/fs-adapter.d.ts
-interface FsLabeledScenarioStoreOptions {
-  /** Root directory for JSONL files. Created if missing. */
-  root: string;
-  /** Per-source rate limit. When set, writes exceeding the cap are rejected
-   *  with a typed error. Default: no limit. */
-  maxWritesPerMinutePerBucket?: number;
-  /** Test seam — override `Date.now()` for deterministic tests. */
-  now?: () => number;
-}
-/** Typed rejection from a labeled-scenario store (bad provenance, rate limit, invalid sample args) — carries a stable string `code`. */
-declare class LabeledScenarioStoreError extends Error {
-  readonly code: string;
-  constructor(code: string, message: string);
-}
-/**
- * Filesystem `LabeledScenarioStore`: appends one JSONL file per source with provenance and
- * rate-limit guards. For tests, local dev, and small workloads — high-throughput lands in Turso.
- */
-declare class FsLabeledScenarioStore implements LabeledScenarioStore {
-  private readonly options;
-  private readonly now;
-  private readonly rateLimits;
-  constructor(options: FsLabeledScenarioStoreOptions);
-  observe(write: LabeledScenarioWrite): Promise<void>;
-  sample(args: LabeledScenarioSampleArgs): Promise<LabeledScenarioRecord[]>;
-  size(): Promise<{
-    train: number;
-    test: number;
-    bySource: Record<string, number>;
-    byTrust: Record<LabelTrust, number>;
-  }>;
-  private assertProvenance;
-  private assertRateLimit;
-  private toRecord;
-  private pathForSource;
-}
-//#endregion
-//#region src/campaign/neutralize.d.ts
-/**
- * @module
- * Footprint-matched neutralization — the placebo control for content-vs-footprint
- * attribution in a promotion gate.
- *
- * A promoted surface can raise a held-out score two different ways:
- *  1. its CONTENT is informative (the thing we want to promote), or
- *  2. it merely added prompt/mount FOOTPRINT — more bytes, more lines, a longer
- *     more authoritative-looking prompt — that the model spends attention on
- *     regardless of what the bytes say.
- *
- * A held-out gate proves the candidate beat baseline; it cannot separate (1) from
- * (2). `neutralizeText` produces a variant that keeps the input's layout and
- * length while carrying ZERO information, so scoring it isolates the footprint
- * contribution (2). Feed the neutralized variant's scores to `neutralizationGate`:
- * any lift it still holds over baseline is decorative, and a candidate whose lift
- * survives neutralization is rejected however large its raw lift.
- */
-/**
- * Blank every non-whitespace character to a 1-byte filler while preserving all
- * whitespace. Line count, indentation, and word/line lengths are unchanged — so
- * the neutralized variant has the same layout and (for ASCII) the same byte
- * footprint as the input, but no readable content. Whitespace is preserved
- * deliberately: collapsing it would change the token structure and stop the
- * variant from being a true footprint match.
- */
-declare function neutralizeText(content: string): string;
-//#endregion
-//#region src/campaign/presets/run-profile-matrix.d.ts
-/** Thrown when the matrix is misconfigured (no profiles, missing resolved model evidence,
- *  etc.). Distinct from `BackendIntegrityError`,
- *  which signals a stub backend at run time. */
-declare class ProfileMatrixError extends AgentEvalError {
-  constructor(message: string);
-}
-/** Dispatch for one cell: render `profile` against `scenario`, returning the
- *  artifact the judges score. Run LLM work through `ctx.cost.runPaidCall` —
- *  the integrity check depends on its receipt. */
-type ProfileDispatchFn<TScenario extends Scenario, TArtifact> = (profile: AgentProfile$1, scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
-interface RunProfileMatrixOptions<TScenario extends Scenario, TArtifact> {
-  /** Axis 3 — the agent-under-test configurations. Each is one column. */
-  profiles: AgentProfile$1[];
-  /** Axis 1 — the persona/scenario corpus, run against every profile. */
-  scenarios: TScenario[];
-  /** Renders one (profile, scenario) cell. */
-  dispatch: ProfileDispatchFn<TScenario, TArtifact>;
-  /** The scoring axis. */
-  judges?: JudgeConfig<TArtifact, TScenario>[];
-  /** Where each profile's campaign writes artifacts/traces. One subdir per
-   *  profile. */
-  runDir: string;
-  /** Git SHA the harness ran from — stamped onto every RunRecord (mandatory
-   *  for paper-grade records). */
-  commitSha: string;
-  /** Additional stable identity for dispatch behavior that can change without
-   *  changing `commitSha`, such as a caller-owned executable or remote config. */
-  dispatchRef?: string;
-  /** Logical experiment id shared across the whole matrix so the promotion
-   *  gate can pair profiles on matched scenarios. Default: a hash of the
-   *  profile + scenario ids. */
-  experimentId?: string;
-  /** Which split these runs belong to. Default `'search'`. */
-  splitTag?: RunSplitTag;
-  /** Replicates per (profile, scenario) cell for CI bands. Default 1. */
-  reps?: number;
-  /** Campaign seed (per profile). Default 42. */
-  seed?: number;
-  /**
-   * Backend-integrity posture, enforced AFTER the matrix completes:
-   *   - `'assert'` (default) — throw `BackendIntegrityError` if the run was a
-   *     stub (and, with `allowMixed:false`, if it was mixed).
-   *   - `'warn'` — log the verdict but never throw.
-   *   - `'off'` — skip the guard entirely (only for offline/replay analysis).
-   */
-  integrity?: 'assert' | 'warn' | 'off';
-  /** Forwarded to `assertRealBackend`. Default true (tolerate partial 429
-   *  cascades); set false for strict CI gates. */
-  allowMixed?: boolean;
-  /** Max concurrent cells WITHIN each profile's campaign. Default 2. */
-  maxConcurrency?: number;
-  /** Max profile campaigns in flight. Default 1. Each profile keeps its own
-   *  run directory and cost ceiling; raise this when those resources are independent. */
-  maxProfileConcurrency?: number;
-  /** Cumulative USD cap per profile campaign. */
-  costCeiling?: number;
-  /** Capture flywheel — forwarded to each campaign. */
-  labeledStore?: LabeledScenarioStore | 'off';
-  captureSource?: LabeledScenarioSource;
-  /** Storage backend. Default `fsCampaignStorage`. Pass
-   *  `inMemoryCampaignStorage()` for edge/CF-Worker/test runs. */
-  storage?: CampaignStorage;
-  /** Test seam — override the wall clock. */
-  now?: () => Date;
-  /** Optional persona key per scenario — drives the `byPersona` pivot. When
-   *  unset, `byPersona` is omitted. */
-  personaOf?: (scenario: TScenario) => string;
-  /** Validate every produced RunRecord with `validateRunRecord` (fail-loud).
-   *  Default true — catches bad model snapshots and non-finite judge dims at
-   *  the boundary instead of letting them poison downstream analysis. */
-  validate?: boolean;
-  /** Corpus-by-default: derive the trajectory text (`prompt` + `completion`)
-   *  for each cell from its artifact + scenario. When set, every produced
-   *  record carries `prompt`/`completion` (a `CorpusRecord`) so the run's
-   *  graded trajectories can be appended to the durable RL corpus with no
-   *  side-channel — `appendToCorpus(result.records, path)`. Fail-soft: a
-   *  throwing or undefined-returning extractor just omits the text. */
-  corpusText?: (artifact: TArtifact, scenario: TScenario) => {
-    prompt: string;
-    completion: string;
-  } | undefined;
-  /**
-   * Optional explicit row selection. The matrix identity remains based on the
-   * complete profiles × scenarios × reps design; this invocation executes only
-   * rows accepted by the predicate.
-   */
-  rowFilter?: (input: {
-    profile: AgentProfile$1;
-    scenario: TScenario;
-    rep: number;
-  }) => boolean;
-  /** Stable matrix identity supplied by a persisted profile-matrix plan. */
-  matrixId?: string;
-  /** Reuse cached failed cells. Normal matrix runs retry them by default. */
-  reuseFailedCells?: boolean;
-}
-interface ProfileSummary {
-  profileId: string;
-  profileHash: string;
-  model: string;
-  /** RunRecords produced for this profile (= scenarios × reps). */
-  records: number;
-  /** Mean across scored records, or null when the profile has no task labels. */
-  meanComposite: number | null;
-  /** Total cost, or null when any call's cost was not captured. */
-  totalCostUsd: number | null;
-  costProvenance: CostProvenance;
-  /** Per-profile integrity verdict — surfaces a single profile that ran stub
-   *  even when the matrix as a whole looks real. */
-  integrity: BackendIntegrityReport;
-}
-interface ScenarioRollup {
-  meanComposite: number;
-  n: number;
-}
-interface RunProfileMatrixResult<TArtifact, TScenario extends Scenario> {
-  matrixId: string;
-  experimentId: string;
-  /** One RunRecord per (profile, scenario, rep) cell — the integrity-checked,
-   *  paper-grade output. Feed straight into `analyzeRuns`, `HeldOutGate`,
-   *  scorecards, the hosted wire format. */
-  records: RunRecord[];
-  byProfile: Record<string, ProfileSummary>;
-  byScenario: Record<string, ScenarioRollup>;
-  /** Present only when `personaOf` was supplied. */
-  byPersona?: Record<string, ScenarioRollup>;
-  /** Whole-matrix integrity report (the one `integrity:'assert'` enforces). */
-  integrity: BackendIntegrityReport;
-  /** The raw per-profile campaign results, keyed by profile id. */
-  campaigns: Record<string, CampaignResult<TArtifact, TScenario>>;
-}
-/**
- * Profile × scenario matrix runner: fan N agent profiles across M scenarios, project each cell to a validated `RunRecord` with real token usage, and enforce the backend-integrity guard before returning.
- */
-declare function runProfileMatrix<TScenario extends Scenario, TArtifact>(opts: RunProfileMatrixOptions<TScenario, TArtifact>): Promise<RunProfileMatrixResult<TArtifact, TScenario>>;
-//#endregion
-//#region src/campaign/presets/playback.d.ts
-/** One step of a user story — what the user does. The driver interprets
- *  `payload` (a Playwright selector + action, or a sandbox chat turn). */
-interface PlaybackStep {
-  /** Human-readable action, captured verbatim in the UX narrative. */
-  action: string;
-  /** Driver-specific payload (e.g. `{ selector, fill }` or `{ turn }`). */
-  payload?: Record<string, unknown>;
-}
-/**
- * A user story = a runnable product journey plus the requirements that define
- * "this story works". Each requirement is one Jira ticket line. Extends
- * `Scenario` so a catalog drops straight into `runProfileMatrix({ scenarios })`.
- */
-interface UserStory extends Scenario {
-  /** Human-readable story title (the ticket headline). */
-  title: string;
-  /** Ordered steps the driver executes. */
-  steps: PlaybackStep[];
-  /** What must hold in the produced state for the story to pass. */
-  requirements: CompletionRequirement[];
-}
-/** Dispatch context plus the profile under test (which cheap model, etc.). */
-interface PlaybackContext extends DispatchContext {
-  profile: AgentProfile;
-}
-/**
- * Drives the real product through a story and returns the runtime event stream
- * `extractProducedState` consumes. Implemented by CONSUMERS —
- * `SandboxPlaybackDriver` (real API / sandbox workspace) and
- * `PlaywrightPlaybackDriver` (real UI) — because they depend on runtime /
- * browser infra the substrate must not import. The driver MUST report LLM
- * usage through `ctx.cost.runPaidCall` so the backend-integrity check sees real
- * tokens (a run that never reports tokens reads as a stub).
- */
-interface PlaybackDriver<TStory extends UserStory = UserStory> {
-  run(story: TStory, ctx: PlaybackContext): Promise<readonly RuntimeEventLike[]>;
-}
-/**
- * Adapt a `PlaybackDriver` into a `runProfileMatrix` dispatch. The artifact the
- * matrix scores is the `ProducedState` extracted from the driver's event
- * stream — grade it with `scoreUserStory` (or a judge wrapping it).
- */
-declare function makePlaybackDispatch<TStory extends UserStory>(driver: PlaybackDriver<TStory>): ProfileDispatchFn<TStory, ProducedState>;
-/** A scored user story — the completion verdict plus its human title. */
-interface UserStoryVerdict extends CompletionVerdict {
-  title: string;
-}
-/**
- * Score one story's produced state against its requirements. Thin wrapper over
- * `verifyCompletion` that builds the gold from the story and returns a
- * per-requirement PASS/FAIL verdict. `checkCorrectness` is injected — a
- * deterministic stub in tests, `createLlmCorrectnessChecker` in production.
- */
-declare function scoreUserStory(story: UserStory, state: ProducedState, checkCorrectness: CorrectnessChecker): Promise<UserStoryVerdict>;
-/** One row of the launch scoreboard — story × requirement → PASS/FAIL. */
-interface ScoreboardRow {
-  storyId: string;
-  storyTitle: string;
-  reqId: string;
-  reqTitle: string;
-  status: 'PASS' | 'FAIL';
-  evidence: string[];
-}
-/**
- * Flatten story verdicts into the per-requirement scoreboard — the literal
- * Jira tick-off: one row per (story, requirement) with PASS/FAIL and the
- * evidence behind the verdict.
- */
-declare function userStoryScoreboard(verdicts: readonly UserStoryVerdict[]): ScoreboardRow[];
-/** Launch-readiness headline counts rolled up from the per-requirement rows. */
-interface ScoreboardSummary {
-  /** Distinct user stories on the board. */
-  stories: number;
-  /** Stories whose every requirement passed. */
-  storiesFullyComplete: number;
-  /** Total (story, requirement) rows. */
-  requirements: number;
-  /** Rows with status PASS. */
-  passed: number;
-  /** Rows with status FAIL. */
-  failed: number;
-  /** passed / requirements; 0 when there are no rows. */
-  passRate: number;
-}
-/** Roll the per-requirement rows up into the launch headline counts. */
-declare function scoreboardSummary(rows: readonly ScoreboardRow[]): ScoreboardSummary;
-interface ScoreboardRenderOptions {
-  /** Document H1. Defaults to a generic playback title. */
-  title?: string;
-  /** Key/value run metadata rendered under the headline (runId, backend, model, date). */
-  meta?: Record<string, string>;
-  /** Max chars of joined evidence shown per row. Default 160. */
-  maxEvidenceChars?: number;
-}
-/**
- * Render the scoreboard as a launch-readiness Markdown document — the literal
- * "tick off every user story" artifact: a headline roll-up, the open tickets
- * (FAIL rows) up top as the launch blockers, then a per-story table of
- * requirement → PASS/FAIL with the evidence behind each verdict. Pure: same
- * rows in, same bytes out (no clock/random), so it is safe to snapshot.
- */
-declare function renderScoreboardMarkdown(rows: readonly ScoreboardRow[], opts?: ScoreboardRenderOptions): string;
-//#endregion
-//#region src/campaign/presets/segmented-profile-matrix.d.ts
-interface ProfileMatrixRow {
-  rowId: string;
-  ordinal: number;
-  profileId: string;
-  scenarioId: string;
-  rep: number;
-}
-interface ProfileMatrixPlan<TScenario extends Scenario, TArtifact> {
-  readonly schemaVersion: 1;
-  readonly matrixId: string;
-  readonly experimentId: string;
-  readonly planDigest: `sha256:${string}`;
-  readonly profiles: readonly AgentProfile$1[];
-  readonly scenarios: readonly TScenario[];
-  readonly judges: readonly JudgeConfig<TArtifact, TScenario>[];
-  readonly reps: number;
-  readonly seed: number;
-  readonly splitTag: NonNullable<RunProfileMatrixOptions<TScenario, TArtifact>['splitTag']>;
-  readonly commitSha: string;
-  /** Stable dispatch implementation/configuration identity used by cell caches. */
-  readonly dispatchRef: string;
-  readonly integrity: NonNullable<RunProfileMatrixOptions<TScenario, TArtifact>['integrity']>;
-  readonly allowMixed: boolean;
-  readonly validate: boolean;
-  readonly personaOf?: (scenario: TScenario) => string;
-  readonly corpusText?: (artifact: TArtifact, scenario: TScenario) => {
-    prompt: string;
-    completion: string;
-  } | undefined;
-  readonly rows: readonly ProfileMatrixRow[];
-}
-interface CreateProfileMatrixPlanOptions<TScenario extends Scenario, TArtifact> extends Pick<RunProfileMatrixOptions<TScenario, TArtifact>, 'profiles' | 'scenarios' | 'judges' | 'commitSha' | 'experimentId' | 'splitTag' | 'reps' | 'seed' | 'integrity' | 'allowMixed' | 'validate' | 'personaOf' | 'corpusText'> {
-  /** Stable dispatch implementation/configuration identity used by cell caches. */
-  dispatchRef: string;
-}
-interface ProfileMatrixCoverage {
-  expected: number;
-  present: number;
-  missing: string[];
-  failed: string[];
-  zeroScore: string[];
-}
-interface RunProfileMatrixSegmentOptions<TScenario extends Scenario, TArtifact> {
-  plan: ProfileMatrixPlan<TScenario, TArtifact>;
-  /** Stable external grant or attempt identity. Reuse it to resume. */
-  segmentId: string;
-  /** Explicit row ids from `plan.rows`; duplicate or unknown rows fail. */
-  rows: readonly (string | ProfileMatrixRow)[];
-  dispatch: ProfileDispatchFn<TScenario, TArtifact>;
-  runDir: string;
-  storage?: CampaignStorage;
-  maxConcurrency?: number;
-  maxProfileConcurrency?: number;
-  costCeiling?: number;
-  labeledStore?: RunProfileMatrixOptions<TScenario, TArtifact>['labeledStore'];
-  captureSource?: RunProfileMatrixOptions<TScenario, TArtifact>['captureSource'];
-  now?: () => Date;
-}
-interface ProfileMatrixSegmentResult<TArtifact, TScenario extends Scenario> {
-  segmentId: string;
-  rowIds: string[];
-  matrix: RunProfileMatrixResult<TArtifact, TScenario>;
-  coverage: ProfileMatrixCoverage;
-}
-interface FinalizeProfileMatrixOptions<TScenario extends Scenario, TArtifact> {
-  plan: ProfileMatrixPlan<TScenario, TArtifact>;
-  runDir: string;
-  storage?: CampaignStorage;
-  maxConcurrency?: number;
-  maxProfileConcurrency?: number;
-  now?: () => Date;
-}
-interface FinalizedProfileMatrixResult<TArtifact, TScenario extends Scenario> extends RunProfileMatrixResult<TArtifact, TScenario> {
-  coverage: ProfileMatrixCoverage;
-}
-declare function createProfileMatrixPlan<TScenario extends Scenario, TArtifact>(opts: CreateProfileMatrixPlanOptions<TScenario, TArtifact>): ProfileMatrixPlan<TScenario, TArtifact>;
-declare function runProfileMatrixSegment<TScenario extends Scenario, TArtifact>(opts: RunProfileMatrixSegmentOptions<TScenario, TArtifact>): Promise<ProfileMatrixSegmentResult<TArtifact, TScenario>>;
-declare function finalizeProfileMatrix<TScenario extends Scenario, TArtifact>(opts: FinalizeProfileMatrixOptions<TScenario, TArtifact>): Promise<FinalizedProfileMatrixResult<TArtifact, TScenario>>;
-//#endregion
-//#region src/campaign/run-dir.d.ts
-/** The shared, out-of-repo root for campaign/benchmark run bundles. Keeping run
- *  outputs here means they never land in a repo working tree (no per-repo
- *  gitignore, no clutter, no accidental commits). Layout:
- *    ~/.tangle/traces/<repo>/runs/<runName>/
- *  where <repo> disambiguates runs across repos in one place. */
-declare function tangleTracesRoot(): string;
-/** Resolve a campaign `runDir`. An absolute path is honored as-is (the caller
- *  chose an explicit location). A bare name is placed under the shared home root
- *  so bundles never pollute a repo working tree — the default the harness should
- *  compute so callers pass a *name*, not a path. */
-declare function resolveRunDir(runDir: string, repo?: string): string;
-//#endregion
-//#region src/campaign/scenario-selection.d.ts
-/**
- * Discriminative scenario selection (research claim E2).
- *
- * The OR benchmark is SATURATING: run 7 measured ~75% tied holdout cells — most
- * problems are solved optimally by the baseline AND every candidate, so those
- * paired cells carry zero signal. A random/balanced holdout split spends its
- * budget on scenarios that cannot separate candidates.
- *
- * This picks the holdout by DISCRIMINATION power instead: a scenario every
- * candidate scores identically (variance ~0) carries no signal; one where the
- * scores spread carries the most. We drop fully saturated ties so each paired
- * holdout cell is spent on a scenario that can actually move a verdict.
- */
-/** Per-scenario observation: the composite scores each candidate earned on it. */
-interface ScenarioSignal {
-  scenarioId: string;
-  /** Per-candidate composite scores observed for this scenario (>=1 values). */
-  scores: number[];
-}
-interface DiscriminationScore {
-  scenarioId: string;
-  /** Higher = separates candidates more (spread of their scores). */
-  discrimination: number;
-  /** Higher = easier / more-saturated (mean of candidate scores). */
-  meanScore: number;
-  variance: number;
-  /** variance ~0 AND meanScore at/above the ceiling ⇒ a saturated tie, no signal. */
-  tied: boolean;
-}
-/**
- * Rank scenarios by how well they DISCRIMINATE candidates.
- *
- * `discrimination = variance` (spread of the candidate scores) — kept simple on
- * purpose; the headroom term (`saturationCeiling - meanScore`) only breaks ties
- * so that, among equally spread scenarios, the one with more room to improve
- * ranks first. Returned sorted by the deterministic order above.
- */
-declare function scoreDiscrimination(signals: ScenarioSignal[], opts?: {
-  saturationCeiling?: number;
-}): DiscriminationScore[];
-/**
- * Select the top-`k` most discriminative scenario ids for a holdout, EXCLUDING
- * fully saturated ties when enough non-tied scenarios exist (a tie in the
- * holdout wastes a paired cell).
- *
- * Prefers non-tied scenarios; if fewer than `k` non-tied exist, fills with the
- * least-saturated tied ones (tied scenarios are already ordered least-saturated
- * first by `meanScore` asc). Deterministic. Throws if `k < 1`. If
- * `signals.length <= k`, returns all ids in discrimination order.
- */
-declare function selectDiscriminative(signals: ScenarioSignal[], k: number, opts?: {
-  saturationCeiling?: number;
-}): string[];
-//#endregion
-//#region src/campaign/score-utils.d.ts
-/** Mean composite across cells with complete task-quality evidence.
- *  Partial judge results remain on their cells but never enter this value.
- *  A campaign with no complete score has no numeric mean and fails loudly. */
-declare function campaignMeanComposite<TArtifact, TScenario extends Scenario>(campaign: CampaignResult<TArtifact, TScenario>): number;
-/** Compare fixed-length lexicographic rank keys where each element is higher-is-better.
- *  Returns a positive number when `a` ranks above `b`, negative when below, and
- *  zero when equal. */
-declare function compareRankKeys(a: readonly number[], b: readonly number[]): number;
-interface CampaignBreakdown {
-  /** Mean score per judge dimension across all cells. */
-  dimensions: Record<string, number>;
-  /** Per-scenario composite (mean over reps + judges) + the judge's free-form
-   *  `notes` for that scenario (the "why" a reflective proposer grounds on) +
-   *  an optional `emitted` excerpt of the candidate's raw output (the "what it
-   *  actually did" a reflective proposer grounds on). */
-  scenarios: Array<{
-    scenarioId: string;
-    composite: number;
-    notes?: string;
-    emitted?: string;
-  }>;
-}
-/** Per-candidate evidence a reflective/patch proposer grounds its next proposal
- *  on: mean score per judge dimension + per-scenario composite. */
-declare function campaignBreakdown<TArtifact, TScenario extends Scenario>(campaign: CampaignResult<TArtifact, TScenario>): CampaignBreakdown;
-//#endregion
-//#region src/campaign/single-run-lock.d.ts
-/**
- * Single-run lock for evaluations that share one mutable environment.
- *
- * Two concurrent runs against a shared stateful gym silently corrupt each
- * other: each resets/mutates environment state mid-cell of the other, and
- * every score from both becomes garbage that LOOKS like worker variance
- * (agent-lab R357 burned hours on flip-flopping scores before tracing them
- * to exactly this). The fix is a pid lockfile: refuse to start while a live
- * holder exists, reclaim stale locks whose pid is gone, release only if the
- * lock is still ours.
- *
- * `alsoCheck` exists because independent runners can guard the same shared
- * resource with differently named lockfiles; a runner must respect all of
- * them even though it writes only its own.
- */
-interface SingleRunLockOptions {
-  /** Lockfile this runner writes (and checks). */
-  readonly lockPath: string;
-  /** Other runners' lockfiles guarding the same resource; checked, never written. */
-  readonly alsoCheck?: readonly string[];
-  /** Install a process 'exit' hook that releases the lock. Default true. */
-  readonly releaseOnExit?: boolean;
-  /** Owner pid recorded in the lockfile metadata. Default process.pid. */
-  readonly pid?: number;
-}
-interface SingleRunLock {
-  /** Remove the lockfile if this process still owns it. Idempotent. */
-  release(): void;
-}
-/**
- * Acquire the lock or throw naming the live holder. A stale lock (holder pid
- * no longer running) is reclaimed by one contender. An interrupted reclaim
- * leaves a marker that fails closed instead of admitting overlapping runs.
- */
-declare function acquireSingleRunLock(opts: SingleRunLockOptions): SingleRunLock;
-//#endregion
-//#region src/campaign/surface-identity.d.ts
-/** Validate the immutable identity shape; the owning executor verifies the Git objects and patch. */
-declare function assertCodeSurfaceIdentity(surface: unknown): asserts surface is CodeSurface;
-/**
- * Deterministic identity material for a component surface.
- *
- * `canonicalString` orders keys by UTF-16 code unit (RFC 8785), which is a
- * property of the value alone. The previous material ordered them with
- * `localeCompare`, which reads the host's collation — so the same surface
- * could produce two different identities on two machines, and the stored
- * identity would stop matching a recomputation of the identical surface.
- */
-declare function componentSurfaceIdentityMaterial(surface: ComponentSurface): string;
-/** Canonical, location-independent identity of a finalized code candidate.
- *  Commit metadata is excluded: two commits with the same base, final tree,
- *  and patch bytes are the same executable candidate. */
-declare function codeSurfaceIdentityMaterial(surface: CodeSurface): string;
-/** Full SHA-256 content identity for a prompt or finalized code surface. */
-declare function surfaceContentHash(surface: MutableSurface): `sha256:${string}`;
-/** Short loop key derived from the same content identity as provenance. */
-declare function surfaceHash(surface: MutableSurface): string;
-/** Canonical customer-visible description of the exact before/after surfaces. */
-declare function renderSurfaceDiff(winnerSurface: MutableSurface, baselineSurface: MutableSurface): string;
-//#endregion
-//#region src/campaign/upstream-evaluators.d.ts
-interface PhoenixEvaluationResultLike {
-  score?: number;
-  label?: string;
-  explanation?: string;
-}
-interface PhoenixEvaluatorLike<TRecord extends Record<string, unknown>> {
-  name: string;
-  kind: 'LLM' | 'CODE';
-  optimizationDirection?: 'MAXIMIZE' | 'MINIMIZE' | 'NEUTRAL';
-  evaluate(record: TRecord, context: UpstreamEvaluationContext): Promise<PhoenixEvaluationResultLike>;
-}
-interface AutoevalsScoreLike {
-  name: string;
-  score: number | null;
-  metadata?: Record<string, unknown>;
-}
-type AutoevalsScorerLike<TInput extends Record<string, unknown>> = (input: TInput, context: UpstreamEvaluationContext) => AutoevalsScoreLike | Promise<AutoevalsScoreLike>;
-interface UpstreamEvaluationContext {
-  readonly signal: AbortSignal;
-  readonly callId?: string;
-}
-type PaidEvaluationOptions<TResult> = Pick<RunPaidCallInput<TResult>, 'maximumCharge' | 'receipt' | 'receiptFromError'> & {
-  model: string;
-};
-interface UpstreamJudgeOptions<TScenario extends Scenario> {
-  name?: string;
-  dimension?: string;
-  judgeVersion?: string;
-  appliesTo?: (scenario: TScenario) => boolean;
-  /** Convert the upstream score when its native scale is not higher-is-better. */
-  toComposite?: (score: number) => number;
-}
-declare function phoenixEvaluatorJudge<TRecord extends Record<string, unknown>, TArtifact, TScenario extends Scenario = Scenario>(evaluator: PhoenixEvaluatorLike<TRecord>, options: UpstreamJudgeOptions<TScenario> & {
-  mapInput(input: {
-    artifact: TArtifact;
-    scenario: TScenario;
-  }): TRecord;
-  paidCall?: PaidEvaluationOptions<PhoenixEvaluationResultLike>;
-}): JudgeConfig<TArtifact, TScenario>;
-declare function autoevalsScorerJudge<TInput extends Record<string, unknown>, TArtifact, TScenario extends Scenario = Scenario>(scorer: AutoevalsScorerLike<TInput>, options: UpstreamJudgeOptions<TScenario> & {
-  name: string;
-  mapInput(input: {
-    artifact: TArtifact;
-    scenario: TScenario;
-  }): TInput;
-} & ({
-  kind: 'CODE';
-  paidCall?: never;
-} | {
-  kind: 'LLM';
-  paidCall: PaidEvaluationOptions<AutoevalsScoreLike>;
-})): JudgeConfig<TArtifact, TScenario>;
-//#endregion
-//#region src/campaign/worktree/index.d.ts
-type GitOutput = string | Uint8Array;
-type GitEnvironment = Readonly<Record<string, string>>;
-type GitRunner = (args: string[], cwd: string, env?: GitEnvironment) => GitOutput;
-interface Worktree {
-  /** Absolute path to the checked-out worktree directory. */
-  readonly path: string;
-  /** The branch the worktree is on (becomes the PR branch on promotion). */
-  readonly branch: string;
-  /** The ref the worktree was forked from. */
-  readonly baseRef: string;
-  /** Exact commit `baseRef` resolved to before the worktree was created. */
-  readonly baseCommit: string;
-  /** Exact tree object for `baseCommit`. */
-  readonly baseTree: string;
-}
-interface WorktreeAdapter {
-  /** Create an isolated worktree on a fresh branch off `baseRef`. */
-  create(opts: {
-    baseRef: string;
-    label: string;
-  }): Promise<Worktree>;
-  /** Commit pending changes, freeze the exact Git objects + binary patch, and
-   *  verify the worktree still matches that identity. */
-  finalize(worktree: Worktree, summary: string): Promise<CodeSurface>;
-  /** Idempotently remove the worktree and branch. Safe to retry after partial cleanup. */
-  discard(worktree: Worktree): Promise<void>;
-}
-/** Typed failure from a `WorktreeAdapter` operation (create/finalize/discard) — wraps the underlying git error as `cause`. */
-declare class WorktreeAdapterError extends Error {
-  readonly cause?: unknown;
-  constructor(message: string, cause?: unknown);
-}
-interface GitWorktreeAdapterOptions {
-  /** Repo root the worktrees fork from. */
-  repoRoot: string;
-  /** Directory worktrees are created under. Default: `<repoRoot>/.worktrees`. */
-  worktreeDir?: string;
-  /** Branch-name prefix. Default: `improve`. */
-  branchPrefix?: string;
-  /** Test seam — defaults to a real `git` runner. The return value must contain
-   *  stdout verbatim, and runners that execute Git must forward the optional
-   *  environment overrides used to isolate patch generation. */
-  git?: GitRunner;
-}
-interface CodeSurfaceVerification {
-  /** Verified worktree path. */
-  path: string;
-  /** Git's canonical root for the verified checkout. */
-  repoRoot: string;
-  /** Recomputed full content identity. */
-  contentHash: `sha256:${string}`;
-  /** Exact verified binary-patch bytes. Candidate-bundle builders encode this
-   *  directly instead of reproducing Git diff options. */
-  patchBytes: Uint8Array;
-}
-/**
- * Git-backed `WorktreeAdapter`: creates isolated worktrees on fresh branches, commits agent changes, and discards losers.
- */
-declare function gitWorktreeAdapter(opts: GitWorktreeAdapterOptions): WorktreeAdapter;
-/** Verify a finalized code surface against its current checkout. This rejects
- *  dirty/ignored files, moved refs, missing Git objects, raw byte/mode
- *  mismatches, external symlinks, and submodules. */
-declare function verifyCodeSurface(surface: CodeSurface, worktreeDir?: string): CodeSurfaceVerification;
-/** Resolve a code candidate for evaluation only after verifying its immutable
- *  identity against the checkout at `worktreeRef`. */
-declare function resolveWorktreePath(surface: CodeSurface, worktreeDir?: string): string;
-//#endregion
-export { makePlaybackDispatch as $, CrossSurfaceEvidenceBreakdown as $t, scoreDiscrimination as A, LoadEvalFixtureScenariosOptions as At, ProfileMatrixSegmentResult as B, CrossSurfaceAttemptCompleteness as Bt, acquireSingleRunLock as C, SearchLedgerIntegrityError as Cn, neutralizationGate as Ct, compareRankKeys as D, EvalFixtureRunPlan as Dt, campaignMeanComposite as E, EvalFixtureLoadOptions as Et, FinalizeProfileMatrixOptions as F, planEvalFixtureRun as Ft, PlaybackContext as G, CrossSurfaceCandidateEvidence as Gt, createProfileMatrixPlan as H, CrossSurfaceBootstrapPolicy as Ht, FinalizedProfileMatrixResult as I, analyzeCrossSurfaceInteractions as It, ScoreboardRenderOptions as J, CrossSurfaceComponent as Jt, PlaybackDriver as K, CrossSurfaceCandidateOutcome as Kt, ProfileMatrixCoverage as L, AnalyzeCrossSurfaceInteractionsInput as Lt, resolveRunDir as M, discoverEvalFixtures as Mt, tangleTracesRoot as N, loadEvalFixture as Nt, DiscriminationScore as O, EvalFixtureScenario as Ot, CreateProfileMatrixPlanOptions as P, loadEvalFixtureScenarios as Pt, UserStoryVerdict as Q, CrossSurfaceEligibility as Qt, ProfileMatrixPlan as R, CrossSurfaceAdditionDecision as Rt, SingleRunLockOptions as S, SearchLedgerError as Sn, NeutralizationGateOptions as St, campaignBreakdown as T, EvalFixtureFile as Tt, finalizeProfileMatrix as U, CrossSurfaceCandidate as Ut, RunProfileMatrixSegmentOptions as V, CrossSurfaceBestSingleSelection as Vt, runProfileMatrixSegment as W, CrossSurfaceCandidateComparison as Wt, ScoreboardSummary as X, CrossSurfaceCompositionStep as Xt, ScoreboardRow as Y, CrossSurfaceComponentEvidence as Yt, UserStory as Z, CrossSurfaceDistribution as Zt, componentSurfaceIdentityMaterial as _, TraceAnalystArtifact as _n, RolloutCall as _t, WorktreeAdapterError as a, CrossSurfaceInteractionTask as an, ProfileMatrixError as at, surfaceHash as b, traceAnalystQualityJudge as bn, classifyUngroundedLiterals as bt, verifyCodeSurface as c, CrossSurfacePairEvidence as cn, RunProfileMatrixResult as ct, PhoenixEvaluationResultLike as d, CrossSurfaceRankedSingle as dn, neutralizeText as dt, CrossSurfaceIneligibilityReason as en, renderScoreboardMarkdown as et, PhoenixEvaluatorLike as f, CrossSurfaceRelativeCost as fn, FsLabeledScenarioStore as ft, codeSurfaceIdentityMaterial as g, BuildTraceAnalystSurfaceDispatchOptions as gn, RolloutArgumentDiffOptions as gt, assertCodeSurfaceIdentity as h, CrossSurfaceTaskRow as hn, RolloutArgumentDiff as ht, WorktreeAdapter as i, CrossSurfaceInteractionReport as in, ProfileDispatchFn as it, selectDiscriminative as j, PlanEvalFixtureRunOptions as jt, ScenarioSignal as k, EvalFixtureValidationMode as kt, AutoevalsScoreLike as l, CrossSurfacePairIncompatibilityReason as ln, ScenarioRollup as lt, phoenixEvaluatorJudge as m, CrossSurfaceSelections as mn, LabeledScenarioStoreError as mt, GitWorktreeAdapterOptions as n, CrossSurfaceInteractionEffect as nn, scoreboardSummary as nt, gitWorktreeAdapter as o, CrossSurfaceNaiveStackSelection as on, ProfileSummary as ot, autoevalsScorerJudge as p, CrossSurfaceSelectionPolicy as pn, FsLabeledScenarioStoreOptions as pt, PlaybackStep as q, CrossSurfaceCandidateSummary as qt, Worktree as r, CrossSurfaceInteractionPath as rn, userStoryScoreboard as rt, resolveWorktreePath as s, CrossSurfacePairCompatibility as sn, RunProfileMatrixOptions as st, CodeSurfaceVerification as t, CrossSurfaceInteractionAwareSelection as tn, scoreUserStory as tt, AutoevalsScorerLike as u, CrossSurfacePairwiseEntry as un, runProfileMatrix as ut, renderSurfaceDiff as v, TraceAnalystScenario as vn, ScoredRollout as vt, CampaignBreakdown as w, EvalFixture as wt, SingleRunLock as x, SearchLedgerConflictError as xn, rolloutArgumentDiff as xt, surfaceContentHash as y, buildTraceAnalystSurfaceDispatch as yn, UngroundedLiteralReport as yt, ProfileMatrixRow as z, CrossSurfaceAdditionRejectionReason as zt };
-//# sourceMappingURL=index-CFDffsKz.d.ts.map