@tangle-network/agent-eval 0.221.8 → 0.222.0

package/dist/{spans-CVngGij3.d.ts → spans-vZoW__3q.d.ts}

@@ -1,6 +1,5 @@
-import { o as RedactionReport } from "./redact-DXdlFb_U.js";
+import { o as RedactionReport } from "./redact-C_wzC4c_.js";
 import { SpanKind } from "@tangle-network/agent-trace-contract";
-//#region src/diagnosis/spans.d.ts
 type DiagnosisSpanStatus = 'OK' | 'ERROR' | 'UNSET';
 interface DiagnosisSpan {
   traceId: string;
@@ -55,6 +54,5 @@ declare function ingestSpans(raw: readonly unknown[], options: {
  * nanoseconds, 15-16 microseconds, 12-14 milliseconds, and fewer are seconds.
  */
 declare function epochMillis(value: unknown): number | null;
-//#endregion
 export { isContentAttribute as a, ingestSpans as i, IngestReport as n, epochMillis as r, DiagnosisSpan as t };
-//# sourceMappingURL=spans-CVngGij3.d.ts.map
+//# sourceMappingURL=spans-vZoW__3q.d.ts.map

package/dist/spans-vZoW__3q.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spans-vZoW__3q.d.ts","names":[],"sources":["../src/diagnosis/spans.ts"],"mappings":";;KAuBY;UAEK;EACf;EACA;EACA;EACA;EACA,MAAM;EACN;EACA;EACA,QAAQ;EACR;EACA;EACA;;;;;;;EAOA;EACA,YAAY;;UAGG;EACf;EACA;;EAEA;;EAEA;;EAEA;EACA,SAAS;;EAET;;iBA0Bc,mBAAmB;;;;;;;iBAUnB,YACd,yBACA;EAAW;;EACR,OAAO;EAAiB,QAAQ;;;;;;;iBAgHrB,YAAY"}

package/dist/{statistical-heldout-BjzSOmLH.d.ts → statistical-heldout-Cei036nE.d.ts}

@@ -1,10 +1,9 @@
-import { a as RunRecord } from "./run-record-C3awiXPf.js";
-import { z as FindingTreatment } from "./types-6Lfdlshp.js";
-import { a as PairedPromotionDecision, i as PairedMcNemarEvidence, l as PairedBootstrapOptions, r as PairedDecisionStatistic, t as PairedDecisionMethod, u as PairedBootstrapResult } from "./paired-promotion-decision-CQMJ5xGN.js";
-import { r as LedgerHash } from "./canonical-CFpojCN5.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-M6eF9m-r.js";
+import { a as RunRecord } from "./run-record-D2BFMPGl.js";
+import { z as FindingTreatment } from "./types-DzCO-S1m.js";
+import { a as PairedPromotionDecision, i as PairedMcNemarEvidence, l as PairedBootstrapOptions, r as PairedDecisionStatistic, t as PairedDecisionMethod, u as PairedBootstrapResult } from "./paired-promotion-decision-BDnqepZ1.js";
+import { r as LedgerHash } from "./canonical-gLeHiqzd.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-C54Uk_a1.js";
 import { z } from "zod";
-//#region src/statistics/paired-binary.d.ts
 /** A binomial proportion estimate with a confidence interval. */
 interface ProportionInterval {
   /** Point estimate successes / n; 0 is a compatibility placeholder when n = 0. */
@@ -197,8 +196,6 @@ declare function pairedRiskDifferenceScore(control: ArrayLike<number | boolean>,
  * form. Requires 1 ≤ k ≤ n and 0 ≤ c ≤ n.
  */
 declare function passAtK(n: number, c: number, k: number): number;
-//#endregion
-//#region src/statistics/sequential-eprocess.d.ts
 interface EProcessOptions {
   /** Type-I error budget. The process decides when wealth ≥ 1/alpha
    *  (Ville's inequality). Default 0.05. */
@@ -284,8 +281,6 @@ interface EProcess {
  * the decision time is the first crossing.
  */
 declare function eProcess(opts?: EProcessOptions): EProcess;
-//#endregion
-//#region src/experiment/final-evidence.d.ts
 declare const reservationSchema: z.ZodObject<{
   requestId: z.ZodString;
   claimDigest: z.ZodString;
@@ -342,8 +337,6 @@ declare class FinalEvidenceConflictError extends FinalEvidenceError {
 declare function openFinalEvidenceLedger(options: {
   path: string;
 }): FinalEvidenceLedger;
-//#endregion
-//#region src/attestation.d.ts
 /**
  * Reproducibility attestation for any serializable report object.
  *
@@ -364,7 +357,7 @@ declare function openFinalEvidenceLedger(options: {
  */
 /** Hash scheme identifier carried by every attestation. A verifier rejects
  * unknown algorithms instead of guessing. */
-declare const ATTESTATION_ALGORITHM: 'sha256/canonical-json';
+declare const ATTESTATION_ALGORITHM: "sha256/canonical-json";
 interface AttestationProvenance {
   /** Every model involved in producing the report, name → version/id. */
   modelVersions: Record<string, string>;
@@ -411,11 +404,9 @@ declare function attest(report: unknown, provenance: AttestationProvenance): Att
  * Missing envelope hashes cannot establish provenance and fail verification.
  */
 declare function verifyAttestation(report: unknown, attested: AttestedReport): AttestationVerification;
-//#endregion
-//#region src/experiment/evidence-receipt.d.ts
-declare const EVIDENCE_RECEIPT_VERSION: '1.0.0';
+declare const EVIDENCE_RECEIPT_VERSION: "1.0.0";
 /** Closed promotion vocabulary. A typo or unknown future kind is never independent by default. */
-declare const EVIDENCE_AUTHORITY_KINDS: readonly ['candidate-self-report', 'independent-evaluator', 'independent-replication', 'human-review', 'production-canary'];
+declare const EVIDENCE_AUTHORITY_KINDS: readonly ["candidate-self-report", "independent-evaluator", "independent-replication", "human-review", "production-canary"];
 type EvidenceAuthorityKind = (typeof EVIDENCE_AUTHORITY_KINDS)[number];
 interface EvidenceAuthority {
   readonly kind: EvidenceAuthorityKind;
@@ -473,8 +464,6 @@ declare function verifyEvidenceReceipt(receipt: EvidenceReceipt): EvidenceReceip
  * and candidate self-reports both return false.
  */
 declare function isIndependentEvidence(receipt: EvidenceReceipt): boolean;
-//#endregion
-//#region src/experiment/campaign-evidence.d.ts
 /** Caller-owned execution context. Eval never infers evaluator authority or environment identity. */
 type CampaignEvidenceContext = Pick<CreateEvidenceReceiptInput, 'pursuitId' | 'evaluatorDigest' | 'environmentDigest' | 'authority' | 'experimentDigest' | 'observerDigest'> & {
   provenance: Omit<AttestationProvenance, 'inputsHash'>;
@@ -485,8 +474,6 @@ declare function createCampaignEvidenceReceipt<S extends Scenario, A>(input: {
   surface: MutableSurface;
   context: CampaignEvidenceContext;
 }): EvidenceReceipt;
-//#endregion
-//#region src/pareto.d.ts
 /**
  * Pareto frontier — multi-objective optimization over candidate runs.
  *
@@ -526,8 +513,6 @@ declare function dominates<T>(a: T, b: T, objectives: Objective<T>[]): boolean;
  * iff no other candidate dominates it.
  */
 declare function paretoFrontier<T>(candidates: T[], objectives: Objective<T>[]): ParetoResult<T>;
-//#endregion
-//#region src/campaign/gates/promotion-policy.d.ts
 /** Where an objective's per-cell scalar comes from. `composite` reads the
  *  judge's composite; `dimension` reads a named per-dimension score. */
 type ObjectiveSource = {
@@ -658,8 +643,6 @@ interface ParetoSignificanceGateOptions extends BuildEvidenceVectorOptions {
  * loop behavior is unchanged because consumers opt in by passing this gate.
  */
 declare function paretoSignificanceGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(options: ParetoSignificanceGateOptions): Gate<TArtifact, TScenario>;
-//#endregion
-//#region src/campaign/gates/power-preflight.d.ts
 /**
  * Approximate detectable lift from baseline variance and the intended sample size.
  *
@@ -715,8 +698,6 @@ interface PowerPreflight {
 }
 /** Estimate detectable lift from baseline independent observations before budgeting a comparison. */
 declare function powerPreflight(opts: PowerPreflightOptions): PowerPreflight;
-//#endregion
-//#region src/arm-populations.d.ts
 /** Expected seed identities must be supplied independently of completed observations. */
 interface ArmAssignment {
   pairKey: string;
@@ -750,8 +731,6 @@ interface ArmPopulationReading {
   asAssigned: ArmPopulationSummary;
   asFormed: ArmPopulationSummary;
 }
-//#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 {
@@ -910,8 +889,6 @@ interface PairRunRecordsResult {
  * 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
@@ -999,8 +976,6 @@ declare function signManifest(m: HypothesisManifest): Promise<SignedManifest>;
  * the manifest itself declares.
  */
 declare function verifyManifest(m: SignedManifest): Promise<boolean>;
-//#endregion
-//#region src/campaign/gates/sequential.d.ts
 type SequentialGateDecision = 'promote' | 'continue' | 'undecided-at-maxN';
 interface SequentialObservation {
   decision: SequentialGateDecision;
@@ -1131,8 +1106,6 @@ interface SequentialDecideFn {
  * 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[];
@@ -1299,6 +1272,5 @@ declare function dimensionRegressions(candidate: Map<string, Record<string, Judg
   independentUnitByScenarioId?: ReadonlyMap<string, string>;
   minProductiveRuns?: number;
 }): DimensionRegression[];
-//#endregion
 export { paretoPolicy as $, PairRunRecordsResult as A, EProcess as At, ArmPopulationSummary as B, mcnemar as Bt, signManifest as C, FinalEvidenceError as Ct, MatchedRunRecordPair as D, FinalEvidenceRecord as Dt, MatchedPair as E, FinalEvidenceOutcome as Et, comparePairedArms as F, ExactRiskDifferenceResult as Ft, AxisVerdict as G, wilson as Gt, PowerPreflightOptions as H, pairedRiskDifferenceExact as Ht, pairArms as I, McNemarResult as It, ObjectiveSource as J, BuildEvidenceVectorOptions as K, pairRunRecords as L, ProportionInterval as Lt, PairedArmsComparison as M, EProcessState as Mt, PairedCorrectness as N, EProcessStep as Nt, PairArmsOptions as O, FinalEvidenceReservation as Ot, PairedMetricDelta as P, eProcess as Pt, buildEvidenceVector as Q, ArmAssignment as R, RiskDifferenceResult as Rt, manifestContentDigest as S, FinalEvidenceConflictError as St, ComparePairedArmsOptions as T, FinalEvidenceMeasurement as Tt, powerPreflight as U, pairedRiskDifferenceScore as Ut, PowerPreflight as V, pairedRiskDifference as Vt, AxisEvidence as W, passAtK as Wt, PromotionObjective as X, ParetoSignificanceGateOptions as Y, PromotionPolicy as Z, HypothesisManifest as _, AttestationProvenance as _t, dimensionRegressions as a, CampaignEvidenceContext as at, SignedManifestAlgo as b, attest as bt, SequentialDecideFn as c, EvidenceAuthority as ct, SequentialObservation as d, EvidenceReceipt as dt, paretoSignificanceGate as et, SequentialPairedGate as f, EvidenceReceiptVerification as ft, sequentialPairedGate as g, ATTESTATION_ALGORITHM as gt, sequentialDecide as h, verifyEvidenceReceipt as ht, PairedHoldout as i, paretoFrontier as it, PairedArmRow as j, EProcessOptions as jt, PairArmsResult as k, openFinalEvidenceLedger as kt, SequentialDecideOptions as l, EvidenceAuthorityKind as lt, SequentialStreamState as m, isIndependentEvidence as mt, HeldoutSignificance as n, ParetoResult as nt, heldoutSignificance as o, createCampaignEvidenceReceipt as ot, SequentialPairedGateOptions as p, createEvidenceReceipt as pt, EvidenceVector as q, HeldoutSignificanceOptions as r, dominates as rt, pairHoldout as s, CreateEvidenceReceiptInput as st, DimensionRegression as t, Objective as tt, SequentialGateDecision as u, EvidenceBinding as ut, HypothesisResult as v, AttestationVerification as vt, verifyManifest as w, FinalEvidenceLedger as wt, hashJson as x, verifyAttestation as xt, SignedManifest as y, AttestedReport as yt, ArmPopulationReading as z, ScoreRiskDifferenceResult as zt };
-//# sourceMappingURL=statistical-heldout-BjzSOmLH.d.ts.map
+//# sourceMappingURL=statistical-heldout-Cei036nE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statistical-heldout-Cei036nE.d.ts","names":["_$__evidence_receipt0.EvidenceReceipt"],"sources":["../src/statistics/paired-binary.ts","../src/statistics/sequential-eprocess.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/arm-populations.ts","../src/paired-arms.ts","../src/pre-registration.ts","../src/campaign/gates/sequential.ts","../src/campaign/gates/statistical-heldout.ts"],"mappings":";;;;;;;UAgBiB;;EAEf;;EAEA;;EAEA;;;;;;;;;;;;iBAac,OAAO,mBAAmB,WAAW,sBAAoB;;UA2DxD;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;iBAec,QACd,SAAS,6BACT,WAAW,8BACV;;UAmBc;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;iBAmBc,qBACd,SAAS,6BACT,WAAW,6BACX,sBACC;;;;UAkCc;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCc,0BACd,SAAS,6BACT,WAAW,6BACX,sBACC;;;UAyEc;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Dc,0BACd,SAAS,6BACT,WAAW,6BACX,sBACC;;;;;;;;;;;iBA6Ga,QAAQ,WAAW,WAAW;UChhB7B;;;EAGf;;;;EAIA;;;;EAIA;;;;;;;;EAQA,SAAS;;UAGM;;EAEf;;EAEA;;EAEA;;;;;;;;;;UAWe,sBAAsB;EACrC;EACA;EACA;;EAEA;;EAEA;;EAEA;;;EAGA;;UAGe;;;EAGf,OAAO,YAAY;EACnB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BK,SAAS,OAAM,kBAAuB;cCnFhD,mBAAiB,EAAA;;;;;;GAQZ,EAAA,KAAA;;KAGC,2BAA2B,EAAE,aAAa;cAEhD,mBAAiB,EAAA;;;GAKZ,EAAA,KAAA;KAEC,2BAA2B,EAAE,aAAa;UAgCrC;EACf,aAAa;EACb,iBAAiB;EACjB;IAAY,aAAa;IAA0B,WAAW;;;KAGpD,qBAAqB;EAC3B;EAAiB,OAAO;;EACxB;EAAkB;IAAS;IAA8C;;;UAE9D;EACf,QACE,OAAO,2BACN,QAAQ;IAAuB,QAAQ;IAAqB;;EAC/D,OACE,mBACA,aAAa,2BACZ,QAAQ;IAAuB,QAAQ;IAAqB;;EAC/D,QAAQ,QAAQ,qBAAqB;;;cAI1B,2BAA2B;WAE3B;EAAA,YAAA,8CACT;;;cAQS,mCAAmC;EAClC,YAAA;;;iBA+HE,wBAAwB;EAAW;IAAiB;;;;;;;;;;;;;;;;;;;;;cCvMvD;UAEI;;EAEf,eAAe;;EAEf;;;EAGA;;EAEA;;EAEA;;;EAGA;;UAGe;;EAEf;EACA,YAAY;EACZ,kBAAkB;;EAElB;;UAGe;EACf;;EAEA;;;;;;;;iBAiBc,OAAO,iBAAiB,YAAY,wBAAwB;;;;;;;;;;iBAoB5D,kBACd,iBACA,UAAU,iBACT;cC1EG;;cAGA;KAQM,gCAAgC;UAS3B;WACN,MAAM;;WAEN;;UAGM;WACN,sBAAsB;;WAEtB;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA,WAAW;;WAEX;;WAEA;;UAGM;WACN,SAAS;WACT,aAAa;;UAGP;WACN;WACA;;UAGM,mCAAmC,KAAK;;;;;;;iBAQzC,sBACd,OAAO,4BACP,YAAY,wBACX;;;;;iBA4Ba,sBAAsB,SAAS,kBAAkB;;;;;;iBAkCjD,sBAAsB,SAAS;;KCjJnC,0BAA0B,KACpC;EAOI,YAAY,KAAK;;;iBAGP,8BAA8B,UAAU,UAAU,GAAG;EACnE,UAAU,eAAe,GAAG;EAC5B,SAAS;EACT,SAAS;IAAAA;;;;;;;;;;;;;;;;KCPC;UAEK,UAAU;;EAEzB;EACA,WAAW;EACX,QAAQ,WAAW;;UAGJ,aAAa;EAC5B,UAAU;EACV,WAAW;;EAEX,cAAc;IAAQ,WAAW;IAAG,WAAW;;;;iBAIjC,UAAU,GAAG,GAAG,GAAG,GAAG,GAAG,YAAY,UAAU;;;;;;iBAmB/C,eAAe,GAAG,YAAY,KAAK,YAAY,UAAU,OAAO,aAAa;;;KCxBjF;EAAoB;;EAAwB;EAAmB;;UAE1D;;EAEf;EACA,QAAQ;;;EAGR,WAAW;;;;EAIX;;;;EAIA;;;;;EAKA;;;;KAKU;UAEK;EACf;EACA,QAAQ;EACR,WAAW;;;;;;;;EAQX,WAAW;;;;;EAKX;;;EAGA;IAAM;IAAa;;;EAEnB,mBAAmB;;EAEnB,SAAS;;;EAGT;;EAEA;EACA;EACA,gBAAgB;EAChB;EACA;EACA,SAAS;;UAGM;;EAEf,MAAM;;;EAGN;;;EAGA;IAAQ;IAAmB;;;;;;KAMjB,mBAAmB,IAAI,mBAAmB;UAErC;;;;EAIf;;EAEA;;EAEA;;EAEA;;;EAGA;;;;;;;;iBASc,oBAAoB,WAAW,kBAAkB,UAC/D,KAAK,YAAY,WAAW,YAC5B,YAAY,sBACZ,OAAM,6BACL;;;;;;cAkIU,cAAc;UA+EV,sCAAsC;;EAErD,YAAY;;;EAGZ,SAAS;;EAET;;;;;;;iBAQc,uBAAuB,qBAAqB,kBAAkB,WAAW,UACvF,SAAS,gCACR,KAAK,WAAW;;;;;;;;;;;;;;;UCzVF;;EAEf;;;EAGA;;EAEA;;EAEA;;;;EAIA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA;;;EAGA;EACA;EACA;;EAEA;;EAEA;;;iBAYc,eAAe,MAAM,wBAAwB;;UC5D5C;EACf;EACA;EACA;EACA,YAAY;;UAEG;EACf;EACA;EACA;EACA;;EAEA;EACA,SAAS;IAAiB;IAAW;IAAiB;IAAoB;;;UAE3D;EACf;EACA,aAAa;EACb;EACA;IAAa;IAAgB;IAAmB;;EAChD,YAAY;EACZ,UAAU;;;;UCoBK;;;EAGf;;;;;EAKA;;EAEA;;EAEA;;EAEA;IAAc;IAAwB;;;EAEtC,YAAY;;EAEZ,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;;EAEhD,uBAAuB;;;;EAIvB;;EAEA,YAAY;;UAGG;;EAEf,iBAAiB;EACjB;EACA;EACA;;;EAGA,aAAa;EACb,cAAc;;;;;;;;;;;;;;;;;;iBAmBA,kBACd,eAAe,gBACf,MAAM,2BACL;UAsEc;EACf;EACA;EACA,UAAU;EACV,WAAW;;UAGI;EACf,OAAO;EACP,kBAAkB;EAClB,mBAAmB;;;;;;;;;iBAeL,eACd,uBAAuB,aACvB,wBAAwB,cACvB;;;;;;;;;;;;;;UCzXc;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;;;KAIU;UAEK,uBAAuB;;EAEtC;;EAEA,MAAM;;UAGS;EACf,UAAU;EACV;EACA;EACA;;;EAGA;;EAEA,kBAAkB;EAGlB;;;;;;;;;;;;;;;;;iBAkBoB,SAAS,GAAG,KAAK,IAAI;;;;;iBAQ3B,sBAAsB,UAAU;;;;;;iBAc1B,aAAa,GAAG,qBAAqB,QAAQ;;;;;iBAS7C,eAAe,GAAG,iBAAiB;KCtE7C;UAEK;EACf,UAAU;;EAEV;;EAEA;;;EAGA;;UAGe;;;EAGf;;;;EAIA;;;EAGA;;EAEA;;;;EAIA;;;EAGA;;;;EAIA,8BAA8B;;;EAG9B,kBAAkB;;EAElB;;;;;;;EAOA,SAAS;;;;;;KAOC,wBAAwB;EAAkB,UAAU;;UAE/C,qBAAqB,qBAAqB,kBAAkB,WAAW,kBAC9E,KAAK,WAAW;;;;;;;;;;EAUxB,QAAQ,gBAAgB;;;EAGxB,SAAS;;;;;;;;;;;;;;;;;iBAuPK,qBAAqB,qBAAqB,kBAAkB,WAAW,UACrF,SAAS,8BACR,qBAAqB,WAAW;UA6GlB;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;GACd;IAAQ,SAAS;;IAAyB;IAAe;;;EAE1D,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BK,iBAAiB,UAAS,0BAA+B;UC9dxD;;EAEf;;EAEA;;EAEA;;;;;;;;;;;;;iBA4Ec,YACd,WAAW,YAAY,eAAe,cACtC,UAAU,YAAY,eAAe,cACrC,aAAa,aACb,SAAS,GAAG,oCACX;UAkEc;EACf,QAAQ;;;;;;;;;;;;EAYR,WAAW;;;;EAIX,iBAAiB;;;;;;;EAOjB,UAAU;;EAEV,mBAAmB;;EAEnB,SAAS;;;;EAIT;;EAEA;;EAEA;EACA;;EAEA;;EAEA;;EAEA,gBAAgB;;EAEhB;;;;EAIA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;EACA;;EAEA,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BhB,oBACd,QAAQ,eACR,OAAM,6BACL;UA2Ec;EACf;;;EAGA,WAAW;;;;EAIX;;EAEA;IAAM;IAAa;;;EAEnB,mBAAmB;;EAEnB,SAAS;;EAET;;;;EAIA;EACA;EACA;EACA;EACA;;EAEA;EACA;;EAEA;;EAEA;;;;;;;;;;iBAkBc,qBACd,WAAW,YAAY,eAAe,cACtC,UAAU,YAAY,eAAe,cACrC,aAAa,aACb,8BACA;EACE;EACA;EACA;EACA;;;EAGA;EACA,8BAA8B;EAC9B;IAED"}

package/dist/{statistical-heldout-Bksv92Th.js → statistical-heldout-TP6ndL0B.js}

@@ -1,6 +1,6 @@
-import { i as pairedBootstrap } from "./mean-BbA_JCzW.js";
-import { t as decidePairedPromotion } from "./paired-promotion-decision-D0SHb-ZL.js";
-//#region src/campaign/gates/statistical-heldout.ts
+import { i as pairedBootstrap } from "./mean-CdDYG-us.js";
+import { t as decidePairedPromotion } from "./paired-promotion-decision-FGvHA4p_.js";
+// src/campaign/gates/statistical-heldout.ts
 /**
 * Held-out inference pairs execution cells and judge identities before taking
 * means within registered independent units. Repetitions can improve a unit's
@@ -250,7 +250,6 @@ function dimensionRegressions(candidate, baseline, scenarioIds, criticalDimensio
 	}
 	return out;
 }
-//#endregion
 export { heldoutSignificance as a, dimensionRegressions as i, aggregatePairedHoldout as n, pairHoldout as o, detectScale as r, TIE_WARN_FRACTION as t };
 
-//# sourceMappingURL=statistical-heldout-Bksv92Th.js.map
+//# sourceMappingURL=statistical-heldout-TP6ndL0B.js.map

package/dist/{statistical-heldout-Bksv92Th.js.map → statistical-heldout-TP6ndL0B.js.map}

@@ -1 +1 @@
-{"version":3,"file":"statistical-heldout-Bksv92Th.js","names":[],"sources":["../src/campaign/gates/statistical-heldout.ts"],"sourcesContent":["/**\n * Held-out inference pairs execution cells and judge identities before taking\n * means within registered independent units. Repetitions can improve a unit's\n * precision without increasing n. Ungrouped inference concerns independently\n * sampled execution cells conditional on a fixed scenario roster.\n *\n * The shared paired decision rule selects the estimator and statistical test.\n * Dimension reports retain missing coverage so required safety checks cannot\n * pass through absent evidence. Thresholds use the judge's native score scale.\n */\n\nimport {\n  decidePairedPromotion,\n  type PairedDecisionMethod,\n  type PairedDecisionStatistic,\n  type PairedMcNemarEvidence,\n  type PairedPromotionDecision,\n} from '../../paired-promotion-decision'\nimport {\n  DECISION_PAIRED_DELTA_STATISTIC,\n  type PairedBootstrapResult,\n  pairedBootstrap,\n} from '../../statistics'\nimport type { JudgeScore } from '../types'\n\n/** Tie fraction at/above which a gate annotates its verdict with the tie share.\n *  Tie-domination of the median bites structurally at >= 0.5 (the median is then\n *  0 by construction); 0.4 is a softer warn threshold that flags a run APPROACHING\n *  that regime, so an operator sees it before the median goes fully blind. */\nexport const TIE_WARN_FRACTION = 0.4\n\nexport interface PairedHoldout {\n  /** Baseline scalar per paired cell (same order as `after`/`cellIds`). */\n  before: number[]\n  /** Candidate scalar per paired cell. */\n  after: number[]\n  /** The full cellIds (`scenario:rep`) that paired, in order. */\n  cellIds: string[]\n}\n\n/** Campaign cell IDs append a numeric repetition after the scenario's full ID. */\nfunction scenarioIdFromCellId(cellId: string): string {\n  const separator = cellId.lastIndexOf(':')\n  const repetition = cellId.slice(separator + 1)\n  if (\n    separator < 1 ||\n    cellId.trim() !== cellId ||\n    !/^(0|[1-9]\\d*)$/.test(repetition) ||\n    !Number.isSafeInteger(Number(repetition))\n  ) {\n    throw new Error(`pairHoldout: malformed cellId '${cellId}'; expected scenarioId:rep`)\n  }\n  return cellId.slice(0, separator)\n}\n\n/** Preserve cell pairing before taking equal-weight independent-unit means. */\nexport function aggregatePairedHoldout(\n  paired: PairedHoldout,\n  independentUnitByScenarioId?: ReadonlyMap<string, string>,\n): { before: number[]; after: number[]; unitIds: string[] } {\n  if (\n    paired.before.length !== paired.after.length ||\n    paired.before.length !== paired.cellIds.length\n  ) {\n    throw new Error('aggregatePairedHoldout: scores and cellIds must have the same length')\n  }\n  if (new Set(paired.cellIds).size !== paired.cellIds.length) {\n    throw new Error('aggregatePairedHoldout: duplicate cellIds cannot count as new observations')\n  }\n  if (\n    paired.before.some((value) => !Number.isFinite(value)) ||\n    paired.after.some((value) => !Number.isFinite(value))\n  ) {\n    throw new Error('aggregatePairedHoldout: paired scores must be finite')\n  }\n  if (independentUnitByScenarioId === undefined) {\n    return { before: [...paired.before], after: [...paired.after], unitIds: [...paired.cellIds] }\n  }\n  const scenarioIds = paired.cellIds.map(scenarioIdFromCellId)\n  const groups = new Map<string, { before: number; after: number; n: number }>()\n  for (let i = 0; i < paired.cellIds.length; i++) {\n    const scenarioId = scenarioIds[i]!\n    const unitId = independentUnitByScenarioId.get(scenarioId)\n    if (typeof unitId !== 'string' || unitId.length === 0 || unitId.trim() !== unitId) {\n      throw new Error(\n        `aggregatePairedHoldout: missing independent unit for scenario '${scenarioId}'`,\n      )\n    }\n    const group = groups.get(unitId) ?? { before: 0, after: 0, n: 0 }\n    group.before += paired.before[i]!\n    group.after += paired.after[i]!\n    group.n += 1\n    groups.set(unitId, group)\n  }\n  const unitIds = [...groups.keys()].sort()\n  return {\n    before: unitIds.map((id) => groups.get(id)!.before / groups.get(id)!.n),\n    after: unitIds.map((id) => groups.get(id)!.after / groups.get(id)!.n),\n    unitIds,\n  }\n}\n\n/**\n * Pair candidate vs baseline holdout observations by FULL cellId. `select`\n * pulls the scalar from a cell's judge reports (composite, or a named\n * dimension); a cell contributes the mean of `select` across its judges. Cells\n * whose scenario is not in `scenarioIds`, or where `select` is undefined for\n * every judge on both sides, are skipped. The selected judge IDs must agree\n * within each pair. Throws when the two maps disagree on holdout cell IDs — a\n * load-bearing invariant: the baseline + winner holdout campaigns run the same\n * scenarios with the same seed base, so their cellIds MUST align; a mismatch\n * means a silent pairing bug, not a soft fallback.\n */\nexport function pairHoldout(\n  candidate: Map<string, Record<string, JudgeScore>>,\n  baseline: Map<string, Record<string, JudgeScore>>,\n  scenarioIds: Set<string>,\n  select: (s: JudgeScore) => number | undefined,\n): PairedHoldout {\n  const cellValues = (\n    byCell: Map<string, Record<string, JudgeScore>>,\n    cellId: string,\n  ): Map<string, number> => {\n    const scores = byCell.get(cellId)\n    const values = new Map<string, number>()\n    if (!scores) return values\n    for (const [judgeId, s] of Object.entries(scores)) {\n      if (s.failed === true) {\n        throw new Error(`pairHoldout: cell '${cellId}' contains a failed judge score`)\n      }\n      const v = select(s)\n      if (typeof v === 'number' && !Number.isFinite(v)) {\n        throw new Error(`pairHoldout: cell '${cellId}' contains a non-finite selected score`)\n      }\n      if (typeof v === 'number') values.set(judgeId, v)\n    }\n    return values\n  }\n\n  const inScope = (cellId: string) => scenarioIds.has(scenarioIdFromCellId(cellId))\n  const candCells = [...candidate.keys()].filter(inScope).sort()\n  const baseCells = [...baseline.keys()].filter(inScope).sort()\n  // Alignment invariant — the holdout campaigns share scenarios + seed, so the\n  // cell sets must be identical. Differ ⇒ a real pairing bug; fail loud.\n  if (candCells.length !== baseCells.length || candCells.some((c, i) => c !== baseCells[i])) {\n    throw new Error(\n      `pairHoldout: candidate/baseline holdout cells do not align — ` +\n        `candidate=[${candCells.join(',')}] baseline=[${baseCells.join(',')}]. ` +\n        `Both holdout campaigns must run the same scenarios with the same seed base.`,\n    )\n  }\n\n  const before: number[] = []\n  const after: number[] = []\n  const cellIds: string[] = []\n  for (const cellId of candCells) {\n    const b = cellValues(baseline, cellId)\n    const a = cellValues(candidate, cellId)\n    // A scalar absent on both sides means that dimension was not scored. A\n    // one-sided absence is asymmetric evidence loss, never a row to discard.\n    if (b.size === 0 && a.size === 0) continue\n    if (b.size === 0 || a.size === 0) {\n      throw new Error(`pairHoldout: cell '${cellId}' has a selected score on only one arm`)\n    }\n    if (b.size !== a.size || [...b.keys()].some((id) => !a.has(id))) {\n      throw new Error(`pairHoldout: cell '${cellId}' selected judge IDs do not align`)\n    }\n    const judgeIds = [...b.keys()].sort()\n    before.push(meanSelectedScores(judgeIds.map((id) => b.get(id)!)))\n    after.push(meanSelectedScores(judgeIds.map((id) => a.get(id)!)))\n    cellIds.push(cellId)\n  }\n  return { before, after, cellIds }\n}\n\nfunction meanSelectedScores(values: number[]): number {\n  const first = values[0]!\n  // Summing identical fractional scores can round their mean outside the\n  // declared binary support. An agreeing judge set preserves its exact value.\n  return values.every((value) => value === first)\n    ? first\n    : values.reduce((sum, value) => sum + value, 0) / values.length\n}\n\nexport interface HeldoutSignificance {\n  paired: PairedHoldout\n  /**\n   * The paired bootstrap on the requested statistic (MEAN by default — see the\n   * tie note on `heldoutSignificance`).\n   *\n   * DIAGNOSTIC, not necessarily the interval the verdict keyed on. On a\n   * two-point (pass/fail) outcome the decision routes to Tango's score interval\n   * instead, because a percentile bootstrap of the mean over a three-atom\n   * lattice is not a valid interval at a nonzero margin. Read\n   * `decision.low`/`decision.high` for the interval that actually decided, and\n   * `decisionStatistic` for which one it is.\n   */\n  bootstrap: PairedBootstrapResult\n  /** The MEDIAN paired-delta bootstrap, reported as a diagnostic. When many\n   *  scenarios are tied (both sides solve them), the median is pinned near 0\n   *  regardless of the mean lift — comparing the two exposes tie-domination. */\n  medianBootstrap: PairedBootstrapResult\n  /**\n   * The full promotion decision: which estimator the outcome's shape admits,\n   * the interval it produced, McNemar's exact veto on the two-point path, and\n   * whether the interval was zero-width (no evidence in either direction). The\n   * single source of `significant`.\n   */\n  decision: PairedPromotionDecision\n  /** Which paired estimator the verdict was decided on. */\n  decisionStatistic: PairedDecisionStatistic\n  /** McNemar's exact evidence on the two-point path; null otherwise. */\n  mcnemar: PairedMcNemarEvidence | null\n  /** Fraction of paired observations that are exact ties (|delta| < 1e-9). A\n   *  high tie fraction is WHY a median-based gate would have missed a real lift;\n   *  it is the observability the tie fix adds. */\n  tieFraction: number\n  /** Number of paired observation units, after configured aggregation. */\n  n: number\n  /** Original matched execution cells, before aggregation. */\n  pairedCellN: number\n  observationUnit: 'registered' | 'cell'\n  /** Registered unit IDs, or cell IDs on the ungrouped path. */\n  unitIds: string[]\n  /** Effective minimum for the requested target and chosen estimator. */\n  minimumRequired: number\n  /** Statistical method that carried the decision. */\n  decisionMethod: PairedDecisionMethod\n  /** Exact one-sided p-value on the small-sample path; otherwise null. */\n  pValue: number | null\n  /** True iff n >= minimumRequired, the DECIDING interval has nonzero width,\n   *  its lower bound clears the threshold, and McNemar's exact test does not\n   *  veto at a non-negative threshold. */\n  significant: boolean\n  /** Set when n < minimumRequired — too little evidence to claim significance. */\n  fewRuns: boolean\n}\n\nexport interface HeldoutSignificanceOptions {\n  deltaThreshold?: number\n  minProductiveRuns?: number\n  confidence?: number\n  resamples?: number\n  /** Fixed by default for a deterministic, reproducible gate verdict. */\n  seed?: number\n  statistic?: 'mean' | 'median'\n  /** Group full cell pairs into equal-weight independent units before inference. */\n  independentUnitByScenarioId?: ReadonlyMap<string, string>\n}\n\n/**\n * Significance of the held-out composite lift: ship only when the lower bound\n * of the interval the outcome's shape ADMITS exceeds `deltaThreshold` (default\n * 0 ⇒ \"confidently positive\"). Interpret `deltaThreshold` in the judge's native\n * scale.\n *\n * The decision is delegated whole to {@link decidePairedPromotion}, the one\n * copy of the rule (`src/paired-promotion-decision.ts`), which `HeldOutGate`\n * also calls. That module's header carries the measurements; the short version\n * is three guards a bare `bootstrap.low > threshold` does not have:\n *\n *   - a two-point (pass/fail) outcome decides on Tango's SCORE interval, the\n *     only paired-binary construction that stays valid at a nonzero margin;\n *   - McNemar's exact test VETOES at any non-negative threshold;\n *   - a ZERO-WIDTH interval is refused rather than promoted, in either\n *     direction — [0,0] clears every negative threshold and [g,g] clears every\n *     threshold below g, and both are an absence of evidence, not a result.\n *\n * Measured on this function before those guards landed, at a nominal 5 %:\n * 14.60 % false promotion at n = 40 on a paired-binary noninferiority boundary,\n * and 88.50 % at n = 6 under a bounded asymmetric null whose true mean paired\n * delta is exactly 0.\n *\n * Continuous mean targets require bootstrap eligibility. Explicit median\n * targets can use the exact sign test at its confidence-dependent minimum.\n */\nexport function heldoutSignificance(\n  paired: PairedHoldout,\n  opts: HeldoutSignificanceOptions = {},\n): HeldoutSignificance {\n  const deltaThreshold = opts.deltaThreshold ?? 0\n  const confidence = opts.confidence ?? 0.95\n  const resamples = opts.resamples ?? 2000\n  const seed = opts.seed ?? 1337\n  // DEFAULT to the MEAN paired delta, not the median. The median is destroyed by\n  // TIES: whenever both baseline and candidate solve a holdout scenario (a common\n  // case once the agent is decent — and INCREASINGLY common as you add holdout\n  // scenarios for statistical power), that scenario contributes delta 0. When\n  // >=50% of paired cells are ties the median is pinned at 0 regardless of a large,\n  // consistent lift on the rest, and the gate holds a genuinely better candidate.\n  // (Measured live, supervisor-lab run 6: 40 cells, 20 ties, MEAN +0.177, MEDIAN 0\n  // → false hold. Doubling the holdout for \"power\" made it WORSE by adding ties.)\n  // The mean equals the reported aggregate lift, ties correctly contribute 0\n  // without dominating, and it is the textbook paired-comparison estimator; the\n  // median is kept as a reported diagnostic. Callers wanting outlier-robustness at\n  // the cost of tie-blindness can still pass `statistic: 'median'`.\n  const statistic = opts.statistic ?? 'mean'\n  const observations = aggregatePairedHoldout(paired, opts.independentUnitByScenarioId)\n  const decision = decidePairedPromotion(observations.before, observations.after, {\n    confidence,\n    resamples,\n    statistic,\n    seed,\n    threshold: deltaThreshold,\n    minPairs: opts.minProductiveRuns,\n  })\n  // `decision.bootstrap` is null exactly when the score interval decided, so\n  // the requested-statistic bootstrap is computed here for the diagnostic\n  // field. Same two bootstraps as before on every path.\n  const bootstrap =\n    decision.bootstrap ??\n    pairedBootstrap(observations.before, observations.after, {\n      confidence,\n      resamples,\n      statistic,\n      seed,\n    })\n  const medianBootstrap =\n    statistic === 'median'\n      ? bootstrap\n      : pairedBootstrap(observations.before, observations.after, {\n          confidence,\n          resamples,\n          statistic: 'median',\n          seed,\n        })\n  const n = observations.before.length\n  let ties = 0\n  for (let i = 0; i < n; i += 1) {\n    const after = observations.after[i]!\n    const before = observations.before[i]!\n    if (Math.abs(after - before) < 1e-9) ties += 1\n  }\n  const tieFraction = n === 0 ? 0 : ties / n\n  return {\n    paired,\n    bootstrap,\n    medianBootstrap,\n    decision,\n    decisionStatistic: decision.statistic,\n    mcnemar: decision.mcnemar,\n    tieFraction,\n    n,\n    pairedCellN: paired.cellIds.length,\n    observationUnit: opts.independentUnitByScenarioId === undefined ? 'cell' : 'registered',\n    unitIds: observations.unitIds,\n    minimumRequired: decision.minimumPairs,\n    decisionMethod: decision.method,\n    pValue: decision.pValue,\n    significant: decision.promote,\n    fewRuns: !decision.sufficient,\n  }\n}\n\nexport interface DimensionRegression {\n  dimension: string\n  /** Paired bootstrap on (candidate − baseline). DIAGNOSTIC on a pass/fail\n   *  dimension, where `ci` carries the interval that decided instead. */\n  bootstrap: PairedBootstrapResult\n  /** Which paired statistic `bootstrap.low` is the lower bound of. `'mean'`\n   *  unless the caller asked for the median. `bootstrap.median` still carries\n   *  the median point estimate either way. */\n  bootstrapStatistic: 'median' | 'mean'\n  /** The interval `regressed` was decided on, in the dimension's native units. */\n  ci: { low: number; high: number }\n  /** Which estimator produced `ci`. */\n  decisionStatistic: PairedDecisionStatistic\n  /** McNemar's exact evidence on a pass/fail dimension; null otherwise. */\n  mcnemar: PairedMcNemarEvidence | null\n  /** `ci` has zero width — no evidence in either direction. */\n  indeterminate: boolean\n  /** The bootstrap lower bound is below negative tolerance, or the shared\n   *  paired test supports a drop exceeding tolerance. Missing coverage and\n   *  insufficient observations are reported separately. */\n  regressed: boolean\n  tolerance: number\n  n: number\n  pairedCellN: number\n  observationUnit: 'registered' | 'cell'\n  /** Statistical minimum for the configured independent observation unit. */\n  minimumRequired: number\n  fewRuns: boolean\n  /** Both arms lack this dimension on these otherwise matched execution cells. */\n  missingCellIds: string[]\n  /** Configured scenarios with no paired dimension measurement at all. */\n  missingScenarioIds: string[]\n}\n\n/** Detect the native scale of a set of scores: 0-100 when any magnitude clears\n *  1.5, else [0,1]. Used to auto-scale the regression tolerance so a default\n *  expressed for [0,1] is not silently a no-op on a 0-100 dimension. */\nexport function detectScale(values: number[]): 1 | 100 {\n  return values.some((v) => Math.abs(v) > 1.5) ? 100 : 1\n}\n\n/**\n * Report required-dimension evidence after full pairing and optional unit means.\n * A bootstrap floor breach or a shared paired test supporting a drop marks\n * regression. These two criteria are distinct; `ci` records the shared\n * estimator and `bootstrap` records the floor interval. Missing observations\n * and insufficient n remain explicit for the caller's evidence policy.\n * The default tolerance is 0.05 on [0,1] and 5 on a detected 0-100 scale.\n */\nexport function dimensionRegressions(\n  candidate: Map<string, Record<string, JudgeScore>>,\n  baseline: Map<string, Record<string, JudgeScore>>,\n  scenarioIds: Set<string>,\n  criticalDimensions: string[],\n  opts: {\n    tolerance?: number\n    confidence?: number\n    resamples?: number\n    seed?: number\n    /** Paired statistic the CI is computed on. Default `'mean'` — see\n     *  {@link DECISION_PAIRED_DELTA_STATISTIC} for why the median is not. */\n    statistic?: 'mean' | 'median'\n    independentUnitByScenarioId?: ReadonlyMap<string, string>\n    minProductiveRuns?: number\n  } = {},\n): DimensionRegression[] {\n  const out: DimensionRegression[] = []\n  const expectedCellIds = [...baseline.keys()]\n    .filter((cellId) => scenarioIds.has(scenarioIdFromCellId(cellId)))\n    .sort()\n  for (const dim of criticalDimensions) {\n    const paired = pairHoldout(candidate, baseline, scenarioIds, (s) => s.dimensions[dim])\n    if (paired.before.length === 0) continue // dimension not scored on this judge\n    const observations = aggregatePairedHoldout(paired, opts.independentUnitByScenarioId)\n    const measuredCells = new Set(paired.cellIds)\n    const measuredScenarios = new Set(paired.cellIds.map(scenarioIdFromCellId))\n    const tolerance = opts.tolerance ?? 0.05 * detectScale([...paired.before, ...paired.after])\n    const bootstrapStatistic = opts.statistic ?? DECISION_PAIRED_DELTA_STATISTIC\n    const shared = {\n      confidence: opts.confidence ?? 0.95,\n      resamples: opts.resamples ?? 2000,\n      statistic: bootstrapStatistic,\n      seed: opts.seed ?? 1337,\n      minPairs: opts.minProductiveRuns,\n    }\n    const guard = decidePairedPromotion(observations.before, observations.after, shared)\n    const regression = decidePairedPromotion(observations.after, observations.before, {\n      ...shared,\n      threshold: tolerance,\n    })\n    const bootstrap =\n      guard.bootstrap ?? pairedBootstrap(observations.before, observations.after, shared)\n    out.push({\n      dimension: dim,\n      bootstrap,\n      bootstrapStatistic,\n      ci: { low: guard.low, high: guard.high },\n      decisionStatistic: guard.statistic,\n      mcnemar: guard.mcnemar,\n      indeterminate: guard.indeterminate,\n      // Fires on EITHER burden of proof — see `floorBreached` in\n      // `promotion-policy.ts` for the same rule and the reasoning. The CI arm\n      // is the contract this interface and `default-production-gate`'s reason\n      // string both state (\"CI.low < -tolerance\"), read off the DECIDING\n      // interval; the exact-test arm adds the small-sample path where the\n      // bootstrap interval is descriptive only.\n      // The credible-worst-case arm stays on the BOOTSTRAP — see the same\n      // decision in `floorBreached` (`promotion-policy.ts`). On a pass/fail\n      // dimension the score interval is ±z²/(n+z²) even when every pair is\n      // concordant, so reading the floor off it would flag an unchanged safety\n      // dimension as regressed at any realistic n. The PROVEN-drop arm does use\n      // the shared rule, which is what closes the fail-open hole that mattered:\n      // a genuine pass/fail regression is now judged on an interval valid at\n      // the nonzero `tolerance`, instead of a bootstrap that is pinned wherever\n      // ties dominate.\n      regressed: bootstrap.low < -tolerance || regression.promote,\n      tolerance,\n      n: observations.before.length,\n      pairedCellN: paired.cellIds.length,\n      observationUnit: opts.independentUnitByScenarioId === undefined ? 'cell' : 'registered',\n      minimumRequired: guard.minimumPairs,\n      fewRuns: !guard.sufficient,\n      missingCellIds: expectedCellIds.filter((cellId) => !measuredCells.has(cellId)),\n      missingScenarioIds: [...scenarioIds].filter((id) => !measuredScenarios.has(id)).sort(),\n    })\n  }\n  return out\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA6BA,MAAa,oBAAoB;;AAYjC,SAAS,qBAAqB,QAAwB;CACpD,MAAM,YAAY,OAAO,YAAY,GAAG;CACxC,MAAM,aAAa,OAAO,MAAM,YAAY,CAAC;CAC7C,IACE,YAAY,KACZ,OAAO,KAAK,MAAM,UAClB,CAAC,iBAAiB,KAAK,UAAU,KACjC,CAAC,OAAO,cAAc,OAAO,UAAU,CAAC,GAExC,MAAM,IAAI,MAAM,kCAAkC,OAAO,2BAA2B;CAEtF,OAAO,OAAO,MAAM,GAAG,SAAS;AAClC;;AAGA,SAAgB,uBACd,QACA,6BAC0D;CAC1D,IACE,OAAO,OAAO,WAAW,OAAO,MAAM,UACtC,OAAO,OAAO,WAAW,OAAO,QAAQ,QAExC,MAAM,IAAI,MAAM,sEAAsE;CAExF,IAAI,IAAI,IAAI,OAAO,OAAO,CAAC,CAAC,SAAS,OAAO,QAAQ,QAClD,MAAM,IAAI,MAAM,4EAA4E;CAE9F,IACE,OAAO,OAAO,MAAM,UAAU,CAAC,OAAO,SAAS,KAAK,CAAC,KACrD,OAAO,MAAM,MAAM,UAAU,CAAC,OAAO,SAAS,KAAK,CAAC,GAEpD,MAAM,IAAI,MAAM,sDAAsD;CAExE,IAAI,gCAAgC,KAAA,GAClC,OAAO;EAAE,QAAQ,CAAC,GAAG,OAAO,MAAM;EAAG,OAAO,CAAC,GAAG,OAAO,KAAK;EAAG,SAAS,CAAC,GAAG,OAAO,OAAO;CAAE;CAE9F,MAAM,cAAc,OAAO,QAAQ,IAAI,oBAAoB;CAC3D,MAAM,yBAAS,IAAI,IAA0D;CAC7E,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,QAAQ,KAAK;EAC9C,MAAM,aAAa,YAAY;EAC/B,MAAM,SAAS,4BAA4B,IAAI,UAAU;EACzD,IAAI,OAAO,WAAW,YAAY,OAAO,WAAW,KAAK,OAAO,KAAK,MAAM,QACzE,MAAM,IAAI,MACR,kEAAkE,WAAW,EAC/E;EAEF,MAAM,QAAQ,OAAO,IAAI,MAAM,KAAK;GAAE,QAAQ;GAAG,OAAO;GAAG,GAAG;EAAE;EAChE,MAAM,UAAU,OAAO,OAAO;EAC9B,MAAM,SAAS,OAAO,MAAM;EAC5B,MAAM,KAAK;EACX,OAAO,IAAI,QAAQ,KAAK;CAC1B;CACA,MAAM,UAAU,CAAC,GAAG,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK;CACxC,OAAO;EACL,QAAQ,QAAQ,KAAK,OAAO,OAAO,IAAI,EAAE,CAAC,CAAE,SAAS,OAAO,IAAI,EAAE,CAAC,CAAE,CAAC;EACtE,OAAO,QAAQ,KAAK,OAAO,OAAO,IAAI,EAAE,CAAC,CAAE,QAAQ,OAAO,IAAI,EAAE,CAAC,CAAE,CAAC;EACpE;CACF;AACF;;;;;;;;;;;;AAaA,SAAgB,YACd,WACA,UACA,aACA,QACe;CACf,MAAM,cACJ,QACA,WACwB;EACxB,MAAM,SAAS,OAAO,IAAI,MAAM;EAChC,MAAM,yBAAS,IAAI,IAAoB;EACvC,IAAI,CAAC,QAAQ,OAAO;EACpB,KAAK,MAAM,CAAC,SAAS,MAAM,OAAO,QAAQ,MAAM,GAAG;GACjD,IAAI,EAAE,WAAW,MACf,MAAM,IAAI,MAAM,sBAAsB,OAAO,gCAAgC;GAE/E,MAAM,IAAI,OAAO,CAAC;GAClB,IAAI,OAAO,MAAM,YAAY,CAAC,OAAO,SAAS,CAAC,GAC7C,MAAM,IAAI,MAAM,sBAAsB,OAAO,uCAAuC;GAEtF,IAAI,OAAO,MAAM,UAAU,OAAO,IAAI,SAAS,CAAC;EAClD;EACA,OAAO;CACT;CAEA,MAAM,WAAW,WAAmB,YAAY,IAAI,qBAAqB,MAAM,CAAC;CAChF,MAAM,YAAY,CAAC,GAAG,UAAU,KAAK,CAAC,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK;CAC7D,MAAM,YAAY,CAAC,GAAG,SAAS,KAAK,CAAC,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK;CAG5D,IAAI,UAAU,WAAW,UAAU,UAAU,UAAU,MAAM,GAAG,MAAM,MAAM,UAAU,EAAE,GACtF,MAAM,IAAI,MACR,2EACgB,UAAU,KAAK,GAAG,EAAE,cAAc,UAAU,KAAK,GAAG,EAAE,+EAExE;CAGF,MAAM,SAAmB,CAAC;CAC1B,MAAM,QAAkB,CAAC;CACzB,MAAM,UAAoB,CAAC;CAC3B,KAAK,MAAM,UAAU,WAAW;EAC9B,MAAM,IAAI,WAAW,UAAU,MAAM;EACrC,MAAM,IAAI,WAAW,WAAW,MAAM;EAGtC,IAAI,EAAE,SAAS,KAAK,EAAE,SAAS,GAAG;EAClC,IAAI,EAAE,SAAS,KAAK,EAAE,SAAS,GAC7B,MAAM,IAAI,MAAM,sBAAsB,OAAO,uCAAuC;EAEtF,IAAI,EAAE,SAAS,EAAE,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,MAAM,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,GAC5D,MAAM,IAAI,MAAM,sBAAsB,OAAO,kCAAkC;EAEjF,MAAM,WAAW,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK;EACpC,OAAO,KAAK,mBAAmB,SAAS,KAAK,OAAO,EAAE,IAAI,EAAE,CAAE,CAAC,CAAC;EAChE,MAAM,KAAK,mBAAmB,SAAS,KAAK,OAAO,EAAE,IAAI,EAAE,CAAE,CAAC,CAAC;EAC/D,QAAQ,KAAK,MAAM;CACrB;CACA,OAAO;EAAE;EAAQ;EAAO;CAAQ;AAClC;AAEA,SAAS,mBAAmB,QAA0B;CACpD,MAAM,QAAQ,OAAO;CAGrB,OAAO,OAAO,OAAO,UAAU,UAAU,KAAK,IAC1C,QACA,OAAO,QAAQ,KAAK,UAAU,MAAM,OAAO,CAAC,IAAI,OAAO;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8FA,SAAgB,oBACd,QACA,OAAmC,CAAC,GACf;CACrB,MAAM,iBAAiB,KAAK,kBAAkB;CAC9C,MAAM,aAAa,KAAK,cAAc;CACtC,MAAM,YAAY,KAAK,aAAa;CACpC,MAAM,OAAO,KAAK,QAAQ;CAa1B,MAAM,YAAY,KAAK,aAAa;CACpC,MAAM,eAAe,uBAAuB,QAAQ,KAAK,2BAA2B;CACpF,MAAM,WAAW,sBAAsB,aAAa,QAAQ,aAAa,OAAO;EAC9E;EACA;EACA;EACA;EACA,WAAW;EACX,UAAU,KAAK;CACjB,CAAC;CAID,MAAM,YACJ,SAAS,aACT,gBAAgB,aAAa,QAAQ,aAAa,OAAO;EACvD;EACA;EACA;EACA;CACF,CAAC;CACH,MAAM,kBACJ,cAAc,WACV,YACA,gBAAgB,aAAa,QAAQ,aAAa,OAAO;EACvD;EACA;EACA,WAAW;EACX;CACF,CAAC;CACP,MAAM,IAAI,aAAa,OAAO;CAC9B,IAAI,OAAO;CACX,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK,GAAG;EAC7B,MAAM,QAAQ,aAAa,MAAM;EACjC,MAAM,SAAS,aAAa,OAAO;EACnC,IAAI,KAAK,IAAI,QAAQ,MAAM,IAAI,MAAM,QAAQ;CAC/C;CACA,MAAM,cAAc,MAAM,IAAI,IAAI,OAAO;CACzC,OAAO;EACL;EACA;EACA;EACA;EACA,mBAAmB,SAAS;EAC5B,SAAS,SAAS;EAClB;EACA;EACA,aAAa,OAAO,QAAQ;EAC5B,iBAAiB,KAAK,gCAAgC,KAAA,IAAY,SAAS;EAC3E,SAAS,aAAa;EACtB,iBAAiB,SAAS;EAC1B,gBAAgB,SAAS;EACzB,QAAQ,SAAS;EACjB,aAAa,SAAS;EACtB,SAAS,CAAC,SAAS;CACrB;AACF;;;;AAuCA,SAAgB,YAAY,QAA2B;CACrD,OAAO,OAAO,MAAM,MAAM,KAAK,IAAI,CAAC,IAAI,GAAG,IAAI,MAAM;AACvD;;;;;;;;;AAUA,SAAgB,qBACd,WACA,UACA,aACA,oBACA,OAUI,CAAC,GACkB;CACvB,MAAM,MAA6B,CAAC;CACpC,MAAM,kBAAkB,CAAC,GAAG,SAAS,KAAK,CAAC,CAAC,CACzC,QAAQ,WAAW,YAAY,IAAI,qBAAqB,MAAM,CAAC,CAAC,CAAC,CACjE,KAAK;CACR,KAAK,MAAM,OAAO,oBAAoB;EACpC,MAAM,SAAS,YAAY,WAAW,UAAU,cAAc,MAAM,EAAE,WAAW,IAAI;EACrF,IAAI,OAAO,OAAO,WAAW,GAAG;EAChC,MAAM,eAAe,uBAAuB,QAAQ,KAAK,2BAA2B;EACpF,MAAM,gBAAgB,IAAI,IAAI,OAAO,OAAO;EAC5C,MAAM,oBAAoB,IAAI,IAAI,OAAO,QAAQ,IAAI,oBAAoB,CAAC;EAC1E,MAAM,YAAY,KAAK,aAAa,MAAO,YAAY,CAAC,GAAG,OAAO,QAAQ,GAAG,OAAO,KAAK,CAAC;EAC1F,MAAM,qBAAqB,KAAK,aAAA;EAChC,MAAM,SAAS;GACb,YAAY,KAAK,cAAc;GAC/B,WAAW,KAAK,aAAa;GAC7B,WAAW;GACX,MAAM,KAAK,QAAQ;GACnB,UAAU,KAAK;EACjB;EACA,MAAM,QAAQ,sBAAsB,aAAa,QAAQ,aAAa,OAAO,MAAM;EACnF,MAAM,aAAa,sBAAsB,aAAa,OAAO,aAAa,QAAQ;GAChF,GAAG;GACH,WAAW;EACb,CAAC;EACD,MAAM,YACJ,MAAM,aAAa,gBAAgB,aAAa,QAAQ,aAAa,OAAO,MAAM;EACpF,IAAI,KAAK;GACP,WAAW;GACX;GACA;GACA,IAAI;IAAE,KAAK,MAAM;IAAK,MAAM,MAAM;GAAK;GACvC,mBAAmB,MAAM;GACzB,SAAS,MAAM;GACf,eAAe,MAAM;GAgBrB,WAAW,UAAU,MAAM,CAAC,aAAa,WAAW;GACpD;GACA,GAAG,aAAa,OAAO;GACvB,aAAa,OAAO,QAAQ;GAC5B,iBAAiB,KAAK,gCAAgC,KAAA,IAAY,SAAS;GAC3E,iBAAiB,MAAM;GACvB,SAAS,CAAC,MAAM;GAChB,gBAAgB,gBAAgB,QAAQ,WAAW,CAAC,cAAc,IAAI,MAAM,CAAC;GAC7E,oBAAoB,CAAC,GAAG,WAAW,CAAC,CAAC,QAAQ,OAAO,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK;EACvF,CAAC;CACH;CACA,OAAO;AACT"}
+{"version":3,"file":"statistical-heldout-TP6ndL0B.js","names":[],"sources":["../src/campaign/gates/statistical-heldout.ts"],"sourcesContent":["/**\n * Held-out inference pairs execution cells and judge identities before taking\n * means within registered independent units. Repetitions can improve a unit's\n * precision without increasing n. Ungrouped inference concerns independently\n * sampled execution cells conditional on a fixed scenario roster.\n *\n * The shared paired decision rule selects the estimator and statistical test.\n * Dimension reports retain missing coverage so required safety checks cannot\n * pass through absent evidence. Thresholds use the judge's native score scale.\n */\n\nimport {\n  decidePairedPromotion,\n  type PairedDecisionMethod,\n  type PairedDecisionStatistic,\n  type PairedMcNemarEvidence,\n  type PairedPromotionDecision,\n} from '../../paired-promotion-decision'\nimport {\n  DECISION_PAIRED_DELTA_STATISTIC,\n  type PairedBootstrapResult,\n  pairedBootstrap,\n} from '../../statistics'\nimport type { JudgeScore } from '../types'\n\n/** Tie fraction at/above which a gate annotates its verdict with the tie share.\n *  Tie-domination of the median bites structurally at >= 0.5 (the median is then\n *  0 by construction); 0.4 is a softer warn threshold that flags a run APPROACHING\n *  that regime, so an operator sees it before the median goes fully blind. */\nexport const TIE_WARN_FRACTION = 0.4\n\nexport interface PairedHoldout {\n  /** Baseline scalar per paired cell (same order as `after`/`cellIds`). */\n  before: number[]\n  /** Candidate scalar per paired cell. */\n  after: number[]\n  /** The full cellIds (`scenario:rep`) that paired, in order. */\n  cellIds: string[]\n}\n\n/** Campaign cell IDs append a numeric repetition after the scenario's full ID. */\nfunction scenarioIdFromCellId(cellId: string): string {\n  const separator = cellId.lastIndexOf(':')\n  const repetition = cellId.slice(separator + 1)\n  if (\n    separator < 1 ||\n    cellId.trim() !== cellId ||\n    !/^(0|[1-9]\\d*)$/.test(repetition) ||\n    !Number.isSafeInteger(Number(repetition))\n  ) {\n    throw new Error(`pairHoldout: malformed cellId '${cellId}'; expected scenarioId:rep`)\n  }\n  return cellId.slice(0, separator)\n}\n\n/** Preserve cell pairing before taking equal-weight independent-unit means. */\nexport function aggregatePairedHoldout(\n  paired: PairedHoldout,\n  independentUnitByScenarioId?: ReadonlyMap<string, string>,\n): { before: number[]; after: number[]; unitIds: string[] } {\n  if (\n    paired.before.length !== paired.after.length ||\n    paired.before.length !== paired.cellIds.length\n  ) {\n    throw new Error('aggregatePairedHoldout: scores and cellIds must have the same length')\n  }\n  if (new Set(paired.cellIds).size !== paired.cellIds.length) {\n    throw new Error('aggregatePairedHoldout: duplicate cellIds cannot count as new observations')\n  }\n  if (\n    paired.before.some((value) => !Number.isFinite(value)) ||\n    paired.after.some((value) => !Number.isFinite(value))\n  ) {\n    throw new Error('aggregatePairedHoldout: paired scores must be finite')\n  }\n  if (independentUnitByScenarioId === undefined) {\n    return { before: [...paired.before], after: [...paired.after], unitIds: [...paired.cellIds] }\n  }\n  const scenarioIds = paired.cellIds.map(scenarioIdFromCellId)\n  const groups = new Map<string, { before: number; after: number; n: number }>()\n  for (let i = 0; i < paired.cellIds.length; i++) {\n    const scenarioId = scenarioIds[i]!\n    const unitId = independentUnitByScenarioId.get(scenarioId)\n    if (typeof unitId !== 'string' || unitId.length === 0 || unitId.trim() !== unitId) {\n      throw new Error(\n        `aggregatePairedHoldout: missing independent unit for scenario '${scenarioId}'`,\n      )\n    }\n    const group = groups.get(unitId) ?? { before: 0, after: 0, n: 0 }\n    group.before += paired.before[i]!\n    group.after += paired.after[i]!\n    group.n += 1\n    groups.set(unitId, group)\n  }\n  const unitIds = [...groups.keys()].sort()\n  return {\n    before: unitIds.map((id) => groups.get(id)!.before / groups.get(id)!.n),\n    after: unitIds.map((id) => groups.get(id)!.after / groups.get(id)!.n),\n    unitIds,\n  }\n}\n\n/**\n * Pair candidate vs baseline holdout observations by FULL cellId. `select`\n * pulls the scalar from a cell's judge reports (composite, or a named\n * dimension); a cell contributes the mean of `select` across its judges. Cells\n * whose scenario is not in `scenarioIds`, or where `select` is undefined for\n * every judge on both sides, are skipped. The selected judge IDs must agree\n * within each pair. Throws when the two maps disagree on holdout cell IDs — a\n * load-bearing invariant: the baseline + winner holdout campaigns run the same\n * scenarios with the same seed base, so their cellIds MUST align; a mismatch\n * means a silent pairing bug, not a soft fallback.\n */\nexport function pairHoldout(\n  candidate: Map<string, Record<string, JudgeScore>>,\n  baseline: Map<string, Record<string, JudgeScore>>,\n  scenarioIds: Set<string>,\n  select: (s: JudgeScore) => number | undefined,\n): PairedHoldout {\n  const cellValues = (\n    byCell: Map<string, Record<string, JudgeScore>>,\n    cellId: string,\n  ): Map<string, number> => {\n    const scores = byCell.get(cellId)\n    const values = new Map<string, number>()\n    if (!scores) return values\n    for (const [judgeId, s] of Object.entries(scores)) {\n      if (s.failed === true) {\n        throw new Error(`pairHoldout: cell '${cellId}' contains a failed judge score`)\n      }\n      const v = select(s)\n      if (typeof v === 'number' && !Number.isFinite(v)) {\n        throw new Error(`pairHoldout: cell '${cellId}' contains a non-finite selected score`)\n      }\n      if (typeof v === 'number') values.set(judgeId, v)\n    }\n    return values\n  }\n\n  const inScope = (cellId: string) => scenarioIds.has(scenarioIdFromCellId(cellId))\n  const candCells = [...candidate.keys()].filter(inScope).sort()\n  const baseCells = [...baseline.keys()].filter(inScope).sort()\n  // Alignment invariant — the holdout campaigns share scenarios + seed, so the\n  // cell sets must be identical. Differ ⇒ a real pairing bug; fail loud.\n  if (candCells.length !== baseCells.length || candCells.some((c, i) => c !== baseCells[i])) {\n    throw new Error(\n      `pairHoldout: candidate/baseline holdout cells do not align — ` +\n        `candidate=[${candCells.join(',')}] baseline=[${baseCells.join(',')}]. ` +\n        `Both holdout campaigns must run the same scenarios with the same seed base.`,\n    )\n  }\n\n  const before: number[] = []\n  const after: number[] = []\n  const cellIds: string[] = []\n  for (const cellId of candCells) {\n    const b = cellValues(baseline, cellId)\n    const a = cellValues(candidate, cellId)\n    // A scalar absent on both sides means that dimension was not scored. A\n    // one-sided absence is asymmetric evidence loss, never a row to discard.\n    if (b.size === 0 && a.size === 0) continue\n    if (b.size === 0 || a.size === 0) {\n      throw new Error(`pairHoldout: cell '${cellId}' has a selected score on only one arm`)\n    }\n    if (b.size !== a.size || [...b.keys()].some((id) => !a.has(id))) {\n      throw new Error(`pairHoldout: cell '${cellId}' selected judge IDs do not align`)\n    }\n    const judgeIds = [...b.keys()].sort()\n    before.push(meanSelectedScores(judgeIds.map((id) => b.get(id)!)))\n    after.push(meanSelectedScores(judgeIds.map((id) => a.get(id)!)))\n    cellIds.push(cellId)\n  }\n  return { before, after, cellIds }\n}\n\nfunction meanSelectedScores(values: number[]): number {\n  const first = values[0]!\n  // Summing identical fractional scores can round their mean outside the\n  // declared binary support. An agreeing judge set preserves its exact value.\n  return values.every((value) => value === first)\n    ? first\n    : values.reduce((sum, value) => sum + value, 0) / values.length\n}\n\nexport interface HeldoutSignificance {\n  paired: PairedHoldout\n  /**\n   * The paired bootstrap on the requested statistic (MEAN by default — see the\n   * tie note on `heldoutSignificance`).\n   *\n   * DIAGNOSTIC, not necessarily the interval the verdict keyed on. On a\n   * two-point (pass/fail) outcome the decision routes to Tango's score interval\n   * instead, because a percentile bootstrap of the mean over a three-atom\n   * lattice is not a valid interval at a nonzero margin. Read\n   * `decision.low`/`decision.high` for the interval that actually decided, and\n   * `decisionStatistic` for which one it is.\n   */\n  bootstrap: PairedBootstrapResult\n  /** The MEDIAN paired-delta bootstrap, reported as a diagnostic. When many\n   *  scenarios are tied (both sides solve them), the median is pinned near 0\n   *  regardless of the mean lift — comparing the two exposes tie-domination. */\n  medianBootstrap: PairedBootstrapResult\n  /**\n   * The full promotion decision: which estimator the outcome's shape admits,\n   * the interval it produced, McNemar's exact veto on the two-point path, and\n   * whether the interval was zero-width (no evidence in either direction). The\n   * single source of `significant`.\n   */\n  decision: PairedPromotionDecision\n  /** Which paired estimator the verdict was decided on. */\n  decisionStatistic: PairedDecisionStatistic\n  /** McNemar's exact evidence on the two-point path; null otherwise. */\n  mcnemar: PairedMcNemarEvidence | null\n  /** Fraction of paired observations that are exact ties (|delta| < 1e-9). A\n   *  high tie fraction is WHY a median-based gate would have missed a real lift;\n   *  it is the observability the tie fix adds. */\n  tieFraction: number\n  /** Number of paired observation units, after configured aggregation. */\n  n: number\n  /** Original matched execution cells, before aggregation. */\n  pairedCellN: number\n  observationUnit: 'registered' | 'cell'\n  /** Registered unit IDs, or cell IDs on the ungrouped path. */\n  unitIds: string[]\n  /** Effective minimum for the requested target and chosen estimator. */\n  minimumRequired: number\n  /** Statistical method that carried the decision. */\n  decisionMethod: PairedDecisionMethod\n  /** Exact one-sided p-value on the small-sample path; otherwise null. */\n  pValue: number | null\n  /** True iff n >= minimumRequired, the DECIDING interval has nonzero width,\n   *  its lower bound clears the threshold, and McNemar's exact test does not\n   *  veto at a non-negative threshold. */\n  significant: boolean\n  /** Set when n < minimumRequired — too little evidence to claim significance. */\n  fewRuns: boolean\n}\n\nexport interface HeldoutSignificanceOptions {\n  deltaThreshold?: number\n  minProductiveRuns?: number\n  confidence?: number\n  resamples?: number\n  /** Fixed by default for a deterministic, reproducible gate verdict. */\n  seed?: number\n  statistic?: 'mean' | 'median'\n  /** Group full cell pairs into equal-weight independent units before inference. */\n  independentUnitByScenarioId?: ReadonlyMap<string, string>\n}\n\n/**\n * Significance of the held-out composite lift: ship only when the lower bound\n * of the interval the outcome's shape ADMITS exceeds `deltaThreshold` (default\n * 0 ⇒ \"confidently positive\"). Interpret `deltaThreshold` in the judge's native\n * scale.\n *\n * The decision is delegated whole to {@link decidePairedPromotion}, the one\n * copy of the rule (`src/paired-promotion-decision.ts`), which `HeldOutGate`\n * also calls. That module's header carries the measurements; the short version\n * is three guards a bare `bootstrap.low > threshold` does not have:\n *\n *   - a two-point (pass/fail) outcome decides on Tango's SCORE interval, the\n *     only paired-binary construction that stays valid at a nonzero margin;\n *   - McNemar's exact test VETOES at any non-negative threshold;\n *   - a ZERO-WIDTH interval is refused rather than promoted, in either\n *     direction — [0,0] clears every negative threshold and [g,g] clears every\n *     threshold below g, and both are an absence of evidence, not a result.\n *\n * Measured on this function before those guards landed, at a nominal 5 %:\n * 14.60 % false promotion at n = 40 on a paired-binary noninferiority boundary,\n * and 88.50 % at n = 6 under a bounded asymmetric null whose true mean paired\n * delta is exactly 0.\n *\n * Continuous mean targets require bootstrap eligibility. Explicit median\n * targets can use the exact sign test at its confidence-dependent minimum.\n */\nexport function heldoutSignificance(\n  paired: PairedHoldout,\n  opts: HeldoutSignificanceOptions = {},\n): HeldoutSignificance {\n  const deltaThreshold = opts.deltaThreshold ?? 0\n  const confidence = opts.confidence ?? 0.95\n  const resamples = opts.resamples ?? 2000\n  const seed = opts.seed ?? 1337\n  // DEFAULT to the MEAN paired delta, not the median. The median is destroyed by\n  // TIES: whenever both baseline and candidate solve a holdout scenario (a common\n  // case once the agent is decent — and INCREASINGLY common as you add holdout\n  // scenarios for statistical power), that scenario contributes delta 0. When\n  // >=50% of paired cells are ties the median is pinned at 0 regardless of a large,\n  // consistent lift on the rest, and the gate holds a genuinely better candidate.\n  // (Measured live, supervisor-lab run 6: 40 cells, 20 ties, MEAN +0.177, MEDIAN 0\n  // → false hold. Doubling the holdout for \"power\" made it WORSE by adding ties.)\n  // The mean equals the reported aggregate lift, ties correctly contribute 0\n  // without dominating, and it is the textbook paired-comparison estimator; the\n  // median is kept as a reported diagnostic. Callers wanting outlier-robustness at\n  // the cost of tie-blindness can still pass `statistic: 'median'`.\n  const statistic = opts.statistic ?? 'mean'\n  const observations = aggregatePairedHoldout(paired, opts.independentUnitByScenarioId)\n  const decision = decidePairedPromotion(observations.before, observations.after, {\n    confidence,\n    resamples,\n    statistic,\n    seed,\n    threshold: deltaThreshold,\n    minPairs: opts.minProductiveRuns,\n  })\n  // `decision.bootstrap` is null exactly when the score interval decided, so\n  // the requested-statistic bootstrap is computed here for the diagnostic\n  // field. Same two bootstraps as before on every path.\n  const bootstrap =\n    decision.bootstrap ??\n    pairedBootstrap(observations.before, observations.after, {\n      confidence,\n      resamples,\n      statistic,\n      seed,\n    })\n  const medianBootstrap =\n    statistic === 'median'\n      ? bootstrap\n      : pairedBootstrap(observations.before, observations.after, {\n          confidence,\n          resamples,\n          statistic: 'median',\n          seed,\n        })\n  const n = observations.before.length\n  let ties = 0\n  for (let i = 0; i < n; i += 1) {\n    const after = observations.after[i]!\n    const before = observations.before[i]!\n    if (Math.abs(after - before) < 1e-9) ties += 1\n  }\n  const tieFraction = n === 0 ? 0 : ties / n\n  return {\n    paired,\n    bootstrap,\n    medianBootstrap,\n    decision,\n    decisionStatistic: decision.statistic,\n    mcnemar: decision.mcnemar,\n    tieFraction,\n    n,\n    pairedCellN: paired.cellIds.length,\n    observationUnit: opts.independentUnitByScenarioId === undefined ? 'cell' : 'registered',\n    unitIds: observations.unitIds,\n    minimumRequired: decision.minimumPairs,\n    decisionMethod: decision.method,\n    pValue: decision.pValue,\n    significant: decision.promote,\n    fewRuns: !decision.sufficient,\n  }\n}\n\nexport interface DimensionRegression {\n  dimension: string\n  /** Paired bootstrap on (candidate − baseline). DIAGNOSTIC on a pass/fail\n   *  dimension, where `ci` carries the interval that decided instead. */\n  bootstrap: PairedBootstrapResult\n  /** Which paired statistic `bootstrap.low` is the lower bound of. `'mean'`\n   *  unless the caller asked for the median. `bootstrap.median` still carries\n   *  the median point estimate either way. */\n  bootstrapStatistic: 'median' | 'mean'\n  /** The interval `regressed` was decided on, in the dimension's native units. */\n  ci: { low: number; high: number }\n  /** Which estimator produced `ci`. */\n  decisionStatistic: PairedDecisionStatistic\n  /** McNemar's exact evidence on a pass/fail dimension; null otherwise. */\n  mcnemar: PairedMcNemarEvidence | null\n  /** `ci` has zero width — no evidence in either direction. */\n  indeterminate: boolean\n  /** The bootstrap lower bound is below negative tolerance, or the shared\n   *  paired test supports a drop exceeding tolerance. Missing coverage and\n   *  insufficient observations are reported separately. */\n  regressed: boolean\n  tolerance: number\n  n: number\n  pairedCellN: number\n  observationUnit: 'registered' | 'cell'\n  /** Statistical minimum for the configured independent observation unit. */\n  minimumRequired: number\n  fewRuns: boolean\n  /** Both arms lack this dimension on these otherwise matched execution cells. */\n  missingCellIds: string[]\n  /** Configured scenarios with no paired dimension measurement at all. */\n  missingScenarioIds: string[]\n}\n\n/** Detect the native scale of a set of scores: 0-100 when any magnitude clears\n *  1.5, else [0,1]. Used to auto-scale the regression tolerance so a default\n *  expressed for [0,1] is not silently a no-op on a 0-100 dimension. */\nexport function detectScale(values: number[]): 1 | 100 {\n  return values.some((v) => Math.abs(v) > 1.5) ? 100 : 1\n}\n\n/**\n * Report required-dimension evidence after full pairing and optional unit means.\n * A bootstrap floor breach or a shared paired test supporting a drop marks\n * regression. These two criteria are distinct; `ci` records the shared\n * estimator and `bootstrap` records the floor interval. Missing observations\n * and insufficient n remain explicit for the caller's evidence policy.\n * The default tolerance is 0.05 on [0,1] and 5 on a detected 0-100 scale.\n */\nexport function dimensionRegressions(\n  candidate: Map<string, Record<string, JudgeScore>>,\n  baseline: Map<string, Record<string, JudgeScore>>,\n  scenarioIds: Set<string>,\n  criticalDimensions: string[],\n  opts: {\n    tolerance?: number\n    confidence?: number\n    resamples?: number\n    seed?: number\n    /** Paired statistic the CI is computed on. Default `'mean'` — see\n     *  {@link DECISION_PAIRED_DELTA_STATISTIC} for why the median is not. */\n    statistic?: 'mean' | 'median'\n    independentUnitByScenarioId?: ReadonlyMap<string, string>\n    minProductiveRuns?: number\n  } = {},\n): DimensionRegression[] {\n  const out: DimensionRegression[] = []\n  const expectedCellIds = [...baseline.keys()]\n    .filter((cellId) => scenarioIds.has(scenarioIdFromCellId(cellId)))\n    .sort()\n  for (const dim of criticalDimensions) {\n    const paired = pairHoldout(candidate, baseline, scenarioIds, (s) => s.dimensions[dim])\n    if (paired.before.length === 0) continue // dimension not scored on this judge\n    const observations = aggregatePairedHoldout(paired, opts.independentUnitByScenarioId)\n    const measuredCells = new Set(paired.cellIds)\n    const measuredScenarios = new Set(paired.cellIds.map(scenarioIdFromCellId))\n    const tolerance = opts.tolerance ?? 0.05 * detectScale([...paired.before, ...paired.after])\n    const bootstrapStatistic = opts.statistic ?? DECISION_PAIRED_DELTA_STATISTIC\n    const shared = {\n      confidence: opts.confidence ?? 0.95,\n      resamples: opts.resamples ?? 2000,\n      statistic: bootstrapStatistic,\n      seed: opts.seed ?? 1337,\n      minPairs: opts.minProductiveRuns,\n    }\n    const guard = decidePairedPromotion(observations.before, observations.after, shared)\n    const regression = decidePairedPromotion(observations.after, observations.before, {\n      ...shared,\n      threshold: tolerance,\n    })\n    const bootstrap =\n      guard.bootstrap ?? pairedBootstrap(observations.before, observations.after, shared)\n    out.push({\n      dimension: dim,\n      bootstrap,\n      bootstrapStatistic,\n      ci: { low: guard.low, high: guard.high },\n      decisionStatistic: guard.statistic,\n      mcnemar: guard.mcnemar,\n      indeterminate: guard.indeterminate,\n      // Fires on EITHER burden of proof — see `floorBreached` in\n      // `promotion-policy.ts` for the same rule and the reasoning. The CI arm\n      // is the contract this interface and `default-production-gate`'s reason\n      // string both state (\"CI.low < -tolerance\"), read off the DECIDING\n      // interval; the exact-test arm adds the small-sample path where the\n      // bootstrap interval is descriptive only.\n      // The credible-worst-case arm stays on the BOOTSTRAP — see the same\n      // decision in `floorBreached` (`promotion-policy.ts`). On a pass/fail\n      // dimension the score interval is ±z²/(n+z²) even when every pair is\n      // concordant, so reading the floor off it would flag an unchanged safety\n      // dimension as regressed at any realistic n. The PROVEN-drop arm does use\n      // the shared rule, which is what closes the fail-open hole that mattered:\n      // a genuine pass/fail regression is now judged on an interval valid at\n      // the nonzero `tolerance`, instead of a bootstrap that is pinned wherever\n      // ties dominate.\n      regressed: bootstrap.low < -tolerance || regression.promote,\n      tolerance,\n      n: observations.before.length,\n      pairedCellN: paired.cellIds.length,\n      observationUnit: opts.independentUnitByScenarioId === undefined ? 'cell' : 'registered',\n      minimumRequired: guard.minimumPairs,\n      fewRuns: !guard.sufficient,\n      missingCellIds: expectedCellIds.filter((cellId) => !measuredCells.has(cellId)),\n      missingScenarioIds: [...scenarioIds].filter((id) => !measuredScenarios.has(id)).sort(),\n    })\n  }\n  return out\n}\n"],"mappings":"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"}

package/dist/{steps-DlepJPwD.d.ts → steps-B8fYY_Vo.d.ts}

@@ -1,4 +1,3 @@
-//#region src/trajectory-replay/steps.d.ts
 /**
  * Recorded shell-trajectory steps and the observation grammar they carry.
  *
@@ -142,6 +141,5 @@ type RecordedFinalOutcome = {
  * that executed nothing, so the last step is the last command the run ran.
  */
 declare function finalRecordedOutcome(steps: readonly RecordedTrajectoryStep[]): RecordedFinalOutcome | null;
-//#endregion
 export { RecordedTrajectoryTurn as a, finalRecordedOutcome as c, RecordedTrajectoryStep as i, RecordedFinalOutcome as n, classifyObservation as o, RecordedObservationKind as r, decodeRecordedTurns as s, DecodedTrajectory as t };
-//# sourceMappingURL=steps-DlepJPwD.d.ts.map
+//# sourceMappingURL=steps-B8fYY_Vo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"steps-B8fYY_Vo.d.ts","names":[],"sources":["../src/trajectory-replay/steps.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmCiB;;WAEN;WACA;;WAEA;;;;;;;;;;;;KAqGC;iBAQI,oBAAoB,6BAA6B;;;;;;;UAwBhD;WACN;WACA;WACA;aAA4B;;WAC5B;;UAGM;;WAEN,gBAAgB;;WAEhB;;;;;;;;;WASA;;WAEA;;WAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCK,oBAAoB,gBAAgB,2BAA2B;;;;;;;;;KAyCnE;WACG;WAA6B;;WAC7B;;WACA;WAA6B,QAAQ;;;;;;;;iBAQpC,qBACd,gBAAgB,2BACf"}

package/dist/{store-B3nWRy3B.d.ts → store-CMs5wGXP.d.ts}

@@ -1,5 +1,4 @@
-import { S as TraceEvent, _ as Span, f as Run, h as RunStatus, i as EventKind, m as RunLayer, n as BudgetLedgerEntry, t as Artifact, y as SpanKind } from "./schema-D6EVKzTB.js";
-//#region src/trace/store.d.ts
+import { S as TraceEvent, _ as Span, f as Run, h as RunStatus, i as EventKind, m as RunLayer, n as BudgetLedgerEntry, t as Artifact, y as SpanKind } from "./schema-CkIvnmLU.js";
 interface RunFilter {
   scenarioId?: string;
   variantId?: string;
@@ -112,6 +111,5 @@ declare class FileSystemTraceStore implements TraceStore {
   budget(runId: string): Promise<BudgetLedgerEntry[]>;
   artifacts(runId: string): Promise<Artifact[]>;
 }
-//#endregion
 export { RunFilter as a, InMemoryTraceStore as i, FileSystemTraceStore as n, SpanFilter as o, FileSystemTraceStoreOptions as r, TraceStore as s, EventFilter as t };
-//# sourceMappingURL=store-B3nWRy3B.d.ts.map
+//# sourceMappingURL=store-CMs5wGXP.d.ts.map

package/dist/store-CMs5wGXP.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-CMs5wGXP.d.ts","names":["_$__schema0.RunLayer"],"sources":["../src/trace/store.ts"],"mappings":";UAuBiB;EACf;EACA;EACA,SAAS;EACT;EACA;EACA;IAAQ;IAAa;;EACrB;EACA;EACA;EACA,QAPSA;;UAUM;EACf;EACA;EACA,OAAO;EACP;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA,OAAO;EACP;EACA;;UAGe;EACf,UAAU,KAAK,MAAM;EACrB,UAAU,eAAe,OAAO,QAAQ,OAAO;EAC/C,WAAW,MAAM,OAAO;EACxB,WAAW,gBAAgB,OAAO,QAAQ,QAAQ;EAClD,YAAY,OAAO,aAAa;EAChC,eAAe,UAAU,WAAW;EACpC,kBAAkB,OAAO,oBAAoB;EAE7C,OAAO,gBAAgB,QAAQ;EAC/B,SAAS,SAAS,YAAY,QAAQ;EACtC,MAAM,SAAS,aAAa,QAAQ;EACpC,OAAO,SAAS,cAAc,QAAQ;EACtC,OAAO,gBAAgB,QAAQ;EAC/B,UAAU,gBAAgB,QAAQ;;cAKvB,8BAA8B;UACjC;UACA;UACA;UACA;UACA;EAEF,UAAU,KAAK,MAAM;EAKrB,UAAU,eAAe,OAAO,QAAQ,OAAO;EAM/C,WAAW,MAAM,OAAO;EAIxB,WAAW,gBAAgB,OAAO,QAAQ,QAAQ;EAMlD,YAAY,OAAO,aAAa;EAIhC,eAAe,UAAU,WAAW;EAIpC,kBAAkB,OAAO,oBAAoB;EAI7C,OAAO,gBAAgB,QAAQ;EAK/B,SAAS,SAAQ,YAAiB,QAAQ;EAI1C,MAAM,SAAQ,aAAkB,QAAQ;EAIxC,OAAO,SAAQ,cAAmB,QAAQ;EAI1C,OAAO,gBAAgB,QAAQ;EAI/B,UAAU,gBAAgB,QAAQ;;UA0CzB;EACf;;EAEA;;cAGW,gCAAgC;UACnC;UACA;;UAEA;;;UAGA;;;UAGA;;;;;;;;UAQA;EAEI,YAAA,SAAS;UAKP;UAKA;UAwBA;UA8BA;UAqBN;UAOM;EAkHR,UAAU,KAAK,MAAM;EAGrB,UAAU,eAAe,OAAO,QAAQ,OAAO;EAM/C,WAAW,MAAM,OAAO;EAGxB,WAAW,gBAAgB,OAAO,QAAQ,QAAQ;EAIlD,YAAY,OAAO,aAAa;EAGhC,eAAe,UAAU,WAAW;EAGpC,kBAAkB,OAAO,oBAAoB;EAI7C,OAAO,gBAAgB,QAAQ;EAG/B,SAAS,SAAS,YAAY,QAAQ;EAGtC,MAAM,SAAS,aAAa,QAAQ;EAGpC,OAAO,SAAS,cAAc,QAAQ;EAGtC,OAAO,gBAAgB,QAAQ;EAG/B,UAAU,gBAAgB,QAAQ"}

package/dist/{store-BhNuLdJw.js → store-ZykIyQmy.js}

@@ -1,4 +1,4 @@
-//#region src/trace/store.ts
+// src/trace/store.ts
 var InMemoryTraceStore = class {
 	runs = /* @__PURE__ */ new Map();
 	allSpans = [];
@@ -278,7 +278,6 @@ var FileSystemTraceStore = class {
 		return (await this.load()).artifacts(runId);
 	}
 };
-//#endregion
 export { InMemoryTraceStore as n, FileSystemTraceStore as t };
 
-//# sourceMappingURL=store-BhNuLdJw.js.map
+//# sourceMappingURL=store-ZykIyQmy.js.map

package/dist/{store-BhNuLdJw.js.map → store-ZykIyQmy.js.map}

@@ -1 +1 @@
-{"version":3,"file":"store-BhNuLdJw.js","names":[],"sources":["../src/trace/store.ts"],"sourcesContent":["/**\n * TraceStore — persistence + query over the TraceSchema v1 corpus.\n *\n * Two implementations ship in the core:\n *   - InMemoryTraceStore: dev + tests, fully in-process\n *   - FileSystemTraceStore: NDJSON append-only files per entity, suitable\n *     for long-running CI jobs; rolled over at 32MB\n *\n * Downstream adapters (DuckDB, Langfuse, R2 parquet) implement this same\n * interface — the rest of the framework is storage-agnostic.\n */\n\nimport type {\n  Artifact,\n  BudgetLedgerEntry,\n  EventKind,\n  Run,\n  RunStatus,\n  Span,\n  SpanKind,\n  TraceEvent,\n} from './schema'\n\nexport interface RunFilter {\n  scenarioId?: string\n  variantId?: string\n  status?: RunStatus\n  since?: number\n  until?: number\n  tag?: { key: string; value: string }\n  parentRunId?: string\n  projectId?: string\n  chatId?: string\n  layer?: import('./schema').RunLayer\n}\n\nexport interface SpanFilter {\n  runId?: string\n  parentSpanId?: string\n  kind?: SpanKind\n  name?: string\n  toolName?: string\n  judgeId?: string\n  since?: number\n  until?: number\n}\n\nexport interface EventFilter {\n  runId?: string\n  spanId?: string\n  kind?: EventKind\n  since?: number\n  until?: number\n}\n\nexport interface TraceStore {\n  appendRun(run: Run): Promise<void>\n  updateRun(runId: string, patch: Partial<Run>): Promise<void>\n  appendSpan(span: Span): Promise<void>\n  updateSpan(spanId: string, patch: Partial<Span>): Promise<void>\n  appendEvent(event: TraceEvent): Promise<void>\n  appendArtifact(artifact: Artifact): Promise<void>\n  appendBudgetEntry(entry: BudgetLedgerEntry): Promise<void>\n\n  getRun(runId: string): Promise<Run | undefined>\n  listRuns(filter?: RunFilter): Promise<Run[]>\n  spans(filter?: SpanFilter): Promise<Span[]>\n  events(filter?: EventFilter): Promise<TraceEvent[]>\n  budget(runId: string): Promise<BudgetLedgerEntry[]>\n  artifacts(runId: string): Promise<Artifact[]>\n}\n\n// ── In-memory ────────────────────────────────────────────────────────\n\nexport class InMemoryTraceStore implements TraceStore {\n  private runs = new Map<string, Run>()\n  private allSpans: Span[] = []\n  private allEvents: TraceEvent[] = []\n  private allArtifacts: Artifact[] = []\n  private allBudget: BudgetLedgerEntry[] = []\n\n  async appendRun(run: Run): Promise<void> {\n    if (this.runs.has(run.runId)) throw new Error(`run ${run.runId} already exists`)\n    this.runs.set(run.runId, { ...run })\n  }\n\n  async updateRun(runId: string, patch: Partial<Run>): Promise<void> {\n    const existing = this.runs.get(runId)\n    if (!existing) throw new Error(`run ${runId} not found`)\n    this.runs.set(runId, { ...existing, ...patch })\n  }\n\n  async appendSpan(span: Span): Promise<void> {\n    this.allSpans.push({ ...span })\n  }\n\n  async updateSpan(spanId: string, patch: Partial<Span>): Promise<void> {\n    const idx = this.allSpans.findIndex((s) => s.spanId === spanId)\n    if (idx < 0) throw new Error(`span ${spanId} not found`)\n    this.allSpans[idx] = { ...this.allSpans[idx], ...patch } as Span\n  }\n\n  async appendEvent(event: TraceEvent): Promise<void> {\n    this.allEvents.push({ ...event })\n  }\n\n  async appendArtifact(artifact: Artifact): Promise<void> {\n    this.allArtifacts.push({ ...artifact })\n  }\n\n  async appendBudgetEntry(entry: BudgetLedgerEntry): Promise<void> {\n    this.allBudget.push({ ...entry })\n  }\n\n  async getRun(runId: string): Promise<Run | undefined> {\n    const r = this.runs.get(runId)\n    return r ? { ...r } : undefined\n  }\n\n  async listRuns(filter: RunFilter = {}): Promise<Run[]> {\n    return [...this.runs.values()].filter((r) => matchesRun(r, filter))\n  }\n\n  async spans(filter: SpanFilter = {}): Promise<Span[]> {\n    return this.allSpans.filter((s) => matchesSpan(s, filter)).map((s) => ({ ...s }))\n  }\n\n  async events(filter: EventFilter = {}): Promise<TraceEvent[]> {\n    return this.allEvents.filter((e) => matchesEvent(e, filter)).map((e) => ({ ...e }))\n  }\n\n  async budget(runId: string): Promise<BudgetLedgerEntry[]> {\n    return this.allBudget.filter((b) => b.runId === runId).map((b) => ({ ...b }))\n  }\n\n  async artifacts(runId: string): Promise<Artifact[]> {\n    return this.allArtifacts.filter((a) => a.runId === runId).map((a) => ({ ...a }))\n  }\n}\n\nfunction matchesRun(r: Run, f: RunFilter): boolean {\n  if (f.scenarioId && r.scenarioId !== f.scenarioId) return false\n  if (f.variantId && r.variantId !== f.variantId) return false\n  if (f.status && r.status !== f.status) return false\n  if (f.since !== undefined && r.startedAt < f.since) return false\n  if (f.until !== undefined && r.startedAt > f.until) return false\n  if (f.tag && r.tags?.[f.tag.key] !== f.tag.value) return false\n  if (f.parentRunId && r.parentRunId !== f.parentRunId) return false\n  if (f.projectId && r.projectId !== f.projectId) return false\n  if (f.chatId && r.chatId !== f.chatId) return false\n  if (f.layer && r.layer !== f.layer) return false\n  return true\n}\n\nfunction matchesSpan(s: Span, f: SpanFilter): boolean {\n  if (f.runId && s.runId !== f.runId) return false\n  if (f.parentSpanId && s.parentSpanId !== f.parentSpanId) return false\n  if (f.kind && s.kind !== f.kind) return false\n  if (f.name && s.name !== f.name) return false\n  if (f.toolName && (s.kind !== 'tool' || s.toolName !== f.toolName)) return false\n  if (f.judgeId && (s.kind !== 'judge' || s.judgeId !== f.judgeId)) return false\n  if (f.since !== undefined && s.startedAt < f.since) return false\n  if (f.until !== undefined && s.startedAt > f.until) return false\n  return true\n}\n\nfunction matchesEvent(e: TraceEvent, f: EventFilter): boolean {\n  if (f.runId && e.runId !== f.runId) return false\n  if (f.spanId && e.spanId !== f.spanId) return false\n  if (f.kind && e.kind !== f.kind) return false\n  if (f.since !== undefined && e.timestamp < f.since) return false\n  if (f.until !== undefined && e.timestamp > f.until) return false\n  return true\n}\n\n// ── Filesystem (NDJSON append-only, one file per entity) ─────────────\n\nexport interface FileSystemTraceStoreOptions {\n  dir: string\n  /** Roll over NDJSON files when they exceed this size in bytes. Default 32 MB. */\n  maxBytes?: number\n}\n\nexport class FileSystemTraceStore implements TraceStore {\n  private dir: string\n  private maxBytes: number\n  /** Lazy in-memory index for queries — populated on first read. */\n  private index?: InMemoryTraceStore\n  /** Memoized index build — concurrent first reads share one build, and an\n   *  append racing an in-flight load awaits this so its row isn't lost. */\n  private indexPromise?: Promise<InMemoryTraceStore>\n  /** Strictly-increasing rollover stamp. Date.now() alone collides when two\n   *  rollovers land in the same millisecond, overwriting a rolled file. */\n  private lastRolloverStamp = 0\n  /**\n   * Per-file append serialization. stat → conditional-rename → appendFile is a\n   * read-modify-write on the active file; without a lock two concurrent appends\n   * to the same `name` can both pass the size check (exceeding maxBytes) or one\n   * can append to a file the other just renamed away. Each entry chains the\n   * next append behind the prior one for that file.\n   */\n  private appendLocks = new Map<string, Promise<void>>()\n\n  constructor(options: FileSystemTraceStoreOptions) {\n    this.dir = options.dir\n    this.maxBytes = options.maxBytes ?? 32 * 1024 * 1024\n  }\n\n  private async ensureDir(): Promise<void> {\n    const fs = await import('node:fs/promises')\n    await fs.mkdir(this.dir, { recursive: true })\n  }\n\n  private async append(name: string, record: unknown): Promise<void> {\n    // If an index load is in flight, wait for it. The row must hit disk AFTER\n    // the load finished reading, so it lands in the completed index via the\n    // mirror below — never lost in the gap before `this.index` is assigned.\n    if (this.indexPromise) await this.indexPromise\n    // Chain this append behind any in-flight append for the same file. The tail\n    // promise never rejects (errors are isolated to each caller's `result`), so\n    // one failed append can't break the lock chain for the next one.\n    const prior = this.appendLocks.get(name) ?? Promise.resolve()\n    const result = prior.then(() => this.appendLocked(name, record))\n    const tail = result.then(\n      () => {},\n      () => {},\n    )\n    this.appendLocks.set(name, tail)\n    try {\n      await result\n    } finally {\n      // Drop the slot once this append is the current tail, so the map doesn't\n      // grow without bound across many appends to the same file.\n      if (this.appendLocks.get(name) === tail) this.appendLocks.delete(name)\n    }\n  }\n\n  private async appendLocked(name: string, record: unknown): Promise<void> {\n    await this.ensureDir()\n    const fs = await import('node:fs/promises')\n    const path = await import('node:path')\n    const active = path.join(this.dir, `${name}.ndjson`)\n    try {\n      const stat = await fs.stat(active)\n      if (stat.size >= this.maxBytes) {\n        // Strictly-increasing, collision-free even within one millisecond — a\n        // bare Date.now() would let two same-ms rollovers overwrite each other.\n        const stamp = Math.max(Date.now(), this.lastRolloverStamp + 1)\n        this.lastRolloverStamp = stamp\n        const rolled = path.join(this.dir, `${name}.${stamp}.ndjson`)\n        await fs.rename(active, rolled)\n      }\n    } catch {\n      /* file doesn't exist yet */\n    }\n    await fs.appendFile(active, `${JSON.stringify(record)}\\n`, 'utf8')\n    // Mirror genuinely-new rows into the lazy index. Update rows (marked\n    // with `_update: true` by updateRun/updateSpan) are applied by those\n    // methods directly via the index's update* APIs — re-inserting them\n    // here triggers a duplicate-id error once the first read populates\n    // the index. Await the mirror: a fire-and-forget would let an index\n    // rejection go unhandled and let disk + index diverge silently.\n    if (this.index && !(record as { _update?: boolean })?._update) {\n      await this.insertInto(name, record)\n    }\n  }\n\n  private async insertInto(name: string, record: unknown): Promise<void> {\n    if (!this.index) return\n    switch (name) {\n      case 'runs':\n        await this.index.appendRun(record as Run)\n        break\n      case 'spans':\n        await this.index.appendSpan(record as Span)\n        break\n      case 'events':\n        await this.index.appendEvent(record as TraceEvent)\n        break\n      case 'artifacts':\n        await this.index.appendArtifact(record as Artifact)\n        break\n      case 'budget':\n        await this.index.appendBudgetEntry(record as BudgetLedgerEntry)\n        break\n    }\n  }\n\n  private load(): Promise<InMemoryTraceStore> {\n    // Memoize: concurrent first reads share one build, and an append racing an\n    // in-flight load awaits this same promise (see append()).\n    this.indexPromise ??= this.buildIndex()\n    return this.indexPromise\n  }\n\n  private async buildIndex(): Promise<InMemoryTraceStore> {\n    const fs = await import('node:fs/promises')\n    const path = await import('node:path')\n    const store = new InMemoryTraceStore()\n    let entries: string[]\n    try {\n      entries = await fs.readdir(this.dir)\n    } catch {\n      // No dir yet (first run / empty corpus). Anything past this point — parse\n      // errors, missing patch bases — is real corruption and must fail loud.\n      this.index = store\n      return store\n    }\n    // Replay files in write order. For one entity, rolled files\n    // (`name.<ts>.ndjson`) are older than the active bare file (`name.ndjson`),\n    // and readdir order is not chronological — so without this sort a patch in\n    // an older rolled file could be applied AFTER (overwrite) a newer patch in\n    // the active file, silently restoring a stale field. Sort: per entity,\n    // rolled ascending by timestamp, then the bare active file last.\n    entries.sort((a, b) => {\n      // Group by the same entity base the loop uses (`split('.')[0]`); within an\n      // entity, real rollover files (`<base>.<ms>.ndjson`) sort by timestamp\n      // ascending and the bare active file (no numeric segment) sorts last.\n      // Non-rollover names tie (Infinity) and a stable sort preserves their\n      // readdir order.\n      const baseA = a.split('.')[0]!\n      const baseB = b.split('.')[0]!\n      if (baseA !== baseB) return baseA < baseB ? -1 : 1\n      const ta = a.match(/^[^.]+\\.(\\d+)\\.ndjson$/)\n      const tb = b.match(/^[^.]+\\.(\\d+)\\.ndjson$/)\n      const tsA = ta ? Number(ta[1]) : Number.POSITIVE_INFINITY\n      const tsB = tb ? Number(tb[1]) : Number.POSITIVE_INFINITY\n      return tsA - tsB\n    })\n    {\n      // Two-pass load. Pass 1 indexes all full (base) rows; pass 2 replays the\n      // `_update` patch rows that updateRun/updateSpan append. readdir order is\n      // not deterministic and rollover splits a stream across files, so a patch\n      // can be read before its base. Applying patches in a separate pass — after\n      // every base row is indexed — means a patch always finds its target.\n      // Doing it in one pass let a patch hit the catch and append a runId-less\n      // fragment, corrupting span/run counts cross-instance.\n      const runUpdates: Array<Record<string, unknown>> = []\n      const spanUpdates: Array<Record<string, unknown>> = []\n      for (const file of entries) {\n        if (!file.endsWith('.ndjson')) continue\n        const full = path.join(this.dir, file)\n        const content = await fs.readFile(full, 'utf8')\n        const base = file.split('.')[0]\n        const lines = content.split('\\n')\n        for (let ln = 0; ln < lines.length; ln++) {\n          const line = lines[ln]!\n          if (!line.trim()) continue\n          let record: ReturnType<typeof JSON.parse>\n          try {\n            record = JSON.parse(line)\n          } catch (err) {\n            // Fail loud WITH context — a bare SyntaxError loses which file/line\n            // is corrupt and which valid rows surround it.\n            throw new Error(\n              `FileSystemTraceStore: corrupt NDJSON in ${file} line ${ln + 1}: ${\n                err instanceof Error ? err.message : String(err)\n              } — ${line.slice(0, 120)}`,\n            )\n          }\n          if (base === 'runs') {\n            if (record?._update) {\n              runUpdates.push(record)\n              continue\n            }\n            // A duplicate full row (same dir loaded twice into one stream) is\n            // collapsed last-write-wins rather than thrown.\n            try {\n              await store.appendRun(record)\n            } catch {\n              await store.updateRun(record.runId, record)\n            }\n          } else if (base === 'spans') {\n            // `updateSpan` appends an `_update: true` patch row instead of\n            // rewriting the original span. Deferred to pass 2 so it collapses\n            // onto the original span — otherwise a fresh FileSystemTraceStore\n            // reading the same dir reports duplicate spans (one full, one\n            // fragment with no runId/kind/name), which breaks any downstream\n            // consumer that re-opens the store cross-process (e.g. the OTLP\n            // converter).\n            if (record?._update) {\n              spanUpdates.push(record)\n              continue\n            }\n            await store.appendSpan(record)\n          } else if (base === 'events') {\n            await store.appendEvent(record)\n          } else if (base === 'artifacts') {\n            await store.appendArtifact(record)\n          } else if (base === 'budget') {\n            await store.appendBudgetEntry(record)\n          }\n        }\n      }\n      // Pass 2: every base row is now indexed. A patch whose base is genuinely\n      // absent (truncated/partial corpus) throws inside update* — we let it\n      // propagate rather than silently appending a fragment, so a corrupt\n      // corpus fails loud instead of polluting counts.\n      for (const record of runUpdates) {\n        await store.updateRun(record.runId as string, record as Partial<Run>)\n      }\n      for (const record of spanUpdates) {\n        await store.updateSpan(record.spanId as string, record as Partial<Span>)\n      }\n    }\n    this.index = store\n    return store\n  }\n\n  async appendRun(run: Run): Promise<void> {\n    await this.append('runs', run)\n  }\n  async updateRun(runId: string, patch: Partial<Run>): Promise<void> {\n    // NDJSON is append-only; record updates as new rows with the same runId —\n    // readers collapse by last-write-wins on load.\n    await this.append('runs', { runId, ...patch, _update: true })\n    if (this.index) await this.index.updateRun(runId, patch)\n  }\n  async appendSpan(span: Span): Promise<void> {\n    await this.append('spans', span)\n  }\n  async updateSpan(spanId: string, patch: Partial<Span>): Promise<void> {\n    await this.append('spans', { spanId, ...patch, _update: true })\n    if (this.index) await this.index.updateSpan(spanId, patch)\n  }\n  async appendEvent(event: TraceEvent): Promise<void> {\n    await this.append('events', event)\n  }\n  async appendArtifact(artifact: Artifact): Promise<void> {\n    await this.append('artifacts', artifact)\n  }\n  async appendBudgetEntry(entry: BudgetLedgerEntry): Promise<void> {\n    await this.append('budget', entry)\n  }\n\n  async getRun(runId: string): Promise<Run | undefined> {\n    return (await this.load()).getRun(runId)\n  }\n  async listRuns(filter?: RunFilter): Promise<Run[]> {\n    return (await this.load()).listRuns(filter)\n  }\n  async spans(filter?: SpanFilter): Promise<Span[]> {\n    return (await this.load()).spans(filter)\n  }\n  async events(filter?: EventFilter): Promise<TraceEvent[]> {\n    return (await this.load()).events(filter)\n  }\n  async budget(runId: string): Promise<BudgetLedgerEntry[]> {\n    return (await this.load()).budget(runId)\n  }\n  async artifacts(runId: string): Promise<Artifact[]> {\n    return (await this.load()).artifacts(runId)\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"store-ZykIyQmy.js","names":[],"sources":["../src/trace/store.ts"],"sourcesContent":["/**\n * TraceStore — persistence + query over the TraceSchema v1 corpus.\n *\n * Two implementations ship in the core:\n *   - InMemoryTraceStore: dev + tests, fully in-process\n *   - FileSystemTraceStore: NDJSON append-only files per entity, suitable\n *     for long-running CI jobs; rolled over at 32MB\n *\n * Downstream adapters (DuckDB, Langfuse, R2 parquet) implement this same\n * interface — the rest of the framework is storage-agnostic.\n */\n\nimport type {\n  Artifact,\n  BudgetLedgerEntry,\n  EventKind,\n  Run,\n  RunStatus,\n  Span,\n  SpanKind,\n  TraceEvent,\n} from './schema'\n\nexport interface RunFilter {\n  scenarioId?: string\n  variantId?: string\n  status?: RunStatus\n  since?: number\n  until?: number\n  tag?: { key: string; value: string }\n  parentRunId?: string\n  projectId?: string\n  chatId?: string\n  layer?: import('./schema').RunLayer\n}\n\nexport interface SpanFilter {\n  runId?: string\n  parentSpanId?: string\n  kind?: SpanKind\n  name?: string\n  toolName?: string\n  judgeId?: string\n  since?: number\n  until?: number\n}\n\nexport interface EventFilter {\n  runId?: string\n  spanId?: string\n  kind?: EventKind\n  since?: number\n  until?: number\n}\n\nexport interface TraceStore {\n  appendRun(run: Run): Promise<void>\n  updateRun(runId: string, patch: Partial<Run>): Promise<void>\n  appendSpan(span: Span): Promise<void>\n  updateSpan(spanId: string, patch: Partial<Span>): Promise<void>\n  appendEvent(event: TraceEvent): Promise<void>\n  appendArtifact(artifact: Artifact): Promise<void>\n  appendBudgetEntry(entry: BudgetLedgerEntry): Promise<void>\n\n  getRun(runId: string): Promise<Run | undefined>\n  listRuns(filter?: RunFilter): Promise<Run[]>\n  spans(filter?: SpanFilter): Promise<Span[]>\n  events(filter?: EventFilter): Promise<TraceEvent[]>\n  budget(runId: string): Promise<BudgetLedgerEntry[]>\n  artifacts(runId: string): Promise<Artifact[]>\n}\n\n// ── In-memory ────────────────────────────────────────────────────────\n\nexport class InMemoryTraceStore implements TraceStore {\n  private runs = new Map<string, Run>()\n  private allSpans: Span[] = []\n  private allEvents: TraceEvent[] = []\n  private allArtifacts: Artifact[] = []\n  private allBudget: BudgetLedgerEntry[] = []\n\n  async appendRun(run: Run): Promise<void> {\n    if (this.runs.has(run.runId)) throw new Error(`run ${run.runId} already exists`)\n    this.runs.set(run.runId, { ...run })\n  }\n\n  async updateRun(runId: string, patch: Partial<Run>): Promise<void> {\n    const existing = this.runs.get(runId)\n    if (!existing) throw new Error(`run ${runId} not found`)\n    this.runs.set(runId, { ...existing, ...patch })\n  }\n\n  async appendSpan(span: Span): Promise<void> {\n    this.allSpans.push({ ...span })\n  }\n\n  async updateSpan(spanId: string, patch: Partial<Span>): Promise<void> {\n    const idx = this.allSpans.findIndex((s) => s.spanId === spanId)\n    if (idx < 0) throw new Error(`span ${spanId} not found`)\n    this.allSpans[idx] = { ...this.allSpans[idx], ...patch } as Span\n  }\n\n  async appendEvent(event: TraceEvent): Promise<void> {\n    this.allEvents.push({ ...event })\n  }\n\n  async appendArtifact(artifact: Artifact): Promise<void> {\n    this.allArtifacts.push({ ...artifact })\n  }\n\n  async appendBudgetEntry(entry: BudgetLedgerEntry): Promise<void> {\n    this.allBudget.push({ ...entry })\n  }\n\n  async getRun(runId: string): Promise<Run | undefined> {\n    const r = this.runs.get(runId)\n    return r ? { ...r } : undefined\n  }\n\n  async listRuns(filter: RunFilter = {}): Promise<Run[]> {\n    return [...this.runs.values()].filter((r) => matchesRun(r, filter))\n  }\n\n  async spans(filter: SpanFilter = {}): Promise<Span[]> {\n    return this.allSpans.filter((s) => matchesSpan(s, filter)).map((s) => ({ ...s }))\n  }\n\n  async events(filter: EventFilter = {}): Promise<TraceEvent[]> {\n    return this.allEvents.filter((e) => matchesEvent(e, filter)).map((e) => ({ ...e }))\n  }\n\n  async budget(runId: string): Promise<BudgetLedgerEntry[]> {\n    return this.allBudget.filter((b) => b.runId === runId).map((b) => ({ ...b }))\n  }\n\n  async artifacts(runId: string): Promise<Artifact[]> {\n    return this.allArtifacts.filter((a) => a.runId === runId).map((a) => ({ ...a }))\n  }\n}\n\nfunction matchesRun(r: Run, f: RunFilter): boolean {\n  if (f.scenarioId && r.scenarioId !== f.scenarioId) return false\n  if (f.variantId && r.variantId !== f.variantId) return false\n  if (f.status && r.status !== f.status) return false\n  if (f.since !== undefined && r.startedAt < f.since) return false\n  if (f.until !== undefined && r.startedAt > f.until) return false\n  if (f.tag && r.tags?.[f.tag.key] !== f.tag.value) return false\n  if (f.parentRunId && r.parentRunId !== f.parentRunId) return false\n  if (f.projectId && r.projectId !== f.projectId) return false\n  if (f.chatId && r.chatId !== f.chatId) return false\n  if (f.layer && r.layer !== f.layer) return false\n  return true\n}\n\nfunction matchesSpan(s: Span, f: SpanFilter): boolean {\n  if (f.runId && s.runId !== f.runId) return false\n  if (f.parentSpanId && s.parentSpanId !== f.parentSpanId) return false\n  if (f.kind && s.kind !== f.kind) return false\n  if (f.name && s.name !== f.name) return false\n  if (f.toolName && (s.kind !== 'tool' || s.toolName !== f.toolName)) return false\n  if (f.judgeId && (s.kind !== 'judge' || s.judgeId !== f.judgeId)) return false\n  if (f.since !== undefined && s.startedAt < f.since) return false\n  if (f.until !== undefined && s.startedAt > f.until) return false\n  return true\n}\n\nfunction matchesEvent(e: TraceEvent, f: EventFilter): boolean {\n  if (f.runId && e.runId !== f.runId) return false\n  if (f.spanId && e.spanId !== f.spanId) return false\n  if (f.kind && e.kind !== f.kind) return false\n  if (f.since !== undefined && e.timestamp < f.since) return false\n  if (f.until !== undefined && e.timestamp > f.until) return false\n  return true\n}\n\n// ── Filesystem (NDJSON append-only, one file per entity) ─────────────\n\nexport interface FileSystemTraceStoreOptions {\n  dir: string\n  /** Roll over NDJSON files when they exceed this size in bytes. Default 32 MB. */\n  maxBytes?: number\n}\n\nexport class FileSystemTraceStore implements TraceStore {\n  private dir: string\n  private maxBytes: number\n  /** Lazy in-memory index for queries — populated on first read. */\n  private index?: InMemoryTraceStore\n  /** Memoized index build — concurrent first reads share one build, and an\n   *  append racing an in-flight load awaits this so its row isn't lost. */\n  private indexPromise?: Promise<InMemoryTraceStore>\n  /** Strictly-increasing rollover stamp. Date.now() alone collides when two\n   *  rollovers land in the same millisecond, overwriting a rolled file. */\n  private lastRolloverStamp = 0\n  /**\n   * Per-file append serialization. stat → conditional-rename → appendFile is a\n   * read-modify-write on the active file; without a lock two concurrent appends\n   * to the same `name` can both pass the size check (exceeding maxBytes) or one\n   * can append to a file the other just renamed away. Each entry chains the\n   * next append behind the prior one for that file.\n   */\n  private appendLocks = new Map<string, Promise<void>>()\n\n  constructor(options: FileSystemTraceStoreOptions) {\n    this.dir = options.dir\n    this.maxBytes = options.maxBytes ?? 32 * 1024 * 1024\n  }\n\n  private async ensureDir(): Promise<void> {\n    const fs = await import('node:fs/promises')\n    await fs.mkdir(this.dir, { recursive: true })\n  }\n\n  private async append(name: string, record: unknown): Promise<void> {\n    // If an index load is in flight, wait for it. The row must hit disk AFTER\n    // the load finished reading, so it lands in the completed index via the\n    // mirror below — never lost in the gap before `this.index` is assigned.\n    if (this.indexPromise) await this.indexPromise\n    // Chain this append behind any in-flight append for the same file. The tail\n    // promise never rejects (errors are isolated to each caller's `result`), so\n    // one failed append can't break the lock chain for the next one.\n    const prior = this.appendLocks.get(name) ?? Promise.resolve()\n    const result = prior.then(() => this.appendLocked(name, record))\n    const tail = result.then(\n      () => {},\n      () => {},\n    )\n    this.appendLocks.set(name, tail)\n    try {\n      await result\n    } finally {\n      // Drop the slot once this append is the current tail, so the map doesn't\n      // grow without bound across many appends to the same file.\n      if (this.appendLocks.get(name) === tail) this.appendLocks.delete(name)\n    }\n  }\n\n  private async appendLocked(name: string, record: unknown): Promise<void> {\n    await this.ensureDir()\n    const fs = await import('node:fs/promises')\n    const path = await import('node:path')\n    const active = path.join(this.dir, `${name}.ndjson`)\n    try {\n      const stat = await fs.stat(active)\n      if (stat.size >= this.maxBytes) {\n        // Strictly-increasing, collision-free even within one millisecond — a\n        // bare Date.now() would let two same-ms rollovers overwrite each other.\n        const stamp = Math.max(Date.now(), this.lastRolloverStamp + 1)\n        this.lastRolloverStamp = stamp\n        const rolled = path.join(this.dir, `${name}.${stamp}.ndjson`)\n        await fs.rename(active, rolled)\n      }\n    } catch {\n      /* file doesn't exist yet */\n    }\n    await fs.appendFile(active, `${JSON.stringify(record)}\\n`, 'utf8')\n    // Mirror genuinely-new rows into the lazy index. Update rows (marked\n    // with `_update: true` by updateRun/updateSpan) are applied by those\n    // methods directly via the index's update* APIs — re-inserting them\n    // here triggers a duplicate-id error once the first read populates\n    // the index. Await the mirror: a fire-and-forget would let an index\n    // rejection go unhandled and let disk + index diverge silently.\n    if (this.index && !(record as { _update?: boolean })?._update) {\n      await this.insertInto(name, record)\n    }\n  }\n\n  private async insertInto(name: string, record: unknown): Promise<void> {\n    if (!this.index) return\n    switch (name) {\n      case 'runs':\n        await this.index.appendRun(record as Run)\n        break\n      case 'spans':\n        await this.index.appendSpan(record as Span)\n        break\n      case 'events':\n        await this.index.appendEvent(record as TraceEvent)\n        break\n      case 'artifacts':\n        await this.index.appendArtifact(record as Artifact)\n        break\n      case 'budget':\n        await this.index.appendBudgetEntry(record as BudgetLedgerEntry)\n        break\n    }\n  }\n\n  private load(): Promise<InMemoryTraceStore> {\n    // Memoize: concurrent first reads share one build, and an append racing an\n    // in-flight load awaits this same promise (see append()).\n    this.indexPromise ??= this.buildIndex()\n    return this.indexPromise\n  }\n\n  private async buildIndex(): Promise<InMemoryTraceStore> {\n    const fs = await import('node:fs/promises')\n    const path = await import('node:path')\n    const store = new InMemoryTraceStore()\n    let entries: string[]\n    try {\n      entries = await fs.readdir(this.dir)\n    } catch {\n      // No dir yet (first run / empty corpus). Anything past this point — parse\n      // errors, missing patch bases — is real corruption and must fail loud.\n      this.index = store\n      return store\n    }\n    // Replay files in write order. For one entity, rolled files\n    // (`name.<ts>.ndjson`) are older than the active bare file (`name.ndjson`),\n    // and readdir order is not chronological — so without this sort a patch in\n    // an older rolled file could be applied AFTER (overwrite) a newer patch in\n    // the active file, silently restoring a stale field. Sort: per entity,\n    // rolled ascending by timestamp, then the bare active file last.\n    entries.sort((a, b) => {\n      // Group by the same entity base the loop uses (`split('.')[0]`); within an\n      // entity, real rollover files (`<base>.<ms>.ndjson`) sort by timestamp\n      // ascending and the bare active file (no numeric segment) sorts last.\n      // Non-rollover names tie (Infinity) and a stable sort preserves their\n      // readdir order.\n      const baseA = a.split('.')[0]!\n      const baseB = b.split('.')[0]!\n      if (baseA !== baseB) return baseA < baseB ? -1 : 1\n      const ta = a.match(/^[^.]+\\.(\\d+)\\.ndjson$/)\n      const tb = b.match(/^[^.]+\\.(\\d+)\\.ndjson$/)\n      const tsA = ta ? Number(ta[1]) : Number.POSITIVE_INFINITY\n      const tsB = tb ? Number(tb[1]) : Number.POSITIVE_INFINITY\n      return tsA - tsB\n    })\n    {\n      // Two-pass load. Pass 1 indexes all full (base) rows; pass 2 replays the\n      // `_update` patch rows that updateRun/updateSpan append. readdir order is\n      // not deterministic and rollover splits a stream across files, so a patch\n      // can be read before its base. Applying patches in a separate pass — after\n      // every base row is indexed — means a patch always finds its target.\n      // Doing it in one pass let a patch hit the catch and append a runId-less\n      // fragment, corrupting span/run counts cross-instance.\n      const runUpdates: Array<Record<string, unknown>> = []\n      const spanUpdates: Array<Record<string, unknown>> = []\n      for (const file of entries) {\n        if (!file.endsWith('.ndjson')) continue\n        const full = path.join(this.dir, file)\n        const content = await fs.readFile(full, 'utf8')\n        const base = file.split('.')[0]\n        const lines = content.split('\\n')\n        for (let ln = 0; ln < lines.length; ln++) {\n          const line = lines[ln]!\n          if (!line.trim()) continue\n          let record: ReturnType<typeof JSON.parse>\n          try {\n            record = JSON.parse(line)\n          } catch (err) {\n            // Fail loud WITH context — a bare SyntaxError loses which file/line\n            // is corrupt and which valid rows surround it.\n            throw new Error(\n              `FileSystemTraceStore: corrupt NDJSON in ${file} line ${ln + 1}: ${\n                err instanceof Error ? err.message : String(err)\n              } — ${line.slice(0, 120)}`,\n            )\n          }\n          if (base === 'runs') {\n            if (record?._update) {\n              runUpdates.push(record)\n              continue\n            }\n            // A duplicate full row (same dir loaded twice into one stream) is\n            // collapsed last-write-wins rather than thrown.\n            try {\n              await store.appendRun(record)\n            } catch {\n              await store.updateRun(record.runId, record)\n            }\n          } else if (base === 'spans') {\n            // `updateSpan` appends an `_update: true` patch row instead of\n            // rewriting the original span. Deferred to pass 2 so it collapses\n            // onto the original span — otherwise a fresh FileSystemTraceStore\n            // reading the same dir reports duplicate spans (one full, one\n            // fragment with no runId/kind/name), which breaks any downstream\n            // consumer that re-opens the store cross-process (e.g. the OTLP\n            // converter).\n            if (record?._update) {\n              spanUpdates.push(record)\n              continue\n            }\n            await store.appendSpan(record)\n          } else if (base === 'events') {\n            await store.appendEvent(record)\n          } else if (base === 'artifacts') {\n            await store.appendArtifact(record)\n          } else if (base === 'budget') {\n            await store.appendBudgetEntry(record)\n          }\n        }\n      }\n      // Pass 2: every base row is now indexed. A patch whose base is genuinely\n      // absent (truncated/partial corpus) throws inside update* — we let it\n      // propagate rather than silently appending a fragment, so a corrupt\n      // corpus fails loud instead of polluting counts.\n      for (const record of runUpdates) {\n        await store.updateRun(record.runId as string, record as Partial<Run>)\n      }\n      for (const record of spanUpdates) {\n        await store.updateSpan(record.spanId as string, record as Partial<Span>)\n      }\n    }\n    this.index = store\n    return store\n  }\n\n  async appendRun(run: Run): Promise<void> {\n    await this.append('runs', run)\n  }\n  async updateRun(runId: string, patch: Partial<Run>): Promise<void> {\n    // NDJSON is append-only; record updates as new rows with the same runId —\n    // readers collapse by last-write-wins on load.\n    await this.append('runs', { runId, ...patch, _update: true })\n    if (this.index) await this.index.updateRun(runId, patch)\n  }\n  async appendSpan(span: Span): Promise<void> {\n    await this.append('spans', span)\n  }\n  async updateSpan(spanId: string, patch: Partial<Span>): Promise<void> {\n    await this.append('spans', { spanId, ...patch, _update: true })\n    if (this.index) await this.index.updateSpan(spanId, patch)\n  }\n  async appendEvent(event: TraceEvent): Promise<void> {\n    await this.append('events', event)\n  }\n  async appendArtifact(artifact: Artifact): Promise<void> {\n    await this.append('artifacts', artifact)\n  }\n  async appendBudgetEntry(entry: BudgetLedgerEntry): Promise<void> {\n    await this.append('budget', entry)\n  }\n\n  async getRun(runId: string): Promise<Run | undefined> {\n    return (await this.load()).getRun(runId)\n  }\n  async listRuns(filter?: RunFilter): Promise<Run[]> {\n    return (await this.load()).listRuns(filter)\n  }\n  async spans(filter?: SpanFilter): Promise<Span[]> {\n    return (await this.load()).spans(filter)\n  }\n  async events(filter?: EventFilter): Promise<TraceEvent[]> {\n    return (await this.load()).events(filter)\n  }\n  async budget(runId: string): Promise<BudgetLedgerEntry[]> {\n    return (await this.load()).budget(runId)\n  }\n  async artifacts(runId: string): Promise<Artifact[]> {\n    return (await this.load()).artifacts(runId)\n  }\n}\n"],"mappings":"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"}

package/dist/{store-otlp-CFf27E8_.js → store-otlp-DmLm65XW.js}

@@ -1,7 +1,7 @@
-import { n as CaptureIntegrityError } from "./errors-BcOs5MKW.js";
-import { D as projectOtlpFlatLine, O as spanEpochMillis, S as TraceNotFoundError, T as extractOtlpAttributes, b as TraceFileMissingError, d as truncateForBudget, f as validateInteger, g as TraceAnalysisLimitError, h as SpanNotFoundError, l as traceSpanSchema, m as TRACE_ANALYSIS_LIMITS, p as DEFAULT_TRACE_ANALYST_BUDGETS, s as bindSpanSourceReader, u as compileSearchRegex, v as TraceAnalysisValidationError, w as compareSpanTime, x as TraceFileTooLargeError, y as TraceFileMalformedError } from "./kind-factory-Dl0PmNQL.js";
+import { n as CaptureIntegrityError } from "./errors-DeEEV9Vx.js";
+import { D as projectOtlpFlatLine, O as spanEpochMillis, S as TraceNotFoundError, T as extractOtlpAttributes, b as TraceFileMissingError, d as truncateForBudget, f as validateInteger, g as TraceAnalysisLimitError, h as SpanNotFoundError, l as traceSpanSchema, m as TRACE_ANALYSIS_LIMITS, p as DEFAULT_TRACE_ANALYST_BUDGETS, s as bindSpanSourceReader, u as compileSearchRegex, v as TraceAnalysisValidationError, w as compareSpanTime, x as TraceFileTooLargeError, y as TraceFileMalformedError } from "./kind-factory-VKysp1ds.js";
 import { readFile, stat } from "node:fs/promises";
-//#region src/trace-analyst/shared-abortable-task.ts
+// src/trace-analyst/shared-abortable-task.ts
 function createSharedAbortableTask(factory) {
 	const controller = new AbortController();
 	const task = {
@@ -40,8 +40,7 @@ function waitForSharedTask(task, signal) {
 		if (signal?.aborted) onAbort();
 	});
 }
-//#endregion
-//#region src/trace-analyst/store-otlp-error-clusters.ts
+// src/trace-analyst/store-otlp-error-clusters.ts
 const ERROR_CLUSTER_EXEMPLARS = 5;
 /** Collapse volatile tokens so semantically identical failures share a key:
 *  hex/uuid ids → <id>, numbers → #, quoted/abs paths → <path>, durations →
@@ -100,8 +99,7 @@ function finalizeErrorClusters(clusters, errorTraceCount) {
 	out.sort((a, b) => b.trace_count - a.trace_count || b.span_count - a.span_count);
 	return out;
 }
-//#endregion
-//#region src/trace-analyst/store-otlp-search-offset.ts
+// src/trace-analyst/store-otlp-search-offset.ts
 /** A `"` at `idx` is a real JSON delimiter only when the run of `\`
 *  immediately preceding it is even-length; an odd run means the quote
 *  is escaped (`\"`) and is part of a string value, not a boundary. */
@@ -141,8 +139,7 @@ function bestAttributePathForOffset(slice, offset) {
 	if (keyOpen < 0) return null;
 	return slice.slice(keyOpen + 1, keyClose);
 }
-//#endregion
-//#region src/trace-analyst/store-otlp-buffered.ts
+// src/trace-analyst/store-otlp-buffered.ts
 /** Lines indexed between event-loop yields. Bounded synchronous work per
 *  tick keeps the index build from starving other tasks on large files
 *  while staying coarse enough that the yields are cheap. */
@@ -688,8 +685,7 @@ var BufferedTraceStore = class {
 		};
 	}
 };
-//#endregion
-//#region src/trace-analyst/store-otlp.ts
+// src/trace-analyst/store-otlp.ts
 /**
 * `OtlpFileTraceStore` — read-only OTLP-JSONL trace store for the
 * trace-analyst.
@@ -797,7 +793,6 @@ function otlpTextToTraceAnalysisStore(text, opts = {}) {
 	if (!source.some((byte) => byte !== 32 && byte !== 9 && byte !== 10 && byte !== 13)) throw new CaptureIntegrityError("OTLP trace text must not be empty");
 	return new BufferTraceStore(source, opts);
 }
-//#endregion
 export { spanRecordsToTraceAnalysisStore as a, otlpTextToTraceAnalysisStore as i, DEFAULT_MAX_TRACE_FILE_BYTES as n, OtlpFileTraceStore as r, BufferTraceStore as t };
 
-//# sourceMappingURL=store-otlp-CFf27E8_.js.map
+//# sourceMappingURL=store-otlp-DmLm65XW.js.map