@tangle-network/agent-eval 0.144.6 → 0.144.8

package/dist/statistical-heldout-Dn9ruizm.d.ts

@@ -0,0 +1,555 @@
+import { a as RunRecord } from "./run-record-DdSa93_W.js";
+import { R as Scenario, b as GenerationRecord, p as Gate, w as JudgeScore } from "./types-DYuNHo9R.js";
+import { E as RiskDifferenceResult, _ as McNemarResult, d as EProcessState, v as PairedBootstrapOptions, y as PairedBootstrapResult } from "./statistics-D6Uebe_4.js";
+import { a as PairedPromotionDecision, i as PairedMcNemarEvidence, r as PairedDecisionStatistic, t as PairedDecisionMethod } from "./paired-promotion-decision-B6zJ3gYM.js";
+//#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/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
+export { PairArmsResult as A, hashJson as C, MatchedPair as D, ComparePairedArmsOptions as E, PairedMetricDelta as F, comparePairedArms as I, pairArms as L, PairedArmRow as M, PairedArmsComparison as N, MatchedRunRecordPair as O, PairedCorrectness as P, pairRunRecords as R, evaluateHypothesis as S, verifyManifest as T, HypothesisManifest as _, detectScale as a, SignedManifestAlgo as b, pairHoldout as c, SequentialDecision as d, SequentialObservation as f, sequentialPairedGate as g, sequentialDecide as h, PairedHoldout as i, PairRunRecordsResult as j, PairArmsOptions as k, SequentialDecideFn as l, SequentialPairedGateOptions as m, HeldoutSignificance as n, dimensionRegressions as o, SequentialPairedGate as p, HeldoutSignificanceOptions as r, heldoutSignificance as s, DimensionRegression as t, SequentialDecideOptions as u, HypothesisResult as v, signManifest as w, canonicalize as x, SignedManifest as y };
+//# sourceMappingURL=statistical-heldout-Dn9ruizm.d.ts.map

package/dist/statistical-heldout-Dn9ruizm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistical-heldout-Dn9ruizm.d.ts","names":[],"sources":["../src/paired-arms.ts","../src/pre-registration.ts","../src/campaign/gates/sequential.ts","../src/campaign/gates/statistical-heldout.ts"],"mappings":";;;;;;;UAwCiB;;;EAGf;;;;;EAKA;;EAEA;;EAEA;;EAEA,UAAU;;UAGK;;EAEf;;EAEA;;;UAIe;EACf;;;;EAIA;EACA,UAAU;EACV,WAAW;;UAGI;;EAEf,OAAO;;;EAGP,kBAAkB;;EAElB,mBAAmB;;;;;;;;;;;;;;;;;;;;iBAqBL,SAAS,eAAe,gBAAgB,MAAM,kBAAkB;;UA8G/D;;EAEf;;EAEA;;EAEA,SAAS;;EAET,gBAAgB;;;UAID;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,aAAa;;EAEb;IAAY;IAAW;;;UAGR,iCAAiC;;;;EAIhD;;EAEA,YAAY;;UAGG;EACf;EACA;EACA;;;EAGA,aAAa;EACb,cAAc;;;;;;;;;;;;;;;iBAgBA,kBACd,eAAe,gBACf,MAAM,2BACL;UAmEc;EACf;EACA;EACA,UAAU;EACV,WAAW;;UAGI;EACf,OAAO;EACP,kBAAkB;EAClB,mBAAmB;;;;;;;;;iBAeL,eACd,uBAAuB,aACvB,wBAAwB,cACvB;;;;;;;;;;;;;UC1Wc;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;;;;;;;;;;KAWU;UAEK,uBAAuB;;EAEtC;;;;;;;;;EASA,OAAO;;UAGQ;EACf,UAAU;EACV;EACA;EACA;;;EAGA;;EAEA,kBAAkB;EAGlB;;;;;;;;;;;iBAYc,aAAa;;;;;;;;;;;;;;;;;;;;;;iBA8BP,SAAS,GAAG,KAAK,IAAI;;;;;;;;;;iBAkBrB,aAAa,GAAG,qBAAqB,QAAQ;;;;;;;iBAW7C,eAAe,GAAG,iBAAiB;;;;;iBAWnC,mBACpB,UAAU,gBACV;EAAY;EAAW;EAAgB;IACtC,QAAQ;;;KCpHC;UAEK;EACf,UAAU;;EAEV;;EAEA;;;EAGA;;UAGe;;;EAGf;;;;EAIA;;;EAGA;;EAEA;;;;EAIA;;;EAGA;;;EAGA,kBAAkB;;EAElB;;UAGe,qBAAqB,qBAAqB,kBAAkB,WAAW,kBAC9E,KAAK,WAAW;;;;;;;;EAQxB,QAAQ,gBAAgB;;EAExB,SAAS;IAAkB,UAAU;;;;;;;;;;;;;;;;;iBA0MvB,qBAAqB,qBAAqB,kBAAkB,WAAW,UACrF,SAAS,8BACR,qBAAqB,WAAW;UAsFlB;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;GACd;IAAQ,SAAS;;IAAyB;IAAe;;;EAE1D,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BK,iBAAiB,UAAS,0BAA+B;;;UCtXxD;;EAEf;;EAEA;;EAEA;;;;;;;;;;;;;iBAcc,YACd,WAAW,YAAY,eAAe,cACtC,UAAU,YAAY,eAAe,cACrC,aAAa,aACb,SAAS,GAAG,oCACX;UAsDc;EACf,QAAQ;;;;;;;;;;;;EAYR,WAAW;;;;EAIX,iBAAiB;;;;;;;EAOjB,UAAU;;EAEV,mBAAmB;;EAEnB,SAAS;;;;EAIT;;EAEA;;EAEA;;EAEA,gBAAgB;;EAEhB;;;;EAIA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6Bc,oBACd,QAAQ,eACR,OAAM,6BACL;UAkEc;EACf;;;EAGA,WAAW;;;;EAIX;;EAEA;IAAM;IAAa;;;EAEnB,mBAAmB;;EAEnB,SAAS;;EAET;;;;;EAKA;EACA;EACA;;;;;iBAMc,YAAY;;;;;;;;;;;;;;;;;;;iBAsBZ,qBACd,WAAW,YAAY,eAAe,cACtC,UAAU,YAAY,eAAe,cACrC,aAAa,aACb,8BACA;EACE;EACA;EACA;EACA;;;EAGA;IAED"}

package/dist/{statistics-C-dm-J6H.d.ts → statistics-D6Uebe_4.d.ts}

@@ -1,4 +1,4 @@
-import { g as JudgeScore } from "./types-XMVEdrE_.js";
+import { g as JudgeScore } from "./types-D216SgwM.js";
 //#region src/judge-calibration.d.ts
 /**
  * Judge calibration — measure judge quality against human gold + bias.
@@ -965,4 +965,4 @@ declare function eProcess(opts?: EProcessOptions): EProcess;
 declare function mulberry32(seed: number): () => number;
 //#endregion
 export { pairedCohensDz as $, WeightedCompositeInput as A, positionalBias as At, eProcess as B, RankTestMethod as C, GoldenItem as Ct, ScoreRiskDifferenceResult as D, calibrateJudge as Dt, RiskDifferenceResult as E, VerbosityBiasResult as Et, cliffsDelta as F, mannWhitneyU as G, interRaterReliability as H, cohensD as I, mcnemarRequiredN as J, mcnemar as K, confidenceInterval as L, WilcoxonSignedRankResult as M, verbosityBias as Mt, benjaminiHochberg as N, SignTestAlternative as O, calibrateJudgeContinuous as Ot, bonferroni as P, pairedBootstrap as Q, corpusInterRaterAgreement as R, ProportionInterval as S, ContinuousCalibrationResult as St, RankTestOptions as T, SelfPreferenceResult as Tt, interpretCliffs as U, holm as V, isBinaryOutcomeVector as W, normalizeScores as X, mulberry32 as Y, pairedBinaryScale as Z, McNemarResult as _, wilson as _t, CorpusAgreementReport as a, pairedSignTest as at, PairedSignTestResult as b, ContinuousAgreement as bt, DEFAULT_PERMUTATIONS as c, passAtK as ct, EProcessState as d, requiredPairedSampleSize as dt, pairedDeltaTieFraction as et, EProcessStep as f, requiredSampleSize as ft, MannWhitneyResult as g, wilcoxonSignedRank as gt, MANN_WHITNEY_EXACT_MAX_WORK as h, weightedMean as ht, CorpusAgreementPerDimension as i, pairedRiskDifferenceScore as it, WeightedCompositeResult as j, selfPreference as jt, WILCOXON_EXACT_MAX_N as k, continuousAgreement as kt, EProcess as l, pearsonR as lt, MANN_WHITNEY_EXACT_MAX_STATES as m, weightedComposite as mt, CliffsMagnitude as n, pairedRiskDifference as nt, CorpusScoreRecord as o, pairedTTest as ot, ExactRiskDifferenceResult as p, spearmanR as pt, mcnemarPower as q, CorpusAgreementOptions as r, pairedRiskDifferenceExact as rt, DECISION_PAIRED_DELTA_STATISTIC as s, partialCredit as st, BOOTSTRAP_GATE_MIN_N as t, pairedMde as tt, EProcessOptions as u, ranks as ut, PairedBootstrapOptions as v, CalibrationResult as vt, RankTestMethodRequest as w, PositionalBiasResult as wt, PairedTTestResult as x, ContinuousAgreementOptions as xt, PairedBootstrapResult as y, CandidateScore as yt, corpusInterRaterAgreementFromJudgeScores as z };
-//# sourceMappingURL=statistics-C-dm-J6H.d.ts.map
+//# sourceMappingURL=statistics-D6Uebe_4.d.ts.map

package/dist/{statistics-C-dm-J6H.d.ts.map → statistics-D6Uebe_4.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"statistics-C-dm-J6H.d.ts","names":[],"sources":["../src/judge-calibration.ts","../src/statistics.ts"],"mappings":"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"}
+{"version":3,"file":"statistics-D6Uebe_4.d.ts","names":[],"sources":["../src/judge-calibration.ts","../src/statistics.ts"],"mappings":"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"}

package/dist/steps-BArUxhna.d.ts

@@ -0,0 +1,51 @@
+//#region src/trajectory-replay/steps.d.ts
+/**
+ * Recorded shell-trajectory steps and the observation grammar they carry.
+ *
+ * A recorded trajectory is the action/observation sequence an agent actually
+ * ran. Scaffolds that execute one shell command per step (mini-SWE and the
+ * CodeTracer-normalized corpora built from it) tag each observation with the
+ * command's returncode and its combined output:
+ *
+ *     <returncode>2</returncode>
+ *     <output>
+ *     …command output…
+ *     </output>
+ *
+ * The parsers here are the only place that grammar is decoded. Everything
+ * downstream — replay verdicts, corpus enumeration, fix prompts — reads the
+ * returncode, the output, and the failure signature through these functions.
+ */
+/**
+ * One step of a recorded shell trajectory. Structural: any richer step record
+ * (file refs, thinking text, tool type) satisfies it.
+ */
+interface RecordedTrajectoryStep {
+  /** 1-based position in the trajectory. */
+  readonly step_id: number;
+  readonly action: string;
+  /** Null when the step recorded no observation (terminal submit steps). */
+  readonly observation: string | null;
+}
+/** Recorded returncode of a step, or null when the observation carries none. */
+declare function parseRecordedReturncode(observation: string | null): number | null;
+/** Text between the observation's <output> tags, or the raw observation when
+ *  the tags are absent. */
+declare function parseObservationOutput(observation: string | null): string;
+/**
+ * Stable failure-signature candidate: the first line of the recorded output
+ * that contains the word "error". Null when no such line exists — a verdict
+ * then falls back to returncode-only matching and says so.
+ * Pass an explicit signature to override (compiler quote glyphs vary with
+ * locale, so a hand-picked ASCII substring is often more robust).
+ */
+declare function deriveFailureSignature(observation: string | null): string | null;
+/** mini-SWE's end-of-run submit convention: the agent echoes this sentinel
+ *  and dumps the diff. A label on this step marks a bad SUBMIT DECISION, not a
+ *  failed command — there is no executable failure to reproduce, so it is
+ *  never a counterfactual replay target. */
+declare const SUBMIT_ACTION_SIGNATURE = "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT";
+declare function isSubmitAction(action: string): boolean;
+//#endregion
+export { parseObservationOutput as a, isSubmitAction as i, SUBMIT_ACTION_SIGNATURE as n, parseRecordedReturncode as o, deriveFailureSignature as r, RecordedTrajectoryStep as t };
+//# sourceMappingURL=steps-BArUxhna.d.ts.map

package/dist/steps-BArUxhna.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps-BArUxhna.d.ts","names":[],"sources":["../src/trajectory-replay/steps.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;UAsBiB;;WAEN;WACA;;WAEA;;;iBAIK,wBAAwB;;;iBAQxB,uBAAuB;;;;;;;;iBAavB,uBAAuB;;;;;cAW1B;iBAEG,eAAe"}