@tangle-network/agent-eval 0.179.0 → 0.181.0

package/dist/{statistical-heldout-0La5ZTlv.d.ts → statistical-heldout-CpVd6FmY.d.ts}

@@ -1,6 +1,8 @@
-import { a as RunRecord } from "./run-record-DTv1MdjK.js";
-import { a as PairedPromotionDecision, d as PairedBootstrapResult, i as PairedMcNemarEvidence, r as PairedDecisionStatistic, t as PairedDecisionMethod, u as PairedBootstrapOptions } from "./paired-promotion-decision-CGzg0cI_.js";
-import { R as Scenario, a as CampaignResult, b as GenerationRecord, h as GateContext, j as MutableSurface, p as Gate, v as GateResult, w as JudgeScore } from "./types-C34V4Vto.js";
+import { a as RunRecord } from "./run-record-BiTWauyO.js";
+import { a as PairedPromotionDecision, d as PairedBootstrapResult, i as PairedMcNemarEvidence, r as PairedDecisionStatistic, t as PairedDecisionMethod, u as PairedBootstrapOptions } from "./paired-promotion-decision-DPsMQm-0.js";
+import { R as Scenario, a as CampaignResult, b as GenerationRecord, h as GateContext, j as MutableSurface, p as Gate, v as GateResult, w as JudgeScore } from "./types-CS0qk_Yp.js";
+import { r as LedgerHash } from "./canonical-CFpojCN5.js";
+import { z } from "zod";
 //#region src/statistics/paired-binary.d.ts
 /** A binomial proportion estimate with a confidence interval. */
 interface ProportionInterval {
@@ -323,6 +325,98 @@ interface EProcess {
  */
 declare function eProcess(opts?: EProcessOptions): EProcess;
 //#endregion
+//#region src/experiment/claim.d.ts
+declare const claimSchema: z.ZodObject<{
+  use: z.ZodEnum<{
+    certification: "certification";
+    comparison: "comparison";
+    development: "development";
+  }>;
+  population: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+  }, z.core.$strict>;
+  samplingFrame: z.ZodString;
+  independentUnit: z.ZodString;
+  generalization: z.ZodEnum<{
+    "fixed-roster": "fixed-roster";
+    "new-units": "new-units";
+  }>;
+  minimumEffect: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/** The population and independent observations a measured result can describe. */
+type EvaluationClaim = z.infer<typeof claimSchema>;
+/** Validate a claim before binding it to a sealed experiment or final evidence. */
+declare function defineEvaluationClaim(input: EvaluationClaim): EvaluationClaim;
+interface EvaluationUnitSummary {
+  observations: number;
+  independentUnits: number;
+  units: Array<{
+    id: string;
+    observations: number;
+  }>;
+}
+/** Repetitions retain their denominator without becoming additional independent units. */
+declare function summarizeEvaluationUnits(claim: EvaluationClaim, rows: readonly object[]): EvaluationUnitSummary;
+//#endregion
+//#region src/experiment/final-evidence.d.ts
+declare const reservationSchema: z.ZodObject<{
+  requestId: z.ZodString;
+  claimDigest: z.ZodString;
+  populationId: z.ZodString;
+  inputDigest: z.ZodString;
+  unitIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/** One final dataset reserved for one adaptive decision, across processes and campaigns. */
+type FinalEvidenceReservation = z.infer<typeof reservationSchema>;
+declare const measurementSchema: z.ZodObject<{
+  evaluatorDigest: z.ZodString;
+  candidateDigests: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+type FinalEvidenceMeasurement = z.infer<typeof measurementSchema>;
+interface FinalEvidenceRecord {
+  reservation: FinalEvidenceReservation;
+  reservationHash: LedgerHash;
+  exposure: {
+    measurement: FinalEvidenceMeasurement;
+    entryHash: LedgerHash;
+  } | null;
+}
+type FinalEvidenceOutcome<T> = {
+  succeeded: true;
+  value: T;
+} | {
+  succeeded: false;
+  error: {
+    kind: 'conflict' | 'invalid' | 'unavailable';
+    message: string;
+  };
+};
+interface FinalEvidenceLedger {
+  reserve(input: FinalEvidenceReservation): Promise<FinalEvidenceOutcome<{
+    record: FinalEvidenceRecord;
+    replayed: boolean;
+  }>>;
+  expose(requestId: string, measurement: FinalEvidenceMeasurement): Promise<FinalEvidenceOutcome<{
+    record: FinalEvidenceRecord;
+    replayed: boolean;
+  }>>;
+  read(): Promise<FinalEvidenceOutcome<FinalEvidenceRecord[]>>;
+}
+/** Retains the distinction between invalid input, consumed evidence, and unavailable storage. */
+declare class FinalEvidenceError extends Error {
+  readonly kind: 'conflict' | 'invalid' | 'unavailable';
+  constructor(kind: 'conflict' | 'invalid' | 'unavailable', message: string);
+}
+/** A consumed or conflicting dataset cannot authorize another adaptive decision. */
+declare class FinalEvidenceConflictError extends FinalEvidenceError {
+  constructor(message: string);
+}
+/** Uses the shared locked journal and requires its trusted head on every reopen. */
+declare function openFinalEvidenceLedger(options: {
+  path: string;
+}): FinalEvidenceLedger;
+//#endregion
 //#region src/attestation.d.ts
 /**
  * Reproducibility attestation for any serializable report object.
@@ -366,19 +460,13 @@ interface AttestedReport {
   reportHash: string;
   provenance: AttestationProvenance;
   algorithm: typeof ATTESTATION_ALGORITHM;
-  /**
-   * Hex sha-256 over `{ reportHash, provenance, algorithm }`. New attestations
-   * always carry it. Optional only so persisted pre-envelope attestations can
-   * still be read and explicitly recognized as legacy by callers.
-   */
-  envelopeHash?: string;
+  /** Hex sha-256 over `{ reportHash, provenance, algorithm }`. */
+  envelopeHash: string;
 }
 interface AttestationVerification {
   valid: boolean;
   /** Populated iff `valid` is false — names the exact mismatch. */
   reason?: string;
-  /** True only for a valid pre-envelope attestation whose provenance is not cryptographically bound. */
-  legacyUnboundProvenance?: true;
 }
 /**
  * Content-address a report and bind it to its provenance. Throws (via
@@ -393,9 +481,8 @@ declare function attest(report: unknown, provenance: AttestationProvenance): Att
  * canonicalizes) is a verification failure with the cause in `reason`, not a
  * crash — verifiers run in pipelines that must record WHY, not die.
  *
- * Legacy attestations without `envelopeHash` remain readable, but verification
- * explicitly marks their provenance as unbound so a promotion path can refuse
- * them instead of accidentally treating old metadata as cryptographic proof.
+ * Both the report hash and the provenance envelope must verify.
+ * Missing envelope hashes cannot establish provenance and fail verification.
  */
 declare function verifyAttestation(report: unknown, attested: AttestedReport): AttestationVerification;
 //#endregion
@@ -451,10 +538,8 @@ interface CreateEvidenceReceiptInput extends Omit<EvidenceBinding, 'schemaVersio
  */
 declare function createEvidenceReceipt(input: CreateEvidenceReceiptInput, provenance: AttestationProvenance): EvidenceReceipt;
 /**
- * Verify promotion-grade evidence. Generic report attestation keeps a legacy read path,
- * but an EvidenceReceipt never accepts unbound provenance: changing the evaluator code,
- * model versions, input commitment provenance, or creation record must invalidate the
- * evidence rather than merely annotating it as legacy.
+ * Verify evidence identity and its provenance envelope. Changing the evaluator,
+ * model versions, input commitment, or creation record invalidates the evidence.
  */
 declare function verifyEvidenceReceipt(receipt: EvidenceReceipt): EvidenceReceiptVerification;
 /**
@@ -533,18 +618,23 @@ interface PromotionObjective {
   /** 'maximize' (quality dims) or 'minimize' (error/risk/length dims). Orients
    *  the paired delta so a positive bootstrap always means "candidate better". */
   direction: Direction;
+  /** Declared binary support {0, binaryScale}, including zero-only observations.
+   *  Must be finite and positive; paired cell scores must be 0 or this scale.
+   *  Uses the risk-difference mean and rejects the 'median' statistic. */
+  binaryScale?: number;
   /** The good-direction paired-delta CI lower bound must EXCEED this to count
    *  as a significant gain on this axis. Interpreted in the judge's native
    *  scale. Default 0 (⇒ "confidently better"). */
   gainThreshold?: number;
   /** A floor breach (regression) is declared when the good-direction CI lower
    *  bound is below −floorTolerance, or when the exact small-sample test proves
-   *  a drop past it. When omitted it auto-scales off observed magnitudes
-   *  (0.05 on [0,1], 5 on 0-100), matching `dimensionRegressions`. */
+   *  a drop past it. Defaults to 0.05 times the declared binary scale, or
+   *  auto-scales off observed magnitudes (0.05 on [0,1], 5 on 0-100). */
   floorTolerance?: number;
 }
-/** Per-axis verdict from the good-direction paired bootstrap. */
-type AxisVerdict = 'improved' | 'regressed' | 'flat' | 'few_runs';
+/** Per-axis verdict from the shared paired decision rule.
+ *  'regressed' includes uncertainty that prevents clearing the regression floor. */
+type AxisVerdict = 'improved' | 'regressed' | 'flat' | 'few_runs' | 'indeterminate';
 interface AxisEvidence {
   name: string;
   source: ObjectiveSource;
@@ -572,8 +662,8 @@ interface AxisEvidence {
   decisionStatistic: PairedDecisionStatistic;
   /** McNemar's exact evidence on a pass/fail axis; null otherwise. */
   mcnemar: PairedMcNemarEvidence | null;
-  /** `ci` has zero width — no evidence in either direction, so the axis is
-   *  neither improved nor regressed however the point estimate sits. */
+  /** `ci` has zero width or non-finite bounds. It cannot establish a gain or
+   *  clear a regression floor, regardless of the point estimate. */
   indeterminate: boolean;
   /** Paired observations contributing to this axis. */
   n: number;
@@ -623,11 +713,9 @@ interface BuildEvidenceVectorOptions {
  */
 declare function buildEvidenceVector<TArtifact, TScenario extends Scenario>(ctx: GateContext<TArtifact, TScenario>, objectives: PromotionObjective[], opts?: BuildEvidenceVectorOptions): EvidenceVector;
 /**
- * The default strategy: symmetric multi-objective Pareto significance. Ship iff
- * the candidate weakly dominates the baseline at the confidence level — no axis
- * credibly worse AND ≥1 axis credibly better. Floor breach on any axis → hold
- * (anti-Goodhart, dominates everything). Insufficient evidence on any axis →
- * need_more_work. Statistically equivalent → hold (never ship noise).
+ * Require a supported gain and every configured regression floor to clear.
+ * A failed floor holds the candidate, including when uncertainty permits a loss.
+ * Missing or indeterminate evidence requires more work; no gain holds release.
  */
 declare const paretoPolicy: PromotionPolicy;
 interface ParetoSignificanceGateOptions extends BuildEvidenceVectorOptions {
@@ -648,76 +736,59 @@ declare function paretoSignificanceGate<TArtifact = unknown, TScenario extends S
 //#endregion
 //#region src/campaign/gates/power-preflight.d.ts
 /**
- * Power preflight — "can this budget detect the effect you are hunting?"
- *
- * The failure it prevents (measured, twice): a live prompt-improvement campaign ran
- * 333 sandbox cells over 5.6 hours and produced a +0.08 holdout lift the ship gate
- * (paired bootstrap, CI.low > 0.05) could not distinguish from zero — because at
- * that holdout size and worker variance the MINIMUM DETECTABLE lift was larger than
- * any effect a prompt change plausibly produces. The budget was spent learning what
- * a 30-second calculation on the baseline cells already knew. No eval framework we
- * know of surfaces this; every underpowered improvement run everywhere ends in an
- * uninformative "hold".
+ * Approximate detectable lift from baseline variance and the intended sample size.
  *
  * Model: the ship rule is `CI.low(paired Δ) > deltaThreshold`. Approximating the
  * bootstrap CI as normal, `CI.low ≈ effect − z·sd_Δ/√n`, so the smallest shippable
- * true effect is `MDE = deltaThreshold + z·sd_Δ/√n`. The paired-delta SD is unknown
- * before the candidate exists; we bound it by the zero-correlation case
- * `sd_Δ ≤ √2·sd_baseline` — a CONSERVATIVE (upper) MDE, which is the correct
- * direction for a warning. Pairing is per cell (`scenario:rep`), so reps multiply n.
+ * effect is `MDE = deltaThreshold + z·sd_Δ/√n`. This estimates `sd_Δ` as
+ * `√2·sd_baseline`, assuming equal arm variances and zero paired correlation.
+ * Actual candidate variance and paired correlation can move the threshold in either direction.
+ * This diagnostic does not replace the gate or guarantee a detection probability.
  *
- * Standalone by design: feed it any baseline composites (a `gate:'none'` run, a
- * live-proof table) BEFORE budgeting the real search; `selfImprove` also attaches
- * it to every result and warns when the run was structurally unable to ship.
+ * Supply one baseline mean per independent observation used by the comparison.
+ * With declared source units, repetitions and variants refine those means without increasing n.
+ * `selfImprove` attaches this diagnostic after its final measurement.
  */
 interface PowerPreflightOptions {
-  /** Per-cell baseline composites on the HOLDOUT scenarios (one per scenario:rep cell). */
+  /** Baseline composites at the comparison's independent observation unit. */
   baselineComposites: number[];
-  /** Paired observations the budgeted comparison will produce
-   *  (holdout scenarios × reps). Defaults to `baselineComposites.length`. */
+  /** Independent paired observations planned for the comparison.
+   *  Defaults to `baselineComposites.length`. */
   pairedN?: number;
   /** The ship gate's effect-size threshold. Default 0.05 (defaultProductionGate). */
   deltaThreshold?: number;
   /** CI confidence the gate uses. Default 0.95. */
   confidence?: number;
-  /** True when the holdout is scored by the SAME judge/scorer family as the gate
-   *  (selfImprove's default composition — one judge scores everything). Under a
-   *  shared channel, raising paired n reduces only the IDIOSYNCRATIC noise share;
-   *  systematic judge bias is untouched, so the MDE here is a lower bound and the
-   *  only full debiaser is an independent second scoring channel
-   *  (recursive-self-improvement S1c, closed form in EXP-023 P0). Default false. */
+  /** Whether the holdout uses the gate's judge family.
+   *  More observations cannot establish freedom from systematic scoring bias.
+   *  Default false. */
   sharedScorerChannel?: boolean;
 }
 interface PowerPreflight {
   /** Paired observations the comparison will have. */
   n: number;
-  /** Baseline per-cell composite standard deviation (the variance the effect must beat). */
+  /** Sample standard deviation of baseline observation means. */
   sd: number;
-  /** Minimum detectable lift: the smallest TRUE effect the gate could ship at this budget. */
+  /** Approximate lift needed to put a normal interval above the gate threshold. */
   mde: number;
   /** Baseline holdout composite mean. */
   baselineMean: number;
   /** Headroom to a perfect 1.0 composite (the largest achievable lift on a [0,1] judge). */
   headroom: number;
-  /** True when even the largest achievable effect (headroom) is below the MDE —
-   *  the run is structurally unable to ship regardless of proposal quality.
-   *  Only asserted for [0,1]-scaled judges (see `scaleAssumed`). */
+  /** Whether this approximation exceeds the estimated [0,1] score headroom.
+   *  This is a planning warning, not a proof that promotion is impossible. */
   underpowered: boolean;
   /** True when composites look [0,1]-scaled; headroom/underpowered are only
    *  meaningful under that convention (0-100 judges get mde/sd/n but no verdict). */
   scaleAssumed: boolean;
   deltaThreshold: number;
   confidence: number;
-  /** Set when the holdout shares the gate's scoring channel: more cells cannot
-   *  buy back systematic judge bias — treat the MDE as a lower bound. */
+  /** Notes unmeasured systematic bias when the gate shares its scoring channel. */
   sharedChannelCaveat?: string;
   /** One actionable sentence for humans and logs. */
   recommendation: string;
 }
-/** Estimate the minimum detectable lift a paired-holdout improvement run can
- *  ship at a given budget, from the baseline holdout composites — call it BEFORE
- *  spending a search to learn whether the effect you are hunting is even
- *  observable at this holdout size and worker variance. */
+/** Estimate detectable lift from baseline independent observations before budgeting a comparison. */
 declare function powerPreflight(opts: PowerPreflightOptions): PowerPreflight;
 //#endregion
 //#region src/paired-arms.d.ts
@@ -877,10 +948,8 @@ declare function pairRunRecords(baselineRuns: readonly RunRecord[], treatmentRun
  * evaluate the manifest against observed results — the library refuses
  * to let you re-interpret a different metric as the declared one.
  *
- * A signed manifest is a portable record: it is written once and verified
- * later, possibly by a different release. `algo` names the digest scheme it
- * was signed under, and verification selects the encoder by that field, so a
- * manifest signed by an earlier release still verifies.
+ * A signed manifest carries its required digest scheme. Verification accepts
+ * only RFC 8785 canonical JSON, using the same encoder as every new identity.
  */
 interface HypothesisManifest {
   id: string;
@@ -904,31 +973,13 @@ interface HypothesisManifest {
   baselineLabel?: string;
   candidateLabel?: string;
 }
-/**
- * Identifier for the hashing scheme used to produce `contentHash`.
- *
- * Both schemes are sha256 hex over the manifest with `contentHash` and `algo`
- * stripped, and differ only in how that manifest is serialized:
- *
- * - `'sha256-rfc8785'` — RFC 8785 canonical JSON. What {@link signManifest}
- *   emits.
- * - `'sha256-content'` — key-sorted `JSON.stringify`. Read-only: manifests
- *   signed by an earlier release carry it, or carry no `algo` at all, and
- *   {@link verifyManifest} still verifies them.
- */
-type SignedManifestAlgo = 'sha256-content' | 'sha256-rfc8785';
+/** SHA-256 over RFC 8785 canonical JSON, excluding `contentHash` and `algo`. */
+type SignedManifestAlgo = 'sha256-rfc8785';
 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;
+  /** Required digest scheme. Missing or unsupported schemes fail verification. */
+  algo: SignedManifestAlgo;
 }
 interface HypothesisResult {
   manifest: SignedManifest;
@@ -959,10 +1010,8 @@ interface HypothesisResult {
  */
 declare function hashJson<T>(obj: T): Promise<string>;
 /**
- * Digest of a manifest under its own declared scheme, with `contentHash` and
- * `algo` stripped. Synchronous, so a caller that must fail before consuming an
- * observation does not have to await. Throws on an `algo` this release does
- * not know — an unverifiable manifest must not read as a valid one.
+ * Digest a manifest after validating its scheme, excluding `contentHash` and
+ * `algo`. This synchronous check can refuse a manifest before consuming data.
  */
 declare function manifestContentDigest(manifest: SignedManifest): string;
 /**
@@ -1002,11 +1051,11 @@ 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
+  /** Minimum independent paired units 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`
+  /** Pre-registered independent-unit budget (scenarios by default in decide()). Required unless `preRegistration`
    *  supplies it via `preRegisteredN` (conflict throws). */
   maxN?: number;
   /** Bet truncation forwarded to `eProcess`. Default 0.5. */
@@ -1015,9 +1064,13 @@ interface SequentialPairedGateOptions {
    *  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. */
+  /** Seed for reproducible ordering of scenario deltas in decide().
+   *  Shuffling does not establish the conditional-mean null. Default 1337. */
   shuffleSeed?: number;
+  /** Independent unit for every scenario passed to decide(). Full cell pairs
+   *  are averaged within each unit before testing. Defaults to scenario IDs.
+   *  The mapping is copied at construction. Direct observe() is unchanged. */
+  independentUnitByScenarioId?: ReadonlyMap<string, string>;
   /** Bind the pre-registered hypothesis. Verified (content hash) at
    *  construction; alpha/maxN/direction/minEffect come FROM the manifest. */
   preRegistration?: SignedManifest;
@@ -1039,8 +1092,10 @@ type SequentialStreamState = EProcessState & {
   decision: SequentialDecision;
 };
 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
+  /** Streaming entry point: feed one paired independent-unit delta
+   *  (candidate − baseline, native scale). Aggregate correlated repetitions
+   *  before calling; the caller must justify E[delta_t | past] under H0.
+   *  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
@@ -1053,15 +1108,16 @@ interface SequentialPairedGate<TArtifact = unknown, TScenario extends Scenario =
 }
 /**
  * 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.
+ * contract: decide(ctx) pairs candidate and baseline by full cellId, then
+ * averages deltas within each configured unit (scenario by default). The
+ * e-process consumes one observation per unit, with equal unit weights.
+ * The streaming observe(delta) entry consumes caller-aggregated independent
+ * units. Repetitions improve a unit's precision and do not increase n.
  *
  * 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)
+ *                            the e-value undecided — more independent units needed)
  *   - 'undecided-at-maxN'  → 'hold', with the reason stating it is NOT
  *                            evidence of no effect (never a silent default)
  */
@@ -1087,9 +1143,8 @@ interface SequentialDecideFn {
   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`.
+ * SurfaceProposer.decide adapter that stops exploration at an e-value threshold.
+ * The selected candidate still requires an independent held-out decision.
  *
  * Stream: for each generation g ≥ 1, the per-scenario composite deltas of
  * generation g's top candidate vs the generation-0 top candidate (the
@@ -1100,10 +1155,11 @@ interface SequentialDecideFn {
  * 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
+ * This is an exploration stopping heuristic. Selection of the best measured
+ * candidate and reuse of measured incumbent scores generally violate the
+ * conditional-mean null, even when the candidates have no true improvement.
+ * More repetitions reduce noise but do not establish exact type-I control.
+ * 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
@@ -1125,8 +1181,8 @@ interface PairedHoldout {
  * 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
+ * every judge on both sides, are skipped. The selected judge IDs must agree
+ * within each pair. Throws when the two maps disagree on holdout cell IDs — 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.
@@ -1165,9 +1221,14 @@ interface HeldoutSignificance {
    *  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. */
+  /** Number of paired observation units, after configured aggregation. */
   n: number;
-  /** Effective minimum after applying the bootstrap's hard statistical floor. */
+  /** Original matched execution cells, before aggregation. */
+  pairedCellN: number;
+  observationUnit: 'registered' | 'cell';
+  /** Registered unit IDs, or cell IDs on the ungrouped path. */
+  unitIds: string[];
+  /** Effective minimum for the requested target and chosen estimator. */
   minimumRequired: number;
   /** Statistical method that carried the decision. */
   decisionMethod: PairedDecisionMethod;
@@ -1188,6 +1249,8 @@ interface HeldoutSignificanceOptions {
   /** Fixed by default for a deterministic, reproducible gate verdict. */
   seed?: number;
   statistic?: 'mean' | 'median';
+  /** Group full cell pairs into equal-weight independent units before inference. */
+  independentUnitByScenarioId?: ReadonlyMap<string, string>;
 }
 /**
  * Significance of the held-out composite lift: ship only when the lower bound
@@ -1212,8 +1275,8 @@ interface HeldoutSignificanceOptions {
  * 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.
+ * Continuous mean targets require bootstrap eligibility. Explicit median
+ * targets can use the exact sign test at its confidence-dependent minimum.
  */
 declare function heldoutSignificance(paired: PairedHoldout, opts?: HeldoutSignificanceOptions): HeldoutSignificance;
 interface DimensionRegression {
@@ -1236,36 +1299,34 @@ interface DimensionRegression {
   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. */
+  /** The bootstrap lower bound is below negative tolerance, or the shared
+   *  paired test supports a drop exceeding tolerance. Missing coverage and
+   *  insufficient observations are reported separately. */
   regressed: boolean;
   tolerance: number;
   n: number;
+  pairedCellN: number;
+  observationUnit: 'registered' | 'cell';
+  /** Statistical minimum for the configured independent observation unit. */
+  minimumRequired: number;
+  fewRuns: boolean;
+  /** Both arms lack this dimension on these otherwise matched execution cells. */
+  missingCellIds: string[];
+  /** Configured scenarios with no paired dimension measurement at all. */
+  missingScenarioIds: string[];
 }
 /** 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. */
+/**
+ * Report required-dimension evidence after full pairing and optional unit means.
+ * A bootstrap floor breach or a shared paired test supporting a drop marks
+ * regression. These two criteria are distinct; `ci` records the shared
+ * estimator and `bootstrap` records the floor interval. Missing observations
+ * and insufficient n remain explicit for the caller's evidence policy.
+ * The default tolerance is 0.05 on [0,1] and 5 on a detected 0-100 scale.
+ */
 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;
@@ -1274,7 +1335,9 @@ declare function dimensionRegressions(candidate: Map<string, Record<string, Judg
   /** Paired statistic the CI is computed on. Default `'mean'` — see
    *  {@link DECISION_PAIRED_DELTA_STATISTIC} for why the median is not. */
   statistic?: 'mean' | 'median';
+  independentUnitByScenarioId?: ReadonlyMap<string, string>;
+  minProductiveRuns?: number;
 }): DimensionRegression[];
 //#endregion
-export { paretoSignificanceGate as $, PairArmsOptions as A, McNemarResult as At, PowerPreflight as B, passAtK as Bt, hashJson as C, verifyAttestation as Ct, ComparePairedArmsOptions as D, EProcessStep as Dt, verifyManifest as E, EProcessState as Et, PairedCorrectness as F, mcnemar as Ft, BuildEvidenceVectorOptions as G, powerPreflight as H, PairedMetricDelta as I, pairedBinaryScale as It, ParetoSignificanceGateOptions as J, EvidenceVector as K, comparePairedArms as L, pairedRiskDifference as Lt, PairRunRecordsResult as M, RiskDifferenceResult as Mt, PairedArmRow as N, ScoreRiskDifferenceResult as Nt, MatchedPair as O, eProcess as Ot, PairedArmsComparison as P, isBinaryOutcomeVector as Pt, paretoPolicy as Q, pairArms as R, pairedRiskDifferenceExact as Rt, evaluateHypothesis as S, attest as St, signManifest as T, EProcessOptions as Tt, AxisEvidence as U, PowerPreflightOptions as V, wilson as Vt, AxisVerdict as W, PromotionPolicy as X, PromotionObjective as Y, buildEvidenceVector as Z, sequentialPairedGate as _, verifyEvidenceReceipt as _t, detectScale as a, createCampaignEvidenceReceipt as at, SignedManifest as b, AttestationVerification as bt, pairHoldout as c, EVIDENCE_RECEIPT_VERSION as ct, SequentialDecision as d, EvidenceBinding as dt, Objective as et, SequentialObservation as f, EvidenceReceipt as ft, sequentialDecide as g, isIndependentEvidence as gt, SequentialStreamState as h, createEvidenceReceipt as ht, PairedHoldout as i, CampaignEvidenceContext as it, PairArmsResult as j, ProportionInterval as jt, MatchedRunRecordPair as k, ExactRiskDifferenceResult as kt, SequentialDecideFn as l, EvidenceAuthority as lt, SequentialPairedGateOptions as m, INDEPENDENT_EVIDENCE_AUTHORITY_KINDS as mt, HeldoutSignificance as n, dominates as nt, dimensionRegressions as o, CreateEvidenceReceiptInput as ot, SequentialPairedGate as p, EvidenceReceiptVerification as pt, ObjectiveSource as q, HeldoutSignificanceOptions as r, paretoFrontier as rt, heldoutSignificance as s, EVIDENCE_AUTHORITY_KINDS as st, DimensionRegression as t, ParetoResult as tt, SequentialDecideOptions as u, EvidenceAuthorityKind as ut, HypothesisManifest as v, ATTESTATION_ALGORITHM as vt, manifestContentDigest as w, EProcess as wt, SignedManifestAlgo as x, AttestedReport as xt, HypothesisResult as y, AttestationProvenance as yt, pairRunRecords as z, pairedRiskDifferenceScore as zt };
-//# sourceMappingURL=statistical-heldout-0La5ZTlv.d.ts.map
+export { paretoSignificanceGate as $, wilson as $t, PairArmsOptions as A, FinalEvidenceReservation as At, PowerPreflight as B, eProcess as Bt, hashJson as C, verifyAttestation as Ct, ComparePairedArmsOptions as D, FinalEvidenceMeasurement as Dt, verifyManifest as E, FinalEvidenceLedger as Et, PairedCorrectness as F, summarizeEvaluationUnits as Ft, BuildEvidenceVectorOptions as G, ScoreRiskDifferenceResult as Gt, powerPreflight as H, McNemarResult as Ht, PairedMetricDelta as I, EProcess as It, ParetoSignificanceGateOptions as J, pairedBinaryScale as Jt, EvidenceVector as K, isBinaryOutcomeVector as Kt, comparePairedArms as L, EProcessOptions as Lt, PairRunRecordsResult as M, EvaluationClaim as Mt, PairedArmRow as N, EvaluationUnitSummary as Nt, MatchedPair as O, FinalEvidenceOutcome as Ot, PairedArmsComparison as P, defineEvaluationClaim as Pt, paretoPolicy as Q, passAtK as Qt, pairArms as R, EProcessState as Rt, evaluateHypothesis as S, attest as St, signManifest as T, FinalEvidenceError as Tt, AxisEvidence as U, ProportionInterval as Ut, PowerPreflightOptions as V, ExactRiskDifferenceResult as Vt, AxisVerdict as W, RiskDifferenceResult as Wt, PromotionPolicy as X, pairedRiskDifferenceExact as Xt, PromotionObjective as Y, pairedRiskDifference as Yt, buildEvidenceVector as Z, pairedRiskDifferenceScore as Zt, sequentialPairedGate as _, verifyEvidenceReceipt as _t, detectScale as a, createCampaignEvidenceReceipt as at, SignedManifest as b, AttestationVerification as bt, pairHoldout as c, EVIDENCE_RECEIPT_VERSION as ct, SequentialDecision as d, EvidenceBinding as dt, Objective as et, SequentialObservation as f, EvidenceReceipt as ft, sequentialDecide as g, isIndependentEvidence as gt, SequentialStreamState as h, createEvidenceReceipt as ht, PairedHoldout as i, CampaignEvidenceContext as it, PairArmsResult as j, openFinalEvidenceLedger as jt, MatchedRunRecordPair as k, FinalEvidenceRecord as kt, SequentialDecideFn as l, EvidenceAuthority as lt, SequentialPairedGateOptions as m, INDEPENDENT_EVIDENCE_AUTHORITY_KINDS as mt, HeldoutSignificance as n, dominates as nt, dimensionRegressions as o, CreateEvidenceReceiptInput as ot, SequentialPairedGate as p, EvidenceReceiptVerification as pt, ObjectiveSource as q, mcnemar as qt, HeldoutSignificanceOptions as r, paretoFrontier as rt, heldoutSignificance as s, EVIDENCE_AUTHORITY_KINDS as st, DimensionRegression as t, ParetoResult as tt, SequentialDecideOptions as u, EvidenceAuthorityKind as ut, HypothesisManifest as v, ATTESTATION_ALGORITHM as vt, manifestContentDigest as w, FinalEvidenceConflictError as wt, SignedManifestAlgo as x, AttestedReport as xt, HypothesisResult as y, AttestationProvenance as yt, pairRunRecords as z, EProcessStep as zt };
+//# sourceMappingURL=statistical-heldout-CpVd6FmY.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statistical-heldout-CpVd6FmY.d.ts","names":[],"sources":["../src/statistics/paired-binary.ts","../src/statistics/sequential-eprocess.ts","../src/experiment/claim.ts","../src/experiment/final-evidence.ts","../src/attestation.ts","../src/experiment/evidence-receipt.ts","../src/experiment/campaign-evidence.ts","../src/pareto.ts","../src/campaign/gates/promotion-policy.ts","../src/campaign/gates/power-preflight.ts","../src/paired-arms.ts","../src/pre-registration.ts","../src/campaign/gates/sequential.ts","../src/campaign/gates/statistical-heldout.ts"],"mappings":"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"}