@tangle-network/agent-eval 0.207.4 → 0.209.1

package/dist/{matrix-Cqkk7eYI.d.ts → matrix-jHTsHEkR.d.ts}

@@ -1,5 +1,5 @@
 import { p as CostProvenance } from "./cost-ledger-DbQdN3nO.js";
-import { w as JudgeScore } from "./types-CFCUZk0B.js";
+import { w as JudgeScore } from "./types-Dv9sYwBB.js";
 import { o as MatrixResult } from "./index-DNgf5gyG.js";
 import { AgentProfile } from "@tangle-network/agent-interface";
 //#region src/multishot/types.d.ts
@@ -398,4 +398,4 @@ interface RunMultishotMatrixResult {
 declare function runMultishotMatrix<TPersona extends MultishotPersona>(opts: RunMultishotMatrixOptions<TPersona>): Promise<RunMultishotMatrixResult>;
 //#endregion
 export { MultishotToolExecutor as A, MultishotFatalToolError as C, MultishotShape as D, MultishotResult as E, assertMultishotShotResult as F, MultishotTransportRequest as M, MultishotTransportResponse as N, MultishotShotResultError as O, MultishotTransportToolCall as P, MultishotDriverEmptyError as S, MultishotPersona as T, JudgeRunResult as _, MultishotCellOutput as a, runJudge as b, RunMultishotMatrixResult as c, MultishotShot as d, RunMultishotOptions as f, JudgeDimension as g, JudgeConfig as h, ConversationJudgeInput as i, MultishotTransport as j, MultishotToolDefinition as k, computeCellComposite as l, DEFAULT_JUDGE_MODEL as m, CellCompositeInput as n, MultishotJudges as o, runMultishot as p, CellCompositeScore as r, RunMultishotMatrixOptions as s, ArtifactJudgeInput as t, runMultishotMatrix as u, renderDimensions as v, MultishotMessage as w, MultishotArtifact as x, renderJsonFooter as y };
-//# sourceMappingURL=matrix-Cqkk7eYI.d.ts.map
+//# sourceMappingURL=matrix-jHTsHEkR.d.ts.map

package/dist/{matrix-Cqkk7eYI.d.ts.map → matrix-jHTsHEkR.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"matrix-Cqkk7eYI.d.ts","names":[],"sources":["../src/multishot/types.ts","../src/multishot/judges.ts","../src/multishot/multishot.ts","../src/multishot/matrix.ts"],"mappings":";;;;;UAIiB;EACf;EACA;EACA;EACA,YAAY;IAAQ;IAAY;IAAc,MAAM;;;UAGrC;EACf;EACA;EACA;IAAc;IAAc,MAAM;;EAClC;;UAGe;EACf,YAAY;EACZ,WAAW;EACX;EACA;;;EAGA;;;;;;;;EAQA,iBAAiB;;UAGF;EACf;EACA;IACE;IACA;IACA,YAAY;;;;;;UAOC;EACf;EACA,UAAU,MAAM;EAChB,QAAQ;EACR;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA;IAAY;IAAc;;;UAGX;EACf;IAAW;IAAyB,aAAa;;EACjD;IAAU;IAAwB;;;;EAGlC;;;;EAIA;;;;;;;;KASU,sBACV,KAAK,8BACF,QAAQ;KAED,yBACV,MAAM,yBACN;;EAEE,WAAW;EACX,SAAS;MAER;EAAU;EAAiB;;UAEf;;EAEf;;GAEC;;;;;;;;UASc,eAAe,iBAAiB;;EAE/C,eAAe,SAAS;;;EAGxB,2BAA2B,SAAS;;cAGzB,kCAAkC;WACjB;EAA5B,YAA4B;;cAMjB,gCAAgC;EAC3C,YAAY;;cAMD,iCAAiC;EAC5C,YAAY;;;;;;;;;;;;;;;;;;;iBAyBE,0BAA0B,yBAAyB,SAAS;;;cCvI/D;UAEI;;EAEf;;EAEA;;UAGe,YAAY;;EAE3B;;;EAGA,WAAW;;EAEX;;EAEA,YAAY;;EAEZ;;;EAGA,cAAc,OAAO;;EAErB;;UAGe;;EAEf,OAAO;;EAEP,MAAM;;iBAGc,SAAS,QAC7B,OAAO,YAAY,SACnB,OAAO,SACN,QAAQ;;;iBAsIK,iBAAiB,eAAe;;iBAKhC,iBAAiB,eAAe;;;UCxK/B,oBAAoB,iBAAiB;EACpD,SAAS;EACT,SAAS;;;EAGT,QAAQ,eAAe;;EAEvB,QAAQ;;EAER,gBAAgB,eAAe;;;;EAI/B,mBAAmB;EACnB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA,gBAAgB;;;;EAIhB,iBAAiB;;;EAGjB,gBAAgB;EAChB,SAAS;;;;;;;;;;;KAYC,cAAc,iBAAiB,qBACzC,MAAM,oBAAoB,cACvB,QAAQ;;;;;;;;;;;;;;;;;iBA2BS,aAAa,iBAAiB,kBAClD,MAAM,oBAAoB,YACzB,QAAQ;;;UClFM,uBAAuB,iBAAiB;EACvD,YAAY;EACZ,SAAS;;UAGM,mBAAmB,iBAAiB;EACnD,UAAU;EACV,SAAS;;UAGM,gBAAgB,iBAAiB;;EAEhD,cAAc,YAAY,uBAAuB;;EAEjD,aAAa,YAAY,mBAAmB;;EAE5C,iBAAiB,YAAY,mBAAmB;;EAEhD;;EAEA;;UAGe;EACf;EACA,cAAc;EACd;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;EAEF;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;;UAIa,0BAA0B,iBAAiB;;EAE1D,UAAU;IAAQ;IAAY,OAAO;;;EAErC,UAAU;;;EAGV,QAAQ,eAAe;;EAEvB,QAAQ,gBAAgB;;EAExB,QAAQ;;EAER,gBAAgB,eAAe;;EAE/B,mBAAmB;;EAEnB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,gBAAgB;;EAEhB,iBAAiB;;;EAGjB,gBAAgB;;;;;;;;;;;;;;;EAehB,UAAU,cAAc;;;;;UAMT;EACf;EACA;EACA;;UAoBe;EACf,cAAc;;EAEd,cAAc,cAAc;;EAE5B,iBAAiB,cAAc;;;;;;;iBAQjB,qBAAqB,OAAO;EAC1C;EACA;EACA;EACA;;UAuBe;EACf,QAAQ,aAAa;;iBAGD,mBAAmB,iBAAiB,kBACxD,MAAM,0BAA0B,YAC/B,QAAQ"}
+{"version":3,"file":"matrix-jHTsHEkR.d.ts","names":[],"sources":["../src/multishot/types.ts","../src/multishot/judges.ts","../src/multishot/multishot.ts","../src/multishot/matrix.ts"],"mappings":";;;;;UAIiB;EACf;EACA;EACA;EACA,YAAY;IAAQ;IAAY;IAAc,MAAM;;;UAGrC;EACf;EACA;EACA;IAAc;IAAc,MAAM;;EAClC;;UAGe;EACf,YAAY;EACZ,WAAW;EACX;EACA;;;EAGA;;;;;;;;EAQA,iBAAiB;;UAGF;EACf;EACA;IACE;IACA;IACA,YAAY;;;;;;UAOC;EACf;EACA,UAAU,MAAM;EAChB,QAAQ;EACR;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA;IAAY;IAAc;;;UAGX;EACf;IAAW;IAAyB,aAAa;;EACjD;IAAU;IAAwB;;;;EAGlC;;;;EAIA;;;;;;;;KASU,sBACV,KAAK,8BACF,QAAQ;KAED,yBACV,MAAM,yBACN;;EAEE,WAAW;EACX,SAAS;MAER;EAAU;EAAiB;;UAEf;;EAEf;;GAEC;;;;;;;;UASc,eAAe,iBAAiB;;EAE/C,eAAe,SAAS;;;EAGxB,2BAA2B,SAAS;;cAGzB,kCAAkC;WACjB;EAA5B,YAA4B;;cAMjB,gCAAgC;EAC3C,YAAY;;cAMD,iCAAiC;EAC5C,YAAY;;;;;;;;;;;;;;;;;;;iBAyBE,0BAA0B,yBAAyB,SAAS;;;cCvI/D;UAEI;;EAEf;;EAEA;;UAGe,YAAY;;EAE3B;;;EAGA,WAAW;;EAEX;;EAEA,YAAY;;EAEZ;;;EAGA,cAAc,OAAO;;EAErB;;UAGe;;EAEf,OAAO;;EAEP,MAAM;;iBAGc,SAAS,QAC7B,OAAO,YAAY,SACnB,OAAO,SACN,QAAQ;;;iBAsIK,iBAAiB,eAAe;;iBAKhC,iBAAiB,eAAe;;;UCxK/B,oBAAoB,iBAAiB;EACpD,SAAS;EACT,SAAS;;;EAGT,QAAQ,eAAe;;EAEvB,QAAQ;;EAER,gBAAgB,eAAe;;;;EAI/B,mBAAmB;EACnB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA,gBAAgB;;;;EAIhB,iBAAiB;;;EAGjB,gBAAgB;EAChB,SAAS;;;;;;;;;;;KAYC,cAAc,iBAAiB,qBACzC,MAAM,oBAAoB,cACvB,QAAQ;;;;;;;;;;;;;;;;;iBA2BS,aAAa,iBAAiB,kBAClD,MAAM,oBAAoB,YACzB,QAAQ;;;UClFM,uBAAuB,iBAAiB;EACvD,YAAY;EACZ,SAAS;;UAGM,mBAAmB,iBAAiB;EACnD,UAAU;EACV,SAAS;;UAGM,gBAAgB,iBAAiB;;EAEhD,cAAc,YAAY,uBAAuB;;EAEjD,aAAa,YAAY,mBAAmB;;EAE5C,iBAAiB,YAAY,mBAAmB;;EAEhD;;EAEA;;UAGe;EACf;EACA,cAAc;EACd;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;EAEF;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;;UAIa,0BAA0B,iBAAiB;;EAE1D,UAAU;IAAQ;IAAY,OAAO;;;EAErC,UAAU;;;EAGV,QAAQ,eAAe;;EAEvB,QAAQ,gBAAgB;;EAExB,QAAQ;;EAER,gBAAgB,eAAe;;EAE/B,mBAAmB;;EAEnB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,gBAAgB;;EAEhB,iBAAiB;;;EAGjB,gBAAgB;;;;;;;;;;;;;;;EAehB,UAAU,cAAc;;;;;UAMT;EACf;EACA;EACA;;UAoBe;EACf,cAAc;;EAEd,cAAc,cAAc;;EAE5B,iBAAiB,cAAc;;;;;;;iBAQjB,qBAAqB,OAAO;EAC1C;EACA;EACA;EACA;;UAuBe;EACf,QAAQ,aAAa;;iBAGD,mBAAmB,iBAAiB,kBACxD,MAAM,0BAA0B,YAC/B,QAAQ"}

package/dist/meta-eval/index.d.ts

@@ -5,7 +5,7 @@ import { r as LedgerHash } from "../canonical-CFpojCN5.js";
 import { s as TraceStore } from "../store-C4avFjIi.js";
 import { a as OutcomeFilter, i as InMemoryOutcomeStore, n as FileSystemOutcomeStore, o as OutcomeStore, r as FileSystemOutcomeStoreOptions, s as OutcomeStoreError, t as DeploymentOutcome } from "../outcome-store-CNt4iZ67.js";
 import { a as ComputedInterval } from "../ast-hI-vjW6J.js";
-import { a as RubricPredictiveValidityReport, c as CorrelationInterval, i as RubricPredictiveValidityInput, l as OutcomeReduction, n as RubricOutcomeExclusion, o as RubricRanking, r as RubricOutcomePair, s as rubricPredictiveValidity, t as OutcomeMetricSpec } from "../rubric-predictive-validity-DIUwJJ9Y.js";
+import { a as RubricPredictiveValidityReport, c as CorrelationInterval, i as RubricPredictiveValidityInput, l as OutcomeReduction, n as RubricOutcomeExclusion, o as RubricRanking, r as RubricOutcomePair, s as rubricPredictiveValidity, t as OutcomeMetricSpec } from "../rubric-predictive-validity-BiNNEjpG.js";
 import { z } from "zod";
 //#region src/meta-eval/correlation-study.d.ts
 export interface EvalMetricSpec {

package/dist/meta-eval/index.js

@@ -3,7 +3,7 @@ import { a as hashCanonical, i as compareCodeUnits } from "../canonical-BsZVgBhW
 import { i as makeRng } from "../internal-CRHwS9iz.js";
 import { t as mulberry32 } from "../random-Dn5fPWkt.js";
 import { a as selfPreference, i as positionalBias, n as calibrateJudgeContinuous, o as verbosityBias, r as continuousAgreement, t as calibrateJudge } from "../judge-calibration-N44V04Se.js";
-import { u as runMetricExtractor } from "../query-DlV0pdx4.js";
+import { l as runMetricExtractor } from "../query-B1D1qp2Z.js";
 import { r as computeInterval } from "../ast-DJ6Bc7ab.js";
 import { t as analyzeSeries } from "../series-convergence-CjO2QdRW.js";
 import { a as reduceOutcomeMetric, i as hasVariation, n as assertUniqueObservationIds, o as validateObservationOptions, r as correlationSummary, t as rubricPredictiveValidity } from "../rubric-predictive-validity-BsgkBfT0.js";

package/dist/{mint-C1W8w5wo.d.ts → mint-CDy-brUR.d.ts}

@@ -1,4 +1,4 @@
-import { a as RunRecord, s as RunSearchCoordinates } from "./run-record-DF-fuu31.js";
+import { a as RunRecord, s as RunSearchCoordinates } from "./run-record-p2AYTrCn.js";
 import { s as TraceStore } from "./store-C4avFjIi.js";
 import { a as MintedRolloutLine, m as RolloutEvidenceAttempt, t as ChatMessage, y as RolloutRole } from "./schema-C-ziyJD7.js";
 //#region src/rollout/reward.d.ts
@@ -152,4 +152,4 @@ declare function unmintableReasons(record: RunRecord): string[];
 declare function mintRolloutRows(records: RunRecord[], store: TraceStore, options?: MintRolloutOptions): Promise<MintRolloutResult>;
 //#endregion
 export { mintRolloutRows as a, ScorePreference as c, observedSplitScore as d, scoreOrigin as f, RolloutSearchLineage as i, isRealnessGated as l, trainingScore as m, MintRolloutResult as n, unmintableReasons as o, trainingReward as p, RolloutScrubber as r, ScoreOrigin as s, MintRolloutOptions as t, observedScore as u };
-//# sourceMappingURL=mint-C1W8w5wo.d.ts.map
+//# sourceMappingURL=mint-CDy-brUR.d.ts.map

package/dist/{mint-C1W8w5wo.d.ts.map → mint-CDy-brUR.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"mint-C1W8w5wo.d.ts","names":[],"sources":["../src/rollout/reward.ts","../src/rollout/mint.ts"],"mappings":";;;;;;;;;KA2BY;;KAGP,SAAS,KAAK;;iBAGH,gBAAgB,QAAQ;;;;;;;;;;;;;;iBAiBxB,mBAAmB,QAAQ,QAAQ,OAAO;;;;;;;;;;;;;;;;iBAmB1C,cACd,QAAQ,QACR,SAAQ;;KAOE;;;;;;;iBAQI,YAAY,QAAQ,QAAQ,SAAQ,kBAA8B;;;;;;;;;iBAelE,cACd,QAAQ,QACR,SAAQ;;;;;;;;;;;;iBAiBM,eAAe,QAAQ;EAAW;EAAuB;;;;;KCrE7D,mBAAmB;;UAGd;;EAEf;;EAEA;;EAEA;;;EAGA;;UAGe;EACf,QAAQ;;;;;;;EAOR,cACE,2BACY,4BAA4B,iBAAiB;;EAE3D,cACE;IAEI;IAAe,mBAAmB;kBAEpC;IAAU;IAAe,mBAAmB;;;EAEhD;;EAEA,OAAO;;EAEP;;EAEA,YAAY;;;;;;;;EAQZ,iBACE,QAAQ,yBACL,uBAAuB,QAAQ;;UAGrB;EACf,MAAM;;EAEN;;;;;;;;;;;;;;iBA4Pc,kBAAkB,QAAQ;;;;;;;iBAsMpB,gBACpB,SAAS,aACT,OAAO,YACP,UAAS,qBACR,QAAQ"}
+{"version":3,"file":"mint-CDy-brUR.d.ts","names":[],"sources":["../src/rollout/reward.ts","../src/rollout/mint.ts"],"mappings":";;;;;;;;;KA2BY;;KAGP,SAAS,KAAK;;iBAGH,gBAAgB,QAAQ;;;;;;;;;;;;;;iBAiBxB,mBAAmB,QAAQ,QAAQ,OAAO;;;;;;;;;;;;;;;;iBAmB1C,cACd,QAAQ,QACR,SAAQ;;KAOE;;;;;;;iBAQI,YAAY,QAAQ,QAAQ,SAAQ,kBAA8B;;;;;;;;;iBAelE,cACd,QAAQ,QACR,SAAQ;;;;;;;;;;;;iBAiBM,eAAe,QAAQ;EAAW;EAAuB;;;;;KCrE7D,mBAAmB;;UAGd;;EAEf;;EAEA;;EAEA;;;EAGA;;UAGe;EACf,QAAQ;;;;;;;EAOR,cACE,2BACY,4BAA4B,iBAAiB;;EAE3D,cACE;IAEI;IAAe,mBAAmB;kBAEpC;IAAU;IAAe,mBAAmB;;;EAEhD;;EAEA,OAAO;;EAEP;;EAEA,YAAY;;;;;;;;EAQZ,iBACE,QAAQ,yBACL,uBAAuB,QAAQ;;UAGrB;EACf,MAAM;;EAEN;;;;;;;;;;;;;;iBA4Pc,kBAAkB,QAAQ;;;;;;;iBAsMpB,gBACpB,SAAS,aACT,OAAO,YACP,UAAS,qBACR,QAAQ"}

package/dist/{mint-CWG-s2mI.js → mint-Csor1BLJ.js}

@@ -1,6 +1,6 @@
 import { s as ValidationError } from "./errors-Dngq5h35.js";
 import { a as scoreOrigin, i as rolloutRewardFields } from "./reward-nw2xZGZG.js";
-import { c as runTaskScore } from "./run-record-BRlM99rX.js";
+import { o as runTaskScore } from "./run-record-DlTZ_lqe.js";
 import { t as buildTrajectory } from "./trajectory-D_7rLrvE.js";
 import { a as assertMinted, r as ROLLOUT_SCHEMA } from "./schema-BuiujZ-g.js";
 //#region src/rollout/mint.ts
@@ -401,4 +401,4 @@ async function mintRolloutRows(records, store, options = {}) {
 //#endregion
 export { unmintableReasons as n, mintRolloutRows as t };
 
-//# sourceMappingURL=mint-CWG-s2mI.js.map
+//# sourceMappingURL=mint-Csor1BLJ.js.map

package/dist/{mint-CWG-s2mI.js.map → mint-Csor1BLJ.js.map}

@@ -1 +1 @@
-{"version":3,"file":"mint-CWG-s2mI.js","names":[],"sources":["../src/rollout/mint.ts"],"sourcesContent":["/**\n * Rollout minting — `tangle.rollout.v1` lines joined from the records the\n * substrate ALREADY keeps. There is no separate rollout store: a rollout\n * is the JOIN of a RunRecord (identity, provenance, cost, outcome) with\n * its trace (spans share `runId`), projected into the canonical line.\n *\n * Composition, not duplication:\n *   - identity/provenance     → `RunRecord` (candidateId, splitTag, agentProfile, hashes)\n *   - step structure          → `buildTrajectory` over the shared TraceStore\n *   - preference-pair export  → `feedbackTrajectoryToOptimizerRow` (feedback-trajectory.ts)\n *   - PRM / reward-model      → `reward-model-export.ts`\n *   - search lineage          → `searchLineage`, read from the run's search ledger\n *\n * Anti-Goodhart invariant: a run whose `outcome.realness.gated` is true is\n * never exported with a positive reward OR with any of the numbers that reward\n * was computed from. The gate travels into the training data (`reward` forced\n * to 0, `realness_gated: true`) and the whole outcome is transformed by\n * `gateGamedOutcome` inside `assertMinted` below, which relocates `metrics` and\n * `verdict` to `provenance.gated_evidence`. Mint returns\n * `MintedRolloutLine[]`: the brand the training exporters require, which only\n * this function, `readRolloutLedger`, and an explicit `assertMinted` can mint.\n *\n * A record carrying NEITHER split score is REJECTED (`ValidationError`), never\n * minted at 0 — \"nobody graded this\" is not the same claim as \"graded a total\n * failure\", and a trainer reading 0 learns the second. Lines that already\n * carry `reward: null` (interchange imports, existing ledgers) remain valid on\n * the wire; only the RunRecord→line door refuses.\n *\n * Records without spans or an explicit full capture become labeled GAP LINES (messages: [],\n * provenance.gap) — present in the output AND surfaced in\n * `missingTraces`; a capture gap is a finding, never a silent omission.\n */\n\nimport { ValidationError } from '../errors'\nimport { type RunRecord, type RunSearchCoordinates, runTaskScore } from '../run-record'\nimport type { LlmSpan, Span, ToolSpan } from '../trace/schema'\nimport type { TraceStore } from '../trace/store'\nimport { buildTrajectory } from '../trajectory'\nimport { rolloutRewardFields, scoreOrigin } from './reward'\nimport {\n  assertMinted,\n  type ChatMessage,\n  type MintedRolloutLine,\n  ROLLOUT_SCHEMA,\n  type RolloutEvidenceAttempt,\n  type RolloutRole,\n  type RolloutSplit,\n  type RolloutStep,\n} from './schema'\n\n/** Redactor for transcript/step payload text (secrets, PII), not opaque identity. */\nexport type RolloutScrubber = (text: string) => string\n\n/** A search cell's place in its search tree, read from the search ledger. */\nexport interface RolloutSearchLineage {\n  /** Edges between the cell's node and the search root; the root is 0. */\n  depth: number\n  /** Order in which the node registered in its search; the root is 0. */\n  ordinal: number\n  /** Repeat index of the cell on its task, from 0. */\n  rep: number\n  /** Run id of the cell whose execution contains this search; null for a\n   *  top-level search. */\n  containingRunId: string | null\n}\n\nexport interface MintRolloutOptions {\n  scrub?: RolloutScrubber\n  /**\n   * Full canonical capture, including turns no longer in the model's context.\n   * When supplied, missing/empty capture is refused, never replaced with a\n   * span summary. Use the execution owner's capture or the existing harness\n   * readers; reviewer traces and compacted histories are not full capture.\n   */\n  messagesOf?: (\n    runId: string,\n  ) => readonly ChatMessage[] | undefined | Promise<readonly ChatMessage[] | undefined>\n  /** Provider attempts from a retained receipt bound to the exact run. */\n  evidenceOf?: (\n    runId: string,\n  ) =>\n    | { runId: string; attempts: readonly RolloutEvidenceAttempt[] }\n    | undefined\n    | Promise<{ runId: string; attempts: readonly RolloutEvidenceAttempt[] } | undefined>\n  /** Cap steps per line (longest runs first drop middle steps). Default: no cap. */\n  maxSteps?: number\n  /** Role recorded on every minted line. Default 'agent' (a solo eval run). */\n  role?: RolloutRole\n  /** Task suite label. Default: the record's `experimentId`. */\n  suite?: string\n  /** Injected clock for deterministic output. */\n  now?: () => Date\n  /**\n   * Lineage of a search run, read from its search ledger. It fills the line's\n   * `generation` (node depth), `candidate_index` (node order), `task.rep` and\n   * `parent_rollout_id` (the containing cell's run). Mint refuses a record\n   * that carries `search` when this is absent, because a null `generation`\n   * states that the run is not part of a search.\n   */\n  searchLineage?: (\n    search: RunSearchCoordinates,\n  ) => RolloutSearchLineage | Promise<RolloutSearchLineage>\n}\n\nexport interface MintRolloutResult {\n  rows: MintedRolloutLine[]\n  /** runIds that had a RunRecord but no spans — emitted as gap lines AND listed here. */\n  missingTraces: string[]\n}\n\nconst asText = (v: unknown, scrub: RolloutScrubber): string => {\n  const s = typeof v === 'string' ? v : JSON.stringify(v)\n  return scrub(s ?? '')\n}\n\nfunction projectStep(span: Span, scrub: RolloutScrubber): RolloutStep {\n  const base: RolloutStep = {\n    kind: span.kind,\n    name: scrub(span.name),\n    status: span.status,\n    durationMs: span.endedAt !== undefined ? span.endedAt - span.startedAt : undefined,\n  }\n  if (span.kind === 'llm') {\n    const llm = span as LlmSpan\n    const last = llm.messages[llm.messages.length - 1]\n    if (last && last.content !== null) base.input = scrub(last.content)\n    if (llm.output !== undefined) base.output = scrub(llm.output)\n  } else if (span.kind === 'tool') {\n    const tool = span as ToolSpan\n    base.input = asText(tool.args, scrub)\n    if (tool.result !== undefined) base.output = asText(tool.result, scrub)\n  }\n  return base\n}\n\n/** Preserve captured fields; invocation ids are opaque linkage, not generated text. */\nfunction projectMessage(message: ChatMessage, scrub: RolloutScrubber): ChatMessage {\n  return {\n    role: message.role,\n    content: message.content === null ? null : scrub(message.content),\n    ...(message.reasoning_content !== undefined\n      ? { reasoning_content: scrub(message.reasoning_content) }\n      : {}),\n    ...(message.tool_calls !== undefined\n      ? {\n          tool_calls: message.tool_calls.map((call) => ({\n            id: call.id,\n            type: call.type,\n            function: {\n              name: call.function.name,\n              arguments: scrub(call.function.arguments),\n            },\n          })),\n        }\n      : {}),\n    ...(message.tool_call_id !== undefined ? { tool_call_id: message.tool_call_id } : {}),\n    ...(message.name !== undefined ? { name: message.name } : {}),\n    ...(message.is_copied_context !== undefined\n      ? { is_copied_context: message.is_copied_context }\n      : {}),\n  }\n}\n\n/** Never recover missing calls from tool names, span order or argument summaries. */\nfunction requireToolLinkage(messages: readonly ChatMessage[], runId: string): void {\n  const seen = new Set<string>()\n  const pending = new Map<string, string>()\n  const refuse: (detail: string) => never = (detail) => {\n    throw new ValidationError(`Cannot mint rollout for run ${runId}: ${detail}`)\n  }\n  for (const message of messages) {\n    if (message.tool_calls !== undefined) {\n      if (message.role !== 'assistant' || !Array.isArray(message.tool_calls)) {\n        refuse('tool calls must be captured on an assistant message')\n      }\n      if (pending.size > 0) refuse('new tool calls precede the prior invocation results')\n      for (const call of message.tool_calls) {\n        if (\n          !call ||\n          typeof call.id !== 'string' ||\n          call.id.length === 0 ||\n          seen.has(call.id) ||\n          call.type !== 'function' ||\n          !call.function ||\n          typeof call.function.name !== 'string' ||\n          call.function.name.length === 0 ||\n          typeof call.function.arguments !== 'string'\n        ) {\n          refuse('missing, duplicate or malformed tool invocation')\n        }\n        seen.add(call.id)\n        pending.set(call.id, call.function.name)\n      }\n    }\n    if (message.role === 'tool') {\n      const id = message.tool_call_id\n      if (typeof id !== 'string' || !pending.has(id)) {\n        refuse('tool result has no captured invocation (or answers it more than once)')\n      }\n      if (message.name !== undefined && message.name !== pending.get(id)) {\n        refuse('tool result name does not match its invocation')\n      }\n      pending.delete(id)\n    } else if (message.tool_call_id !== undefined) {\n      refuse('tool_call_id is only valid on a tool result')\n    } else if (pending.size > 0 && message.tool_calls === undefined) {\n      refuse('conversation advances before all tool results were captured')\n    }\n  }\n  if (pending.size > 0) refuse('tool invocation has no captured result')\n}\n\n/** Legacy span history; callers with compacted contexts supply messagesOf instead. */\nfunction finalConversation(spans: Span[]): ChatMessage[] {\n  const llms = spans.filter((s): s is LlmSpan => s.kind === 'llm')\n  const last = llms[llms.length - 1]\n  if (!last) return []\n  const messages: ChatMessage[] = [...last.messages]\n  if (last.output !== undefined && last.output !== '') {\n    messages.push({ role: 'assistant', content: last.output })\n  }\n  return messages\n}\n\n// The reward derivations live in the leaf module `./reward` so gate and\n// reporting code can import them without dragging in the trace store; they are\n// re-exported here because the derivations shipped from this path.\nexport {\n  isRealnessGated,\n  observedScore,\n  observedSplitScore,\n  type ScoreOrigin,\n  type ScorePreference,\n  scoreOrigin,\n  trainingReward,\n  trainingScore,\n} from './reward'\n\nconst REWARD_SOURCE: Record<ReturnType<typeof scoreOrigin>, string> = {\n  holdout: 'run-record/holdout-score',\n  search: 'run-record/search-score',\n  unscored: 'run-record/unscored',\n}\n\n/**\n * The mint door refuses an execution-only record: a missing training label is\n * not a zero reward, and not a mintable line either. Lines that already carry\n * `reward: null` — interchange imports, existing ledgers — stay valid on the\n * wire and keep their labeled gap; this guard is only about the\n * RunRecord→line door, where the producer can still be told to go score the\n * run instead of shipping an unlabeled row.\n */\nfunction requireTaskScore(record: RunRecord): void {\n  if (runTaskScore(record) === undefined) {\n    throw new ValidationError(`Cannot mint rollout for run ${record.runId}: task score is missing`)\n  }\n}\n\nconst isObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null\n\ninterface MintFieldCheck {\n  /** The RunRecord path, spelled the way the caller has to fix it. */\n  readonly field: string\n  /** True when the record carries something the line can honestly be built from. */\n  readonly present: (bag: Record<string, unknown>) => boolean\n  /** What the caller writes onto the record, and why that value and not another. */\n  readonly remedy: string\n}\n\n/**\n * The RunRecord fields mint reads that a record can be missing even though the\n * TYPE says it cannot. There are exactly two ways that happens:\n *\n *   1. The field was OPTIONAL when the record was serialized. `costProvenance`,\n *      `terminalOutcome` and `scenarioId` were optional through agent-eval\n *      0.125 and became required in 0.126, with no on-disk migration — so every\n *      ledger written before 0.126 is full of records the type calls complete.\n *   2. Mint reads a level DEEPER than the record's own type is checked at:\n *      `outcome.raw`, `tokenUsage.input`, `tokenUsage.output`.\n *\n * Nothing else needs a check here. Every other field mint copies is a top-level\n * scalar landing in a typed slot on the line, where an absent value arrives as\n * `undefined` and `assertMinted` refuses it by name. These are the ones where an\n * absent value instead kills the join with `TypeError: Cannot read properties of\n * undefined`, or — worse — mints a line that reads as measured.\n *\n * This is deliberately NOT `validateRunRecord`. That validator answers \"is this\n * a valid RunRecord\", which is a wider question than \"can a rollout line be\n * built from this one\": it also enforces model-snapshot discipline, the\n * `terminalFailureReason` coupling, and the `costUsd === costProvenance.usd`\n * agreement. Routing the mint door through it would refuse records mint can\n * mint honestly today (a model alias with no snapshot date, for one), which is\n * a policy change with its own blast radius and not this bug. The door asks the\n * narrower question and answers it precisely.\n */\nconst MINT_FIELD_CHECKS: readonly MintFieldCheck[] = [\n  {\n    field: 'costProvenance',\n    present: (bag) => isObject(bag.costProvenance) && typeof bag.costProvenance.kind === 'string',\n    remedy:\n      \"Records written before agent-eval 0.126 predate this field and carry `costUsd: 0` as the documented uncaptured sentinel, which is NOT an observed zero. Backfill it as costProvenance: { kind: 'uncaptured', usd: null } WITH costUsd: null — an uncaptured cost whose costUsd is non-null is rejected by validateRunRecord, so provenance alone leaves the record invalid.\",\n  },\n  {\n    field: 'tokenUsage',\n    present: (bag) => isObject(bag.tokenUsage),\n    remedy:\n      \"The line's cost.tokens_in and cost.tokens_out are read from it. Backfill it from the provider's usage report; mint will not write 0 for tokens nobody counted.\",\n  },\n  {\n    field: 'tokenUsage.input',\n    present: (bag) => !isObject(bag.tokenUsage) || typeof bag.tokenUsage.input === 'number',\n    remedy: \"The line's cost.tokens_in is read from it, and a missing count is not a zero count.\",\n  },\n  {\n    field: 'tokenUsage.output',\n    present: (bag) => !isObject(bag.tokenUsage) || typeof bag.tokenUsage.output === 'number',\n    remedy: \"The line's cost.tokens_out is read from it, and a missing count is not a zero count.\",\n  },\n  {\n    field: 'outcome',\n    present: (bag) => isObject(bag.outcome),\n    remedy:\n      \"The line's reward, reward_source and metrics are all read from it. A record with no outcome carries no training label at all, and mint refuses an unlabeled row.\",\n  },\n  {\n    field: 'outcome.raw',\n    // Reported only when `outcome` itself is present: one absent field should\n    // produce one reason per CAUSE, not one per path that dereferences it.\n    present: (bag) => !isObject(bag.outcome) || isObject(bag.outcome.raw),\n    remedy:\n      'It is the metric bag copied verbatim into the line\\'s outcome.metrics. `{ ...undefined }` spreads to `{}` without complaint, so an absent bag would mint as \"this run reported no metrics\" — a different claim from \"this record predates the field\". Backfill it as {} only when that is what you mean.',\n  },\n  {\n    field: 'terminalOutcome',\n    present: (bag) => typeof bag.terminalOutcome === 'string',\n    remedy:\n      \"It became required in agent-eval 0.126. Backfill it from root-run or process evidence, or as 'unknown' when the producer has none — mint will not decide the line's is_completed and is_truncated for you.\",\n  },\n  {\n    field: 'scenarioId',\n    present: (bag) => typeof bag.scenarioId === 'string' && bag.scenarioId.length > 0,\n    remedy:\n      \"It became required in agent-eval 0.126 and becomes the line's task.instance_id, which must be a non-empty string. Backfill it from the scenario the run was dealt (pre-0.126 producers often left it in outcome.raw.scenario_id).\",\n  },\n]\n\n/**\n * Why a record cannot be minted, one entry per missing field, empty when it can.\n *\n * Exported so a caller can partition a whole ledger — \"which of my 2742 records\n * predate 0.126\" — without catching an exception per record, and without\n * re-deriving the field list on their side. A re-derived list is a list that\n * drifts from the door it is supposed to predict.\n *\n * Takes a `RunRecord` because that is what the caller holds and what the\n * compiler agrees they hold. The type is precisely the thing that is wrong, so\n * the checks read the record as the untyped bag it actually is on disk.\n */\nexport function unmintableReasons(record: RunRecord): string[] {\n  const bag = record as unknown as Record<string, unknown>\n  return MINT_FIELD_CHECKS.filter((check) => !check.present(bag)).map(\n    (check) => `${check.field} is missing. ${check.remedy}`,\n  )\n}\n\n/**\n * The mint door THROWS on a record it cannot build a line from. It does NOT\n * normalise an absent `costProvenance` to `{kind:'uncaptured', usd:null}`, and\n * the choice is not stylistic:\n *\n *   - Normalising cannot cover the record, only part of it. `terminalOutcome`\n *     feeds `is_completed` and `is_truncated`, which the rollout schema requires\n *     to be BOOLEAN — there is no null to fall back to, so every possible\n *     default is a claim about how the run ended. A door that quietly fixes the\n *     cost and invents the ending is a door no caller can predict.\n *   - Normalising the cost requires knowing what `costUsd: 0` meant, and mint\n *     cannot know. A genuinely free run and an uncaptured one are the same bytes\n *     in a pre-0.126 record; only the producer can tell them apart. Guessing is\n *     exactly the failure this guard exists to stop — the 0.125 optional chain\n *     `record.costProvenance?.kind === 'uncaptured'` already made that guess,\n *     silently, and every record it touched minted `cost.usd: 0`: an unmeasured\n *     cost published as a measured zero, into a training dataset.\n *   - `requireTaskScore`, directly above, already refuses an unlabeled record\n *     for the same reason: \"nobody graded this\" is not \"graded zero\". \"Nobody\n *     billed this\" is not \"billed zero\".\n *\n * The caller who wants historical records minted backfills them at their store,\n * in one pass, where `costUsd` can be corrected alongside `costProvenance` —\n * which is the only place that decision can be made correctly. The refusal names\n * the run, names every missing field, and spells the value to write.\n */\nfunction requireMintableRecord(record: RunRecord): void {\n  const reasons = unmintableReasons(record)\n  if (reasons.length === 0) return\n  throw new ValidationError(`Cannot mint rollout for run ${record.runId}: ${reasons.join('\\n  ')}`)\n}\n\n/** The search lineage a record's line is built from; undefined for a record outside a search. */\nasync function resolveSearchLineage(\n  record: RunRecord,\n  options: MintRolloutOptions,\n): Promise<RolloutSearchLineage | undefined> {\n  if (record.search === undefined) return undefined\n  const refuse: (detail: string) => never = (detail) => {\n    throw new ValidationError(`Cannot mint rollout for search run ${record.runId}: ${detail}`)\n  }\n  if (!options.searchLineage) {\n    refuse('pass searchLineage so generation, candidate_index, rep and parent come from its ledger')\n  }\n  const lineage = await options.searchLineage(record.search)\n  const isCount = (value: unknown): boolean => Number.isSafeInteger(value) && (value as number) >= 0\n  if (!isCount(lineage.depth)) refuse('lineage depth must be a non-negative integer')\n  if (!isCount(lineage.ordinal)) refuse('lineage ordinal must be a non-negative integer')\n  if (!isCount(lineage.rep)) refuse('lineage rep must be a non-negative integer')\n  if (\n    lineage.containingRunId !== null &&\n    (typeof lineage.containingRunId !== 'string' || lineage.containingRunId.length === 0)\n  ) {\n    refuse('lineage containingRunId must be null or a non-empty run id')\n  }\n  if (lineage.containingRunId === record.runId) refuse('a run cannot contain itself')\n  return lineage\n}\n\nconst SPLIT_FROM_TAG: Record<RunRecord['splitTag'], RolloutSplit> = {\n  search: 'search',\n  dev: 'dev',\n  holdout: 'holdout',\n}\n\nfunction mintLine(\n  record: RunRecord,\n  lineage: RolloutSearchLineage | undefined,\n  steps: RolloutStep[],\n  messages: ChatMessage[],\n  options: MintRolloutOptions,\n  capturedAt: string,\n  gap?: string,\n  attempts?: readonly RolloutEvidenceAttempt[],\n  lossyProjection = false,\n): MintedRolloutLine {\n  // Field presence first, and BEFORE `requireTaskScore`: that guard reads\n  // `record.outcome.searchScore` on its way to the answer, so an absent\n  // `outcome` would throw a bare TypeError from inside the guard whose whole\n  // job is to produce a clean refusal.\n  //\n  // Both branches of `mintRolloutRows` — the traced line and the gap line —\n  // land here, which is the point: `mintLine` is the only constructor of a\n  // `MintedRolloutLine` from a RunRecord, so there is no path into the waist\n  // that skips the check and no way to get this wrong from the outside.\n  requireMintableRecord(record)\n  // A missing task score is refused before anything is built: an\n  // execution-only record has no training label, and a missing label is\n  // neither a zero reward nor a mintable row.\n  requireTaskScore(record)\n  // `reward` and `realness_gated` come out of one call, so neither door into\n  // the waist can write one and forget the other.\n  const rewardFields = rolloutRewardFields(record)\n  // Only an observed or estimated amount is a total; a lower bound is not.\n  const knownTotal =\n    record.costProvenance.kind === 'observed' || record.costProvenance.kind === 'estimated'\n  const terminalOutcome = record.terminalOutcome\n  const isCompleted = terminalOutcome === 'succeeded' || terminalOutcome === 'failed'\n  const isTruncated = terminalOutcome === 'cancelled' || terminalOutcome === 'incomplete'\n  const terminalError =\n    terminalOutcome === 'failed' ||\n    terminalOutcome === 'cancelled' ||\n    terminalOutcome === 'incomplete'\n      ? (record.terminalFailureReason ?? `run ended ${terminalOutcome}`)\n      : null\n  // `assertMinted` rather than a cast: mint is the producer the whole gate\n  // rests on, so it proves the line it just built is valid instead of asserting\n  // it by fiat. The brand is unforgeable precisely because nobody casts to it.\n  return assertMinted(\n    {\n      schema: ROLLOUT_SCHEMA,\n      rollout_id: record.runId,\n      parent_rollout_id: lineage?.containingRunId ?? null,\n      run_id: record.runId,\n      experiment_id: record.experimentId,\n      candidate_id: record.candidateId,\n      generation: lineage?.depth ?? null,\n      candidate_index: lineage?.ordinal ?? null,\n      role: options.role ?? 'agent',\n      task: {\n        suite: options.suite ?? record.experimentId,\n        instance_id: record.scenarioId,\n        split: SPLIT_FROM_TAG[record.splitTag],\n        seed: record.seed,\n        rep: lineage?.rep ?? 0,\n      },\n      policy: {\n        harness: null,\n        harness_version: null,\n        model: record.model,\n        provider: null,\n        profile_commit: record.commitSha,\n        prompt_hash: record.promptHash,\n        config_hash: record.configHash,\n        agent_profile_cell_id: record.agentProfile?.cellId ?? null,\n        sampling: null,\n      },\n      messages,\n      tool_defs: [],\n      ...(steps.length > 0 ? { steps } : {}),\n      outcome: {\n        ...rewardFields,\n        reward_source: REWARD_SOURCE[scoreOrigin(record)],\n        verdict: null,\n        // A verbatim bulk copy, deliberately UNFILTERED here. `outcome.raw`\n        // holds the per-layer verifier scores (`layer.*`) that the reward was\n        // derived from, so on a gated run this dict is the reward signal in\n        // component form — but filtering it at this call site is the pattern\n        // that has now leaked twice, because the next producer to write a\n        // reward-bearing field forgets. The gate is applied to the whole\n        // outcome once, in `assertMinted` below (`gateGamedOutcome`), which\n        // moves the block to `provenance.gated_evidence` when the run is gated\n        // and leaves it here untouched when it is not.\n        metrics: { ...record.outcome.raw },\n        is_completed: isCompleted,\n        is_truncated: isTruncated,\n        error: terminalError,\n      },\n      cost: {\n        usd: knownTotal ? record.costUsd : null,\n        tokens_in: record.tokenUsage.input,\n        tokens_out: record.tokenUsage.output,\n        tokens_reasoning: record.tokenUsage.reasoning ?? null,\n        cache_read: record.tokenUsage.cached ?? null,\n        cache_write: record.tokenUsage.cacheWrite ?? null,\n        wall_s: Math.round(record.wallMs / 1000),\n      },\n      artifacts: {\n        patch_path: null,\n        run_dir: null,\n        transcript_ref: record.traceRef ? `trace:${record.traceRef.traceId}` : null,\n      },\n      provenance: {\n        captured_at: capturedAt,\n        capture: 'mint',\n        ...(record.search !== undefined ? { search: { ...record.search } } : {}),\n        ...(attempts !== undefined ? { attempts: [...attempts] } : {}),\n        ...(lossyProjection ? { lossy_projection: true } : {}),\n        ...(gap !== undefined ? { gap } : {}),\n      },\n    },\n    `minted rollout line for run ${record.runId}`,\n  )\n}\n\n/**\n * Join RunRecords with their traces into canonical rollout lines. Records\n * without spans or an explicit capture are emitted as labeled gap lines and reported in\n * `missingTraces`. Execution-only records without a task score are rejected\n * because a missing training label is not a zero reward.\n */\nexport async function mintRolloutRows(\n  records: RunRecord[],\n  store: TraceStore,\n  options: MintRolloutOptions = {},\n): Promise<MintRolloutResult> {\n  const scrub = options.scrub ?? ((t) => t)\n  const capturedAt = (options.now?.() ?? new Date()).toISOString()\n  if (\n    options.maxSteps !== undefined &&\n    (!Number.isSafeInteger(options.maxSteps) || options.maxSteps < 1)\n  ) {\n    throw new ValidationError('maxSteps must be a positive integer')\n  }\n  const rows: MintedRolloutLine[] = []\n  const missingTraces: string[] = []\n  for (const record of records) {\n    const trajectory = await buildTrajectory(store, record.runId)\n    const captured = options.messagesOf ? await options.messagesOf(record.runId) : undefined\n    const evidence = options.evidenceOf ? await options.evidenceOf(record.runId) : undefined\n    if (evidence !== undefined && evidence?.runId !== record.runId) {\n      throw new ValidationError(\n        `Cannot mint rollout for run ${record.runId}: capture evidence belongs to another run`,\n      )\n    }\n    if (\n      options.evidenceOf &&\n      (!evidence || !Array.isArray(evidence.attempts) || evidence.attempts.length === 0)\n    ) {\n      throw new ValidationError(\n        `Cannot mint rollout for run ${record.runId}: provider attempt evidence is missing`,\n      )\n    }\n    if (\n      evidence?.attempts.some(\n        (attempt) =>\n          !attempt ||\n          !Array.isArray(attempt.nativeSessionIds) ||\n          !Array.isArray(attempt.processIds) ||\n          !Array.isArray(attempt.missingReasons),\n      )\n    ) {\n      throw new ValidationError(\n        `Cannot mint rollout for run ${record.runId}: malformed provider attempt evidence`,\n      )\n    }\n    const attempts = evidence?.attempts.map((attempt) => ({\n      ...attempt,\n      nativeSessionIds: [...attempt.nativeSessionIds],\n      processIds: [...attempt.processIds],\n      missingReasons: attempt.missingReasons.map(scrub),\n    }))\n    if (options.messagesOf && (!Array.isArray(captured) || captured.length === 0)) {\n      throw new ValidationError(\n        `Cannot mint rollout for run ${record.runId}: full capture is missing`,\n      )\n    }\n    const lineage = await resolveSearchLineage(record, options)\n    if (trajectory.steps.length === 0 && !options.messagesOf) {\n      missingTraces.push(record.runId)\n      rows.push(\n        mintLine(\n          record,\n          lineage,\n          [],\n          [],\n          options,\n          capturedAt,\n          'no trace spans recorded for this runId',\n          attempts,\n        ),\n      )\n      continue\n    }\n    let steps = trajectory.steps.map((s) => projectStep(s.span, scrub))\n    const omittedSteps =\n      options.maxSteps !== undefined && steps.length > options.maxSteps\n        ? steps.length - options.maxSteps\n        : 0\n    if (options.maxSteps !== undefined && omittedSteps > 0) {\n      // Keep the head and tail — the middle of a long run is the least\n      // informative for outcome attribution.\n      const head = Math.ceil(options.maxSteps / 2)\n      const tail = options.maxSteps - head\n      steps = [...steps.slice(0, head), ...steps.slice(steps.length - tail)]\n    }\n    const spans = trajectory.steps.map((s) => s.span)\n    const messages = captured ?? finalConversation(spans)\n    requireToolLinkage(messages, record.runId)\n    const conversation = messages.map((message) => projectMessage(message, scrub))\n    // SFT drops copied context. That projection must not orphan a retained result.\n    requireToolLinkage(\n      conversation.filter((message) => message.is_copied_context !== true),\n      record.runId,\n    )\n    const gaps: string[] = []\n    if (conversation.length === 0) gaps.push('trace has no llm spans; no conversation to inline')\n    else if (!options.messagesOf) {\n      gaps.push('messages project only the last LLM context; full transcript was not captured')\n    }\n    if (omittedSteps > 0) gaps.push(`${omittedSteps} middle trace steps omitted by maxSteps`)\n    for (const attempt of attempts ?? []) {\n      if (attempt.missingReasons.length > 0) {\n        gaps.push(`provider attempt ${attempt.ordinal}: ${attempt.missingReasons.join(', ')}`)\n      }\n    }\n    rows.push(\n      mintLine(\n        record,\n        lineage,\n        steps,\n        conversation,\n        options,\n        capturedAt,\n        gaps.length > 0 ? gaps.join('; ') : undefined,\n        attempts,\n        (conversation.length > 0 && !options.messagesOf) ||\n          omittedSteps > 0 ||\n          (attempts?.some((attempt) => attempt.missingReasons.length > 0) ?? false),\n      ),\n    )\n  }\n  return { rows, missingTraces }\n}\n"],"mappings":"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"}
+{"version":3,"file":"mint-Csor1BLJ.js","names":[],"sources":["../src/rollout/mint.ts"],"sourcesContent":["/**\n * Rollout minting — `tangle.rollout.v1` lines joined from the records the\n * substrate ALREADY keeps. There is no separate rollout store: a rollout\n * is the JOIN of a RunRecord (identity, provenance, cost, outcome) with\n * its trace (spans share `runId`), projected into the canonical line.\n *\n * Composition, not duplication:\n *   - identity/provenance     → `RunRecord` (candidateId, splitTag, agentProfile, hashes)\n *   - step structure          → `buildTrajectory` over the shared TraceStore\n *   - preference-pair export  → `feedbackTrajectoryToOptimizerRow` (feedback-trajectory.ts)\n *   - PRM / reward-model      → `reward-model-export.ts`\n *   - search lineage          → `searchLineage`, read from the run's search ledger\n *\n * Anti-Goodhart invariant: a run whose `outcome.realness.gated` is true is\n * never exported with a positive reward OR with any of the numbers that reward\n * was computed from. The gate travels into the training data (`reward` forced\n * to 0, `realness_gated: true`) and the whole outcome is transformed by\n * `gateGamedOutcome` inside `assertMinted` below, which relocates `metrics` and\n * `verdict` to `provenance.gated_evidence`. Mint returns\n * `MintedRolloutLine[]`: the brand the training exporters require, which only\n * this function, `readRolloutLedger`, and an explicit `assertMinted` can mint.\n *\n * A record carrying NEITHER split score is REJECTED (`ValidationError`), never\n * minted at 0 — \"nobody graded this\" is not the same claim as \"graded a total\n * failure\", and a trainer reading 0 learns the second. Lines that already\n * carry `reward: null` (interchange imports, existing ledgers) remain valid on\n * the wire; only the RunRecord→line door refuses.\n *\n * Records without spans or an explicit full capture become labeled GAP LINES (messages: [],\n * provenance.gap) — present in the output AND surfaced in\n * `missingTraces`; a capture gap is a finding, never a silent omission.\n */\n\nimport { ValidationError } from '../errors'\nimport { type RunRecord, type RunSearchCoordinates, runTaskScore } from '../run-record'\nimport type { LlmSpan, Span, ToolSpan } from '../trace/schema'\nimport type { TraceStore } from '../trace/store'\nimport { buildTrajectory } from '../trajectory'\nimport { rolloutRewardFields, scoreOrigin } from './reward'\nimport {\n  assertMinted,\n  type ChatMessage,\n  type MintedRolloutLine,\n  ROLLOUT_SCHEMA,\n  type RolloutEvidenceAttempt,\n  type RolloutRole,\n  type RolloutSplit,\n  type RolloutStep,\n} from './schema'\n\n/** Redactor for transcript/step payload text (secrets, PII), not opaque identity. */\nexport type RolloutScrubber = (text: string) => string\n\n/** A search cell's place in its search tree, read from the search ledger. */\nexport interface RolloutSearchLineage {\n  /** Edges between the cell's node and the search root; the root is 0. */\n  depth: number\n  /** Order in which the node registered in its search; the root is 0. */\n  ordinal: number\n  /** Repeat index of the cell on its task, from 0. */\n  rep: number\n  /** Run id of the cell whose execution contains this search; null for a\n   *  top-level search. */\n  containingRunId: string | null\n}\n\nexport interface MintRolloutOptions {\n  scrub?: RolloutScrubber\n  /**\n   * Full canonical capture, including turns no longer in the model's context.\n   * When supplied, missing/empty capture is refused, never replaced with a\n   * span summary. Use the execution owner's capture or the existing harness\n   * readers; reviewer traces and compacted histories are not full capture.\n   */\n  messagesOf?: (\n    runId: string,\n  ) => readonly ChatMessage[] | undefined | Promise<readonly ChatMessage[] | undefined>\n  /** Provider attempts from a retained receipt bound to the exact run. */\n  evidenceOf?: (\n    runId: string,\n  ) =>\n    | { runId: string; attempts: readonly RolloutEvidenceAttempt[] }\n    | undefined\n    | Promise<{ runId: string; attempts: readonly RolloutEvidenceAttempt[] } | undefined>\n  /** Cap steps per line (longest runs first drop middle steps). Default: no cap. */\n  maxSteps?: number\n  /** Role recorded on every minted line. Default 'agent' (a solo eval run). */\n  role?: RolloutRole\n  /** Task suite label. Default: the record's `experimentId`. */\n  suite?: string\n  /** Injected clock for deterministic output. */\n  now?: () => Date\n  /**\n   * Lineage of a search run, read from its search ledger. It fills the line's\n   * `generation` (node depth), `candidate_index` (node order), `task.rep` and\n   * `parent_rollout_id` (the containing cell's run). Mint refuses a record\n   * that carries `search` when this is absent, because a null `generation`\n   * states that the run is not part of a search.\n   */\n  searchLineage?: (\n    search: RunSearchCoordinates,\n  ) => RolloutSearchLineage | Promise<RolloutSearchLineage>\n}\n\nexport interface MintRolloutResult {\n  rows: MintedRolloutLine[]\n  /** runIds that had a RunRecord but no spans — emitted as gap lines AND listed here. */\n  missingTraces: string[]\n}\n\nconst asText = (v: unknown, scrub: RolloutScrubber): string => {\n  const s = typeof v === 'string' ? v : JSON.stringify(v)\n  return scrub(s ?? '')\n}\n\nfunction projectStep(span: Span, scrub: RolloutScrubber): RolloutStep {\n  const base: RolloutStep = {\n    kind: span.kind,\n    name: scrub(span.name),\n    status: span.status,\n    durationMs: span.endedAt !== undefined ? span.endedAt - span.startedAt : undefined,\n  }\n  if (span.kind === 'llm') {\n    const llm = span as LlmSpan\n    const last = llm.messages[llm.messages.length - 1]\n    if (last && last.content !== null) base.input = scrub(last.content)\n    if (llm.output !== undefined) base.output = scrub(llm.output)\n  } else if (span.kind === 'tool') {\n    const tool = span as ToolSpan\n    base.input = asText(tool.args, scrub)\n    if (tool.result !== undefined) base.output = asText(tool.result, scrub)\n  }\n  return base\n}\n\n/** Preserve captured fields; invocation ids are opaque linkage, not generated text. */\nfunction projectMessage(message: ChatMessage, scrub: RolloutScrubber): ChatMessage {\n  return {\n    role: message.role,\n    content: message.content === null ? null : scrub(message.content),\n    ...(message.reasoning_content !== undefined\n      ? { reasoning_content: scrub(message.reasoning_content) }\n      : {}),\n    ...(message.tool_calls !== undefined\n      ? {\n          tool_calls: message.tool_calls.map((call) => ({\n            id: call.id,\n            type: call.type,\n            function: {\n              name: call.function.name,\n              arguments: scrub(call.function.arguments),\n            },\n          })),\n        }\n      : {}),\n    ...(message.tool_call_id !== undefined ? { tool_call_id: message.tool_call_id } : {}),\n    ...(message.name !== undefined ? { name: message.name } : {}),\n    ...(message.is_copied_context !== undefined\n      ? { is_copied_context: message.is_copied_context }\n      : {}),\n  }\n}\n\n/** Never recover missing calls from tool names, span order or argument summaries. */\nfunction requireToolLinkage(messages: readonly ChatMessage[], runId: string): void {\n  const seen = new Set<string>()\n  const pending = new Map<string, string>()\n  const refuse: (detail: string) => never = (detail) => {\n    throw new ValidationError(`Cannot mint rollout for run ${runId}: ${detail}`)\n  }\n  for (const message of messages) {\n    if (message.tool_calls !== undefined) {\n      if (message.role !== 'assistant' || !Array.isArray(message.tool_calls)) {\n        refuse('tool calls must be captured on an assistant message')\n      }\n      if (pending.size > 0) refuse('new tool calls precede the prior invocation results')\n      for (const call of message.tool_calls) {\n        if (\n          !call ||\n          typeof call.id !== 'string' ||\n          call.id.length === 0 ||\n          seen.has(call.id) ||\n          call.type !== 'function' ||\n          !call.function ||\n          typeof call.function.name !== 'string' ||\n          call.function.name.length === 0 ||\n          typeof call.function.arguments !== 'string'\n        ) {\n          refuse('missing, duplicate or malformed tool invocation')\n        }\n        seen.add(call.id)\n        pending.set(call.id, call.function.name)\n      }\n    }\n    if (message.role === 'tool') {\n      const id = message.tool_call_id\n      if (typeof id !== 'string' || !pending.has(id)) {\n        refuse('tool result has no captured invocation (or answers it more than once)')\n      }\n      if (message.name !== undefined && message.name !== pending.get(id)) {\n        refuse('tool result name does not match its invocation')\n      }\n      pending.delete(id)\n    } else if (message.tool_call_id !== undefined) {\n      refuse('tool_call_id is only valid on a tool result')\n    } else if (pending.size > 0 && message.tool_calls === undefined) {\n      refuse('conversation advances before all tool results were captured')\n    }\n  }\n  if (pending.size > 0) refuse('tool invocation has no captured result')\n}\n\n/** Legacy span history; callers with compacted contexts supply messagesOf instead. */\nfunction finalConversation(spans: Span[]): ChatMessage[] {\n  const llms = spans.filter((s): s is LlmSpan => s.kind === 'llm')\n  const last = llms[llms.length - 1]\n  if (!last) return []\n  const messages: ChatMessage[] = [...last.messages]\n  if (last.output !== undefined && last.output !== '') {\n    messages.push({ role: 'assistant', content: last.output })\n  }\n  return messages\n}\n\n// The reward derivations live in the leaf module `./reward` so gate and\n// reporting code can import them without dragging in the trace store; they are\n// re-exported here because the derivations shipped from this path.\nexport {\n  isRealnessGated,\n  observedScore,\n  observedSplitScore,\n  type ScoreOrigin,\n  type ScorePreference,\n  scoreOrigin,\n  trainingReward,\n  trainingScore,\n} from './reward'\n\nconst REWARD_SOURCE: Record<ReturnType<typeof scoreOrigin>, string> = {\n  holdout: 'run-record/holdout-score',\n  search: 'run-record/search-score',\n  unscored: 'run-record/unscored',\n}\n\n/**\n * The mint door refuses an execution-only record: a missing training label is\n * not a zero reward, and not a mintable line either. Lines that already carry\n * `reward: null` — interchange imports, existing ledgers — stay valid on the\n * wire and keep their labeled gap; this guard is only about the\n * RunRecord→line door, where the producer can still be told to go score the\n * run instead of shipping an unlabeled row.\n */\nfunction requireTaskScore(record: RunRecord): void {\n  if (runTaskScore(record) === undefined) {\n    throw new ValidationError(`Cannot mint rollout for run ${record.runId}: task score is missing`)\n  }\n}\n\nconst isObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null\n\ninterface MintFieldCheck {\n  /** The RunRecord path, spelled the way the caller has to fix it. */\n  readonly field: string\n  /** True when the record carries something the line can honestly be built from. */\n  readonly present: (bag: Record<string, unknown>) => boolean\n  /** What the caller writes onto the record, and why that value and not another. */\n  readonly remedy: string\n}\n\n/**\n * The RunRecord fields mint reads that a record can be missing even though the\n * TYPE says it cannot. There are exactly two ways that happens:\n *\n *   1. The field was OPTIONAL when the record was serialized. `costProvenance`,\n *      `terminalOutcome` and `scenarioId` were optional through agent-eval\n *      0.125 and became required in 0.126, with no on-disk migration — so every\n *      ledger written before 0.126 is full of records the type calls complete.\n *   2. Mint reads a level DEEPER than the record's own type is checked at:\n *      `outcome.raw`, `tokenUsage.input`, `tokenUsage.output`.\n *\n * Nothing else needs a check here. Every other field mint copies is a top-level\n * scalar landing in a typed slot on the line, where an absent value arrives as\n * `undefined` and `assertMinted` refuses it by name. These are the ones where an\n * absent value instead kills the join with `TypeError: Cannot read properties of\n * undefined`, or — worse — mints a line that reads as measured.\n *\n * This is deliberately NOT `validateRunRecord`. That validator answers \"is this\n * a valid RunRecord\", which is a wider question than \"can a rollout line be\n * built from this one\": it also enforces model-snapshot discipline, the\n * `terminalFailureReason` coupling, and the `costUsd === costProvenance.usd`\n * agreement. Routing the mint door through it would refuse records mint can\n * mint honestly today (a model alias with no snapshot date, for one), which is\n * a policy change with its own blast radius and not this bug. The door asks the\n * narrower question and answers it precisely.\n */\nconst MINT_FIELD_CHECKS: readonly MintFieldCheck[] = [\n  {\n    field: 'costProvenance',\n    present: (bag) => isObject(bag.costProvenance) && typeof bag.costProvenance.kind === 'string',\n    remedy:\n      \"Records written before agent-eval 0.126 predate this field and carry `costUsd: 0` as the documented uncaptured sentinel, which is NOT an observed zero. Backfill it as costProvenance: { kind: 'uncaptured', usd: null } WITH costUsd: null — an uncaptured cost whose costUsd is non-null is rejected by validateRunRecord, so provenance alone leaves the record invalid.\",\n  },\n  {\n    field: 'tokenUsage',\n    present: (bag) => isObject(bag.tokenUsage),\n    remedy:\n      \"The line's cost.tokens_in and cost.tokens_out are read from it. Backfill it from the provider's usage report; mint will not write 0 for tokens nobody counted.\",\n  },\n  {\n    field: 'tokenUsage.input',\n    present: (bag) => !isObject(bag.tokenUsage) || typeof bag.tokenUsage.input === 'number',\n    remedy: \"The line's cost.tokens_in is read from it, and a missing count is not a zero count.\",\n  },\n  {\n    field: 'tokenUsage.output',\n    present: (bag) => !isObject(bag.tokenUsage) || typeof bag.tokenUsage.output === 'number',\n    remedy: \"The line's cost.tokens_out is read from it, and a missing count is not a zero count.\",\n  },\n  {\n    field: 'outcome',\n    present: (bag) => isObject(bag.outcome),\n    remedy:\n      \"The line's reward, reward_source and metrics are all read from it. A record with no outcome carries no training label at all, and mint refuses an unlabeled row.\",\n  },\n  {\n    field: 'outcome.raw',\n    // Reported only when `outcome` itself is present: one absent field should\n    // produce one reason per CAUSE, not one per path that dereferences it.\n    present: (bag) => !isObject(bag.outcome) || isObject(bag.outcome.raw),\n    remedy:\n      'It is the metric bag copied verbatim into the line\\'s outcome.metrics. `{ ...undefined }` spreads to `{}` without complaint, so an absent bag would mint as \"this run reported no metrics\" — a different claim from \"this record predates the field\". Backfill it as {} only when that is what you mean.',\n  },\n  {\n    field: 'terminalOutcome',\n    present: (bag) => typeof bag.terminalOutcome === 'string',\n    remedy:\n      \"It became required in agent-eval 0.126. Backfill it from root-run or process evidence, or as 'unknown' when the producer has none — mint will not decide the line's is_completed and is_truncated for you.\",\n  },\n  {\n    field: 'scenarioId',\n    present: (bag) => typeof bag.scenarioId === 'string' && bag.scenarioId.length > 0,\n    remedy:\n      \"It became required in agent-eval 0.126 and becomes the line's task.instance_id, which must be a non-empty string. Backfill it from the scenario the run was dealt (pre-0.126 producers often left it in outcome.raw.scenario_id).\",\n  },\n]\n\n/**\n * Why a record cannot be minted, one entry per missing field, empty when it can.\n *\n * Exported so a caller can partition a whole ledger — \"which of my 2742 records\n * predate 0.126\" — without catching an exception per record, and without\n * re-deriving the field list on their side. A re-derived list is a list that\n * drifts from the door it is supposed to predict.\n *\n * Takes a `RunRecord` because that is what the caller holds and what the\n * compiler agrees they hold. The type is precisely the thing that is wrong, so\n * the checks read the record as the untyped bag it actually is on disk.\n */\nexport function unmintableReasons(record: RunRecord): string[] {\n  const bag = record as unknown as Record<string, unknown>\n  return MINT_FIELD_CHECKS.filter((check) => !check.present(bag)).map(\n    (check) => `${check.field} is missing. ${check.remedy}`,\n  )\n}\n\n/**\n * The mint door THROWS on a record it cannot build a line from. It does NOT\n * normalise an absent `costProvenance` to `{kind:'uncaptured', usd:null}`, and\n * the choice is not stylistic:\n *\n *   - Normalising cannot cover the record, only part of it. `terminalOutcome`\n *     feeds `is_completed` and `is_truncated`, which the rollout schema requires\n *     to be BOOLEAN — there is no null to fall back to, so every possible\n *     default is a claim about how the run ended. A door that quietly fixes the\n *     cost and invents the ending is a door no caller can predict.\n *   - Normalising the cost requires knowing what `costUsd: 0` meant, and mint\n *     cannot know. A genuinely free run and an uncaptured one are the same bytes\n *     in a pre-0.126 record; only the producer can tell them apart. Guessing is\n *     exactly the failure this guard exists to stop — the 0.125 optional chain\n *     `record.costProvenance?.kind === 'uncaptured'` already made that guess,\n *     silently, and every record it touched minted `cost.usd: 0`: an unmeasured\n *     cost published as a measured zero, into a training dataset.\n *   - `requireTaskScore`, directly above, already refuses an unlabeled record\n *     for the same reason: \"nobody graded this\" is not \"graded zero\". \"Nobody\n *     billed this\" is not \"billed zero\".\n *\n * The caller who wants historical records minted backfills them at their store,\n * in one pass, where `costUsd` can be corrected alongside `costProvenance` —\n * which is the only place that decision can be made correctly. The refusal names\n * the run, names every missing field, and spells the value to write.\n */\nfunction requireMintableRecord(record: RunRecord): void {\n  const reasons = unmintableReasons(record)\n  if (reasons.length === 0) return\n  throw new ValidationError(`Cannot mint rollout for run ${record.runId}: ${reasons.join('\\n  ')}`)\n}\n\n/** The search lineage a record's line is built from; undefined for a record outside a search. */\nasync function resolveSearchLineage(\n  record: RunRecord,\n  options: MintRolloutOptions,\n): Promise<RolloutSearchLineage | undefined> {\n  if (record.search === undefined) return undefined\n  const refuse: (detail: string) => never = (detail) => {\n    throw new ValidationError(`Cannot mint rollout for search run ${record.runId}: ${detail}`)\n  }\n  if (!options.searchLineage) {\n    refuse('pass searchLineage so generation, candidate_index, rep and parent come from its ledger')\n  }\n  const lineage = await options.searchLineage(record.search)\n  const isCount = (value: unknown): boolean => Number.isSafeInteger(value) && (value as number) >= 0\n  if (!isCount(lineage.depth)) refuse('lineage depth must be a non-negative integer')\n  if (!isCount(lineage.ordinal)) refuse('lineage ordinal must be a non-negative integer')\n  if (!isCount(lineage.rep)) refuse('lineage rep must be a non-negative integer')\n  if (\n    lineage.containingRunId !== null &&\n    (typeof lineage.containingRunId !== 'string' || lineage.containingRunId.length === 0)\n  ) {\n    refuse('lineage containingRunId must be null or a non-empty run id')\n  }\n  if (lineage.containingRunId === record.runId) refuse('a run cannot contain itself')\n  return lineage\n}\n\nconst SPLIT_FROM_TAG: Record<RunRecord['splitTag'], RolloutSplit> = {\n  search: 'search',\n  dev: 'dev',\n  holdout: 'holdout',\n}\n\nfunction mintLine(\n  record: RunRecord,\n  lineage: RolloutSearchLineage | undefined,\n  steps: RolloutStep[],\n  messages: ChatMessage[],\n  options: MintRolloutOptions,\n  capturedAt: string,\n  gap?: string,\n  attempts?: readonly RolloutEvidenceAttempt[],\n  lossyProjection = false,\n): MintedRolloutLine {\n  // Field presence first, and BEFORE `requireTaskScore`: that guard reads\n  // `record.outcome.searchScore` on its way to the answer, so an absent\n  // `outcome` would throw a bare TypeError from inside the guard whose whole\n  // job is to produce a clean refusal.\n  //\n  // Both branches of `mintRolloutRows` — the traced line and the gap line —\n  // land here, which is the point: `mintLine` is the only constructor of a\n  // `MintedRolloutLine` from a RunRecord, so there is no path into the waist\n  // that skips the check and no way to get this wrong from the outside.\n  requireMintableRecord(record)\n  // A missing task score is refused before anything is built: an\n  // execution-only record has no training label, and a missing label is\n  // neither a zero reward nor a mintable row.\n  requireTaskScore(record)\n  // `reward` and `realness_gated` come out of one call, so neither door into\n  // the waist can write one and forget the other.\n  const rewardFields = rolloutRewardFields(record)\n  // Only an observed or estimated amount is a total; a lower bound is not.\n  const knownTotal =\n    record.costProvenance.kind === 'observed' || record.costProvenance.kind === 'estimated'\n  const terminalOutcome = record.terminalOutcome\n  const isCompleted = terminalOutcome === 'succeeded' || terminalOutcome === 'failed'\n  const isTruncated = terminalOutcome === 'cancelled' || terminalOutcome === 'incomplete'\n  const terminalError =\n    terminalOutcome === 'failed' ||\n    terminalOutcome === 'cancelled' ||\n    terminalOutcome === 'incomplete'\n      ? (record.terminalFailureReason ?? `run ended ${terminalOutcome}`)\n      : null\n  // `assertMinted` rather than a cast: mint is the producer the whole gate\n  // rests on, so it proves the line it just built is valid instead of asserting\n  // it by fiat. The brand is unforgeable precisely because nobody casts to it.\n  return assertMinted(\n    {\n      schema: ROLLOUT_SCHEMA,\n      rollout_id: record.runId,\n      parent_rollout_id: lineage?.containingRunId ?? null,\n      run_id: record.runId,\n      experiment_id: record.experimentId,\n      candidate_id: record.candidateId,\n      generation: lineage?.depth ?? null,\n      candidate_index: lineage?.ordinal ?? null,\n      role: options.role ?? 'agent',\n      task: {\n        suite: options.suite ?? record.experimentId,\n        instance_id: record.scenarioId,\n        split: SPLIT_FROM_TAG[record.splitTag],\n        seed: record.seed,\n        rep: lineage?.rep ?? 0,\n      },\n      policy: {\n        harness: null,\n        harness_version: null,\n        model: record.model,\n        provider: null,\n        profile_commit: record.commitSha,\n        prompt_hash: record.promptHash,\n        config_hash: record.configHash,\n        agent_profile_cell_id: record.agentProfile?.cellId ?? null,\n        sampling: null,\n      },\n      messages,\n      tool_defs: [],\n      ...(steps.length > 0 ? { steps } : {}),\n      outcome: {\n        ...rewardFields,\n        reward_source: REWARD_SOURCE[scoreOrigin(record)],\n        verdict: null,\n        // A verbatim bulk copy, deliberately UNFILTERED here. `outcome.raw`\n        // holds the per-layer verifier scores (`layer.*`) that the reward was\n        // derived from, so on a gated run this dict is the reward signal in\n        // component form — but filtering it at this call site is the pattern\n        // that has now leaked twice, because the next producer to write a\n        // reward-bearing field forgets. The gate is applied to the whole\n        // outcome once, in `assertMinted` below (`gateGamedOutcome`), which\n        // moves the block to `provenance.gated_evidence` when the run is gated\n        // and leaves it here untouched when it is not.\n        metrics: { ...record.outcome.raw },\n        is_completed: isCompleted,\n        is_truncated: isTruncated,\n        error: terminalError,\n      },\n      cost: {\n        usd: knownTotal ? record.costUsd : null,\n        tokens_in: record.tokenUsage.input,\n        tokens_out: record.tokenUsage.output,\n        tokens_reasoning: record.tokenUsage.reasoning ?? null,\n        cache_read: record.tokenUsage.cached ?? null,\n        cache_write: record.tokenUsage.cacheWrite ?? null,\n        wall_s: Math.round(record.wallMs / 1000),\n      },\n      artifacts: {\n        patch_path: null,\n        run_dir: null,\n        transcript_ref: record.traceRef ? `trace:${record.traceRef.traceId}` : null,\n      },\n      provenance: {\n        captured_at: capturedAt,\n        capture: 'mint',\n        ...(record.search !== undefined ? { search: { ...record.search } } : {}),\n        ...(attempts !== undefined ? { attempts: [...attempts] } : {}),\n        ...(lossyProjection ? { lossy_projection: true } : {}),\n        ...(gap !== undefined ? { gap } : {}),\n      },\n    },\n    `minted rollout line for run ${record.runId}`,\n  )\n}\n\n/**\n * Join RunRecords with their traces into canonical rollout lines. Records\n * without spans or an explicit capture are emitted as labeled gap lines and reported in\n * `missingTraces`. Execution-only records without a task score are rejected\n * because a missing training label is not a zero reward.\n */\nexport async function mintRolloutRows(\n  records: RunRecord[],\n  store: TraceStore,\n  options: MintRolloutOptions = {},\n): Promise<MintRolloutResult> {\n  const scrub = options.scrub ?? ((t) => t)\n  const capturedAt = (options.now?.() ?? new Date()).toISOString()\n  if (\n    options.maxSteps !== undefined &&\n    (!Number.isSafeInteger(options.maxSteps) || options.maxSteps < 1)\n  ) {\n    throw new ValidationError('maxSteps must be a positive integer')\n  }\n  const rows: MintedRolloutLine[] = []\n  const missingTraces: string[] = []\n  for (const record of records) {\n    const trajectory = await buildTrajectory(store, record.runId)\n    const captured = options.messagesOf ? await options.messagesOf(record.runId) : undefined\n    const evidence = options.evidenceOf ? await options.evidenceOf(record.runId) : undefined\n    if (evidence !== undefined && evidence?.runId !== record.runId) {\n      throw new ValidationError(\n        `Cannot mint rollout for run ${record.runId}: capture evidence belongs to another run`,\n      )\n    }\n    if (\n      options.evidenceOf &&\n      (!evidence || !Array.isArray(evidence.attempts) || evidence.attempts.length === 0)\n    ) {\n      throw new ValidationError(\n        `Cannot mint rollout for run ${record.runId}: provider attempt evidence is missing`,\n      )\n    }\n    if (\n      evidence?.attempts.some(\n        (attempt) =>\n          !attempt ||\n          !Array.isArray(attempt.nativeSessionIds) ||\n          !Array.isArray(attempt.processIds) ||\n          !Array.isArray(attempt.missingReasons),\n      )\n    ) {\n      throw new ValidationError(\n        `Cannot mint rollout for run ${record.runId}: malformed provider attempt evidence`,\n      )\n    }\n    const attempts = evidence?.attempts.map((attempt) => ({\n      ...attempt,\n      nativeSessionIds: [...attempt.nativeSessionIds],\n      processIds: [...attempt.processIds],\n      missingReasons: attempt.missingReasons.map(scrub),\n    }))\n    if (options.messagesOf && (!Array.isArray(captured) || captured.length === 0)) {\n      throw new ValidationError(\n        `Cannot mint rollout for run ${record.runId}: full capture is missing`,\n      )\n    }\n    const lineage = await resolveSearchLineage(record, options)\n    if (trajectory.steps.length === 0 && !options.messagesOf) {\n      missingTraces.push(record.runId)\n      rows.push(\n        mintLine(\n          record,\n          lineage,\n          [],\n          [],\n          options,\n          capturedAt,\n          'no trace spans recorded for this runId',\n          attempts,\n        ),\n      )\n      continue\n    }\n    let steps = trajectory.steps.map((s) => projectStep(s.span, scrub))\n    const omittedSteps =\n      options.maxSteps !== undefined && steps.length > options.maxSteps\n        ? steps.length - options.maxSteps\n        : 0\n    if (options.maxSteps !== undefined && omittedSteps > 0) {\n      // Keep the head and tail — the middle of a long run is the least\n      // informative for outcome attribution.\n      const head = Math.ceil(options.maxSteps / 2)\n      const tail = options.maxSteps - head\n      steps = [...steps.slice(0, head), ...steps.slice(steps.length - tail)]\n    }\n    const spans = trajectory.steps.map((s) => s.span)\n    const messages = captured ?? finalConversation(spans)\n    requireToolLinkage(messages, record.runId)\n    const conversation = messages.map((message) => projectMessage(message, scrub))\n    // SFT drops copied context. That projection must not orphan a retained result.\n    requireToolLinkage(\n      conversation.filter((message) => message.is_copied_context !== true),\n      record.runId,\n    )\n    const gaps: string[] = []\n    if (conversation.length === 0) gaps.push('trace has no llm spans; no conversation to inline')\n    else if (!options.messagesOf) {\n      gaps.push('messages project only the last LLM context; full transcript was not captured')\n    }\n    if (omittedSteps > 0) gaps.push(`${omittedSteps} middle trace steps omitted by maxSteps`)\n    for (const attempt of attempts ?? []) {\n      if (attempt.missingReasons.length > 0) {\n        gaps.push(`provider attempt ${attempt.ordinal}: ${attempt.missingReasons.join(', ')}`)\n      }\n    }\n    rows.push(\n      mintLine(\n        record,\n        lineage,\n        steps,\n        conversation,\n        options,\n        capturedAt,\n        gaps.length > 0 ? gaps.join('; ') : undefined,\n        attempts,\n        (conversation.length > 0 && !options.messagesOf) ||\n          omittedSteps > 0 ||\n          (attempts?.some((attempt) => attempt.missingReasons.length > 0) ?? false),\n      ),\n    )\n  }\n  return { rows, missingTraces }\n}\n"],"mappings":"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"}

package/dist/multishot/golden/index.d.ts

@@ -1,4 +1,4 @@
-import { E as MultishotResult, M as MultishotTransportRequest, T as MultishotPersona, c as RunMultishotMatrixResult, f as RunMultishotOptions, k as MultishotToolDefinition, s as RunMultishotMatrixOptions } from "../../matrix-Cqkk7eYI.js";
+import { E as MultishotResult, M as MultishotTransportRequest, T as MultishotPersona, c as RunMultishotMatrixResult, f as RunMultishotOptions, k as MultishotToolDefinition, s as RunMultishotMatrixOptions } from "../../matrix-jHTsHEkR.js";
 //#region src/multishot/golden/compare.d.ts
 interface CompareOptions {
   /** Stop after this many mismatches. A structural divergence high in the

package/dist/multishot/index.d.ts

@@ -1,5 +1,5 @@
-import { w as JudgeScore } from "../types-CFCUZk0B.js";
-import { A as MultishotToolExecutor, C as MultishotFatalToolError, D as MultishotShape, E as MultishotResult, F as assertMultishotShotResult, M as MultishotTransportRequest, N as MultishotTransportResponse, O as MultishotShotResultError, P as MultishotTransportToolCall, S as MultishotDriverEmptyError, T as MultishotPersona, _ as JudgeRunResult, a as MultishotCellOutput, b as runJudge, c as RunMultishotMatrixResult, d as MultishotShot, f as RunMultishotOptions, g as JudgeDimension, h as JudgeConfig, i as ConversationJudgeInput, j as MultishotTransport, k as MultishotToolDefinition, l as computeCellComposite, m as DEFAULT_JUDGE_MODEL, n as CellCompositeInput, o as MultishotJudges, p as runMultishot, r as CellCompositeScore, s as RunMultishotMatrixOptions, t as ArtifactJudgeInput, u as runMultishotMatrix, v as renderDimensions, w as MultishotMessage, x as MultishotArtifact, y as renderJsonFooter } from "../matrix-Cqkk7eYI.js";
+import { w as JudgeScore } from "../types-Dv9sYwBB.js";
+import { A as MultishotToolExecutor, C as MultishotFatalToolError, D as MultishotShape, E as MultishotResult, F as assertMultishotShotResult, M as MultishotTransportRequest, N as MultishotTransportResponse, O as MultishotShotResultError, P as MultishotTransportToolCall, S as MultishotDriverEmptyError, T as MultishotPersona, _ as JudgeRunResult, a as MultishotCellOutput, b as runJudge, c as RunMultishotMatrixResult, d as MultishotShot, f as RunMultishotOptions, g as JudgeDimension, h as JudgeConfig, i as ConversationJudgeInput, j as MultishotTransport, k as MultishotToolDefinition, l as computeCellComposite, m as DEFAULT_JUDGE_MODEL, n as CellCompositeInput, o as MultishotJudges, p as runMultishot, r as CellCompositeScore, s as RunMultishotMatrixOptions, t as ArtifactJudgeInput, u as runMultishotMatrix, v as renderDimensions, w as MultishotMessage, x as MultishotArtifact, y as renderJsonFooter } from "../matrix-jHTsHEkR.js";
 import { AgentProfile } from "@tangle-network/agent-interface";
 //#region src/multishot/cost.d.ts
 /**

package/dist/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "@tangle-network/agent-eval — wire protocol",
-    "version": "0.207.4",
+    "version": "0.209.1",
     "description": "HTTP and stdio RPC interface to agent-eval. The TypeScript runtime is the source of truth; this spec is the contract that cross-language clients (Python, Rust, Go) generate from.\n\nWire-protocol version: 1.1.0. Bumps on breaking changes to request/response schemas.",
     "contact": {
       "name": "Tangle Network",

package/dist/{paired-arms-CgWT7sHy.js → paired-arms-B5v-X7No.js}

@@ -8,8 +8,6 @@ import { r as pairedBootstrap } from "./paired-tests-jbwPdSz5.js";
 const MANN_WHITNEY_EXACT_MAX_STATES = 8192;
 /** Maximum inner-loop transitions used by an exact two-sample rank test. */
 const MANN_WHITNEY_EXACT_MAX_WORK = 25e4;
-/** Non-zero differences up to which the signed-rank null is enumerated exactly. */
-const WILCOXON_EXACT_MAX_N = 20;
 /** Resamples used when a rank test falls back to Monte Carlo permutation. */
 const DEFAULT_PERMUTATIONS = 1e5;
 /**
@@ -641,6 +639,6 @@ function metricValue(row, name) {
 	return v;
 }
 //#endregion
-export { MANN_WHITNEY_EXACT_MAX_STATES as a, mannWhitneyU as c, DEFAULT_PERMUTATIONS as i, wilcoxonSignedRank as l, pairArms as n, MANN_WHITNEY_EXACT_MAX_WORK as o, pairRunRecords as r, WILCOXON_EXACT_MAX_N as s, comparePairedArms as t };
+export { wilcoxonSignedRank as a, mannWhitneyU as i, pairArms as n, pairRunRecords as r, comparePairedArms as t };
 
-//# sourceMappingURL=paired-arms-CgWT7sHy.js.map
+//# sourceMappingURL=paired-arms-B5v-X7No.js.map

package/dist/{paired-arms-CgWT7sHy.js.map → paired-arms-B5v-X7No.js.map}

@@ -1 +1 @@
-{"version":3,"file":"paired-arms-CgWT7sHy.js","names":[],"sources":["../src/statistics/rank-tests.ts","../src/paired-arms.ts"],"sourcesContent":["import { ValidationError } from '../errors'\nimport { normalCdf } from '../math/normal'\nimport { lnGamma } from '../math/special-functions'\nimport {\n  assertFiniteSample,\n  binomialSignTwoSided,\n  makeRng,\n  symmetricTwoSampleSeed,\n} from './internal'\n\n// ── Rank tests: exact by default ─────────────────────────────────────\n//\n// At 3–10 repetitions per arm the binding constraint on a rank test is\n// combinatorial, not numerical. Three versus three admits only 20 splits, so\n// the attainable two-sided p-grid starts at 0.1000 and α = 0.05 is out of\n// reach at that design; a normal approximation reports 0.0495, a p-value that\n// describes no attainable outcome. No better approximation fixes this — adding\n// the tie correction moves `[0,0,0]` versus `[1,1,1]` from 0.0495 to 0.0469,\n// further from its exact 0.1000, not closer.\n//\n// So both null distributions are enumerated exactly inside bounded state and\n// work budgets, by convolution over the observed midranks (identical to\n// enumerating every split / sign pattern, and cheaper), which conditions on the\n// realised tie pattern for free. Above those budgets the default is a seeded\n// Monte Carlo permutation. The asymptotic path is never chosen automatically,\n// and asking for it inside the exact-feasible range throws.\n//\n// Every result carries `method` and `pFloor` so a downstream gate can SEE the\n// discreteness rather than infer it: a gate handed data whose `pFloor` exceeds\n// its alpha is underpowered by construction, which is a true statement about\n// the experiment, not a false one about the effect.\n\n/** How a rank test's p-value was actually computed. */\nexport type RankTestMethod = 'exact' | 'permutation' | 'asymptotic'\n\n/**\n * What the caller asks for. `'auto'` selects `'exact'` inside the enumeration\n * threshold and `'permutation'` above it, and never selects `'asymptotic'`.\n */\nexport type RankTestMethodRequest = 'auto' | 'exact' | 'asymptotic'\n\nexport interface RankTestOptions {\n  /** Default `'auto'`. `'asymptotic'` inside the exact-feasible range throws. */\n  method?: RankTestMethodRequest\n  /** Resamples on the Monte Carlo permutation path. Default 100000. */\n  permutations?: number\n  /** Seed for the permutation path. Omitted ⇒ derived from the data itself, so\n   *  the result is reproducible either way. */\n  seed?: number\n}\n\n/** Maximum dynamic-programming cells used by an exact two-sample rank test. */\nexport const MANN_WHITNEY_EXACT_MAX_STATES = 8_192\n/** Maximum inner-loop transitions used by an exact two-sample rank test. */\nexport const MANN_WHITNEY_EXACT_MAX_WORK = 250_000\n/** Non-zero differences up to which the signed-rank null is enumerated exactly. */\nexport const WILCOXON_EXACT_MAX_N = 20\n/** Resamples used when a rank test falls back to Monte Carlo permutation. */\nexport const DEFAULT_PERMUTATIONS = 100_000\n\nexport interface MannWhitneyResult {\n  /** `min(U_a, U_b)` — the conventional reported statistic. */\n  u: number\n  /** U for sample `a`. Carries the direction of the effect, which `u` discards. */\n  uA: number\n  /** Two-sided p-value. */\n  p: number\n  /** How `p` was computed. */\n  method: RankTestMethod\n  /** Smallest two-sided p this design can produce. `p` can never be below it. */\n  pFloor: number\n}\n\n/**\n * Mann-Whitney U — two independent samples, no distributional assumption.\n *\n * Exact conditional (permutation) p by default when the dynamic program fits\n * {@link MANN_WHITNEY_EXACT_MAX_STATES} cells and\n * {@link MANN_WHITNEY_EXACT_MAX_WORK} transitions, seeded Monte Carlo\n * permutation above those limits. This keeps imbalanced designs such as 1+24\n * exact without admitting expensive balanced designs merely because they have\n * the same total size. Throws on non-finite input and on `method:\n * 'asymptotic'` where an exact answer is available. Empty input yields `p = 1,\n * pFloor = 1` — no design, no attainable evidence.\n */\nexport function mannWhitneyU(\n  a: number[],\n  b: number[],\n  opts: RankTestOptions = {},\n): MannWhitneyResult {\n  assertFiniteSample('mannWhitneyU', 'a', a)\n  assertFiniteSample('mannWhitneyU', 'b', b)\n\n  const n1 = a.length\n  const n2 = b.length\n  if (n1 === 0 || n2 === 0) return { u: 0, uA: 0, p: 1, method: 'exact', pFloor: 1 }\n\n  const total = n1 + n2\n  const combined = [\n    ...a.map((v) => ({ v, fromA: true })),\n    ...b.map((v) => ({ v, fromA: false })),\n  ].sort((x, y) => x.v - y.v)\n\n  const { midranks, tieTerm } = midranksWithTieTerm(combined.map((entry) => entry.v))\n  let rankSumA = 0\n  for (let k = 0; k < total; k++) {\n    if (combined[k]!.fromA) rankSumA += midranks[k]!\n  }\n\n  const uA = rankSumA - (n1 * (n1 + 1)) / 2\n  const u = Math.min(uA, n1 * n2 - uA)\n  // Midranks are integers or halves, so doubling makes the null convolution\n  // integral. U is centred on n₁n₂/2, hence a doubled centre of n₁n₂.\n  const doubled = midranks.map((rank) => Math.round(rank * 2))\n  const doubledDeviation = Math.abs(2 * uA - n1 * n2)\n  const selectedN = Math.min(n1, n2)\n  const otherN = total - selectedN\n  const exactCost = exactTwoSampleCost(doubled, selectedN)\n\n  const designFloor = exactTwoSampleFloor(doubled, selectedN)\n  const method = selectRankTestMethod(\n    'mannWhitneyU',\n    opts.method ?? 'auto',\n    `n1=${n1}, n2=${n2}`,\n    exactCost.states <= MANN_WHITNEY_EXACT_MAX_STATES &&\n      exactCost.work <= MANN_WHITNEY_EXACT_MAX_WORK,\n    designFloor,\n    `${MANN_WHITNEY_EXACT_MAX_STATES.toLocaleString('en-US')} states and ` +\n      `${MANN_WHITNEY_EXACT_MAX_WORK.toLocaleString('en-US')} transitions`,\n  )\n\n  if (method === 'exact') {\n    const { p, pFloor } = exactTwoSampleP(doubled, selectedN, otherN, doubledDeviation)\n    return { u, uA, p, method, pFloor }\n  }\n\n  if (method === 'asymptotic') {\n    return {\n      u,\n      uA,\n      p: asymptoticTwoSidedP(doubledDeviation / 2, twoSampleSigma(n1, n2, total, tieTerm)),\n      method,\n      pFloor: designFloor,\n    }\n  }\n\n  const permutations = resolvePermutations('mannWhitneyU', opts.permutations)\n  const rng = opts.seed === undefined ? makeRng(symmetricTwoSampleSeed(a, b)) : makeRng(opts.seed)\n  let atLeastAsExtreme = 0\n  const pool = [...doubled]\n  for (let iteration = 0; iteration < permutations; iteration++) {\n    let doubledRankSum = 0\n    for (let k = 0; k < selectedN; k++) {\n      const pick = k + Math.floor(rng() * (total - k))\n      const swapped = pool[pick]!\n      pool[pick] = pool[k]!\n      pool[k] = swapped\n      doubledRankSum += swapped\n    }\n    if (\n      Math.abs(doubledRankSum - selectedN * (selectedN + 1) - selectedN * otherN) >=\n      doubledDeviation\n    ) {\n      atLeastAsExtreme++\n    }\n  }\n  const pFloor = Math.max(1 / (permutations + 1), designFloor)\n  return {\n    u,\n    uA,\n    p: Math.max((1 + atLeastAsExtreme) / (permutations + 1), pFloor),\n    method,\n    pFloor,\n  }\n}\n\nexport interface WilcoxonSignedRankResult {\n  /** W⁺, the rank sum of the positive differences. (scipy reports\n   *  `min(W⁺, W⁻)`; compare statistics only after converting.) */\n  w: number\n  /** Two-sided p-value. */\n  p: number\n  /** How `p` was computed. */\n  method: RankTestMethod\n  /** Smallest two-sided p this design can produce. */\n  pFloor: number\n  /** Non-zero differences — zero differences are dropped and carry no rank. */\n  nNonZero: number\n}\n\n/**\n * Wilcoxon signed-rank — paired, no distributional assumption on the deltas.\n *\n * Exact conditional (sign-flip) p by default at `n ≤\n * {@link WILCOXON_EXACT_MAX_N}` non-zero differences, seeded Monte Carlo\n * permutation above it. Throws on non-finite input and on `method:\n * 'asymptotic'` where an exact answer is available.\n *\n * `n` is the count of NON-ZERO differences: exact ties are dropped before\n * ranking, so a run of tied pairs shrinks the design and raises `pFloor`.\n * All-tied input yields `p = 1, pFloor = 1` — no attainable evidence, which\n * `pFloor` states rather than leaving `p = 1` to be read as a measured null.\n */\nexport function wilcoxonSignedRank(\n  before: number[],\n  after: number[],\n  opts: RankTestOptions = {},\n): WilcoxonSignedRankResult {\n  if (before.length !== after.length) {\n    throw new ValidationError(\n      `wilcoxonSignedRank: unequal sample sizes (${before.length} vs ${after.length})`,\n    )\n  }\n  assertFiniteSample('wilcoxonSignedRank', 'before', before)\n  assertFiniteSample('wilcoxonSignedRank', 'after', after)\n\n  const diffs = before.map((b, i) => after[i]! - b).filter((d) => d !== 0)\n  const n = diffs.length\n  if (n === 0) return { w: 0, p: 1, method: 'exact', pFloor: 1, nNonZero: 0 }\n\n  // When every non-zero difference has the same magnitude, the signed-rank\n  // null reduces exactly to a binomial sign distribution. This is the common\n  // pass/fail shape ({-1, 0, +1}); recognizing it avoids a 100k-draw\n  // permutation for every repeated gate evaluation while preserving the exact\n  // p-value and attainable floor. Explicit method requests still retain their\n  // documented behavior.\n  const abs = Math.abs(diffs[0]!)\n  const allEqualAbs = diffs.every((d) => Math.abs(d) === abs)\n  if ((opts.method === undefined || opts.method === 'auto') && allEqualAbs) {\n    const positive = diffs.filter((d) => d > 0).length\n    const negative = n - positive\n    return {\n      w: (positive * (n + 1)) / 2,\n      p: binomialSignTwoSided(positive, negative),\n      method: 'exact',\n      pFloor: Math.min(1, 2 ** (1 - n)),\n      nNonZero: n,\n    }\n  }\n\n  const order = diffs.map((d, i) => ({ abs: Math.abs(d), i })).sort((x, y) => x.abs - y.abs)\n  const { midranks, tieTerm } = midranksWithTieTerm(order.map((entry) => entry.abs))\n  const ranks: number[] = new Array(n)\n  for (let k = 0; k < n; k++) ranks[order[k]!.i] = midranks[k]!\n\n  let wPlus = 0\n  for (let k = 0; k < n; k++) if (diffs[k]! > 0) wPlus += ranks[k]!\n\n  // Midranks are integers or halves; doubling makes the convolution integral.\n  // Σ midranks = n(n+1)/2 whatever the tie pattern, so E[W⁺] = n(n+1)/4 and\n  // the doubled centre is n(n+1)/2.\n  const doubled = midranks.map((rank) => Math.round(rank * 2))\n  const doubledDeviation = Math.abs(2 * wPlus - (n * (n + 1)) / 2)\n\n  const designFloor = Math.min(1, 2 ** (1 - n))\n  const method = selectRankTestMethod(\n    'wilcoxonSignedRank',\n    opts.method ?? 'auto',\n    `n=${n} non-zero differences`,\n    n <= WILCOXON_EXACT_MAX_N,\n    designFloor,\n    `${WILCOXON_EXACT_MAX_N} non-zero differences`,\n  )\n\n  if (method === 'exact') {\n    const { p, pFloor } = exactSignedRankP(doubled, doubledDeviation)\n    return { w: wPlus, p, method, pFloor, nNonZero: n }\n  }\n\n  if (method === 'asymptotic') {\n    const variance = (n * (n + 1) * (2 * n + 1)) / 24 - tieTerm / 48\n    return {\n      w: wPlus,\n      p: asymptoticTwoSidedP(doubledDeviation / 2, Math.sqrt(variance)),\n      method,\n      pFloor: designFloor,\n      nNonZero: n,\n    }\n  }\n\n  const permutations = resolvePermutations('wilcoxonSignedRank', opts.permutations)\n  const rng = makeRng(opts.seed, before, after)\n  const doubledCentre = (n * (n + 1)) / 2\n  let atLeastAsExtreme = 0\n  for (let iteration = 0; iteration < permutations; iteration++) {\n    let doubledWPlus = 0\n    for (let k = 0; k < n; k++) if (rng() < 0.5) doubledWPlus += doubled[k]!\n    if (Math.abs(doubledWPlus - doubledCentre) >= doubledDeviation) atLeastAsExtreme++\n  }\n  return {\n    w: wPlus,\n    p: (1 + atLeastAsExtreme) / (permutations + 1),\n    method,\n    pFloor: Math.max(1 / (permutations + 1), designFloor),\n    nNonZero: n,\n  }\n}\n\n/**\n * Average ranks over an ASCENDING-sorted array, plus `Σ(t³ − t)` over tie\n * groups of size `t` — the correction term both asymptotic rank-test variances\n * need.\n */\nfunction midranksWithTieTerm(sorted: readonly number[]): { midranks: number[]; tieTerm: number } {\n  const midranks = new Array<number>(sorted.length)\n  let tieTerm = 0\n  let i = 0\n  while (i < sorted.length) {\n    let j = i\n    while (j < sorted.length && sorted[j] === sorted[i]) j++\n    const average = (i + 1 + j) / 2\n    for (let k = i; k < j; k++) midranks[k] = average\n    const groupSize = j - i\n    if (groupSize > 1) tieTerm += groupSize ** 3 - groupSize\n    i = j\n  }\n  return { midranks, tieTerm }\n}\n\nfunction selectRankTestMethod(\n  fn: string,\n  request: RankTestMethodRequest,\n  design: string,\n  exactFeasible: boolean,\n  designFloor: number,\n  threshold: string,\n): RankTestMethod {\n  if (request === 'auto') return exactFeasible ? 'exact' : 'permutation'\n  if (request === 'exact') {\n    if (exactFeasible) return 'exact'\n    throw new ValidationError(\n      `${fn}: method 'exact' is out of range at ${design} — enumeration is bounded by ` +\n        `${threshold}. Use 'auto' for the seeded Monte Carlo permutation, which converges ` +\n        'to the same answer.',\n    )\n  }\n  if (exactFeasible) {\n    throw new ValidationError(\n      `${fn}: method 'asymptotic' is refused at ${design} — the exact p-grid at this design ` +\n        `starts at ${formatProbability(designFloor)}, so an asymptotic p below it describes no ` +\n        `attainable outcome. Use method 'exact' (the default) or add repetitions past ` +\n        `${threshold}.`,\n    )\n  }\n  return 'asymptotic'\n}\n\nfunction resolvePermutations(fn: string, permutations: number | undefined): number {\n  if (permutations === undefined) return DEFAULT_PERMUTATIONS\n  if (!Number.isInteger(permutations) || permutations < 1) {\n    throw new ValidationError(`${fn}: permutations must be a positive integer, got ${permutations}`)\n  }\n  return permutations\n}\n\n/** Two-sided normal-approximation tail with the continuity correction. */\nfunction asymptoticTwoSidedP(deviation: number, sigma: number): number {\n  if (!(sigma > 0)) return 1\n  return Math.min(1, 2 * (1 - normalCdf(Math.max(0, deviation - 0.5) / sigma)))\n}\n\n/** SD of U under the permutation null, corrected for the realised ties. The\n *  tie term reduces (N+1) and reaches it exactly when every value is tied, so\n *  the variance floors at 0 rather than going negative. */\nfunction twoSampleSigma(n1: number, n2: number, total: number, tieTerm: number): number {\n  if (total < 2) return 0\n  const variance = ((n1 * n2) / 12) * (total + 1 - tieTerm / (total * (total - 1)))\n  return Math.sqrt(Math.max(0, variance))\n}\n\nfunction logChoose(n: number, k: number): number {\n  return lnGamma(n + 1) - lnGamma(k + 1) - lnGamma(n - k + 1)\n}\n\nfunction formatProbability(value: number): string {\n  return value >= 1e-4 || value === 0 ? value.toFixed(4) : value.toExponential(3)\n}\n\n/**\n * Exact DP allocation and loop count for this observed rank vector.\n *\n * The smaller arm is sufficient because selecting its complement produces the\n * same two-sided U deviation while using fewer rows in the state table.\n */\nfunction exactTwoSampleCost(\n  doubledRanks: readonly number[],\n  selectedN: number,\n): { states: number; work: number } {\n  const maxSum = doubledRanks.reduce((sum, rank) => sum + rank, 0)\n  let work = 0\n  for (let placed = 0; placed < doubledRanks.length; placed++) {\n    work += Math.min(selectedN, placed + 1) * (maxSum - doubledRanks[placed]! + 1)\n  }\n  return {\n    states: (selectedN + 1) * (maxSum + 1),\n    work,\n  }\n}\n\n/**\n * Smallest attainable two-sided p under the observed ties.\n *\n * Only subsets with the minimum or maximum rank sum can attain the largest\n * deviation. Their multiplicity is the number of ways to choose within the\n * tie group at each boundary, so this calculation is exact without allocating\n * the full null distribution.\n */\nfunction exactTwoSampleFloor(doubledRanks: readonly number[], selectedN: number): number {\n  const total = doubledRanks.length\n  const otherN = total - selectedN\n  const minimumSum = doubledRanks.slice(0, selectedN).reduce((sum, rank) => sum + rank, 0)\n  const maximumSum = doubledRanks.slice(total - selectedN).reduce((sum, rank) => sum + rank, 0)\n  if (minimumSum === maximumSum) return 1\n\n  const centre = selectedN * (selectedN + 1) + selectedN * otherN\n  const minimumDeviation = Math.abs(minimumSum - centre)\n  const maximumDeviation = Math.abs(maximumSum - centre)\n  const totalLogWays = logChoose(total, selectedN)\n  const minimumMass = Math.exp(\n    logExtremeSubsetWays(doubledRanks, selectedN, 'minimum') - totalLogWays,\n  )\n  const maximumMass = Math.exp(\n    logExtremeSubsetWays(doubledRanks, selectedN, 'maximum') - totalLogWays,\n  )\n\n  if (minimumDeviation > maximumDeviation) return minimumMass\n  if (maximumDeviation > minimumDeviation) return maximumMass\n  return Math.min(1, minimumMass + maximumMass)\n}\n\nfunction logExtremeSubsetWays(\n  sortedRanks: readonly number[],\n  selectedN: number,\n  side: 'minimum' | 'maximum',\n): number {\n  const boundaryIndex = side === 'minimum' ? selectedN - 1 : sortedRanks.length - selectedN\n  const boundary = sortedRanks[boundaryIndex]!\n  let first = boundaryIndex\n  let afterLast = boundaryIndex + 1\n  while (first > 0 && sortedRanks[first - 1] === boundary) first--\n  while (afterLast < sortedRanks.length && sortedRanks[afterLast] === boundary) afterLast++\n\n  const tieSize = afterLast - first\n  const fixed = side === 'minimum' ? first : sortedRanks.length - afterLast\n  return logChoose(tieSize, selectedN - fixed)\n}\n\n/**\n * Exact conditional two-sided p for the two-sample rank test.\n *\n * Convolves the observed doubled midranks into the null distribution of group\n * a's rank sum over every `C(n₁+n₂, n₁)` split — identical to enumerating the\n * splits, but `O(N·n₁·ΣR)` instead of `O(C(N,n₁)·n₁n₂)`. Conditioning on the\n * realised multiset makes the tie handling exact rather than a correction.\n *\n * The null is symmetric about `n₁n₂/2` (negating every value maps `U → n₁n₂ −\n * U` and permutes the split set onto itself), so the two-sided p is the mass\n * at least as far from the centre as the observation.\n */\nfunction exactTwoSampleP(\n  doubledRanks: readonly number[],\n  n1: number,\n  n2: number,\n  doubledDeviation: number,\n): { p: number; pFloor: number } {\n  const maxSum = doubledRanks.reduce((sum, rank) => sum + rank, 0)\n  const width = maxSum + 1\n  // ways[k][s] = number of size-k subsets whose doubled rank sum is s.\n  const ways: Float64Array[] = Array.from({ length: n1 + 1 }, () => new Float64Array(width))\n  ways[0]![0] = 1\n  let placed = 0\n  for (const rank of doubledRanks) {\n    for (let k = Math.min(n1, placed + 1); k >= 1; k--) {\n      const from = ways[k - 1]!\n      const into = ways[k]!\n      for (let sum = maxSum - rank; sum >= 0; sum--) {\n        const count = from[sum]!\n        if (count !== 0) into[sum + rank]! += count\n      }\n    }\n    placed++\n  }\n\n  // U = rankSum − n₁(n₁+1)/2, so doubled U = s − n₁(n₁+1), and the doubled\n  // centre 2·(n₁n₂/2) is n₁n₂.\n  const shift = n1 * (n1 + 1) + n1 * n2\n  const chosen = ways[n1]!\n  let totalWays = 0\n  let extremeWays = 0\n  let tailWays = 0\n  let maxDeviation = -1\n  for (let sum = 0; sum < width; sum++) {\n    const count = chosen[sum]!\n    if (count === 0) continue\n    totalWays += count\n    const deviation = Math.abs(sum - shift)\n    if (deviation >= doubledDeviation) tailWays += count\n    if (deviation > maxDeviation) {\n      maxDeviation = deviation\n      extremeWays = count\n    } else if (deviation === maxDeviation) {\n      extremeWays += count\n    }\n  }\n  return { p: tailWays / totalWays, pFloor: extremeWays / totalWays }\n}\n\n/**\n * Exact conditional two-sided p for the paired signed-rank test.\n *\n * Convolves the observed doubled absolute midranks over all `2ⁿ` sign\n * assignments in `O(n·ΣR)`. Probabilities rather than counts keep `2ⁿ` off the\n * arithmetic. The null is symmetric about `n(n+1)/4`.\n */\nfunction exactSignedRankP(\n  doubledRanks: readonly number[],\n  doubledDeviation: number,\n): { p: number; pFloor: number } {\n  const maxSum = doubledRanks.reduce((sum, rank) => sum + rank, 0)\n  const width = maxSum + 1\n  let mass = new Float64Array(width)\n  mass[0] = 1\n  for (const rank of doubledRanks) {\n    const next = new Float64Array(width)\n    for (let sum = 0; sum < width; sum++) {\n      const probability = mass[sum]!\n      if (probability === 0) continue\n      next[sum]! += probability * 0.5\n      next[sum + rank]! += probability * 0.5\n    }\n    mass = next\n  }\n\n  const centre = maxSum / 2\n  let tail = 0\n  let extreme = 0\n  let maxDeviation = -1\n  for (let sum = 0; sum < width; sum++) {\n    const probability = mass[sum]!\n    if (probability === 0) continue\n    const deviation = Math.abs(sum - centre)\n    if (deviation >= doubledDeviation) tail += probability\n    if (deviation > maxDeviation) {\n      maxDeviation = deviation\n      extreme = probability\n    } else if (deviation === maxDeviation) {\n      extreme += probability\n    }\n  }\n  return { p: Math.min(1, tail), pFloor: Math.min(1, extreme) }\n}\n","/**\n * Matched-pair arm comparison — \"did the treatment arm beat the baseline arm\n * on the SAME work items?\"\n *\n * An arm A/B over run records is only trustworthy when it is PAIRED: the same\n * task/scenario/seed evaluated under both arms, compared item-by-item, so\n * inter-item difficulty variance cancels instead of masquerading as an arm\n * effect. This module owns the two error-prone steps every consumer otherwise\n * hand-rolls:\n *\n *   1. Pairing — matching rows across arms by `pairKey` (and by `repKey`\n *      within multi-rep items), with leftovers REPORTED rather than silently\n *      dropped (a silently unbalanced pairing biases every paired statistic\n *      downstream). Pairing never keys on outcome content: matching reps by\n *      their outcomes deflates discordant-pair counts and makes McNemar\n *      anti-conservative, so reps pair only by (`pairKey`, `repKey`) identity.\n *   2. Composition — feeding the matched pairs to the correct paired\n *      estimators that already live in `statistics`: `mcnemar` +\n *      `pairedRiskDifference` for pass/fail, `pairedBootstrap` +\n *      `wilcoxonSignedRank` for continuous metrics. No statistic is\n *      re-implemented here.\n *\n * The row shape is deliberately structural — callers project a `RunRecord`\n * (or any record) into `{ pairKey, arm, pass?, metrics? }`. Arm names are\n * caller-supplied parameters; the module ships no domain literal.\n */\n\nimport { ValidationError } from './errors'\nimport type { RunRecord } from './run-record'\nimport type { McNemarResult, PairedBootstrapOptions, PairedBootstrapResult } from './statistics'\nimport {\n  mcnemar,\n  pairedBootstrap,\n  pairedRiskDifference,\n  type RiskDifferenceResult,\n  wilcoxonSignedRank,\n} from './statistics'\n\n/** One arm observation of one work item. Structural on purpose: callers\n *  project their own record type (e.g. a `RunRecord`) into this shape. */\nexport interface PairedArmRow {\n  /** Matching key — rows sharing a `pairKey` across both arms form pairs\n   *  (typically the task/scenario/seed identity). */\n  pairKey: string\n  /** Rep identity within a `pairKey` (e.g. a seed or rep number). Required on\n   *  every row of a `pairKey` that has more than one rep in either arm; reps\n   *  then pair only on exact (`pairKey`, `repKey`) match, never on outcome\n   *  content. Optional when each arm has at most one rep of the item. */\n  repKey?: string\n  /** Arm label this row was produced under. */\n  arm: string\n  /** Binary outcome; omit when the comparison has no pass/fail notion. */\n  pass?: boolean\n  /** Named numeric measurements (score, cost, latency, …). */\n  metrics?: Record<string, number>\n}\n\nexport interface PairArmsOptions {\n  /** Arm treated as the control side of every pair. */\n  baselineArm: string\n  /** Arm treated as the treatment side of every pair. */\n  treatmentArm: string\n}\n\n/** One matched (baseline, treatment) observation of the same work item. */\nexport interface MatchedPair {\n  pairKey: string\n  /** 0-based position of this pair within its `pairKey`, ordered by sorted\n   *  `repKey` (always 0 for a single-rep item). The rep identity itself is on\n   *  the rows (`baseline.repKey` / `treatment.repKey`). */\n  repIndex: number\n  baseline: PairedArmRow\n  treatment: PairedArmRow\n}\n\nexport interface PairArmsResult {\n  /** Matched pairs, ordered by (`pairKey`, `repIndex`). */\n  pairs: MatchedPair[]\n  /** Baseline rows left without a treatment counterpart — reported, never\n   *  silently dropped. */\n  unpairedBaseline: PairedArmRow[]\n  /** Treatment rows left without a baseline counterpart. */\n  unpairedTreatment: PairedArmRow[]\n}\n\n/**\n * Match rows across two arms into (baseline, treatment) pairs by `pairKey`.\n *\n * A `pairKey` with at most one row per arm pairs directly, no `repKey`\n * needed. A `pairKey` with multiple reps in either arm requires `repKey` on\n * every one of its rows, and reps pair only on exact (`pairKey`, `repKey`)\n * match — pairing is keyed purely on row identity, never on outcome content\n * (outcome-keyed matching deflates discordant counts and biases McNemar), and\n * is therefore independent of input order. Reps whose `repKey` has no\n * counterpart in the other arm, and items present in only one arm, land in\n * the unpaired lists — reported, never truncated.\n *\n * Fail-loud: throws when either named arm has zero rows (an unknown arm\n * name would otherwise read as \"everything unpaired\"), when the two arm\n * names are equal, when a multi-rep `pairKey` has a row without `repKey`, or\n * when a (`pairKey`, arm) group repeats a `repKey` (the match would be\n * ambiguous).\n */\nexport function pairArms(rows: readonly PairedArmRow[], opts: PairArmsOptions): PairArmsResult {\n  const { baselineArm, treatmentArm } = opts\n  if (baselineArm === treatmentArm) {\n    throw new ValidationError(\n      `pairArms: baselineArm and treatmentArm are both '${baselineArm}' — an arm cannot be compared to itself`,\n    )\n  }\n\n  // arm → pairKey → rows\n  const byArm = new Map<string, Map<string, PairedArmRow[]>>()\n  const armsSeen = new Set<string>()\n  for (const row of rows) {\n    armsSeen.add(row.arm)\n    if (row.arm !== baselineArm && row.arm !== treatmentArm) continue\n    const byKey = byArm.get(row.arm) ?? new Map<string, PairedArmRow[]>()\n    const group = byKey.get(row.pairKey) ?? []\n    group.push(row)\n    byKey.set(row.pairKey, group)\n    byArm.set(row.arm, byKey)\n  }\n\n  for (const arm of [baselineArm, treatmentArm]) {\n    if (!byArm.has(arm)) {\n      const seen = [...armsSeen].sort().join(', ') || '<none>'\n      throw new ValidationError(`pairArms: no rows for arm '${arm}' (arms present: ${seen})`)\n    }\n  }\n\n  const baselineByKey = byArm.get(baselineArm)!\n  const treatmentByKey = byArm.get(treatmentArm)!\n\n  const allKeys = [...new Set([...baselineByKey.keys(), ...treatmentByKey.keys()])].sort()\n  const pairs: MatchedPair[] = []\n  const unpairedBaseline: PairedArmRow[] = []\n  const unpairedTreatment: PairedArmRow[] = []\n  for (const pairKey of allKeys) {\n    const b = baselineByKey.get(pairKey) ?? []\n    const t = treatmentByKey.get(pairKey) ?? []\n\n    if (b.length <= 1 && t.length <= 1) {\n      if (b.length === 1 && t.length === 1) {\n        const baseline = b[0]!\n        const treatment = t[0]!\n        if (baseline.repKey !== undefined || treatment.repKey !== undefined) {\n          if (\n            baseline.repKey === undefined ||\n            treatment.repKey === undefined ||\n            baseline.repKey !== treatment.repKey\n          ) {\n            unpairedBaseline.push(baseline)\n            unpairedTreatment.push(treatment)\n            continue\n          }\n        }\n        pairs.push({ pairKey, repIndex: 0, baseline, treatment })\n      } else {\n        unpairedBaseline.push(...b)\n        unpairedTreatment.push(...t)\n      }\n      continue\n    }\n\n    const bByRep = indexByRepKey(b, pairKey, baselineArm)\n    const tByRep = indexByRepKey(t, pairKey, treatmentArm)\n    const repKeys = [...new Set([...bByRep.keys(), ...tByRep.keys()])].sort()\n    let repIndex = 0\n    for (const repKey of repKeys) {\n      const baseline = bByRep.get(repKey)\n      const treatment = tByRep.get(repKey)\n      if (baseline !== undefined && treatment !== undefined) {\n        pairs.push({ pairKey, repIndex: repIndex++, baseline, treatment })\n      } else if (baseline !== undefined) {\n        unpairedBaseline.push(baseline)\n      } else if (treatment !== undefined) {\n        unpairedTreatment.push(treatment)\n      }\n    }\n  }\n\n  return { pairs, unpairedBaseline, unpairedTreatment }\n}\n\n/** Index a multi-rep (pairKey, arm) group by `repKey`, enforcing that every\n *  row carries one and that no repKey repeats within the group. */\nfunction indexByRepKey(\n  group: readonly PairedArmRow[],\n  pairKey: string,\n  arm: string,\n): Map<string, PairedArmRow> {\n  const byRep = new Map<string, PairedArmRow>()\n  for (const row of group) {\n    if (row.repKey === undefined) {\n      throw new ValidationError(\n        `pairArms: pairKey '${pairKey}' has multiple reps in an arm, but a row in arm '${arm}' ` +\n          `is missing repKey — multi-rep items require an explicit repKey on every row so reps ` +\n          `pair by identity (pairing reps by outcome or by index would bias the paired statistics)`,\n      )\n    }\n    if (byRep.has(row.repKey)) {\n      throw new ValidationError(\n        `pairArms: duplicate repKey '${row.repKey}' for pairKey '${pairKey}' in arm '${arm}' — ` +\n          `(pairKey, repKey) must uniquely identify a rep within an arm`,\n      )\n    }\n    byRep.set(row.repKey, row)\n  }\n  return byRep\n}\n\n/** Paired pass/fail comparison over the pairs where BOTH sides carry `pass`. */\nexport interface PairedCorrectness {\n  /** Discordant pairs where the treatment passed and the baseline failed. */\n  b10: number\n  /** Discordant pairs where the baseline passed and the treatment failed. */\n  b01: number\n  /** Exact McNemar significance over the paired outcomes (`b === b10`, `c === b01`). */\n  mcnemar: McNemarResult\n  /** Paired effect size: p(treatment) − p(baseline) with a paired-variance CI. */\n  riskDifference: RiskDifferenceResult\n}\n\n/** Paired delta summary for one named metric (delta = treatment − baseline). */\nexport interface PairedMetricDelta {\n  name: string\n  /** Pairs where BOTH sides carry a finite value for this metric. */\n  n: number\n  /** Pairs where at least one side does not carry the metric. */\n  nMissing: number\n  /** Median paired delta, or null when `n === 0`. */\n  medianDelta: number | null\n  /** Mean paired delta, or null when `n === 0`. */\n  meanDelta: number | null\n  /** Bootstrap CI on the paired delta (`pairedBootstrap`); null when\n   *  `n === 0` — a zero-width [0, 0] interval on no data would read as a\n   *  measured tight null. */\n  bootstrapCi: PairedBootstrapResult | null\n  /** Wilcoxon signed-rank test on the paired deltas; null when `n === 0`. */\n  wilcoxon: { w: number; p: number } | null\n}\n\nexport interface ComparePairedArmsOptions extends PairArmsOptions {\n  /** Metrics to compare. Default: every metric name observed on any matched\n   *  pair, sorted. A name that appears on no pair is still reported (with\n   *  `n = 0`) so a misspelled metric is visible instead of vanishing. */\n  metricNames?: string[]\n  /** Passed through to `pairedBootstrap` — set `seed` for reproducible CIs. */\n  bootstrap?: PairedBootstrapOptions\n}\n\nexport interface PairedArmsComparison {\n  nPairs: number\n  nUnpairedBaseline: number\n  nUnpairedTreatment: number\n  /** null when no matched pair carries `pass` on both sides — a pass/fail\n   *  verdict over rows that never measured pass/fail would be fabricated. */\n  correctness: PairedCorrectness | null\n  metricDeltas: PairedMetricDelta[]\n}\n\n/**\n * Full matched-pair arm comparison: pair via {@link pairArms}, then compose\n * the paired estimators from `statistics` over the matched pairs.\n *\n * Correctness uses only the pairs where both sides carry `pass` (`mcnemar.n`\n * is that subset's size); each metric uses only the pairs where both sides\n * carry a finite value for it, with the remainder counted in `nMissing`.\n * Deltas are treatment − baseline throughout.\n *\n * Fail-loud: inherits {@link pairArms}'s unknown-arm throw, and throws on a\n * non-finite metric value — silently treating corrupt telemetry as \"metric\n * absent\" would misreport it as missing coverage.\n */\nexport function comparePairedArms(\n  rows: readonly PairedArmRow[],\n  opts: ComparePairedArmsOptions,\n): PairedArmsComparison {\n  const { pairs, unpairedBaseline, unpairedTreatment } = pairArms(rows, opts)\n\n  let correctness: PairedCorrectness | null = null\n  const baselinePass: number[] = []\n  const treatmentPass: number[] = []\n  for (const pair of pairs) {\n    if (pair.baseline.pass === undefined || pair.treatment.pass === undefined) continue\n    baselinePass.push(pair.baseline.pass ? 1 : 0)\n    treatmentPass.push(pair.treatment.pass ? 1 : 0)\n  }\n  if (baselinePass.length > 0) {\n    const mc = mcnemar(baselinePass, treatmentPass)\n    correctness = {\n      b10: mc.b,\n      b01: mc.c,\n      mcnemar: mc,\n      riskDifference: pairedRiskDifference(baselinePass, treatmentPass),\n    }\n  }\n\n  const metricNames =\n    opts.metricNames ??\n    [\n      ...new Set(\n        pairs.flatMap((p) => [\n          ...Object.keys(p.baseline.metrics ?? {}),\n          ...Object.keys(p.treatment.metrics ?? {}),\n        ]),\n      ),\n    ].sort()\n\n  const metricDeltas: PairedMetricDelta[] = metricNames.map((name) => {\n    const before: number[] = []\n    const after: number[] = []\n    let nMissing = 0\n    for (const pair of pairs) {\n      const b = metricValue(pair.baseline, name)\n      const t = metricValue(pair.treatment, name)\n      if (b === undefined || t === undefined) {\n        nMissing++\n        continue\n      }\n      before.push(b)\n      after.push(t)\n    }\n    const bootstrapCi = before.length === 0 ? null : pairedBootstrap(before, after, opts.bootstrap)\n    return {\n      name,\n      n: before.length,\n      nMissing,\n      medianDelta: bootstrapCi?.median ?? null,\n      meanDelta: bootstrapCi?.mean ?? null,\n      bootstrapCi,\n      wilcoxon: before.length === 0 ? null : wilcoxonSignedRank(before, after),\n    }\n  })\n\n  return {\n    nPairs: pairs.length,\n    nUnpairedBaseline: unpairedBaseline.length,\n    nUnpairedTreatment: unpairedTreatment.length,\n    correctness,\n    metricDeltas,\n  }\n}\n\nexport interface MatchedRunRecordPair {\n  pairKey: string\n  repKey: string\n  baseline: RunRecord\n  treatment: RunRecord\n}\n\nexport interface PairRunRecordsResult {\n  pairs: MatchedRunRecordPair[]\n  unpairedBaseline: RunRecord[]\n  unpairedTreatment: RunRecord[]\n}\n\ninterface RunRecordArmRow extends PairedArmRow {\n  run: RunRecord\n  repKey: string\n}\n\n/**\n * Pair two RunRecord arms by the identity of the evaluated work:\n * `(experimentId, scenarioId, seed)`.\n *\n * Falling back to array order, candidate id, or experiment id can compare\n * different tasks and fabricate lift. Duplicate identities throw.\n */\nexport function pairRunRecords(\n  baselineRuns: readonly RunRecord[],\n  treatmentRuns: readonly RunRecord[],\n): PairRunRecordsResult {\n  const baselineRows = runRecordArmRows(baselineRuns, 'baseline')\n  const treatmentRows = runRecordArmRows(treatmentRuns, 'treatment')\n  validateRunRecordArmRows(baselineRows, 'baseline')\n  validateRunRecordArmRows(treatmentRows, 'treatment')\n  if (baselineRows.length === 0 || treatmentRows.length === 0) {\n    return {\n      pairs: [],\n      unpairedBaseline: baselineRows.map((row) => row.run),\n      unpairedTreatment: treatmentRows.map((row) => row.run),\n    }\n  }\n\n  const result = pairArms([...baselineRows, ...treatmentRows], {\n    baselineArm: 'baseline',\n    treatmentArm: 'treatment',\n  })\n  return {\n    pairs: result.pairs.map((pair) => {\n      const baseline = pair.baseline as RunRecordArmRow\n      const treatment = pair.treatment as RunRecordArmRow\n      return {\n        pairKey: pair.pairKey,\n        repKey: baseline.repKey,\n        baseline: baseline.run,\n        treatment: treatment.run,\n      }\n    }),\n    unpairedBaseline: result.unpairedBaseline.map((row) => (row as RunRecordArmRow).run),\n    unpairedTreatment: result.unpairedTreatment.map((row) => (row as RunRecordArmRow).run),\n  }\n}\n\nfunction runRecordArmRows(runs: readonly RunRecord[], arm: string): RunRecordArmRow[] {\n  return runs.map((run) => {\n    const scenarioId = run.scenarioId.trim()\n    if (!scenarioId) {\n      throw new ValidationError(\n        `pairRunRecords: run '${run.runId}' is missing scenarioId; paired comparisons require explicit scenario identity`,\n      )\n    }\n    return {\n      pairKey: JSON.stringify([run.experimentId, scenarioId]),\n      repKey: String(run.seed),\n      arm,\n      run,\n    }\n  })\n}\n\nfunction validateRunRecordArmRows(rows: readonly RunRecordArmRow[], arm: string): void {\n  const byPairKey = new Map<string, RunRecordArmRow[]>()\n  for (const row of rows) {\n    const group = byPairKey.get(row.pairKey) ?? []\n    group.push(row)\n    byPairKey.set(row.pairKey, group)\n  }\n  for (const [pairKey, group] of byPairKey) {\n    if (group.length > 1) indexByRepKey(group, pairKey, arm)\n  }\n}\n\nfunction metricValue(row: PairedArmRow, name: string): number | undefined {\n  const v = row.metrics?.[name]\n  if (v === undefined) return undefined\n  if (!Number.isFinite(v)) {\n    throw new ValidationError(\n      `comparePairedArms: non-finite value for metric '${name}' on pairKey '${row.pairKey}' (arm '${row.arm}'): ${v}`,\n    )\n  }\n  return v\n}\n"],"mappings":"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"}
+{"version":3,"file":"paired-arms-B5v-X7No.js","names":[],"sources":["../src/statistics/rank-tests.ts","../src/paired-arms.ts"],"sourcesContent":["import { ValidationError } from '../errors'\nimport { normalCdf } from '../math/normal'\nimport { lnGamma } from '../math/special-functions'\nimport {\n  assertFiniteSample,\n  binomialSignTwoSided,\n  makeRng,\n  symmetricTwoSampleSeed,\n} from './internal'\n\n// ── Rank tests: exact by default ─────────────────────────────────────\n//\n// At 3–10 repetitions per arm the binding constraint on a rank test is\n// combinatorial, not numerical. Three versus three admits only 20 splits, so\n// the attainable two-sided p-grid starts at 0.1000 and α = 0.05 is out of\n// reach at that design; a normal approximation reports 0.0495, a p-value that\n// describes no attainable outcome. No better approximation fixes this — adding\n// the tie correction moves `[0,0,0]` versus `[1,1,1]` from 0.0495 to 0.0469,\n// further from its exact 0.1000, not closer.\n//\n// So both null distributions are enumerated exactly inside bounded state and\n// work budgets, by convolution over the observed midranks (identical to\n// enumerating every split / sign pattern, and cheaper), which conditions on the\n// realised tie pattern for free. Above those budgets the default is a seeded\n// Monte Carlo permutation. The asymptotic path is never chosen automatically,\n// and asking for it inside the exact-feasible range throws.\n//\n// Every result carries `method` and `pFloor` so a downstream gate can SEE the\n// discreteness rather than infer it: a gate handed data whose `pFloor` exceeds\n// its alpha is underpowered by construction, which is a true statement about\n// the experiment, not a false one about the effect.\n\n/** How a rank test's p-value was actually computed. */\nexport type RankTestMethod = 'exact' | 'permutation' | 'asymptotic'\n\n/**\n * What the caller asks for. `'auto'` selects `'exact'` inside the enumeration\n * threshold and `'permutation'` above it, and never selects `'asymptotic'`.\n */\nexport type RankTestMethodRequest = 'auto' | 'exact' | 'asymptotic'\n\nexport interface RankTestOptions {\n  /** Default `'auto'`. `'asymptotic'` inside the exact-feasible range throws. */\n  method?: RankTestMethodRequest\n  /** Resamples on the Monte Carlo permutation path. Default 100000. */\n  permutations?: number\n  /** Seed for the permutation path. Omitted ⇒ derived from the data itself, so\n   *  the result is reproducible either way. */\n  seed?: number\n}\n\n/** Maximum dynamic-programming cells used by an exact two-sample rank test. */\nexport const MANN_WHITNEY_EXACT_MAX_STATES = 8_192\n/** Maximum inner-loop transitions used by an exact two-sample rank test. */\nexport const MANN_WHITNEY_EXACT_MAX_WORK = 250_000\n/** Non-zero differences up to which the signed-rank null is enumerated exactly. */\nexport const WILCOXON_EXACT_MAX_N = 20\n/** Resamples used when a rank test falls back to Monte Carlo permutation. */\nexport const DEFAULT_PERMUTATIONS = 100_000\n\nexport interface MannWhitneyResult {\n  /** `min(U_a, U_b)` — the conventional reported statistic. */\n  u: number\n  /** U for sample `a`. Carries the direction of the effect, which `u` discards. */\n  uA: number\n  /** Two-sided p-value. */\n  p: number\n  /** How `p` was computed. */\n  method: RankTestMethod\n  /** Smallest two-sided p this design can produce. `p` can never be below it. */\n  pFloor: number\n}\n\n/**\n * Mann-Whitney U — two independent samples, no distributional assumption.\n *\n * Exact conditional (permutation) p by default when the dynamic program fits\n * {@link MANN_WHITNEY_EXACT_MAX_STATES} cells and\n * {@link MANN_WHITNEY_EXACT_MAX_WORK} transitions, seeded Monte Carlo\n * permutation above those limits. This keeps imbalanced designs such as 1+24\n * exact without admitting expensive balanced designs merely because they have\n * the same total size. Throws on non-finite input and on `method:\n * 'asymptotic'` where an exact answer is available. Empty input yields `p = 1,\n * pFloor = 1` — no design, no attainable evidence.\n */\nexport function mannWhitneyU(\n  a: number[],\n  b: number[],\n  opts: RankTestOptions = {},\n): MannWhitneyResult {\n  assertFiniteSample('mannWhitneyU', 'a', a)\n  assertFiniteSample('mannWhitneyU', 'b', b)\n\n  const n1 = a.length\n  const n2 = b.length\n  if (n1 === 0 || n2 === 0) return { u: 0, uA: 0, p: 1, method: 'exact', pFloor: 1 }\n\n  const total = n1 + n2\n  const combined = [\n    ...a.map((v) => ({ v, fromA: true })),\n    ...b.map((v) => ({ v, fromA: false })),\n  ].sort((x, y) => x.v - y.v)\n\n  const { midranks, tieTerm } = midranksWithTieTerm(combined.map((entry) => entry.v))\n  let rankSumA = 0\n  for (let k = 0; k < total; k++) {\n    if (combined[k]!.fromA) rankSumA += midranks[k]!\n  }\n\n  const uA = rankSumA - (n1 * (n1 + 1)) / 2\n  const u = Math.min(uA, n1 * n2 - uA)\n  // Midranks are integers or halves, so doubling makes the null convolution\n  // integral. U is centred on n₁n₂/2, hence a doubled centre of n₁n₂.\n  const doubled = midranks.map((rank) => Math.round(rank * 2))\n  const doubledDeviation = Math.abs(2 * uA - n1 * n2)\n  const selectedN = Math.min(n1, n2)\n  const otherN = total - selectedN\n  const exactCost = exactTwoSampleCost(doubled, selectedN)\n\n  const designFloor = exactTwoSampleFloor(doubled, selectedN)\n  const method = selectRankTestMethod(\n    'mannWhitneyU',\n    opts.method ?? 'auto',\n    `n1=${n1}, n2=${n2}`,\n    exactCost.states <= MANN_WHITNEY_EXACT_MAX_STATES &&\n      exactCost.work <= MANN_WHITNEY_EXACT_MAX_WORK,\n    designFloor,\n    `${MANN_WHITNEY_EXACT_MAX_STATES.toLocaleString('en-US')} states and ` +\n      `${MANN_WHITNEY_EXACT_MAX_WORK.toLocaleString('en-US')} transitions`,\n  )\n\n  if (method === 'exact') {\n    const { p, pFloor } = exactTwoSampleP(doubled, selectedN, otherN, doubledDeviation)\n    return { u, uA, p, method, pFloor }\n  }\n\n  if (method === 'asymptotic') {\n    return {\n      u,\n      uA,\n      p: asymptoticTwoSidedP(doubledDeviation / 2, twoSampleSigma(n1, n2, total, tieTerm)),\n      method,\n      pFloor: designFloor,\n    }\n  }\n\n  const permutations = resolvePermutations('mannWhitneyU', opts.permutations)\n  const rng = opts.seed === undefined ? makeRng(symmetricTwoSampleSeed(a, b)) : makeRng(opts.seed)\n  let atLeastAsExtreme = 0\n  const pool = [...doubled]\n  for (let iteration = 0; iteration < permutations; iteration++) {\n    let doubledRankSum = 0\n    for (let k = 0; k < selectedN; k++) {\n      const pick = k + Math.floor(rng() * (total - k))\n      const swapped = pool[pick]!\n      pool[pick] = pool[k]!\n      pool[k] = swapped\n      doubledRankSum += swapped\n    }\n    if (\n      Math.abs(doubledRankSum - selectedN * (selectedN + 1) - selectedN * otherN) >=\n      doubledDeviation\n    ) {\n      atLeastAsExtreme++\n    }\n  }\n  const pFloor = Math.max(1 / (permutations + 1), designFloor)\n  return {\n    u,\n    uA,\n    p: Math.max((1 + atLeastAsExtreme) / (permutations + 1), pFloor),\n    method,\n    pFloor,\n  }\n}\n\nexport interface WilcoxonSignedRankResult {\n  /** W⁺, the rank sum of the positive differences. (scipy reports\n   *  `min(W⁺, W⁻)`; compare statistics only after converting.) */\n  w: number\n  /** Two-sided p-value. */\n  p: number\n  /** How `p` was computed. */\n  method: RankTestMethod\n  /** Smallest two-sided p this design can produce. */\n  pFloor: number\n  /** Non-zero differences — zero differences are dropped and carry no rank. */\n  nNonZero: number\n}\n\n/**\n * Wilcoxon signed-rank — paired, no distributional assumption on the deltas.\n *\n * Exact conditional (sign-flip) p by default at `n ≤\n * {@link WILCOXON_EXACT_MAX_N}` non-zero differences, seeded Monte Carlo\n * permutation above it. Throws on non-finite input and on `method:\n * 'asymptotic'` where an exact answer is available.\n *\n * `n` is the count of NON-ZERO differences: exact ties are dropped before\n * ranking, so a run of tied pairs shrinks the design and raises `pFloor`.\n * All-tied input yields `p = 1, pFloor = 1` — no attainable evidence, which\n * `pFloor` states rather than leaving `p = 1` to be read as a measured null.\n */\nexport function wilcoxonSignedRank(\n  before: number[],\n  after: number[],\n  opts: RankTestOptions = {},\n): WilcoxonSignedRankResult {\n  if (before.length !== after.length) {\n    throw new ValidationError(\n      `wilcoxonSignedRank: unequal sample sizes (${before.length} vs ${after.length})`,\n    )\n  }\n  assertFiniteSample('wilcoxonSignedRank', 'before', before)\n  assertFiniteSample('wilcoxonSignedRank', 'after', after)\n\n  const diffs = before.map((b, i) => after[i]! - b).filter((d) => d !== 0)\n  const n = diffs.length\n  if (n === 0) return { w: 0, p: 1, method: 'exact', pFloor: 1, nNonZero: 0 }\n\n  // When every non-zero difference has the same magnitude, the signed-rank\n  // null reduces exactly to a binomial sign distribution. This is the common\n  // pass/fail shape ({-1, 0, +1}); recognizing it avoids a 100k-draw\n  // permutation for every repeated gate evaluation while preserving the exact\n  // p-value and attainable floor. Explicit method requests still retain their\n  // documented behavior.\n  const abs = Math.abs(diffs[0]!)\n  const allEqualAbs = diffs.every((d) => Math.abs(d) === abs)\n  if ((opts.method === undefined || opts.method === 'auto') && allEqualAbs) {\n    const positive = diffs.filter((d) => d > 0).length\n    const negative = n - positive\n    return {\n      w: (positive * (n + 1)) / 2,\n      p: binomialSignTwoSided(positive, negative),\n      method: 'exact',\n      pFloor: Math.min(1, 2 ** (1 - n)),\n      nNonZero: n,\n    }\n  }\n\n  const order = diffs.map((d, i) => ({ abs: Math.abs(d), i })).sort((x, y) => x.abs - y.abs)\n  const { midranks, tieTerm } = midranksWithTieTerm(order.map((entry) => entry.abs))\n  const ranks: number[] = new Array(n)\n  for (let k = 0; k < n; k++) ranks[order[k]!.i] = midranks[k]!\n\n  let wPlus = 0\n  for (let k = 0; k < n; k++) if (diffs[k]! > 0) wPlus += ranks[k]!\n\n  // Midranks are integers or halves; doubling makes the convolution integral.\n  // Σ midranks = n(n+1)/2 whatever the tie pattern, so E[W⁺] = n(n+1)/4 and\n  // the doubled centre is n(n+1)/2.\n  const doubled = midranks.map((rank) => Math.round(rank * 2))\n  const doubledDeviation = Math.abs(2 * wPlus - (n * (n + 1)) / 2)\n\n  const designFloor = Math.min(1, 2 ** (1 - n))\n  const method = selectRankTestMethod(\n    'wilcoxonSignedRank',\n    opts.method ?? 'auto',\n    `n=${n} non-zero differences`,\n    n <= WILCOXON_EXACT_MAX_N,\n    designFloor,\n    `${WILCOXON_EXACT_MAX_N} non-zero differences`,\n  )\n\n  if (method === 'exact') {\n    const { p, pFloor } = exactSignedRankP(doubled, doubledDeviation)\n    return { w: wPlus, p, method, pFloor, nNonZero: n }\n  }\n\n  if (method === 'asymptotic') {\n    const variance = (n * (n + 1) * (2 * n + 1)) / 24 - tieTerm / 48\n    return {\n      w: wPlus,\n      p: asymptoticTwoSidedP(doubledDeviation / 2, Math.sqrt(variance)),\n      method,\n      pFloor: designFloor,\n      nNonZero: n,\n    }\n  }\n\n  const permutations = resolvePermutations('wilcoxonSignedRank', opts.permutations)\n  const rng = makeRng(opts.seed, before, after)\n  const doubledCentre = (n * (n + 1)) / 2\n  let atLeastAsExtreme = 0\n  for (let iteration = 0; iteration < permutations; iteration++) {\n    let doubledWPlus = 0\n    for (let k = 0; k < n; k++) if (rng() < 0.5) doubledWPlus += doubled[k]!\n    if (Math.abs(doubledWPlus - doubledCentre) >= doubledDeviation) atLeastAsExtreme++\n  }\n  return {\n    w: wPlus,\n    p: (1 + atLeastAsExtreme) / (permutations + 1),\n    method,\n    pFloor: Math.max(1 / (permutations + 1), designFloor),\n    nNonZero: n,\n  }\n}\n\n/**\n * Average ranks over an ASCENDING-sorted array, plus `Σ(t³ − t)` over tie\n * groups of size `t` — the correction term both asymptotic rank-test variances\n * need.\n */\nfunction midranksWithTieTerm(sorted: readonly number[]): { midranks: number[]; tieTerm: number } {\n  const midranks = new Array<number>(sorted.length)\n  let tieTerm = 0\n  let i = 0\n  while (i < sorted.length) {\n    let j = i\n    while (j < sorted.length && sorted[j] === sorted[i]) j++\n    const average = (i + 1 + j) / 2\n    for (let k = i; k < j; k++) midranks[k] = average\n    const groupSize = j - i\n    if (groupSize > 1) tieTerm += groupSize ** 3 - groupSize\n    i = j\n  }\n  return { midranks, tieTerm }\n}\n\nfunction selectRankTestMethod(\n  fn: string,\n  request: RankTestMethodRequest,\n  design: string,\n  exactFeasible: boolean,\n  designFloor: number,\n  threshold: string,\n): RankTestMethod {\n  if (request === 'auto') return exactFeasible ? 'exact' : 'permutation'\n  if (request === 'exact') {\n    if (exactFeasible) return 'exact'\n    throw new ValidationError(\n      `${fn}: method 'exact' is out of range at ${design} — enumeration is bounded by ` +\n        `${threshold}. Use 'auto' for the seeded Monte Carlo permutation, which converges ` +\n        'to the same answer.',\n    )\n  }\n  if (exactFeasible) {\n    throw new ValidationError(\n      `${fn}: method 'asymptotic' is refused at ${design} — the exact p-grid at this design ` +\n        `starts at ${formatProbability(designFloor)}, so an asymptotic p below it describes no ` +\n        `attainable outcome. Use method 'exact' (the default) or add repetitions past ` +\n        `${threshold}.`,\n    )\n  }\n  return 'asymptotic'\n}\n\nfunction resolvePermutations(fn: string, permutations: number | undefined): number {\n  if (permutations === undefined) return DEFAULT_PERMUTATIONS\n  if (!Number.isInteger(permutations) || permutations < 1) {\n    throw new ValidationError(`${fn}: permutations must be a positive integer, got ${permutations}`)\n  }\n  return permutations\n}\n\n/** Two-sided normal-approximation tail with the continuity correction. */\nfunction asymptoticTwoSidedP(deviation: number, sigma: number): number {\n  if (!(sigma > 0)) return 1\n  return Math.min(1, 2 * (1 - normalCdf(Math.max(0, deviation - 0.5) / sigma)))\n}\n\n/** SD of U under the permutation null, corrected for the realised ties. The\n *  tie term reduces (N+1) and reaches it exactly when every value is tied, so\n *  the variance floors at 0 rather than going negative. */\nfunction twoSampleSigma(n1: number, n2: number, total: number, tieTerm: number): number {\n  if (total < 2) return 0\n  const variance = ((n1 * n2) / 12) * (total + 1 - tieTerm / (total * (total - 1)))\n  return Math.sqrt(Math.max(0, variance))\n}\n\nfunction logChoose(n: number, k: number): number {\n  return lnGamma(n + 1) - lnGamma(k + 1) - lnGamma(n - k + 1)\n}\n\nfunction formatProbability(value: number): string {\n  return value >= 1e-4 || value === 0 ? value.toFixed(4) : value.toExponential(3)\n}\n\n/**\n * Exact DP allocation and loop count for this observed rank vector.\n *\n * The smaller arm is sufficient because selecting its complement produces the\n * same two-sided U deviation while using fewer rows in the state table.\n */\nfunction exactTwoSampleCost(\n  doubledRanks: readonly number[],\n  selectedN: number,\n): { states: number; work: number } {\n  const maxSum = doubledRanks.reduce((sum, rank) => sum + rank, 0)\n  let work = 0\n  for (let placed = 0; placed < doubledRanks.length; placed++) {\n    work += Math.min(selectedN, placed + 1) * (maxSum - doubledRanks[placed]! + 1)\n  }\n  return {\n    states: (selectedN + 1) * (maxSum + 1),\n    work,\n  }\n}\n\n/**\n * Smallest attainable two-sided p under the observed ties.\n *\n * Only subsets with the minimum or maximum rank sum can attain the largest\n * deviation. Their multiplicity is the number of ways to choose within the\n * tie group at each boundary, so this calculation is exact without allocating\n * the full null distribution.\n */\nfunction exactTwoSampleFloor(doubledRanks: readonly number[], selectedN: number): number {\n  const total = doubledRanks.length\n  const otherN = total - selectedN\n  const minimumSum = doubledRanks.slice(0, selectedN).reduce((sum, rank) => sum + rank, 0)\n  const maximumSum = doubledRanks.slice(total - selectedN).reduce((sum, rank) => sum + rank, 0)\n  if (minimumSum === maximumSum) return 1\n\n  const centre = selectedN * (selectedN + 1) + selectedN * otherN\n  const minimumDeviation = Math.abs(minimumSum - centre)\n  const maximumDeviation = Math.abs(maximumSum - centre)\n  const totalLogWays = logChoose(total, selectedN)\n  const minimumMass = Math.exp(\n    logExtremeSubsetWays(doubledRanks, selectedN, 'minimum') - totalLogWays,\n  )\n  const maximumMass = Math.exp(\n    logExtremeSubsetWays(doubledRanks, selectedN, 'maximum') - totalLogWays,\n  )\n\n  if (minimumDeviation > maximumDeviation) return minimumMass\n  if (maximumDeviation > minimumDeviation) return maximumMass\n  return Math.min(1, minimumMass + maximumMass)\n}\n\nfunction logExtremeSubsetWays(\n  sortedRanks: readonly number[],\n  selectedN: number,\n  side: 'minimum' | 'maximum',\n): number {\n  const boundaryIndex = side === 'minimum' ? selectedN - 1 : sortedRanks.length - selectedN\n  const boundary = sortedRanks[boundaryIndex]!\n  let first = boundaryIndex\n  let afterLast = boundaryIndex + 1\n  while (first > 0 && sortedRanks[first - 1] === boundary) first--\n  while (afterLast < sortedRanks.length && sortedRanks[afterLast] === boundary) afterLast++\n\n  const tieSize = afterLast - first\n  const fixed = side === 'minimum' ? first : sortedRanks.length - afterLast\n  return logChoose(tieSize, selectedN - fixed)\n}\n\n/**\n * Exact conditional two-sided p for the two-sample rank test.\n *\n * Convolves the observed doubled midranks into the null distribution of group\n * a's rank sum over every `C(n₁+n₂, n₁)` split — identical to enumerating the\n * splits, but `O(N·n₁·ΣR)` instead of `O(C(N,n₁)·n₁n₂)`. Conditioning on the\n * realised multiset makes the tie handling exact rather than a correction.\n *\n * The null is symmetric about `n₁n₂/2` (negating every value maps `U → n₁n₂ −\n * U` and permutes the split set onto itself), so the two-sided p is the mass\n * at least as far from the centre as the observation.\n */\nfunction exactTwoSampleP(\n  doubledRanks: readonly number[],\n  n1: number,\n  n2: number,\n  doubledDeviation: number,\n): { p: number; pFloor: number } {\n  const maxSum = doubledRanks.reduce((sum, rank) => sum + rank, 0)\n  const width = maxSum + 1\n  // ways[k][s] = number of size-k subsets whose doubled rank sum is s.\n  const ways: Float64Array[] = Array.from({ length: n1 + 1 }, () => new Float64Array(width))\n  ways[0]![0] = 1\n  let placed = 0\n  for (const rank of doubledRanks) {\n    for (let k = Math.min(n1, placed + 1); k >= 1; k--) {\n      const from = ways[k - 1]!\n      const into = ways[k]!\n      for (let sum = maxSum - rank; sum >= 0; sum--) {\n        const count = from[sum]!\n        if (count !== 0) into[sum + rank]! += count\n      }\n    }\n    placed++\n  }\n\n  // U = rankSum − n₁(n₁+1)/2, so doubled U = s − n₁(n₁+1), and the doubled\n  // centre 2·(n₁n₂/2) is n₁n₂.\n  const shift = n1 * (n1 + 1) + n1 * n2\n  const chosen = ways[n1]!\n  let totalWays = 0\n  let extremeWays = 0\n  let tailWays = 0\n  let maxDeviation = -1\n  for (let sum = 0; sum < width; sum++) {\n    const count = chosen[sum]!\n    if (count === 0) continue\n    totalWays += count\n    const deviation = Math.abs(sum - shift)\n    if (deviation >= doubledDeviation) tailWays += count\n    if (deviation > maxDeviation) {\n      maxDeviation = deviation\n      extremeWays = count\n    } else if (deviation === maxDeviation) {\n      extremeWays += count\n    }\n  }\n  return { p: tailWays / totalWays, pFloor: extremeWays / totalWays }\n}\n\n/**\n * Exact conditional two-sided p for the paired signed-rank test.\n *\n * Convolves the observed doubled absolute midranks over all `2ⁿ` sign\n * assignments in `O(n·ΣR)`. Probabilities rather than counts keep `2ⁿ` off the\n * arithmetic. The null is symmetric about `n(n+1)/4`.\n */\nfunction exactSignedRankP(\n  doubledRanks: readonly number[],\n  doubledDeviation: number,\n): { p: number; pFloor: number } {\n  const maxSum = doubledRanks.reduce((sum, rank) => sum + rank, 0)\n  const width = maxSum + 1\n  let mass = new Float64Array(width)\n  mass[0] = 1\n  for (const rank of doubledRanks) {\n    const next = new Float64Array(width)\n    for (let sum = 0; sum < width; sum++) {\n      const probability = mass[sum]!\n      if (probability === 0) continue\n      next[sum]! += probability * 0.5\n      next[sum + rank]! += probability * 0.5\n    }\n    mass = next\n  }\n\n  const centre = maxSum / 2\n  let tail = 0\n  let extreme = 0\n  let maxDeviation = -1\n  for (let sum = 0; sum < width; sum++) {\n    const probability = mass[sum]!\n    if (probability === 0) continue\n    const deviation = Math.abs(sum - centre)\n    if (deviation >= doubledDeviation) tail += probability\n    if (deviation > maxDeviation) {\n      maxDeviation = deviation\n      extreme = probability\n    } else if (deviation === maxDeviation) {\n      extreme += probability\n    }\n  }\n  return { p: Math.min(1, tail), pFloor: Math.min(1, extreme) }\n}\n","/**\n * Matched-pair arm comparison — \"did the treatment arm beat the baseline arm\n * on the SAME work items?\"\n *\n * An arm A/B over run records is only trustworthy when it is PAIRED: the same\n * task/scenario/seed evaluated under both arms, compared item-by-item, so\n * inter-item difficulty variance cancels instead of masquerading as an arm\n * effect. This module owns the two error-prone steps every consumer otherwise\n * hand-rolls:\n *\n *   1. Pairing — matching rows across arms by `pairKey` (and by `repKey`\n *      within multi-rep items), with leftovers REPORTED rather than silently\n *      dropped (a silently unbalanced pairing biases every paired statistic\n *      downstream). Pairing never keys on outcome content: matching reps by\n *      their outcomes deflates discordant-pair counts and makes McNemar\n *      anti-conservative, so reps pair only by (`pairKey`, `repKey`) identity.\n *   2. Composition — feeding the matched pairs to the correct paired\n *      estimators that already live in `statistics`: `mcnemar` +\n *      `pairedRiskDifference` for pass/fail, `pairedBootstrap` +\n *      `wilcoxonSignedRank` for continuous metrics. No statistic is\n *      re-implemented here.\n *\n * The row shape is deliberately structural — callers project a `RunRecord`\n * (or any record) into `{ pairKey, arm, pass?, metrics? }`. Arm names are\n * caller-supplied parameters; the module ships no domain literal.\n */\n\nimport { ValidationError } from './errors'\nimport type { RunRecord } from './run-record'\nimport type { McNemarResult, PairedBootstrapOptions, PairedBootstrapResult } from './statistics'\nimport {\n  mcnemar,\n  pairedBootstrap,\n  pairedRiskDifference,\n  type RiskDifferenceResult,\n  wilcoxonSignedRank,\n} from './statistics'\n\n/** One arm observation of one work item. Structural on purpose: callers\n *  project their own record type (e.g. a `RunRecord`) into this shape. */\nexport interface PairedArmRow {\n  /** Matching key — rows sharing a `pairKey` across both arms form pairs\n   *  (typically the task/scenario/seed identity). */\n  pairKey: string\n  /** Rep identity within a `pairKey` (e.g. a seed or rep number). Required on\n   *  every row of a `pairKey` that has more than one rep in either arm; reps\n   *  then pair only on exact (`pairKey`, `repKey`) match, never on outcome\n   *  content. Optional when each arm has at most one rep of the item. */\n  repKey?: string\n  /** Arm label this row was produced under. */\n  arm: string\n  /** Binary outcome; omit when the comparison has no pass/fail notion. */\n  pass?: boolean\n  /** Named numeric measurements (score, cost, latency, …). */\n  metrics?: Record<string, number>\n}\n\nexport interface PairArmsOptions {\n  /** Arm treated as the control side of every pair. */\n  baselineArm: string\n  /** Arm treated as the treatment side of every pair. */\n  treatmentArm: string\n}\n\n/** One matched (baseline, treatment) observation of the same work item. */\nexport interface MatchedPair {\n  pairKey: string\n  /** 0-based position of this pair within its `pairKey`, ordered by sorted\n   *  `repKey` (always 0 for a single-rep item). The rep identity itself is on\n   *  the rows (`baseline.repKey` / `treatment.repKey`). */\n  repIndex: number\n  baseline: PairedArmRow\n  treatment: PairedArmRow\n}\n\nexport interface PairArmsResult {\n  /** Matched pairs, ordered by (`pairKey`, `repIndex`). */\n  pairs: MatchedPair[]\n  /** Baseline rows left without a treatment counterpart — reported, never\n   *  silently dropped. */\n  unpairedBaseline: PairedArmRow[]\n  /** Treatment rows left without a baseline counterpart. */\n  unpairedTreatment: PairedArmRow[]\n}\n\n/**\n * Match rows across two arms into (baseline, treatment) pairs by `pairKey`.\n *\n * A `pairKey` with at most one row per arm pairs directly, no `repKey`\n * needed. A `pairKey` with multiple reps in either arm requires `repKey` on\n * every one of its rows, and reps pair only on exact (`pairKey`, `repKey`)\n * match — pairing is keyed purely on row identity, never on outcome content\n * (outcome-keyed matching deflates discordant counts and biases McNemar), and\n * is therefore independent of input order. Reps whose `repKey` has no\n * counterpart in the other arm, and items present in only one arm, land in\n * the unpaired lists — reported, never truncated.\n *\n * Fail-loud: throws when either named arm has zero rows (an unknown arm\n * name would otherwise read as \"everything unpaired\"), when the two arm\n * names are equal, when a multi-rep `pairKey` has a row without `repKey`, or\n * when a (`pairKey`, arm) group repeats a `repKey` (the match would be\n * ambiguous).\n */\nexport function pairArms(rows: readonly PairedArmRow[], opts: PairArmsOptions): PairArmsResult {\n  const { baselineArm, treatmentArm } = opts\n  if (baselineArm === treatmentArm) {\n    throw new ValidationError(\n      `pairArms: baselineArm and treatmentArm are both '${baselineArm}' — an arm cannot be compared to itself`,\n    )\n  }\n\n  // arm → pairKey → rows\n  const byArm = new Map<string, Map<string, PairedArmRow[]>>()\n  const armsSeen = new Set<string>()\n  for (const row of rows) {\n    armsSeen.add(row.arm)\n    if (row.arm !== baselineArm && row.arm !== treatmentArm) continue\n    const byKey = byArm.get(row.arm) ?? new Map<string, PairedArmRow[]>()\n    const group = byKey.get(row.pairKey) ?? []\n    group.push(row)\n    byKey.set(row.pairKey, group)\n    byArm.set(row.arm, byKey)\n  }\n\n  for (const arm of [baselineArm, treatmentArm]) {\n    if (!byArm.has(arm)) {\n      const seen = [...armsSeen].sort().join(', ') || '<none>'\n      throw new ValidationError(`pairArms: no rows for arm '${arm}' (arms present: ${seen})`)\n    }\n  }\n\n  const baselineByKey = byArm.get(baselineArm)!\n  const treatmentByKey = byArm.get(treatmentArm)!\n\n  const allKeys = [...new Set([...baselineByKey.keys(), ...treatmentByKey.keys()])].sort()\n  const pairs: MatchedPair[] = []\n  const unpairedBaseline: PairedArmRow[] = []\n  const unpairedTreatment: PairedArmRow[] = []\n  for (const pairKey of allKeys) {\n    const b = baselineByKey.get(pairKey) ?? []\n    const t = treatmentByKey.get(pairKey) ?? []\n\n    if (b.length <= 1 && t.length <= 1) {\n      if (b.length === 1 && t.length === 1) {\n        const baseline = b[0]!\n        const treatment = t[0]!\n        if (baseline.repKey !== undefined || treatment.repKey !== undefined) {\n          if (\n            baseline.repKey === undefined ||\n            treatment.repKey === undefined ||\n            baseline.repKey !== treatment.repKey\n          ) {\n            unpairedBaseline.push(baseline)\n            unpairedTreatment.push(treatment)\n            continue\n          }\n        }\n        pairs.push({ pairKey, repIndex: 0, baseline, treatment })\n      } else {\n        unpairedBaseline.push(...b)\n        unpairedTreatment.push(...t)\n      }\n      continue\n    }\n\n    const bByRep = indexByRepKey(b, pairKey, baselineArm)\n    const tByRep = indexByRepKey(t, pairKey, treatmentArm)\n    const repKeys = [...new Set([...bByRep.keys(), ...tByRep.keys()])].sort()\n    let repIndex = 0\n    for (const repKey of repKeys) {\n      const baseline = bByRep.get(repKey)\n      const treatment = tByRep.get(repKey)\n      if (baseline !== undefined && treatment !== undefined) {\n        pairs.push({ pairKey, repIndex: repIndex++, baseline, treatment })\n      } else if (baseline !== undefined) {\n        unpairedBaseline.push(baseline)\n      } else if (treatment !== undefined) {\n        unpairedTreatment.push(treatment)\n      }\n    }\n  }\n\n  return { pairs, unpairedBaseline, unpairedTreatment }\n}\n\n/** Index a multi-rep (pairKey, arm) group by `repKey`, enforcing that every\n *  row carries one and that no repKey repeats within the group. */\nfunction indexByRepKey(\n  group: readonly PairedArmRow[],\n  pairKey: string,\n  arm: string,\n): Map<string, PairedArmRow> {\n  const byRep = new Map<string, PairedArmRow>()\n  for (const row of group) {\n    if (row.repKey === undefined) {\n      throw new ValidationError(\n        `pairArms: pairKey '${pairKey}' has multiple reps in an arm, but a row in arm '${arm}' ` +\n          `is missing repKey — multi-rep items require an explicit repKey on every row so reps ` +\n          `pair by identity (pairing reps by outcome or by index would bias the paired statistics)`,\n      )\n    }\n    if (byRep.has(row.repKey)) {\n      throw new ValidationError(\n        `pairArms: duplicate repKey '${row.repKey}' for pairKey '${pairKey}' in arm '${arm}' — ` +\n          `(pairKey, repKey) must uniquely identify a rep within an arm`,\n      )\n    }\n    byRep.set(row.repKey, row)\n  }\n  return byRep\n}\n\n/** Paired pass/fail comparison over the pairs where BOTH sides carry `pass`. */\nexport interface PairedCorrectness {\n  /** Discordant pairs where the treatment passed and the baseline failed. */\n  b10: number\n  /** Discordant pairs where the baseline passed and the treatment failed. */\n  b01: number\n  /** Exact McNemar significance over the paired outcomes (`b === b10`, `c === b01`). */\n  mcnemar: McNemarResult\n  /** Paired effect size: p(treatment) − p(baseline) with a paired-variance CI. */\n  riskDifference: RiskDifferenceResult\n}\n\n/** Paired delta summary for one named metric (delta = treatment − baseline). */\nexport interface PairedMetricDelta {\n  name: string\n  /** Pairs where BOTH sides carry a finite value for this metric. */\n  n: number\n  /** Pairs where at least one side does not carry the metric. */\n  nMissing: number\n  /** Median paired delta, or null when `n === 0`. */\n  medianDelta: number | null\n  /** Mean paired delta, or null when `n === 0`. */\n  meanDelta: number | null\n  /** Bootstrap CI on the paired delta (`pairedBootstrap`); null when\n   *  `n === 0` — a zero-width [0, 0] interval on no data would read as a\n   *  measured tight null. */\n  bootstrapCi: PairedBootstrapResult | null\n  /** Wilcoxon signed-rank test on the paired deltas; null when `n === 0`. */\n  wilcoxon: { w: number; p: number } | null\n}\n\nexport interface ComparePairedArmsOptions extends PairArmsOptions {\n  /** Metrics to compare. Default: every metric name observed on any matched\n   *  pair, sorted. A name that appears on no pair is still reported (with\n   *  `n = 0`) so a misspelled metric is visible instead of vanishing. */\n  metricNames?: string[]\n  /** Passed through to `pairedBootstrap` — set `seed` for reproducible CIs. */\n  bootstrap?: PairedBootstrapOptions\n}\n\nexport interface PairedArmsComparison {\n  nPairs: number\n  nUnpairedBaseline: number\n  nUnpairedTreatment: number\n  /** null when no matched pair carries `pass` on both sides — a pass/fail\n   *  verdict over rows that never measured pass/fail would be fabricated. */\n  correctness: PairedCorrectness | null\n  metricDeltas: PairedMetricDelta[]\n}\n\n/**\n * Full matched-pair arm comparison: pair via {@link pairArms}, then compose\n * the paired estimators from `statistics` over the matched pairs.\n *\n * Correctness uses only the pairs where both sides carry `pass` (`mcnemar.n`\n * is that subset's size); each metric uses only the pairs where both sides\n * carry a finite value for it, with the remainder counted in `nMissing`.\n * Deltas are treatment − baseline throughout.\n *\n * Fail-loud: inherits {@link pairArms}'s unknown-arm throw, and throws on a\n * non-finite metric value — silently treating corrupt telemetry as \"metric\n * absent\" would misreport it as missing coverage.\n */\nexport function comparePairedArms(\n  rows: readonly PairedArmRow[],\n  opts: ComparePairedArmsOptions,\n): PairedArmsComparison {\n  const { pairs, unpairedBaseline, unpairedTreatment } = pairArms(rows, opts)\n\n  let correctness: PairedCorrectness | null = null\n  const baselinePass: number[] = []\n  const treatmentPass: number[] = []\n  for (const pair of pairs) {\n    if (pair.baseline.pass === undefined || pair.treatment.pass === undefined) continue\n    baselinePass.push(pair.baseline.pass ? 1 : 0)\n    treatmentPass.push(pair.treatment.pass ? 1 : 0)\n  }\n  if (baselinePass.length > 0) {\n    const mc = mcnemar(baselinePass, treatmentPass)\n    correctness = {\n      b10: mc.b,\n      b01: mc.c,\n      mcnemar: mc,\n      riskDifference: pairedRiskDifference(baselinePass, treatmentPass),\n    }\n  }\n\n  const metricNames =\n    opts.metricNames ??\n    [\n      ...new Set(\n        pairs.flatMap((p) => [\n          ...Object.keys(p.baseline.metrics ?? {}),\n          ...Object.keys(p.treatment.metrics ?? {}),\n        ]),\n      ),\n    ].sort()\n\n  const metricDeltas: PairedMetricDelta[] = metricNames.map((name) => {\n    const before: number[] = []\n    const after: number[] = []\n    let nMissing = 0\n    for (const pair of pairs) {\n      const b = metricValue(pair.baseline, name)\n      const t = metricValue(pair.treatment, name)\n      if (b === undefined || t === undefined) {\n        nMissing++\n        continue\n      }\n      before.push(b)\n      after.push(t)\n    }\n    const bootstrapCi = before.length === 0 ? null : pairedBootstrap(before, after, opts.bootstrap)\n    return {\n      name,\n      n: before.length,\n      nMissing,\n      medianDelta: bootstrapCi?.median ?? null,\n      meanDelta: bootstrapCi?.mean ?? null,\n      bootstrapCi,\n      wilcoxon: before.length === 0 ? null : wilcoxonSignedRank(before, after),\n    }\n  })\n\n  return {\n    nPairs: pairs.length,\n    nUnpairedBaseline: unpairedBaseline.length,\n    nUnpairedTreatment: unpairedTreatment.length,\n    correctness,\n    metricDeltas,\n  }\n}\n\nexport interface MatchedRunRecordPair {\n  pairKey: string\n  repKey: string\n  baseline: RunRecord\n  treatment: RunRecord\n}\n\nexport interface PairRunRecordsResult {\n  pairs: MatchedRunRecordPair[]\n  unpairedBaseline: RunRecord[]\n  unpairedTreatment: RunRecord[]\n}\n\ninterface RunRecordArmRow extends PairedArmRow {\n  run: RunRecord\n  repKey: string\n}\n\n/**\n * Pair two RunRecord arms by the identity of the evaluated work:\n * `(experimentId, scenarioId, seed)`.\n *\n * Falling back to array order, candidate id, or experiment id can compare\n * different tasks and fabricate lift. Duplicate identities throw.\n */\nexport function pairRunRecords(\n  baselineRuns: readonly RunRecord[],\n  treatmentRuns: readonly RunRecord[],\n): PairRunRecordsResult {\n  const baselineRows = runRecordArmRows(baselineRuns, 'baseline')\n  const treatmentRows = runRecordArmRows(treatmentRuns, 'treatment')\n  validateRunRecordArmRows(baselineRows, 'baseline')\n  validateRunRecordArmRows(treatmentRows, 'treatment')\n  if (baselineRows.length === 0 || treatmentRows.length === 0) {\n    return {\n      pairs: [],\n      unpairedBaseline: baselineRows.map((row) => row.run),\n      unpairedTreatment: treatmentRows.map((row) => row.run),\n    }\n  }\n\n  const result = pairArms([...baselineRows, ...treatmentRows], {\n    baselineArm: 'baseline',\n    treatmentArm: 'treatment',\n  })\n  return {\n    pairs: result.pairs.map((pair) => {\n      const baseline = pair.baseline as RunRecordArmRow\n      const treatment = pair.treatment as RunRecordArmRow\n      return {\n        pairKey: pair.pairKey,\n        repKey: baseline.repKey,\n        baseline: baseline.run,\n        treatment: treatment.run,\n      }\n    }),\n    unpairedBaseline: result.unpairedBaseline.map((row) => (row as RunRecordArmRow).run),\n    unpairedTreatment: result.unpairedTreatment.map((row) => (row as RunRecordArmRow).run),\n  }\n}\n\nfunction runRecordArmRows(runs: readonly RunRecord[], arm: string): RunRecordArmRow[] {\n  return runs.map((run) => {\n    const scenarioId = run.scenarioId.trim()\n    if (!scenarioId) {\n      throw new ValidationError(\n        `pairRunRecords: run '${run.runId}' is missing scenarioId; paired comparisons require explicit scenario identity`,\n      )\n    }\n    return {\n      pairKey: JSON.stringify([run.experimentId, scenarioId]),\n      repKey: String(run.seed),\n      arm,\n      run,\n    }\n  })\n}\n\nfunction validateRunRecordArmRows(rows: readonly RunRecordArmRow[], arm: string): void {\n  const byPairKey = new Map<string, RunRecordArmRow[]>()\n  for (const row of rows) {\n    const group = byPairKey.get(row.pairKey) ?? []\n    group.push(row)\n    byPairKey.set(row.pairKey, group)\n  }\n  for (const [pairKey, group] of byPairKey) {\n    if (group.length > 1) indexByRepKey(group, pairKey, arm)\n  }\n}\n\nfunction metricValue(row: PairedArmRow, name: string): number | undefined {\n  const v = row.metrics?.[name]\n  if (v === undefined) return undefined\n  if (!Number.isFinite(v)) {\n    throw new ValidationError(\n      `comparePairedArms: non-finite value for metric '${name}' on pairKey '${row.pairKey}' (arm '${row.arm}'): ${v}`,\n    )\n  }\n  return v\n}\n"],"mappings":"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"}

package/dist/pipelines/index.d.ts

@@ -3,7 +3,7 @@ import { a as RunFilter, s as TraceStore } from "../store-C4avFjIi.js";
 import { n as FailureClusterReport, r as failureClusterView, t as FailureCluster } from "../failure-cluster-CbgEDcFJ.js";
 import { t as DiagnosisSpan } from "../spans-D9_ehFuk.js";
 import { n as TrajectoryStep } from "../trajectory-Y1fmdlw7.js";
-import { c as computeToolUseMetrics, d as judgeAgreementView, f as BudgetBreachFinding, g as BaselineReport, h as BaselineOptions, i as toolWasteView, l as JudgeAgreementReport, m as budgetBreachView, n as ToolWasteOptions, p as BudgetBreachReport, r as ToolWasteReport, t as ToolWasteFinding, u as JudgePair } from "../tool-waste-DxlebQkx.js";
+import { c as computeToolUseMetrics, d as judgeAgreementView, f as BudgetBreachFinding, g as BaselineReport, h as BaselineOptions, i as toolWasteView, l as JudgeAgreementReport, m as budgetBreachView, n as ToolWasteOptions, p as BudgetBreachReport, r as ToolWasteReport, t as ToolWasteFinding, u as JudgePair } from "../tool-waste-Wi4g6Ekb.js";
 //#region src/pipelines/first-divergence.d.ts
 /** One step of a run, as the diff reads it. */
 export interface DiffStep {