@tangle-network/agent-eval 0.144.5 → 0.144.7

package/dist/{index-CpxZSlB7.d.ts → index-Sh2I0DRc.d.ts}

@@ -1,15 +1,16 @@
-import { l as ValidationError, t as AgentEvalError } from "./errors-DkfjIDvD.js";
-import { T as RunPaidCallInput, m as CostReceipt, p as CostProvenance } from "./cost-ledger-FuQvHxPm.js";
-import { a as RunRecord, s as RunSplitTag } from "./run-record-ooo9FWns.js";
-import { f as AnalystUsageReceipt, i as AnalystFinding, l as AnalystRunResult, x as TraceAnalysisStore } from "./types-CZt1PBIk.js";
-import { n as CompletionVerdict, o as ProducedState, r as CorrectnessChecker, t as CompletionRequirement } from "./completion-verifier-VvpHRu78.js";
-import { _ as AnalystIssueExpectation, a as AnalystBenchmarkLabelState, t as AnalystBenchmarkCase } from "./benchmark-Fmo42QVE.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, b as GenerationRecord, d as DispatchContext, j as MutableSurface, k as LabeledScenarioStore, l as CodeSurface, p as Gate, u as ComponentSurface, w as JudgeScore } from "./types-Dcoaqcsc.js";
-import { E as RiskDifferenceResult, _ as McNemarResult, d as EProcessState, v as PairedBootstrapOptions, y as PairedBootstrapResult } from "./statistics-B4u_CiFd.js";
-import { A as PairedMcNemarEvidence, D as PairedDecisionMethod, j as PairedPromotionDecision, k as PairedDecisionStatistic } from "./summary-report-BOM6dfP7.js";
-import { in as PlanCampaignRunOptions, nn as CampaignRunPlan, un as CampaignStorage } from "./skillopt-optimization-method-CGz9ywhM.js";
-import { D as LedgerHash, m as LedgerTrustedHeadRemoval, p as LedgerTrustedHead } from "./index-DEb46kc6.js";
-import { AgentProfile, AgentProfile as AgentProfile$1, HarnessType, HarnessType as HarnessType$1 } from "@tangle-network/agent-interface";
+import { l as ValidationError, t as AgentEvalError } from "./errors-CKPfb2aH.js";
+import { T as RunPaidCallInput, m as CostReceipt, p as CostProvenance } from "./cost-ledger-Bv_e8XHY.js";
+import { a as RunRecord, s as RunSplitTag } from "./run-record-DdSa93_W.js";
+import { f as AnalystUsageReceipt, i as AnalystFinding, l as AnalystRunResult, w as TraceAnalysisStore } from "./types-DF_Udrp-.js";
+import { n as CompletionVerdict, o as ProducedState, r as CorrectnessChecker, t as CompletionRequirement } from "./completion-verifier-foUCLif_.js";
+import { D as AnalystIssueExpectation, d as AnalystBenchmarkCase, h as AnalystBenchmarkLabelState, t as AgentProfile$1 } from "./agent-profile-CgDTo40f.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-DYuNHo9R.js";
+import { y as PairedBootstrapResult } from "./statistics-D6Uebe_4.js";
+import { Ht as CampaignStorage, It as PlanCampaignRunOptions, Pt as CampaignRunPlan } from "./skillopt-optimization-method-BO7NAl3b.js";
+import { N as PairedArmsComparison } from "./statistical-heldout-Dn9ruizm.js";
+import "./promotion-policy-ChWhTDBH.js";
+import { D as LedgerHash, m as LedgerTrustedHeadRemoval, p as LedgerTrustedHead } from "./index-CvSN3IG1.js";
+import { AgentProfile } from "@tangle-network/agent-interface";
 //#region src/campaign/analyst-surface.d.ts
 interface TraceAnalystScenario extends Scenario {
   kind: 'trace-analyst';
@@ -34,152 +35,6 @@ interface BuildTraceAnalystSurfaceDispatchOptions {
 declare function buildTraceAnalystSurfaceDispatch(options: BuildTraceAnalystSurfaceDispatchOptions): (surface: MutableSurface, scenario: TraceAnalystScenario, context: DispatchContext) => Promise<TraceAnalystArtifact>;
 declare function traceAnalystQualityJudge(): JudgeConfig<TraceAnalystArtifact, TraceAnalystScenario>;
 //#endregion
-//#region src/paired-arms.d.ts
-/** One arm observation of one work item. Structural on purpose: callers
- *  project their own record type (e.g. a `RunRecord`) into this shape. */
-interface PairedArmRow {
-  /** Matching key — rows sharing a `pairKey` across both arms form pairs
-   *  (typically the task/scenario/seed identity). */
-  pairKey: string;
-  /** Rep identity within a `pairKey` (e.g. a seed or rep number). Required on
-   *  every row of a `pairKey` that has more than one rep in either arm; reps
-   *  then pair only on exact (`pairKey`, `repKey`) match, never on outcome
-   *  content. Optional when each arm has at most one rep of the item. */
-  repKey?: string;
-  /** Arm label this row was produced under. */
-  arm: string;
-  /** Binary outcome; omit when the comparison has no pass/fail notion. */
-  pass?: boolean;
-  /** Named numeric measurements (score, cost, latency, …). */
-  metrics?: Record<string, number>;
-}
-interface PairArmsOptions {
-  /** Arm treated as the control side of every pair. */
-  baselineArm: string;
-  /** Arm treated as the treatment side of every pair. */
-  treatmentArm: string;
-}
-/** One matched (baseline, treatment) observation of the same work item. */
-interface MatchedPair {
-  pairKey: string;
-  /** 0-based position of this pair within its `pairKey`, ordered by sorted
-   *  `repKey` (always 0 for a single-rep item). The rep identity itself is on
-   *  the rows (`baseline.repKey` / `treatment.repKey`). */
-  repIndex: number;
-  baseline: PairedArmRow;
-  treatment: PairedArmRow;
-}
-interface PairArmsResult {
-  /** Matched pairs, ordered by (`pairKey`, `repIndex`). */
-  pairs: MatchedPair[];
-  /** Baseline rows left without a treatment counterpart — reported, never
-   *  silently dropped. */
-  unpairedBaseline: PairedArmRow[];
-  /** Treatment rows left without a baseline counterpart. */
-  unpairedTreatment: PairedArmRow[];
-}
-/**
- * Match rows across two arms into (baseline, treatment) pairs by `pairKey`.
- *
- * A `pairKey` with at most one row per arm pairs directly, no `repKey`
- * needed. A `pairKey` with multiple reps in either arm requires `repKey` on
- * every one of its rows, and reps pair only on exact (`pairKey`, `repKey`)
- * match — pairing is keyed purely on row identity, never on outcome content
- * (outcome-keyed matching deflates discordant counts and biases McNemar), and
- * is therefore independent of input order. Reps whose `repKey` has no
- * counterpart in the other arm, and items present in only one arm, land in
- * the unpaired lists — reported, never truncated.
- *
- * Fail-loud: throws when either named arm has zero rows (an unknown arm
- * name would otherwise read as "everything unpaired"), when the two arm
- * names are equal, when a multi-rep `pairKey` has a row without `repKey`, or
- * when a (`pairKey`, arm) group repeats a `repKey` (the match would be
- * ambiguous).
- */
-declare function pairArms(rows: readonly PairedArmRow[], opts: PairArmsOptions): PairArmsResult;
-/** Paired pass/fail comparison over the pairs where BOTH sides carry `pass`. */
-interface PairedCorrectness {
-  /** Discordant pairs where the treatment passed and the baseline failed. */
-  b10: number;
-  /** Discordant pairs where the baseline passed and the treatment failed. */
-  b01: number;
-  /** Exact McNemar significance over the paired outcomes (`b === b10`, `c === b01`). */
-  mcnemar: McNemarResult;
-  /** Paired effect size: p(treatment) − p(baseline) with a paired-variance CI. */
-  riskDifference: RiskDifferenceResult;
-}
-/** Paired delta summary for one named metric (delta = treatment − baseline). */
-interface PairedMetricDelta {
-  name: string;
-  /** Pairs where BOTH sides carry a finite value for this metric. */
-  n: number;
-  /** Pairs where at least one side does not carry the metric. */
-  nMissing: number;
-  /** Median paired delta, or null when `n === 0`. */
-  medianDelta: number | null;
-  /** Mean paired delta, or null when `n === 0`. */
-  meanDelta: number | null;
-  /** Bootstrap CI on the paired delta (`pairedBootstrap`); null when
-   *  `n === 0` — a zero-width [0, 0] interval on no data would read as a
-   *  measured tight null. */
-  bootstrapCi: PairedBootstrapResult | null;
-  /** Wilcoxon signed-rank test on the paired deltas; null when `n === 0`. */
-  wilcoxon: {
-    w: number;
-    p: number;
-  } | null;
-}
-interface ComparePairedArmsOptions extends PairArmsOptions {
-  /** Metrics to compare. Default: every metric name observed on any matched
-   *  pair, sorted. A name that appears on no pair is still reported (with
-   *  `n = 0`) so a misspelled metric is visible instead of vanishing. */
-  metricNames?: string[];
-  /** Passed through to `pairedBootstrap` — set `seed` for reproducible CIs. */
-  bootstrap?: PairedBootstrapOptions;
-}
-interface PairedArmsComparison {
-  nPairs: number;
-  nUnpairedBaseline: number;
-  nUnpairedTreatment: number;
-  /** null when no matched pair carries `pass` on both sides — a pass/fail
-   *  verdict over rows that never measured pass/fail would be fabricated. */
-  correctness: PairedCorrectness | null;
-  metricDeltas: PairedMetricDelta[];
-}
-/**
- * Full matched-pair arm comparison: pair via {@link pairArms}, then compose
- * the paired estimators from `statistics` over the matched pairs.
- *
- * Correctness uses only the pairs where both sides carry `pass` (`mcnemar.n`
- * is that subset's size); each metric uses only the pairs where both sides
- * carry a finite value for it, with the remainder counted in `nMissing`.
- * Deltas are treatment − baseline throughout.
- *
- * Fail-loud: inherits {@link pairArms}'s unknown-arm throw, and throws on a
- * non-finite metric value — silently treating corrupt telemetry as "metric
- * absent" would misreport it as missing coverage.
- */
-declare function comparePairedArms(rows: readonly PairedArmRow[], opts: ComparePairedArmsOptions): PairedArmsComparison;
-interface MatchedRunRecordPair {
-  pairKey: string;
-  repKey: string;
-  baseline: RunRecord;
-  treatment: RunRecord;
-}
-interface PairRunRecordsResult {
-  pairs: MatchedRunRecordPair[];
-  unpairedBaseline: RunRecord[];
-  unpairedTreatment: RunRecord[];
-}
-/**
- * Pair two RunRecord arms by the identity of the evaluated work:
- * `(experimentId, scenarioId, seed)`.
- *
- * Falling back to array order, candidate id, or experiment id can compare
- * different tasks and fabricate lift. Duplicate identities throw.
- */
-declare function pairRunRecords(baselineRuns: readonly RunRecord[], treatmentRuns: readonly RunRecord[]): PairRunRecordsResult;
-//#endregion
 //#region src/campaign/cross-surface-types.d.ts
 /** Whether one candidate attempt produced a usable executable outcome. */
 type CrossSurfaceAttemptCompleteness = 'complete' | 'missing' | 'invalid';
@@ -525,409 +380,6 @@ interface NeutralizationGateOptions<TScenario extends Scenario = Scenario> {
  */
 declare function neutralizationGate<TArtifact, TScenario extends Scenario>(options: NeutralizationGateOptions<TScenario>): Gate<TArtifact, TScenario>;
 //#endregion
-//#region src/pre-registration.d.ts
-/**
- * Pre-registered hypotheses — declare what you're testing BEFORE the
- * run, check it AFTER. Prevents p-hacking, optional stopping, and the
- * "we ran until it looked good" failure mode.
- *
- * Manifest is a plain JSON-friendly object. Sign it with a content hash
- * + timestamp; the registered record becomes immutable. Post-run,
- * evaluate the manifest against observed results — the library refuses
- * to let you re-interpret a different metric as the declared one.
- */
-interface HypothesisManifest {
-  id: string;
-  /** Human prose — goes into the audit trail. */
-  hypothesis: string;
-  /** Metric the hypothesis claims to move. */
-  metric: string;
-  /** 'increase' = candidate should score higher than baseline; 'decrease' = lower. */
-  direction: 'increase' | 'decrease';
-  /** Minimum effect size to count (same units as the metric). */
-  minEffect: number;
-  /** Alpha threshold. */
-  alpha: number;
-  /** Target statistical power at which sample size was pre-computed. */
-  power: number;
-  /** Declared N per arm before running. */
-  preRegisteredN: number;
-  /** ISO8601 timestamp the manifest was registered. */
-  registeredAt: string;
-  /** Optional identifiers to tie into the trace corpus. */
-  baselineLabel?: string;
-  candidateLabel?: string;
-}
-/**
- * Identifier for the hashing scheme used to produce `contentHash`.
- *
- * `'sha256-content'` — sha256 hex over the canonicalized manifest with
- * the `contentHash` and `algo` fields stripped. Held as a string union
- * so future schemes can be added without breaking parsers; SignedManifest
- * values without `algo` deserialize cleanly because the field is optional.
- */
-type SignedManifestAlgo = 'sha256-content';
-interface SignedManifest extends HypothesisManifest {
-  /** sha256 hex of canonicalized manifest (everything except contentHash and algo). */
-  contentHash: string;
-  /**
-   * Algorithm string describing how `contentHash` was produced.
-   *
-   * Optional on the type so serialized manifests without it still parse,
-   * but ALWAYS populated by {@link signManifest}. Consumers that want to
-   * enforce a known algorithm should reject manifests where this field
-   * is missing or unrecognized.
-   */
-  algo?: SignedManifestAlgo;
-}
-interface HypothesisResult {
-  manifest: SignedManifest;
-  observedN: number;
-  observedEffect: number;
-  observedPValue: number;
-  /** True iff the observed effect hits the pre-declared direction with
-   *  magnitude ≥ minEffect AND p < alpha. */
-  confirmed: boolean;
-  /** Enumerated reasons the hypothesis was rejected (each a machine-tag). */
-  rejectionReasons: Array<'wrong_direction' | 'effect_too_small' | 'not_significant' | 'undersampled'>;
-  notes?: string;
-}
-/**
- * Deterministic JSON canonicalization — sort object keys recursively.
- *
- * Two semantically-equal objects produce byte-identical canonicalized output;
- * this is what makes a content-hash stable across encoders, key insertion
- * orders, and runtime versions. Exported for any consumer that needs the same
- * canonicalization guarantee outside the manifest-signing path (e.g., signing
- * an artifact bundle, hashing a dataset version, etc.).
- */
-declare function canonicalize(v: unknown): unknown;
-/**
- * SHA-256 hex (full 64 chars) over the canonicalized JSON encoding of `obj`.
- *
- * The same primitive `signManifest` and `verifyManifest` are built on, exposed
- * directly so consumers signing arbitrary structured content (artifact bundles,
- * production packets, dataset manifests, etc.) don't have to re-derive
- * canonicalize+sha256 from scratch.
- *
- * Stable across:
- *   - object key insertion order (canonicalization sorts keys recursively)
- *   - encoder choice (UTF-8 via TextEncoder, fixed)
- *   - runtime (uses the Web Crypto subtle digest, present in Node ≥18 and browsers)
- *
- * Named `hashJson` to disambiguate from `prompt-registry.ts`'s `hashContent`,
- * which takes a string input and returns a truncated 12-char prompt id.
- * Use `hashJson` when you mean "canonicalize then hash."
- *
- * @example
- *   const hash = await hashJson({ id: '1', kind: 'spec' })
- *   // 'a3f1...' (64 hex chars)
- */
-declare function hashJson<T>(obj: T): Promise<string>;
-/**
- * Sign a manifest with a SHA-256 content hash.
- *
- * The hash covers the canonicalized manifest with the `contentHash`
- * and `algo` fields stripped; this lets verifiers re-sign the rest and
- * compare. Returned manifest always carries `algo: 'sha256-content'`
- * so downstream consumers can identify the scheme; manifests without
- * `algo` still verify because it is stripped before hashing on both sides.
- */
-declare function signManifest(m: HypothesisManifest): Promise<SignedManifest>;
-/**
- * Verify that a signed manifest has not been tampered with.
- *
- * Strips `contentHash` and `algo` before re-signing so manifests without
- * `algo` verify identically to ones that carry it.
- */
-declare function verifyManifest(m: SignedManifest): Promise<boolean>;
-/**
- * Evaluate a pre-registered hypothesis against observed results.
- * Mechanical — no re-interpretation permitted.
- */
-declare function evaluateHypothesis(manifest: SignedManifest, observed: {
-  n: number;
-  effect: number;
-  pValue: number;
-}): Promise<HypothesisResult>;
-//#endregion
-//#region src/campaign/gates/sequential.d.ts
-type SequentialDecision = 'promote' | 'continue' | 'undecided-at-maxN';
-interface SequentialObservation {
-  decision: SequentialDecision;
-  /** Current e-value (the betting wealth) against H0. */
-  eValue: number;
-  /** Paired deltas consumed so far. */
-  n: number;
-  /** Names the decision basis. For 'undecided-at-maxN' it states explicitly
-   *  that exhausting the budget is NOT evidence of no effect. */
-  reason: string;
-}
-interface SequentialPairedGateOptions {
-  /** Type-I budget. With `preRegistration` bound this MUST match
-   *  `manifest.alpha` (conflict throws). Default 0.05. */
-  alpha?: number;
-  /** Minimum paired deltas before a promote may fire. The stopping rule is
-   *  "first n ≥ minN with e-value ≥ 1/alpha" — still a valid stopping time.
-   *  Default 5. */
-  minN?: number;
-  /** Pre-registered observation budget. Required unless `preRegistration`
-   *  supplies it via `preRegisteredN` (conflict throws). */
-  maxN?: number;
-  /** Bet truncation forwarded to `eProcess`. Default 0.5. */
-  maxBet?: number;
-  /** Bound on |delta| in the judge's native scale; deltas are mapped to
-   *  x = (d/scale + 1)/2 ∈ [0,1]. A delta outside ±scale throws (use
-   *  `detectScale` to pick 1 vs 100 BEFORE streaming). Default 1. */
-  scale?: number;
-  /** Seed for the data-independent shuffle of paired deltas in `decide(ctx)`
-   *  (exchangeability guard). Default 1337. */
-  shuffleSeed?: number;
-  /** Bind the pre-registered hypothesis. Verified (content hash) at
-   *  construction; alpha/maxN/direction/minEffect come FROM the manifest. */
-  preRegistration?: SignedManifest;
-  /** Override the gate name in reports. */
-  name?: string;
-}
-interface SequentialPairedGate<TArtifact = unknown, TScenario extends Scenario = Scenario> extends Gate<TArtifact, TScenario> {
-  /** Streaming entry point: feed one paired per-scenario delta
-   *  (candidate − baseline, native scale). Each gate instance carries ONE
-   *  observe-stream; `decide(ctx)` runs on its own fresh stream and never
-   *  consumes or advances this one. 'promote' is sticky; observing past the
-   *  pre-registered maxN throws (extending a finished stream after seeing
-   *  the result reopens optional stopping — start a NEW pre-registered
-   *  test). */
-  observe(delta: number): SequentialObservation;
-  /** Read-only snapshot of the observe-stream. */
-  state(): EProcessState & {
-    decision: SequentialDecision;
-  };
-}
-/**
- * Anytime-valid sequential paired gate. Conforms to the existing `Gate`
- * contract (`decide(ctx)` consumes candidate vs baseline judge scores via
- * `pairHoldout` — same pairing granularity as the fixed-n gates: full cellId,
- * never scenarioId) and adds a streaming `observe(delta)` entry for campaigns
- * that score cells incrementally and want to stop mid-stream.
- *
- * Decision mapping onto the substrate's five-valued `GateDecision`:
- *   - 'promote'            → 'ship'
- *   - 'continue'           → 'need_more_work' (stream ended before maxN with
- *                            the e-value undecided — more reps could decide)
- *   - 'undecided-at-maxN'  → 'hold', with the reason stating it is NOT
- *                            evidence of no effect (never a silent default)
- */
-declare function sequentialPairedGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(options: SequentialPairedGateOptions): SequentialPairedGate<TArtifact, TScenario>;
-interface SequentialDecideOptions {
-  /** Type-I budget for the early-stop evidence. Default 0.05. */
-  alpha?: number;
-  /** Minimum paired deltas before a stop may fire. Default 5. */
-  minN?: number;
-  /** Bet truncation forwarded to `eProcess`. Default 0.5. */
-  maxBet?: number;
-  /** Bound on |per-scenario composite delta|. Default 1. */
-  scale?: number;
-}
-interface SequentialDecideFn {
-  (args: {
-    history: GenerationRecord[];
-  }): {
-    stop: boolean;
-    reason?: string;
-  };
-  /** Read-only snapshot of the accumulated e-process (observability + tests). */
-  state(): EProcessState;
-}
-/**
- * `SurfaceProposer.decide` adapter — stops the optimization loop the moment
- * the e-process decides the loop has produced a real improvement, instead of
- * always running `maxGenerations`.
- *
- * Stream: for each generation g ≥ 1, the per-scenario composite deltas of
- * generation g's top candidate vs the generation-0 top candidate (the
- * incumbent the loop set out to beat), paired by scenarioId. H0: no proposed
- * surface improves any scenario's expected composite over the incumbent —
- * under it every delta has conditional mean ≤ 0 and the e-process is valid.
- * Once wealth ≥ 1/alpha the loop stops and hands the winner to the promotion
- * gate (which re-scores on HELD-OUT data — this adapter only spends the
- * exploration budget, it never promotes).
- *
- * Honesty caveats: (1) the incumbent's scores are measured once and shared
- * across all generations' deltas, so type-I control is exact only insofar as
- * those scores approximate the incumbent's true per-scenario means (more reps
- * → tighter); (2) an UNDECIDED process never stops the loop — absence of a
- * crossing is NOT evidence of no effect, so the loop simply runs its normal
- * course. Calling the adapter repeatedly with a growing history consumes each
- * generation exactly once (re-feeding an already-seen record would double-count
- * evidence).
- */
-declare function sequentialDecide(options?: SequentialDecideOptions): SequentialDecideFn;
-//#endregion
-//#region src/campaign/gates/statistical-heldout.d.ts
-interface PairedHoldout {
-  /** Baseline scalar per paired cell (same order as `after`/`cellIds`). */
-  before: number[];
-  /** Candidate scalar per paired cell. */
-  after: number[];
-  /** The full cellIds (`scenario:rep`) that paired, in order. */
-  cellIds: string[];
-}
-/**
- * Pair candidate vs baseline holdout observations by FULL cellId. `select`
- * pulls the scalar from a cell's judge reports (composite, or a named
- * dimension); a cell contributes the mean of `select` across its judges. Cells
- * whose scenario is not in `scenarioIds`, or where `select` is undefined for
- * every judge on either side, are skipped on BOTH sides so the arrays stay
- * paired. Throws when the two maps disagree on which holdout cells exist — a
- * load-bearing invariant: the baseline + winner holdout campaigns run the same
- * scenarios with the same seed base, so their cellIds MUST align; a mismatch
- * means a silent pairing bug, not a soft fallback.
- */
-declare function pairHoldout(candidate: Map<string, Record<string, JudgeScore>>, baseline: Map<string, Record<string, JudgeScore>>, scenarioIds: Set<string>, select: (s: JudgeScore) => number | undefined): PairedHoldout;
-interface HeldoutSignificance {
-  paired: PairedHoldout;
-  /**
-   * The paired bootstrap on the requested statistic (MEAN by default — see the
-   * tie note on `heldoutSignificance`).
-   *
-   * DIAGNOSTIC, not necessarily the interval the verdict keyed on. On a
-   * two-point (pass/fail) outcome the decision routes to Tango's score interval
-   * instead, because a percentile bootstrap of the mean over a three-atom
-   * lattice is not a valid interval at a nonzero margin. Read
-   * `decision.low`/`decision.high` for the interval that actually decided, and
-   * `decisionStatistic` for which one it is.
-   */
-  bootstrap: PairedBootstrapResult;
-  /** The MEDIAN paired-delta bootstrap, reported as a diagnostic. When many
-   *  scenarios are tied (both sides solve them), the median is pinned near 0
-   *  regardless of the mean lift — comparing the two exposes tie-domination. */
-  medianBootstrap: PairedBootstrapResult;
-  /**
-   * The full promotion decision: which estimator the outcome's shape admits,
-   * the interval it produced, McNemar's exact veto on the two-point path, and
-   * whether the interval was zero-width (no evidence in either direction). The
-   * single source of `significant`.
-   */
-  decision: PairedPromotionDecision;
-  /** Which paired estimator the verdict was decided on. */
-  decisionStatistic: PairedDecisionStatistic;
-  /** McNemar's exact evidence on the two-point path; null otherwise. */
-  mcnemar: PairedMcNemarEvidence | null;
-  /** Fraction of paired observations that are exact ties (|delta| < 1e-9). A
-   *  high tie fraction is WHY a median-based gate would have missed a real lift;
-   *  it is the observability the tie fix adds. */
-  tieFraction: number;
-  /** n paired observations. */
-  n: number;
-  /** Effective minimum after applying the bootstrap's hard statistical floor. */
-  minimumRequired: number;
-  /** Statistical method that carried the decision. */
-  decisionMethod: PairedDecisionMethod;
-  /** Exact one-sided p-value on the small-sample path; otherwise null. */
-  pValue: number | null;
-  /** True iff n >= minimumRequired, the DECIDING interval has nonzero width,
-   *  its lower bound clears the threshold, and McNemar's exact test does not
-   *  veto at a non-negative threshold. */
-  significant: boolean;
-  /** Set when n < minimumRequired — too little evidence to claim significance. */
-  fewRuns: boolean;
-}
-interface HeldoutSignificanceOptions {
-  deltaThreshold?: number;
-  minProductiveRuns?: number;
-  confidence?: number;
-  resamples?: number;
-  /** Fixed by default for a deterministic, reproducible gate verdict. */
-  seed?: number;
-  statistic?: 'mean' | 'median';
-}
-/**
- * Significance of the held-out composite lift: ship only when the lower bound
- * of the interval the outcome's shape ADMITS exceeds `deltaThreshold` (default
- * 0 ⇒ "confidently positive"). Interpret `deltaThreshold` in the judge's native
- * scale.
- *
- * The decision is delegated whole to {@link decidePairedPromotion}, the one
- * copy of the rule (`src/paired-promotion-decision.ts`), which `HeldOutGate`
- * also calls. That module's header carries the measurements; the short version
- * is three guards a bare `bootstrap.low > threshold` does not have:
- *
- *   - a two-point (pass/fail) outcome decides on Tango's SCORE interval, the
- *     only paired-binary construction that stays valid at a nonzero margin;
- *   - McNemar's exact test VETOES at any non-negative threshold;
- *   - a ZERO-WIDTH interval is refused rather than promoted, in either
- *     direction — [0,0] clears every negative threshold and [g,g] clears every
- *     threshold below g, and both are an absence of evidence, not a result.
- *
- * Measured on this function before those guards landed, at a nominal 5 %:
- * 14.60 % false promotion at n = 40 on a paired-binary noninferiority boundary,
- * and 88.50 % at n = 6 under a bounded asymmetric null whose true mean paired
- * delta is exactly 0.
- *
- * At small n, where the percentile bootstrap is descriptive only, a
- * pre-registered exact sign test still carries the bootstrap path.
- */
-declare function heldoutSignificance(paired: PairedHoldout, opts?: HeldoutSignificanceOptions): HeldoutSignificance;
-interface DimensionRegression {
-  dimension: string;
-  /** Paired bootstrap on (candidate − baseline). DIAGNOSTIC on a pass/fail
-   *  dimension, where `ci` carries the interval that decided instead. */
-  bootstrap: PairedBootstrapResult;
-  /** Which paired statistic `bootstrap.low` is the lower bound of. `'mean'`
-   *  unless the caller asked for the median. `bootstrap.median` still carries
-   *  the median point estimate either way. */
-  bootstrapStatistic: 'median' | 'mean';
-  /** The interval `regressed` was decided on, in the dimension's native units. */
-  ci: {
-    low: number;
-    high: number;
-  };
-  /** Which estimator produced `ci`. */
-  decisionStatistic: PairedDecisionStatistic;
-  /** McNemar's exact evidence on a pass/fail dimension; null otherwise. */
-  mcnemar: PairedMcNemarEvidence | null;
-  /** `ci` has zero width — no evidence in either direction. */
-  indeterminate: boolean;
-  /** True iff the candidate may have regressed this dimension by more than
-   *  tolerance: the lower bound of the DECIDING interval on (candidate −
-   *  baseline) is below −tolerance, OR the exact small-sample test proves a drop
-   *  past tolerance. */
-  regressed: boolean;
-  tolerance: number;
-  n: number;
-}
-/** Detect the native scale of a set of scores: 0-100 when any magnitude clears
- *  1.5, else [0,1]. Used to auto-scale the regression tolerance so a default
- *  expressed for [0,1] is not silently a no-op on a 0-100 dimension. */
-declare function detectScale(values: number[]): 1 | 100;
-/** Per-critical-dimension regression guard. For each dimension, pair the
- *  candidate vs baseline values by full cellId and bootstrap the paired delta;
- *  a dimension is "regressed" when the CI lower bound < −tolerance (conservative
- *  — blocks if the credible worst case exceeds tolerance, which is the right
- *  posture for safety dimensions like `hallucination_free`). When `tolerance`
- *  is omitted it auto-scales: 0.05 on [0,1], 5 on 0-100.
- *
- *  The interval comes from {@link decidePairedPromotion}, so a pass/fail
- *  dimension is judged on Tango's score interval rather than a percentile
- *  bootstrap of the mean — `tolerance` is a NONZERO margin, and the bootstrap
- *  is not a valid interval at one. That matters most here because this guard
- *  fails OPEN by construction: `tolerance` is positive, so an interval pinned at
- *  [0,0] never satisfies `low < −tolerance` and a real regression on a safety
- *  dimension would be reported as `regressed: false`. On the median it fails the
- *  same way for the same reason — when most pairs tie, which is automatic for a
- *  pass/fail dimension on {0,1} and on the 0-100 encoding `detectScale` exists
- *  to support, the median CI collapses to [0,0]. Pass `statistic: 'median'` to
- *  restore the pre-0.134 behaviour. */
-declare function dimensionRegressions(candidate: Map<string, Record<string, JudgeScore>>, baseline: Map<string, Record<string, JudgeScore>>, scenarioIds: Set<string>, criticalDimensions: string[], opts?: {
-  tolerance?: number;
-  confidence?: number;
-  resamples?: number;
-  seed?: number;
-  /** Paired statistic the CI is computed on. Default `'mean'` — see
-   *  {@link DECISION_PAIRED_DELTA_STATISTIC} for why the median is not. */
-  statistic?: 'mean' | 'median';
-}): DimensionRegression[];
-//#endregion
 //#region src/campaign/grounded-reflection.d.ts
 /**
  * Evidence grounding for reflective optimizers (GEPA-style revise loops).
@@ -1118,92 +570,6 @@ type RuntimeEventLike = ToolCallEventLike | ArtifactEventLike | ProposalEventLik
  */
 declare function extractProducedState(events: readonly RuntimeEventLike[]): ProducedState;
 //#endregion
-//#region src/agent-profile.d.ts
-/**
- * The agentic coding harnesses an eval sweeps by default — the ones we care about
- * ranking. This is the SINGLE source of that list; consumers import it instead of
- * re-declaring their own (a re-declared list is how the fleet drifts). Pass an
- * explicit `harnesses` (e.g. `harnessTypeSchema.options` for literally every known
- * harness) to widen beyond these.
- */
-declare const CODING_HARNESSES: readonly HarnessType[];
-interface ProfileAxisSpec {
-  /** The domain profile to sweep. Its prompt/tools/skills are held fixed; only the
-   *  harness and model vary. `model.default` is the fallback model. */
-  base: AgentProfile;
-  /** Harnesses to cross. Default: {@link CODING_HARNESSES}. */
-  harnesses?: readonly HarnessType[];
-  /** Models to cross. Default: `[base.model.default]` — one model, i.e. today's
-   *  single-model behaviour, so omitting this never changes an existing run. */
-  models?: readonly string[];
-  /** Force every (harness, model) pair verbatim, even ones the harness can't run —
-   *  for deliberately testing failure modes. Default (false): SNAP instead — a
-   *  vendor-locked harness runs only the swept models in its family, or its native
-   *  default when it supports none, so no harness is dropped and none gets a
-   *  guaranteed-failing foreign-model cell. */
-  keepIncompatible?: boolean;
-}
-/** Model sentinel for a vendor-locked harness that supports none of the swept models:
- *  it carries no provider prefix, so `harnessSupportsModel` accepts it and the harness
- *  resolves it to its own native default model at runtime (e.g. kimi-code → its Kimi
- *  model). Lets `expandProfileAxes` snap-instead-of-drop without a per-harness flagship
- *  table that would rot as router catalogs change. */
-declare const HARNESS_NATIVE_MODEL = "default";
-/**
- * Expand a base profile across the harness × model matrix into the `AgentProfile[]`
- * that `runProfileMatrix` / `selfImprove` score — the ONE place "which harnesses ×
- * which models do we evaluate" lives, so no product hand-rolls its own harness list
- * or column→profile mapping (the pattern that let those copies drift and silently
- * break the harness pivot).
- *
- * Each cell clones `base`, sets the canonical top-level `harness` and `model.default`,
- * and stamps `metadata.harness` + `metadata.harnessModel` for matrix grouping. Both
- * metadata fields are hash-bearing, so every cell gets a distinct `agentProfileId` row
- * and results join back by harness/model via {@link harnessAxisOf} with no
- * hand-recomputed key. A vendor-locked harness snaps to its family's swept models — or
- * its native default ({@link HARNESS_NATIVE_MODEL}) when it supports none — so every
- * requested harness runs; `keepIncompatible` forces every pair verbatim.
- *
- * Omit `harnesses`/`models` to sweep the full default set — the "turn it on for
- * everything we care about" switch, identical in shape whether one harness or all.
- */
-declare function expandProfileAxes(spec: ProfileAxisSpec): AgentProfile[];
-/**
- * Read the (harness, model) a matrix cell ran under, off a profile or a result row's
- * profile — the join-back for a `byHarness` pivot. Returns undefined when the profile
- * wasn't produced by {@link expandProfileAxes}. Callers group `result.byProfile` by
- * this instead of recomputing an id (recomputing the wrong key is what broke the pivot
- * in the hand-rolled copies).
- */
-declare function harnessAxisOf(profile: Pick<AgentProfile, 'metadata'>): {
-  harness: HarnessType;
-  model: string;
-} | undefined;
-/**
- * Collision-resistant, path-safe, human-readable profile id for eval artifacts.
- * Scorecard joins still use `agentProfileHash`; this id is for run ids, matrix
- * keys, and directory names where two profiles must not collapse onto one row.
- * The suffix is the first 64 bits of the behaviour hash, enough for ordinary
- * eval matrices while keeping filenames readable.
- */
-declare function agentProfileId(profile: AgentProfile): string;
-/**
- * Model snapshot used for `RunRecord.model`. Eval surfaces require a concrete
- * model id because run records reject bare/missing model aliases.
- */
-declare function agentProfileModelId(profile: AgentProfile): string;
-/**
- * Deterministic behaviour identity for the canonical
- * `@tangle-network/agent-interface` AgentProfile.
- *
- * `name` and `description` are labels and do not affect the hash. Profile
- * `version`, prompt, model hints, tools, resources, hooks, modes, permissions,
- * and extensions do affect the hash. Resource array order is hash-bearing
- * because mount order can change agent behaviour. Undefined fields are treated
- * as absent; explicit `null` fields remain hash-bearing.
- */
-declare function agentProfileHash(profile: AgentProfile): string;
-//#endregion
 //#region src/integrity/backend-integrity.d.ts
 interface BackendIntegrityReport {
   /** Total records inspected. */
@@ -2145,5 +1511,5 @@ declare function verifyCodeSurface(surface: CodeSurface, worktreeDir?: string):
  *  identity against the checkout at `worktreeRef`. */
 declare function resolveWorktreePath(surface: CodeSurface, worktreeDir?: string): string;
 //#endregion
-export { SearchPlannedEvent as $, EvalFixtureScenario as $n, pairRunRecords as $r, HarnessType$1 as $t, SearchAccountingAudit as A, SequentialDecideFn as An, CrossSurfaceInteractionTask as Ar, UserStory as At, SearchCostAccounting as B, SignedManifest as Bn, CrossSurfaceTaskRow as Br, RunProfileMatrixOptions as Bt, surfaceHash as C, HeldoutSignificance as Cn, CrossSurfaceEligibility as Cr, tangleTracesRoot as Ct, FileSearchLedger as D, dimensionRegressions as Dn, CrossSurfaceInteractionEffect as Dr, ScoreboardRenderOptions as Dt, acquireSingleRunLock as E, detectScale as En, CrossSurfaceInteractionAwareSelection as Er, PlaybackStep as Et, SearchCandidateRegisteredEvent as F, SequentialPairedGateOptions as Fn, CrossSurfacePairwiseEntry as Fr, scoreboardSummary as Ft, SearchLedgerEvent as G, signManifest as Gn, PairArmsResult as Gr, BackendIntegrityReport as Gt, SearchLedger as H, canonicalize as Hn, MatchedPair as Hr, ScenarioRollup as Ht, SearchCandidateSlot as I, sequentialDecide as In, CrossSurfaceRankedSingle as Ir, userStoryScoreboard as It, SearchLedgerTrustedHeadMode as J, neutralizationGate as Jn, PairedArmsComparison as Jr, summarizeAgentReceiptIntegrity as Jt, SearchLedgerHash as K, verifyManifest as Kn, PairRunRecordsResult as Kr, assertRealAgentReceipts as Kt, SearchCandidateSlotClosedEvent as L, sequentialPairedGate as Ln, CrossSurfaceRelativeCost as Lr, ProfileDispatchFn as Lt, SearchAttemptAccounting as M, SequentialDecision as Mn, CrossSurfacePairCompatibility as Mr, makePlaybackDispatch as Mt, SearchCandidateDecidedEvent as N, SequentialObservation as Nn, CrossSurfacePairEvidence as Nr, renderScoreboardMarkdown as Nt, OpenSearchLedgerOptions as O, heldoutSignificance as On, CrossSurfaceInteractionPath as Or, ScoreboardRow as Ot, SearchCandidateLineage as P, SequentialPairedGate as Pn, CrossSurfacePairIncompatibilityReason as Pr, scoreUserStory as Pt, SearchPlan as Q, EvalFixtureRunPlan as Qn, pairArms as Qr, HARNESS_NATIVE_MODEL as Qt, SearchCandidateSurface as R, HypothesisManifest as Rn, CrossSurfaceSelectionPolicy as Rr, ProfileMatrixError as Rt, surfaceContentHash as S, DimensionRegression as Sn, CrossSurfaceDistribution as Sr, resolveRunDir as St, SingleRunLockOptions as T, PairedHoldout as Tn, CrossSurfaceIneligibilityReason as Tr, PlaybackDriver as Tt, SearchLedgerAppendResult as U, evaluateHypothesis as Un, MatchedRunRecordPair as Ur, runProfileMatrix as Ut, SearchFailureReason as V, SignedManifestAlgo as Vn, ComparePairedArmsOptions as Vr, RunProfileMatrixResult as Vt, SearchLedgerEntry as W, hashJson as Wn, PairArmsOptions as Wr, BackendIntegrityError as Wt, SearchOperationKind as X, EvalFixtureFile as Xn, PairedMetricDelta as Xr, AgentProfile$1 as Xt, SearchModelIdentity as Y, EvalFixture as Yn, PairedCorrectness as Yr, summarizeBackendIntegrity as Yt, SearchOperationRecordedEvent as Z, EvalFixtureLoadOptions as Zn, comparePairedArms as Zr, CODING_HARNESSES as Zt, assertCodeSurfaceIdentity as _, RolloutCall as _n, CrossSurfaceCandidateOutcome as _r, compareRankKeys as _t, WorktreeAdapterError as a, harnessAxisOf as an, loadEvalFixtureScenarios as ar, SearchSurfaceKind as at, componentSurfaceIdentityMaterial as b, classifyUngroundedLiterals as bn, CrossSurfaceComponentEvidence as br, scoreDiscrimination as bt, verifyCodeSurface as c, RuntimeEventLike as cn, AnalyzeCrossSurfaceInteractionsInput as cr, SearchTokenAccounting as ct, PhoenixEvaluationResultLike as d, neutralizeText as dn, CrossSurfaceAttemptCompleteness as dr, SearchLedgerConflictError as dt, BuildTraceAnalystSurfaceDispatchOptions as ei, ProfileAxisSpec as en, EvalFixtureValidationMode as er, SearchPlannedOperation as et, PhoenixEvaluatorLike as f, FsLabeledScenarioStore as fn, CrossSurfaceBestSingleSelection as fr, SearchLedgerError as ft, isTransientTransportFailure as g, RolloutArgumentDiffOptions as gn, CrossSurfaceCandidateEvidence as gr, campaignMeanComposite as gt, TransientFailureOptions as h, RolloutArgumentDiff as hn, CrossSurfaceCandidateComparison as hr, campaignBreakdown as ht, WorktreeAdapter as i, traceAnalystQualityJudge as ii, expandProfileAxes as in, loadEvalFixture as ir, SearchSurfaceEvidence as it, SearchArtifactRef as j, SequentialDecideOptions as jn, CrossSurfaceNaiveStackSelection as jr, UserStoryVerdict as jt, SEARCH_LEDGER_SCHEMA as k, pairHoldout as kn, CrossSurfaceInteractionReport as kr, ScoreboardSummary as kt, AutoevalsScoreLike as l, ToolCallEventLike as ln, CrossSurfaceAdditionDecision as lr, openSearchLedger as lt, phoenixEvaluatorJudge as m, LabeledScenarioStoreError as mn, CrossSurfaceCandidate as mr, CampaignBreakdown as mt, GitWorktreeAdapterOptions as n, TraceAnalystScenario as ni, agentProfileId as nn, PlanEvalFixtureRunOptions as nr, SearchSourceRef as nt, gitWorktreeAdapter as o, ArtifactEventLike as on, planEvalFixtureRun as or, SearchTaskAttemptedEvent as ot, autoevalsScorerJudge as p, FsLabeledScenarioStoreOptions as pn, CrossSurfaceBootstrapPolicy as pr, SearchLedgerIntegrityError as pt, SearchLedgerReplay as q, NeutralizationGateOptions as qn, PairedArmRow as qr, assertRealBackend as qt, Worktree as r, buildTraceAnalystSurfaceDispatch as ri, agentProfileModelId as rn, discoverEvalFixtures as rr, SearchSurfaceEffect as rt, resolveWorktreePath as s, ProposalEventLike as sn, analyzeCrossSurfaceInteractions as sr, SearchTaskOutcome as st, CodeSurfaceVerification as t, TraceAnalystArtifact as ti, agentProfileHash as tn, LoadEvalFixtureScenariosOptions as tr, SearchPlannedTask as tt, AutoevalsScorerLike as u, extractProducedState as un, CrossSurfaceAdditionRejectionReason as ur, validateSearchLedgerEvent as ut, assertComponentSurface as v, ScoredRollout as vn, CrossSurfaceCandidateSummary as vr, DiscriminationScore as vt, SingleRunLock as w, HeldoutSignificanceOptions as wn, CrossSurfaceEvidenceBreakdown as wr, PlaybackContext as wt, renderSurfaceDiff as x, rolloutArgumentDiff as xn, CrossSurfaceCompositionStep as xr, selectDiscriminative as xt, codeSurfaceIdentityMaterial as y, UngroundedLiteralReport as yn, CrossSurfaceComponent as yr, ScenarioSignal as yt, SearchCompletedEvent as z, HypothesisResult as zn, CrossSurfaceSelections as zr, ProfileSummary as zt };
-//# sourceMappingURL=index-CpxZSlB7.d.ts.map
+export { SearchPlannedEvent as $, CrossSurfacePairIncompatibilityReason as $n, ToolCallEventLike as $t, SearchAccountingAudit as A, CrossSurfaceAttemptCompleteness as An, UserStory as At, SearchCostAccounting as B, CrossSurfaceCompositionStep as Bn, RunProfileMatrixOptions as Bt, surfaceHash as C, loadEvalFixture as Cn, tangleTracesRoot as Ct, FileSearchLedger as D, AnalyzeCrossSurfaceInteractionsInput as Dn, ScoreboardRenderOptions as Dt, acquireSingleRunLock as E, analyzeCrossSurfaceInteractions as En, PlaybackStep as Et, SearchCandidateRegisteredEvent as F, CrossSurfaceCandidateEvidence as Fn, scoreboardSummary as Ft, SearchLedgerEvent as G, CrossSurfaceInteractionAwareSelection as Gn, BackendIntegrityReport as Gt, SearchLedger as H, CrossSurfaceEligibility as Hn, ScenarioRollup as Ht, SearchCandidateSlot as I, CrossSurfaceCandidateOutcome as In, userStoryScoreboard as It, SearchLedgerTrustedHeadMode as J, CrossSurfaceInteractionReport as Jn, summarizeAgentReceiptIntegrity as Jt, SearchLedgerHash as K, CrossSurfaceInteractionEffect as Kn, assertRealAgentReceipts as Kt, SearchCandidateSlotClosedEvent as L, CrossSurfaceCandidateSummary as Ln, ProfileDispatchFn as Lt, SearchAttemptAccounting as M, CrossSurfaceBootstrapPolicy as Mn, makePlaybackDispatch as Mt, SearchCandidateDecidedEvent as N, CrossSurfaceCandidate as Nn, renderScoreboardMarkdown as Nt, OpenSearchLedgerOptions as O, CrossSurfaceAdditionDecision as On, ScoreboardRow as Ot, SearchCandidateLineage as P, CrossSurfaceCandidateComparison as Pn, scoreUserStory as Pt, SearchPlan as Q, CrossSurfacePairEvidence as Qn, RuntimeEventLike as Qt, SearchCandidateSurface as R, CrossSurfaceComponent as Rn, ProfileMatrixError as Rt, surfaceContentHash as S, discoverEvalFixtures as Sn, resolveRunDir as St, SingleRunLockOptions as T, planEvalFixtureRun as Tn, PlaybackDriver as Tt, SearchLedgerAppendResult as U, CrossSurfaceEvidenceBreakdown as Un, runProfileMatrix as Ut, SearchFailureReason as V, CrossSurfaceDistribution as Vn, RunProfileMatrixResult as Vt, SearchLedgerEntry as W, CrossSurfaceIneligibilityReason as Wn, BackendIntegrityError as Wt, SearchOperationKind as X, CrossSurfaceNaiveStackSelection as Xn, ArtifactEventLike as Xt, SearchModelIdentity as Y, CrossSurfaceInteractionTask as Yn, summarizeBackendIntegrity as Yt, SearchOperationRecordedEvent as Z, CrossSurfacePairCompatibility as Zn, ProposalEventLike as Zt, assertCodeSurfaceIdentity as _, EvalFixtureRunPlan as _n, compareRankKeys as _t, WorktreeAdapterError as a, RolloutArgumentDiff as an, CrossSurfaceTaskRow as ar, SearchSurfaceKind as at, componentSurfaceIdentityMaterial as b, LoadEvalFixtureScenariosOptions as bn, scoreDiscrimination as bt, verifyCodeSurface as c, ScoredRollout as cn, TraceAnalystScenario as cr, SearchTokenAccounting as ct, PhoenixEvaluationResultLike as d, rolloutArgumentDiff as dn, SearchLedgerConflictError as dt, extractProducedState as en, CrossSurfacePairwiseEntry as er, SearchPlannedOperation as et, PhoenixEvaluatorLike as f, NeutralizationGateOptions as fn, SearchLedgerError as ft, isTransientTransportFailure as g, EvalFixtureLoadOptions as gn, campaignMeanComposite as gt, TransientFailureOptions as h, EvalFixtureFile as hn, campaignBreakdown as ht, WorktreeAdapter as i, LabeledScenarioStoreError as in, CrossSurfaceSelections as ir, SearchSurfaceEvidence as it, SearchArtifactRef as j, CrossSurfaceBestSingleSelection as jn, UserStoryVerdict as jt, SEARCH_LEDGER_SCHEMA as k, CrossSurfaceAdditionRejectionReason as kn, ScoreboardSummary as kt, AutoevalsScoreLike as l, UngroundedLiteralReport as ln, buildTraceAnalystSurfaceDispatch as lr, openSearchLedger as lt, phoenixEvaluatorJudge as m, EvalFixture as mn, CampaignBreakdown as mt, GitWorktreeAdapterOptions as n, FsLabeledScenarioStore as nn, CrossSurfaceRelativeCost as nr, SearchSourceRef as nt, gitWorktreeAdapter as o, RolloutArgumentDiffOptions as on, BuildTraceAnalystSurfaceDispatchOptions as or, SearchTaskAttemptedEvent as ot, autoevalsScorerJudge as p, neutralizationGate as pn, SearchLedgerIntegrityError as pt, SearchLedgerReplay as q, CrossSurfaceInteractionPath as qn, assertRealBackend as qt, Worktree as r, FsLabeledScenarioStoreOptions as rn, CrossSurfaceSelectionPolicy as rr, SearchSurfaceEffect as rt, resolveWorktreePath as s, RolloutCall as sn, TraceAnalystArtifact as sr, SearchTaskOutcome as st, CodeSurfaceVerification as t, neutralizeText as tn, CrossSurfaceRankedSingle as tr, SearchPlannedTask as tt, AutoevalsScorerLike as u, classifyUngroundedLiterals as un, traceAnalystQualityJudge as ur, validateSearchLedgerEvent as ut, assertComponentSurface as v, EvalFixtureScenario as vn, DiscriminationScore as vt, SingleRunLock as w, loadEvalFixtureScenarios as wn, PlaybackContext as wt, renderSurfaceDiff as x, PlanEvalFixtureRunOptions as xn, selectDiscriminative as xt, codeSurfaceIdentityMaterial as y, EvalFixtureValidationMode as yn, ScenarioSignal as yt, SearchCompletedEvent as z, CrossSurfaceComponentEvidence as zn, ProfileSummary as zt };
+//# sourceMappingURL=index-Sh2I0DRc.d.ts.map