@tangle-network/agent-eval 1.0.19 → 1.0.20

package/dist/{schema-CfoA9U_U.d.ts → schema-PDKQ_iNE.d.ts}

@@ -1,132 +1,3 @@
-/**
- * Descriptive statistics: means, bootstrap spread, correlation, and the
- * weighted judge-dimension composite. Nothing here is a significance test.
- */
-/** Weighted mean — falls back to uniform weights when omitted */
-declare function weightedMean(scores: {
-  score: number;
-  weight?: number;
-}[]): number;
-/**
- * Percentile bootstrap confidence interval on the mean of `scores`.
- *
- * Descriptive spread. It is not a significance test, and at small n its bounds
- * are anti-conservative in the same way {@link pairedBootstrap}'s are — see
- * {@link BOOTSTRAP_GATE_MIN_N}. With no `seed` the resampling is seeded from
- * the scores themselves, so the interval is reproducible either way.
- */
-declare function confidenceInterval(scores: number[], confidence?: number, opts?: {
-  seed?: number;
-  resamples?: number;
-}): {
-  mean: number;
-  lower: number;
-  upper: number;
-};
-/**
- * Two-sided Student-t critical value: the `t` with `P(|T| ≤ t) = confidence`
- * for `df` degrees of freedom. Exact, from {@link studentTQuantile}, so any
- * confidence in (0, 1) and fractional `df` are supported.
- */
-declare function studentTCritical(df: number, confidence?: number): number;
-/** One-sample Student-t interval on the mean; see {@link meanConfidenceInterval}. */
-interface MeanConfidenceInterval {
-  readonly n: number;
-  /** Null for an empty sample. */
-  readonly mean: number | null;
-  /** Sample standard deviation (n − 1 denominator); null below two samples. */
-  readonly stdev: number | null;
-  readonly low: number | null;
-  readonly high: number | null;
-  /** Two-sided Student-t critical value for df = n − 1; null below two samples. */
-  readonly criticalValue: number | null;
-}
-/**
- * Student-t confidence interval on the mean of one sample:
- * `mean ± t(df = n − 1) · s / √n`. Below two samples there is no spread to
- * estimate, so the bounds are null rather than a zero-width interval that
- * would read as certainty. Unlike {@link confidenceInterval} (a percentile
- * bootstrap), the width keeps the small-n t penalty that z = 1.96 drops.
- */
-declare function meanConfidenceInterval(samples: readonly number[], confidence?: number): MeanConfidenceInterval;
-/** Partial credit: returns 0-1 ratio of current toward target */
-declare function partialCredit(current: number, target: number): number;
-/** Distribution summary of a number series: count, extremes, quantiles, sum. */
-interface SeriesDistribution {
-  readonly n: number;
-  readonly min: number;
-  readonly p50: number;
-  readonly p90: number;
-  readonly max: number;
-  readonly sum: number;
-  readonly percentiles?: Readonly<Record<number, number>>;
-  readonly medianInterval?: {
-    readonly method: 'normal-order-statistics';
-    readonly criticalValue: number;
-    readonly sampleSize: number;
-    readonly lowRank: number;
-    readonly highRank: number;
-    readonly low: number;
-    readonly high: number;
-  };
-}
-interface SeriesDistributionOptions {
-  /** Nearest-rank percentiles on a 0–100 scale, including fractional tails. */
-  percentiles?: readonly number[];
-  /** Descriptive median rank band, not a bootstrap interval or promotion test. */
-  medianInterval?: {
-    criticalValue: number;
-  };
-}
-/**
- * Fold a number series into its distribution summary. Quantiles use the
- * nearest-rank definition — the `ceil(q·n)`-th order statistic — so every
- * reported quantile is a value from the series. Returns `null` for an empty
- * series: an empty series has no distribution, and a zero-filled summary
- * would read as a measured all-zero series.
- */
-declare function summarizeNumberSeries(values: readonly number[], options?: SeriesDistributionOptions): SeriesDistribution | null;
-/**
- * Average-rank-with-ties transform (1-indexed). Tied values receive the mean
- * of the ranks they span, the standard correction for Spearman's ρ.
- */
-declare function ranks(xs: number[]): number[];
-/**
- * Pearson product-moment correlation coefficient r ∈ [-1, 1] between two
- * equal-length series. See the edge-case contract above: NaN for n < 2 or
- * unequal lengths, 1 when both series are constant, 0 when exactly one is.
- */
-declare function pearsonR(a: number[], b: number[]): number;
-/**
- * Spearman's rank correlation ρ — Pearson over the average-rank-with-ties
- * transform of each series. Same edge-case contract as {@link pearsonR}.
- */
-declare function spearmanR(a: number[], b: number[]): number;
-interface WeightedCompositeInput {
-  /** Per-dimension scores (typically 0..1). */
-  dims: Record<string, number>;
-  /** Weight per dimension. Every weighted dimension MUST be present in
-   *  `dims` — a weight for an absent dimension is a config error and throws,
-   *  because silently dropping it would renormalise the composite onto a
-   *  different denominator than intended. */
-  weights: Record<string, number>;
-  /** Optional pass threshold; when set, the result reports `pass`. */
-  threshold?: number;
-}
-interface WeightedCompositeResult {
-  composite: number;
-  pass?: boolean;
-}
-/**
- * Weighted composite over judge dimensions: `Σ(score_d · w_d) / Σ(w_d)` across
- * the weighted dimensions. The canonical replacement for the per-consumer
- * hand-rolled composite math (tax/legal/creative/gtm each ship a copy).
- *
- * Fail-loud: throws if a weighted dimension is missing from `dims`, if any
- * weight is negative, or if the weights sum to 0 — none of which can produce
- * a meaningful composite.
- */
-declare function weightedComposite(input: WeightedCompositeInput): WeightedCompositeResult;
 type LicenseClass = 'open-weight-api' | 'restricted' | 'evaluation-only' | 'human';
 declare const LICENSE_CLASSES: readonly LicenseClass[];
 /** Classify a model or harness name; `null` when it names no known family. */
@@ -527,5 +398,5 @@ type MintedRolloutLine = Omit<RolloutLine, 'outcome'> & {
 declare function assertMinted(value: unknown, context?: string): MintedRolloutLine;
 /** `assertMinted` over a batch, naming the offending index in the error. */
 declare function assertMintedLines(values: readonly unknown[], context?: string): MintedRolloutLine[];
-export { isTrainableSplit as A, WeightedCompositeInput as B, RolloutWorkspaceCapture as C, assertRolloutLine as D, assertMintedLines as E, licenseClassOf as F, pearsonR as G, confidenceInterval as H, licenseClassOfName as I, studentTCritical as J, ranks as K, MeanConfidenceInterval as L, LICENSE_CLASSES as M, LicenseClass as N, gateGamedOutcome as O, isLicenseEligible as P, SeriesDistribution as R, RolloutTask as S, assertMinted as T, meanConfidenceInterval as U, WeightedCompositeResult as V, partialCredit as W, weightedComposite as X, summarizeNumberSeries as Y, weightedMean as Z, RolloutPolicy as _, MintedRolloutLine as a, RolloutSplit as b, ROLLOUT_ROLES as c, RolloutArtifacts as d, RolloutCapture as f, RolloutOutcome as g, RolloutLine as h, GatedEvidence as i, validateRolloutLine as j, isRolloutLine as k, ROLLOUT_SCHEMA as l, RolloutEvidenceAttempt as m, ChatRole as n, MintedRolloutOutcome as o, RolloutCostBlock as p, spearmanR as q, ChatToolCall as r, ROLLOUT_CAPTURES as s, ChatMessage as t, ROLLOUT_SPLITS as u, RolloutProvenance as v, ToolDef as w, RolloutStep as x, RolloutRole as y, SeriesDistributionOptions as z };
-//# sourceMappingURL=schema-CfoA9U_U.d.ts.map
+export { isTrainableSplit as A, RolloutWorkspaceCapture as C, assertRolloutLine as D, assertMintedLines as E, licenseClassOf as F, licenseClassOfName as I, LICENSE_CLASSES as M, LicenseClass as N, gateGamedOutcome as O, isLicenseEligible as P, RolloutTask as S, assertMinted as T, RolloutPolicy as _, MintedRolloutLine as a, RolloutSplit as b, ROLLOUT_ROLES as c, RolloutArtifacts as d, RolloutCapture as f, RolloutOutcome as g, RolloutLine as h, GatedEvidence as i, validateRolloutLine as j, isRolloutLine as k, ROLLOUT_SCHEMA as l, RolloutEvidenceAttempt as m, ChatRole as n, MintedRolloutOutcome as o, RolloutCostBlock as p, ChatToolCall as r, ROLLOUT_CAPTURES as s, ChatMessage as t, ROLLOUT_SPLITS as u, RolloutProvenance as v, ToolDef as w, RolloutStep as x, RolloutRole as y };
+//# sourceMappingURL=schema-PDKQ_iNE.d.ts.map

package/dist/schema-PDKQ_iNE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-PDKQ_iNE.d.ts","names":[],"sources":["../src/rollout/license.ts","../src/rollout/schema.ts"],"mappings":"A,KAyBY;cACC,0BAA0B;;iBAYvB,mBAAmB,kCAAkC;;iBAQrD,eAAe,MAAM,KAAK,yBAAyB;;iBASnD,kBACd,MAAM,KAAK,wBACX,mBAAmB;cCLR;;KAGD;cACC,wBAAwB;;KAUzB;cACC,yBAAyB;iBAItB,iBAAiB,OAAO;;KAK5B;cACC,2BAA2B;KAM5B;UAGK;EACf;EACA;EACA;IACE;;IAEA;;;UAIa;EACf,MAAM;EACN;;EAEA;EACA,aAAa;;EAEb;EACA;;;;;;;;EAQA;;UAGe;EACf;EACA;IACE;IACA;IACA,aAAa;;;;;;;;UASA;EACf;EACA;;EAEA;;EAEA;EACA;EACA;;;;;EAUA;;EAEA;;EAEA;;;;;;EAMA;;UAOe;;EAEf;EACA;EACA,OAAO;;EAEP;;EAEA;;UAGe;;EAEf;EACA;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,UAAU;;EAEV,gBAAgB;;UAGD;;;;;EAKf;;EAEA;;EAEA;;EAEA,SAAS;EACT;EACA;EACA;;;;;;;;;;;;;EAaA;;;;;;;;;;;;;;;;;;;;;EAqBA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;;;EAKA;;UAGe;EACf;EACA;;;EAGA;;;;;;;UAQe;;EAEf,UAAU;;EAEV;;;;;;;;;EASA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;UAIe;WACN;WACA;;WAEA;WACA;WACA;;WAEA;WACA;WACA;;UAGM;EACf;EACA,SAAS;;EAET;IAAW;IAAkB;IAAgB;IAAgB;;;EAE7D,WAAW;;EAEX,8BAA8B;;EAE9B;;;;;;;EAOA;;;;;;;EAOA,iBAAiB;;UAGF;EACf,eAAe;EACf;;;EAGA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;EACA,MAAM;EACN,MAAM;EACN,QAAQ;;EAER,UAAU;EACV,WAAW;;EAEX,QAAQ;EACR,SAAS;EACT,MAAM;EACN,WAAW;EACX,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0GE,iBAAiB,MAAM,cAAc;iBAgXrC,oBAAoB;iBAmBpB,kBACd,gBACA,2BACS,SAAS;iBAOJ,cAAc,iBAAiB,SAAS;;;;;;cAa1C;;;;;;UAOG,6BAA6B;EAC5C;;;;;;;;;;;;;;;;;;;;;;KAuBU,oBAAoB,KAAK;YACzB;EACV,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCK,aAAa,gBAAgB,mBAA2B;;iBAiBxD,kBACd,4BACA,mBACC"}

package/dist/search/index.d.ts

@@ -1,6 +1,6 @@
 import { A as SearchLedgerHash, C as SearchEdgeOperator, G as SearchSplit, H as SearchProposerKind, I as SearchNodeStatus, L as SearchOpenedEvent, T as SearchEstimateMethod, W as SearchSourceRef, i as SearchArtifactRef, j as SearchModelIdentity, l as SearchCandidateSurface, m as SearchClaim, t as NodeEstimate, y as SearchCloseReason } from "../search-ledger-types-qiYRUo_N.js";
-import { X as SearchStateView, st as SearchNode } from "../types-wDBk14lj.js";
-import { $ as ExpansionOperator, I as SearchPolicy, R as SearchPolicyView, a as SearchArtifactCodec, at as OperatorYieldSignal, ct as LensSampleSummary, et as MIN_OUTCOMES_FOR_WEIGHT, h as SearchRunResult, i as RunSearchOptions, it as OperatorYieldRow, j as SearchUnitExtension, l as SearchLane, lt as LensSignal, nt as OperatorYieldData, ot as operatorYield, rt as OperatorYieldOptions, st as LensResult, tt as OperatorOutcomeCounts, ut as summarizeSamples } from "../search-kernel-DjqaPJqL.js";
+import { X as SearchStateView, st as SearchNode } from "../types-CeMZYsNF.js";
+import { $ as ExpansionOperator, I as SearchPolicy, R as SearchPolicyView, a as SearchArtifactCodec, at as OperatorYieldSignal, ct as LensSampleSummary, et as MIN_OUTCOMES_FOR_WEIGHT, h as SearchRunResult, i as RunSearchOptions, it as OperatorYieldRow, j as SearchUnitExtension, l as SearchLane, lt as LensSignal, nt as OperatorYieldData, ot as operatorYield, rt as OperatorYieldOptions, st as LensResult, tt as OperatorOutcomeCounts, ut as summarizeSamples } from "../search-kernel-Ds2zILpY.js";
 import { AgentProfileResourceRef } from "@tangle-network/agent-interface";
 interface EditCreditOptions {
   /**

package/dist/search/index.js

@@ -1,6 +1,6 @@
 import { a as hashCanonical } from "../canonical-CicJlINA.js";
-import { c as MIN_OUTCOMES_FOR_WEIGHT, f as summarizeSamples, i as runSearch, l as operatorYield } from "../pareto-a3EOmjfe.js";
-import { _ as vectorEmbedding, a as skillCalibration, b as editCreditText, c as META_SEARCH_SCORE_SOURCE, d as searchPolicyGenome, f as landscape, g as surfaceTextEdits, h as lineageEdits, i as nextUnitExtension, l as metaSearch, n as taskMatrix, o as skillManifold, p as draftOnPlateau, s as renderMetaSearchText, t as tree, u as metaSearchScore, v as front, y as editCredit } from "../tree-DIHp6UQ0.js";
+import { c as MIN_OUTCOMES_FOR_WEIGHT, f as summarizeSamples, i as runSearch, l as operatorYield } from "../pareto-C445lnEH.js";
+import { _ as vectorEmbedding, a as skillCalibration, b as editCreditText, c as META_SEARCH_SCORE_SOURCE, d as searchPolicyGenome, f as landscape, g as surfaceTextEdits, h as lineageEdits, i as nextUnitExtension, l as metaSearch, n as taskMatrix, o as skillManifold, p as draftOnPlateau, s as renderMetaSearchText, t as tree, u as metaSearchScore, v as front, y as editCredit } from "../tree-B2y1UR8o.js";
 // src/search/nested-search.ts
 /** The deterministic id of the inner search one outer cell attempt runs. */
 function nestedSearchId(containment) {

package/dist/{search-kernel-DjqaPJqL.d.ts → search-kernel-Ds2zILpY.d.ts}

@@ -1,9 +1,9 @@
 import { t as CostLedger } from "./cost-ledger-Czro9wmo.js";
 import { a as RunRecord } from "./run-record-D2BFMPGl.js";
-import { a as PairedPromotionDecision } from "./paired-promotion-decision-BDnqepZ1.js";
 import { A as SearchLedgerHash, C as SearchEdgeOperator, E as SearchExecutionIdentity, G as SearchSplit, H as SearchProposerKind, I as SearchNodeStatus, L as SearchOpenedEvent, N as SearchNodeDecision, O as SearchLedgerEntry, P as SearchNodeRef, Q as SearchTaskOutcome, R as SearchOperationKind, S as SearchEdgeAttribution, T as SearchEstimateMethod, U as SearchReservation, V as SearchProposer, W as SearchSourceRef, Y as SearchSurfaceEvidence, Z as SearchTask, _ as SearchClaimPower, a as SearchAttemptAccounting, et as SearchTraceRef, i as SearchArtifactRef, j as SearchModelIdentity, k as SearchLedgerEvent, l as SearchCandidateSurface, m as SearchClaim, nt as EvaluationClaim, o as SearchAudit, p as SearchCellStage, t as NodeEstimate, tt as SearchUnknown, y as SearchCloseReason, z as SearchOperationRecordedEvent } from "./search-ledger-types-qiYRUo_N.js";
 import { C as LedgerTrustedHead, v as LedgerLineContext, w as LedgerTrustedHeadRemoval, x as LedgerTextStore } from "./index-lRKqfyg4.js";
-import { X as SearchStateView, dt as SearchUnitScore, j as MutableSurface, lt as SearchScoredCell, st as SearchNode } from "./types-wDBk14lj.js";
+import { X as SearchStateView, dt as SearchUnitScore, j as MutableSurface, lt as SearchScoredCell, st as SearchNode } from "./types-CeMZYsNF.js";
+import { a as PairedPromotionDecision } from "./paired-promotion-decision-BNzPfXDw.js";
 /**
  * `CampaignStorage` — the filesystem seam `runCampaign` writes through
  * (run/cell dirs, the resumability cache, per-cell artifacts, trace spans).
@@ -1166,4 +1166,4 @@ declare function searchDivergence(state: SearchStateView, nodeId: string): {
 /** Run a search to its close, or continue one from its ledger. */
 declare function runSearch<TArtifact>(options: RunSearchOptions<TArtifact>): Promise<SearchRunResult>;
 export { ExpansionOperator as $, SearchRungDecision as A, SearchHistoryReceipt as At, beam as B, openSearchLedger as Bt, searchClaimDecision as C, surfaceNode as Ct, SearchAllocationView as D, SearchHistoryCoverage as Dt, AshaOptions as E, SearchHistoryAuditSummary as Et, SearchExpansion as F, FileSearchLedger as Ft, NodePosterior as G, createRunCostLedger as Gt, incumbent as H, replaySearchLedgerText as Ht, SearchPolicy as I, OpenSearchLedgerOptions as It, estimateNode as J, SEARCH_ESTIMATOR as K, fsCampaignStorage as Kt, SearchPolicyNode as L, SearchLedger as Lt, asha as M, createSearchHistoryReceipt as Mt, uniform as N, verifySearchHistoryArtifact as Nt, SearchAllocator as O, SearchHistoryCoverageRow as Ot, AideOptions as P, verifySearchHistoryReceipt as Pt, searchPosterior as Q, SearchPolicyView as R, SearchLedgerAppendResult as Rt, planSearchClaim as S, surfaceDiff as St, verifySearchClaim as T, SearchHistoryAdmissionOptions as Tt, incumbentWithOperatorBandit as U, validateSearchLedgerEvent as Ut, crowdedFrontierParent as V, parseSearchLedgerLine as Vt, EstimateNodeCellsInput as W, CampaignStorage as Wt, searchCellSetDigest as X, estimateNodeFromCells as Y, searchEstimateMethod as Z, SEARCH_CLAIM_RULE as _, SearchRecorderOptions as _t, SearchArtifactCodec as a, OperatorYieldSignal as at, SearchClaimVerification as b, developmentClaim as bt, SearchExecutor as c, LensSampleSummary as ct, SearchProposalRequest as d, AllocateSearchCellInput as dt, MIN_OUTCOMES_FOR_WEIGHT as et, SearchProposalResult as f, RecordSearchEdgeInput as ft, PlanSearchClaimInput as g, SearchRecorder as gt, SearchRunResult as h, SearchOpening as ht, RunSearchOptions as i, OperatorYieldRow as it, SearchUnitExtension as j, assertSearchHistoryMatchesState as jt, SearchCellPlan as k, SearchHistoryPolicy as kt, SearchLane as l, LensSignal as lt, SearchProposerPort as m, SearchLedgerBinding as mt, searchDivergence as n, OperatorYieldData as nt, SearchCellResult as o, operatorYield as ot, SearchProposedChild as p, RegisterSearchNodeInput as pt, SearchPosterior as q, inMemoryCampaignStorage as qt, searchPolicyView as r, OperatorYieldOptions as rt, SearchCellWork as s, LensResult as st, runSearch as t, OperatorOutcomeCounts as tt, SearchProposalBlob as u, summarizeSamples as ut, SearchClaimDecision as v, SearchRunIdentity as vt, searchClaimReserveUsd as w, CreateSearchHistoryReceiptInput as wt, decideSearchClaim as x, searchEdgeId as xt, SearchClaimPlan as y, SettleSearchCellInput as yt, aide as z, SearchLedgerTrustedHeadMode as zt };
-//# sourceMappingURL=search-kernel-DjqaPJqL.d.ts.map
+//# sourceMappingURL=search-kernel-Ds2zILpY.d.ts.map

package/dist/{search-kernel-DjqaPJqL.d.ts.map → search-kernel-Ds2zILpY.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"search-kernel-DjqaPJqL.d.ts","names":[],"sources":["../src/campaign/storage.ts","../src/campaign/search-ledger.ts","../src/campaign/search-history-receipt.ts","../src/campaign/search-ledger-recording.ts","../src/search/lenses/shared.ts","../src/search/lenses/operator-yield.ts","../src/campaign/estimate-node.ts","../src/campaign/search-policy.ts","../src/campaign/allocation.ts","../src/campaign/search-claim.ts","../src/campaign/search-kernel-contract.ts","../src/campaign/search-kernel-policy-view.ts","../src/campaign/search-kernel.ts"],"mappings":"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"}
+{"version":3,"file":"search-kernel-Ds2zILpY.d.ts","names":[],"sources":["../src/campaign/storage.ts","../src/campaign/search-ledger.ts","../src/campaign/search-history-receipt.ts","../src/campaign/search-ledger-recording.ts","../src/search/lenses/shared.ts","../src/search/lenses/operator-yield.ts","../src/campaign/estimate-node.ts","../src/campaign/search-policy.ts","../src/campaign/allocation.ts","../src/campaign/search-claim.ts","../src/campaign/search-kernel-contract.ts","../src/campaign/search-kernel-policy-view.ts","../src/campaign/search-kernel.ts"],"mappings":"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"}

package/dist/{search-summary-RJ5zXjHN.js → search-summary-BSftVrGY.js}

@@ -1,7 +1,7 @@
-import "./paired-tests-Buh6feJ4.js";
-import { r as minimumPairsForPairedDeltaTest } from "./paired-promotion-decision-CiueaTTj.js";
+import "./statistics-DCZIC-qT.js";
+import { r as minimumPairsForPairedDeltaTest } from "./paired-promotion-decision-Nt4CkkOT.js";
 import { a as SearchLedgerError } from "./search-ledger-file-BhOdgYIt.js";
-import { w as estimateNode } from "./pareto-a3EOmjfe.js";
+import { w as estimateNode } from "./pareto-C445lnEH.js";
 // src/campaign/search-summary.ts
 /**
 * The agent's view of a search: the same projection a human reads.
@@ -129,4 +129,4 @@ function formatEstimate(estimate) {
 }
 export { searchProposerView as n, renderSearchSummary as t };
 
-//# sourceMappingURL=search-summary-RJ5zXjHN.js.map
+//# sourceMappingURL=search-summary-BSftVrGY.js.map

package/dist/{search-summary-RJ5zXjHN.js.map → search-summary-BSftVrGY.js.map}

@@ -1 +1 @@
-{"version":3,"file":"search-summary-RJ5zXjHN.js","names":[],"sources":["../src/campaign/search-summary.ts"],"sourcesContent":["/**\n * The agent's view of a search: the same projection a human reads.\n *\n * `renderSearchSummary` turns a `SearchStateView` into compact text — the\n * leading nodes with their estimates, the most recently discarded ideas with\n * why they were discarded, and a log of recent proposals — as AIDE's journal\n * summary does for its own search. `agent-eval search show <ledger>` prints\n * the same text for a terminal; `runOptimization` puts it on every\n * `ProposeContext` a proposer receives.\n *\n * `searchProposerView` is the train-only read `ProposeContext.train` carries.\n * It has no parameter that can select another split, so a proposer built on\n * it cannot reach the selection or test split even by mistake: the sealed\n * splits (§6.6 of the search-tree design) are unreachable by construction,\n * not by convention.\n */\n\nimport { minimumPairsForPairedDeltaTest } from '../paired-delta-test'\nimport { BOOTSTRAP_GATE_MIN_N } from '../statistics'\nimport { estimateNode } from './estimate-node'\nimport { SearchLedgerError } from './search-ledger-errors'\nimport type { NodeEstimate, SearchSplit } from './search-ledger-types'\nimport type { SearchNode, SearchScoredCell, SearchStateView, SearchUnitScore } from './search-state'\n\nconst DESCRIPTIVE_FROM = minimumPairsForPairedDeltaTest(0.95)\n\n/** The proposer's own read of a search: its node's cells on the train split,\n * the only split a proposer may ever see. */\nexport interface SearchProposerView {\n  readonly searchId: string\n  readonly direction: 'maximize' | 'minimize'\n  /** `nodeId`'s scored train cells. Unscored cells (errored, cancelled or in\n   * flight) are absent, never zero. */\n  scoredCells(nodeId: string): readonly SearchScoredCell[]\n  /** Per-unit train-split means of `nodeId`, in unitId order. */\n  unitScores(nodeId: string): readonly SearchUnitScore[]\n}\n\n/** The train-only view `ProposeContext.train` carries. */\nexport function searchProposerView(state: SearchStateView): SearchProposerView {\n  const header = state.header\n  if (!header) throw new SearchLedgerError(`search ${state.searchId} has not been opened`)\n  return {\n    searchId: state.searchId,\n    direction: header.objective.direction,\n    scoredCells: (nodeId) => state.scoredCells(nodeId, 'train'),\n    unitScores: (nodeId) => state.unitScores(nodeId, 'train'),\n  }\n}\n\nexport interface SearchSummaryOptions {\n  /**\n   * The split every estimate in the summary is computed on. A proposer's\n   * context must always pass `'train'`: the selection and test splits stay\n   * unread by anything a proposer's text can reach. The CLI passes the\n   * search's own ranking split, `'selection'` when the search declares one\n   * else `'train'`, matching `searchPolicyView`.\n   */\n  split: SearchSplit\n  /** Nodes shown under \"Leading\" and under \"Recently discarded\". Default 5. */\n  limit?: number\n}\n\n/**\n * `SearchState` as compact text: a header line with the search's shape and\n * spend, the leading nodes against the root with their estimates, the most\n * recently discarded nodes with the measurement that discarded them, and a\n * log of recent proposals (operator and label — the ledger's inline,\n * redacted summary of each rationale; the full rationale is a blob this\n * function never reads, so it stays a pure, I/O-free projection of the\n * state already in hand).\n */\nexport function renderSearchSummary(state: SearchStateView, options: SearchSummaryOptions): string {\n  const header = state.header\n  if (!header) return `search ${state.searchId}: not yet opened`\n  const limit = options.limit ?? 5\n  if (limit < 1 || !Number.isInteger(limit)) {\n    throw new SearchLedgerError(\n      `renderSearchSummary: limit must be a positive integer, got ${limit}`,\n    )\n  }\n  const split = options.split\n  const direction = header.objective.direction\n  const root = state.rootNodeId\n  const lines: string[] = [headerLine(state), spendLine(state), statusLine(state)]\n\n  if (root === null) {\n    lines.push('', 'No nodes yet.')\n    return lines.join('\\n')\n  }\n\n  const others = state.nodes().filter((node) => node.nodeId !== root)\n  const estimated = others\n    .filter((node) => node.status !== 'invalid')\n    .map((node) => ({ node, estimate: estimateNode(state, node.nodeId, { against: root, split }) }))\n\n  const leading = estimated\n    .filter(({ estimate }) => estimate.delta !== null)\n    .sort((a, b) => signed(b.estimate, direction) - signed(a.estimate, direction))\n    .slice(0, limit)\n  lines.push('', `Leading nodes (vs root, ${split} split):`)\n  if (leading.length === 0) lines.push('  none measured yet')\n  for (const { node, estimate } of leading)\n    lines.push(`  ${nodeLine(node)}: ${formatEstimate(estimate)}`)\n\n  const discarded = others\n    .filter(\n      (node) => node.status === 'pruned' || node.status === 'rejected' || node.status === 'invalid',\n    )\n    .sort((a, b) => b.updatedSequence - a.updatedSequence)\n    .slice(0, limit)\n  lines.push('', 'Recently discarded:')\n  if (discarded.length === 0) lines.push('  none yet')\n  for (const node of discarded) lines.push(`  ${nodeLine(node)}: ${discardLine(node)}`)\n\n  const recent = [...state.edges()].reverse().slice(0, limit)\n  lines.push('', 'Recent proposals:')\n  if (recent.length === 0) lines.push('  none yet')\n  for (const edge of recent) {\n    const childId = edge.childNodeId\n    const label = edge.label.length > 0 ? edge.label : '(no label)'\n    lines.push(`  ${edge.operator} → ${childId}: ${label}`)\n  }\n\n  return lines.join('\\n')\n}\n\nfunction headerLine(state: SearchStateView): string {\n  const header = state.header!\n  return `search ${state.searchId} — ${header.subject} — ${header.objective.direction} ${header.objective.metric}`\n}\n\nfunction spendLine(state: SearchStateView): string {\n  const { audit } = state\n  const known = audit.spend.knownUsd.toFixed(2)\n  const floor = audit.spend.floorUsd.toFixed(2)\n  const unknown = audit.spend.unknownCostCells\n  const floorPart =\n    unknown > 0\n      ? ` + floor $${floor} across ${unknown} unknown-cost cell${unknown === 1 ? '' : 's'}`\n      : ''\n  return `  ${audit.nodes} nodes · ${audit.cells.settled} settled cells (${audit.cells.open} open) · $${known} known${floorPart}`\n}\n\nfunction statusLine(state: SearchStateView): string {\n  if (!state.closed) return '  status: open'\n  const claim = state.closed.claim\n  const claimText =\n    claim === null\n      ? ''\n      : claim.decision === 'ship'\n        ? ` · claim: ship ${claim.selected}`\n        : ` · claim: ${claim.decision}`\n  return `  status: closed (${state.closed.reason})${claimText}`\n}\n\nfunction nodeLine(node: SearchNode): string {\n  const rung = node.status === 'advanced' ? ` rung ${node.rung}` : ''\n  return `${node.nodeId} (${node.status ?? 'undecided'}${rung})`\n}\n\nfunction discardLine(node: SearchNode): string {\n  const decision = node.decisions.at(-1)\n  if (!decision) return 'no decision recorded'\n  const basis = decision.basis === null ? 'no measured basis' : formatEstimate(decision.basis)\n  return `${basis} — ${decision.rule}: ${decision.reason}`\n}\n\n/** `estimate.delta` in the objective's own units; positive is always better. */\nfunction signed(estimate: NodeEstimate, direction: 'maximize' | 'minimize'): number {\n  if (estimate.delta === null) return Number.NEGATIVE_INFINITY\n  return direction === 'maximize' ? estimate.delta : -estimate.delta\n}\n\n/** The display rules of search-tree-design §6.4: no whisker below 6 shared\n * units, a dashed descriptive interval with its exact sign p from 6 to 19,\n * a decision-grade whisker from `BOOTSTRAP_GATE_MIN_N`. */\nfunction formatEstimate(estimate: NodeEstimate): string {\n  const unit = (n: number) => `${n} unit${n === 1 ? '' : 's'}`\n  if (estimate.method === 'none') return `unknown (${unit(estimate.pairs)})`\n  if (estimate.indeterminate)\n    return `no measurable difference (indeterminate, ${unit(estimate.pairs)})`\n  const delta =\n    estimate.delta === null ? 'null' : (estimate.delta >= 0 ? '+' : '') + estimate.delta.toFixed(4)\n  if (estimate.method === 'insufficient') {\n    return `Δ=${delta} (${estimate.pairs} of ${DESCRIPTIVE_FROM} units, insufficient)`\n  }\n  const interval = estimate.interval\n    ? ` [${estimate.interval[0].toFixed(4)}, ${estimate.interval[1].toFixed(4)}]`\n    : ''\n  if (estimate.method === 'descriptive') {\n    const signP = estimate.exactSignP === null ? 'null' : estimate.exactSignP.toPrecision(3)\n    return `Δ=${delta}${interval} dashed, sign p=${signP} (${unit(estimate.pairs)})`\n  }\n  return `Δ=${delta}${interval} (${unit(estimate.pairs)}, ≥${BOOTSTRAP_GATE_MIN_N})`\n}\n"],"mappings":"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"}
+{"version":3,"file":"search-summary-BSftVrGY.js","names":[],"sources":["../src/campaign/search-summary.ts"],"sourcesContent":["/**\n * The agent's view of a search: the same projection a human reads.\n *\n * `renderSearchSummary` turns a `SearchStateView` into compact text — the\n * leading nodes with their estimates, the most recently discarded ideas with\n * why they were discarded, and a log of recent proposals — as AIDE's journal\n * summary does for its own search. `agent-eval search show <ledger>` prints\n * the same text for a terminal; `runOptimization` puts it on every\n * `ProposeContext` a proposer receives.\n *\n * `searchProposerView` is the train-only read `ProposeContext.train` carries.\n * It has no parameter that can select another split, so a proposer built on\n * it cannot reach the selection or test split even by mistake: the sealed\n * splits (§6.6 of the search-tree design) are unreachable by construction,\n * not by convention.\n */\n\nimport { minimumPairsForPairedDeltaTest } from '../paired-delta-test'\nimport { BOOTSTRAP_GATE_MIN_N } from '../statistics'\nimport { estimateNode } from './estimate-node'\nimport { SearchLedgerError } from './search-ledger-errors'\nimport type { NodeEstimate, SearchSplit } from './search-ledger-types'\nimport type { SearchNode, SearchScoredCell, SearchStateView, SearchUnitScore } from './search-state'\n\nconst DESCRIPTIVE_FROM = minimumPairsForPairedDeltaTest(0.95)\n\n/** The proposer's own read of a search: its node's cells on the train split,\n * the only split a proposer may ever see. */\nexport interface SearchProposerView {\n  readonly searchId: string\n  readonly direction: 'maximize' | 'minimize'\n  /** `nodeId`'s scored train cells. Unscored cells (errored, cancelled or in\n   * flight) are absent, never zero. */\n  scoredCells(nodeId: string): readonly SearchScoredCell[]\n  /** Per-unit train-split means of `nodeId`, in unitId order. */\n  unitScores(nodeId: string): readonly SearchUnitScore[]\n}\n\n/** The train-only view `ProposeContext.train` carries. */\nexport function searchProposerView(state: SearchStateView): SearchProposerView {\n  const header = state.header\n  if (!header) throw new SearchLedgerError(`search ${state.searchId} has not been opened`)\n  return {\n    searchId: state.searchId,\n    direction: header.objective.direction,\n    scoredCells: (nodeId) => state.scoredCells(nodeId, 'train'),\n    unitScores: (nodeId) => state.unitScores(nodeId, 'train'),\n  }\n}\n\nexport interface SearchSummaryOptions {\n  /**\n   * The split every estimate in the summary is computed on. A proposer's\n   * context must always pass `'train'`: the selection and test splits stay\n   * unread by anything a proposer's text can reach. The CLI passes the\n   * search's own ranking split, `'selection'` when the search declares one\n   * else `'train'`, matching `searchPolicyView`.\n   */\n  split: SearchSplit\n  /** Nodes shown under \"Leading\" and under \"Recently discarded\". Default 5. */\n  limit?: number\n}\n\n/**\n * `SearchState` as compact text: a header line with the search's shape and\n * spend, the leading nodes against the root with their estimates, the most\n * recently discarded nodes with the measurement that discarded them, and a\n * log of recent proposals (operator and label — the ledger's inline,\n * redacted summary of each rationale; the full rationale is a blob this\n * function never reads, so it stays a pure, I/O-free projection of the\n * state already in hand).\n */\nexport function renderSearchSummary(state: SearchStateView, options: SearchSummaryOptions): string {\n  const header = state.header\n  if (!header) return `search ${state.searchId}: not yet opened`\n  const limit = options.limit ?? 5\n  if (limit < 1 || !Number.isInteger(limit)) {\n    throw new SearchLedgerError(\n      `renderSearchSummary: limit must be a positive integer, got ${limit}`,\n    )\n  }\n  const split = options.split\n  const direction = header.objective.direction\n  const root = state.rootNodeId\n  const lines: string[] = [headerLine(state), spendLine(state), statusLine(state)]\n\n  if (root === null) {\n    lines.push('', 'No nodes yet.')\n    return lines.join('\\n')\n  }\n\n  const others = state.nodes().filter((node) => node.nodeId !== root)\n  const estimated = others\n    .filter((node) => node.status !== 'invalid')\n    .map((node) => ({ node, estimate: estimateNode(state, node.nodeId, { against: root, split }) }))\n\n  const leading = estimated\n    .filter(({ estimate }) => estimate.delta !== null)\n    .sort((a, b) => signed(b.estimate, direction) - signed(a.estimate, direction))\n    .slice(0, limit)\n  lines.push('', `Leading nodes (vs root, ${split} split):`)\n  if (leading.length === 0) lines.push('  none measured yet')\n  for (const { node, estimate } of leading)\n    lines.push(`  ${nodeLine(node)}: ${formatEstimate(estimate)}`)\n\n  const discarded = others\n    .filter(\n      (node) => node.status === 'pruned' || node.status === 'rejected' || node.status === 'invalid',\n    )\n    .sort((a, b) => b.updatedSequence - a.updatedSequence)\n    .slice(0, limit)\n  lines.push('', 'Recently discarded:')\n  if (discarded.length === 0) lines.push('  none yet')\n  for (const node of discarded) lines.push(`  ${nodeLine(node)}: ${discardLine(node)}`)\n\n  const recent = [...state.edges()].reverse().slice(0, limit)\n  lines.push('', 'Recent proposals:')\n  if (recent.length === 0) lines.push('  none yet')\n  for (const edge of recent) {\n    const childId = edge.childNodeId\n    const label = edge.label.length > 0 ? edge.label : '(no label)'\n    lines.push(`  ${edge.operator} → ${childId}: ${label}`)\n  }\n\n  return lines.join('\\n')\n}\n\nfunction headerLine(state: SearchStateView): string {\n  const header = state.header!\n  return `search ${state.searchId} — ${header.subject} — ${header.objective.direction} ${header.objective.metric}`\n}\n\nfunction spendLine(state: SearchStateView): string {\n  const { audit } = state\n  const known = audit.spend.knownUsd.toFixed(2)\n  const floor = audit.spend.floorUsd.toFixed(2)\n  const unknown = audit.spend.unknownCostCells\n  const floorPart =\n    unknown > 0\n      ? ` + floor $${floor} across ${unknown} unknown-cost cell${unknown === 1 ? '' : 's'}`\n      : ''\n  return `  ${audit.nodes} nodes · ${audit.cells.settled} settled cells (${audit.cells.open} open) · $${known} known${floorPart}`\n}\n\nfunction statusLine(state: SearchStateView): string {\n  if (!state.closed) return '  status: open'\n  const claim = state.closed.claim\n  const claimText =\n    claim === null\n      ? ''\n      : claim.decision === 'ship'\n        ? ` · claim: ship ${claim.selected}`\n        : ` · claim: ${claim.decision}`\n  return `  status: closed (${state.closed.reason})${claimText}`\n}\n\nfunction nodeLine(node: SearchNode): string {\n  const rung = node.status === 'advanced' ? ` rung ${node.rung}` : ''\n  return `${node.nodeId} (${node.status ?? 'undecided'}${rung})`\n}\n\nfunction discardLine(node: SearchNode): string {\n  const decision = node.decisions.at(-1)\n  if (!decision) return 'no decision recorded'\n  const basis = decision.basis === null ? 'no measured basis' : formatEstimate(decision.basis)\n  return `${basis} — ${decision.rule}: ${decision.reason}`\n}\n\n/** `estimate.delta` in the objective's own units; positive is always better. */\nfunction signed(estimate: NodeEstimate, direction: 'maximize' | 'minimize'): number {\n  if (estimate.delta === null) return Number.NEGATIVE_INFINITY\n  return direction === 'maximize' ? estimate.delta : -estimate.delta\n}\n\n/** The display rules of search-tree-design §6.4: no whisker below 6 shared\n * units, a dashed descriptive interval with its exact sign p from 6 to 19,\n * a decision-grade whisker from `BOOTSTRAP_GATE_MIN_N`. */\nfunction formatEstimate(estimate: NodeEstimate): string {\n  const unit = (n: number) => `${n} unit${n === 1 ? '' : 's'}`\n  if (estimate.method === 'none') return `unknown (${unit(estimate.pairs)})`\n  if (estimate.indeterminate)\n    return `no measurable difference (indeterminate, ${unit(estimate.pairs)})`\n  const delta =\n    estimate.delta === null ? 'null' : (estimate.delta >= 0 ? '+' : '') + estimate.delta.toFixed(4)\n  if (estimate.method === 'insufficient') {\n    return `Δ=${delta} (${estimate.pairs} of ${DESCRIPTIVE_FROM} units, insufficient)`\n  }\n  const interval = estimate.interval\n    ? ` [${estimate.interval[0].toFixed(4)}, ${estimate.interval[1].toFixed(4)}]`\n    : ''\n  if (estimate.method === 'descriptive') {\n    const signP = estimate.exactSignP === null ? 'null' : estimate.exactSignP.toPrecision(3)\n    return `Δ=${delta}${interval} dashed, sign p=${signP} (${unit(estimate.pairs)})`\n  }\n  return `Δ=${delta}${interval} (${unit(estimate.pairs)}, ≥${BOOTSTRAP_GATE_MIN_N})`\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAwBA,MAAM,mBAAmB,+BAA+B,GAAI;;AAe5D,SAAgB,mBAAmB,OAA4C;CAC7E,MAAM,SAAS,MAAM;CACrB,IAAI,CAAC,QAAQ,MAAM,IAAI,kBAAkB,UAAU,MAAM,SAAS,qBAAqB;CACvF,OAAO;EACL,UAAU,MAAM;EAChB,WAAW,OAAO,UAAU;EAC5B,cAAc,WAAW,MAAM,YAAY,QAAQ,OAAO;EAC1D,aAAa,WAAW,MAAM,WAAW,QAAQ,OAAO;CAC1D;AACF;;;;;;;;;;AAwBA,SAAgB,oBAAoB,OAAwB,SAAuC;CACjG,MAAM,SAAS,MAAM;CACrB,IAAI,CAAC,QAAQ,OAAO,UAAU,MAAM,SAAS;CAC7C,MAAM,QAAQ,QAAQ,SAAS;CAC/B,IAAI,QAAQ,KAAK,CAAC,OAAO,UAAU,KAAK,GACtC,MAAM,IAAI,kBACR,8DAA8D,OAChE;CAEF,MAAM,QAAQ,QAAQ;CACtB,MAAM,YAAY,OAAO,UAAU;CACnC,MAAM,OAAO,MAAM;CACnB,MAAM,QAAkB;EAAC,WAAW,KAAK;EAAG,UAAU,KAAK;EAAG,WAAW,KAAK;CAAC;CAE/E,IAAI,SAAS,MAAM;EACjB,MAAM,KAAK,IAAI,eAAe;EAC9B,OAAO,MAAM,KAAK,IAAI;CACxB;CAEA,MAAM,SAAS,MAAM,MAAM,CAAC,CAAC,QAAQ,SAAS,KAAK,WAAW,IAAI;CAKlE,MAAM,UAJY,OACf,QAAQ,SAAS,KAAK,WAAW,SAAS,CAAC,CAC3C,KAAK,UAAU;EAAE;EAAM,UAAU,aAAa,OAAO,KAAK,QAAQ;GAAE,SAAS;GAAM;EAAM,CAAC;CAAE,EAEvE,CAAC,CACtB,QAAQ,EAAE,eAAe,SAAS,UAAU,IAAI,CAAC,CACjD,MAAM,GAAG,MAAM,OAAO,EAAE,UAAU,SAAS,IAAI,OAAO,EAAE,UAAU,SAAS,CAAC,CAAC,CAC7E,MAAM,GAAG,KAAK;CACjB,MAAM,KAAK,IAAI,2BAA2B,MAAM,SAAS;CACzD,IAAI,QAAQ,WAAW,GAAG,MAAM,KAAK,qBAAqB;CAC1D,KAAK,MAAM,EAAE,MAAM,cAAc,SAC/B,MAAM,KAAK,KAAK,SAAS,IAAI,EAAE,IAAI,eAAe,QAAQ,GAAG;CAE/D,MAAM,YAAY,OACf,QACE,SAAS,KAAK,WAAW,YAAY,KAAK,WAAW,cAAc,KAAK,WAAW,SACtF,CAAC,CACA,MAAM,GAAG,MAAM,EAAE,kBAAkB,EAAE,eAAe,CAAC,CACrD,MAAM,GAAG,KAAK;CACjB,MAAM,KAAK,IAAI,qBAAqB;CACpC,IAAI,UAAU,WAAW,GAAG,MAAM,KAAK,YAAY;CACnD,KAAK,MAAM,QAAQ,WAAW,MAAM,KAAK,KAAK,SAAS,IAAI,EAAE,IAAI,YAAY,IAAI,GAAG;CAEpF,MAAM,SAAS,CAAC,GAAG,MAAM,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,KAAK;CAC1D,MAAM,KAAK,IAAI,mBAAmB;CAClC,IAAI,OAAO,WAAW,GAAG,MAAM,KAAK,YAAY;CAChD,KAAK,MAAM,QAAQ,QAAQ;EACzB,MAAM,UAAU,KAAK;EACrB,MAAM,QAAQ,KAAK,MAAM,SAAS,IAAI,KAAK,QAAQ;EACnD,MAAM,KAAK,KAAK,KAAK,SAAS,KAAK,QAAQ,IAAI,OAAO;CACxD;CAEA,OAAO,MAAM,KAAK,IAAI;AACxB;AAEA,SAAS,WAAW,OAAgC;CAClD,MAAM,SAAS,MAAM;CACrB,OAAO,UAAU,MAAM,SAAS,KAAK,OAAO,QAAQ,KAAK,OAAO,UAAU,UAAU,GAAG,OAAO,UAAU;AAC1G;AAEA,SAAS,UAAU,OAAgC;CACjD,MAAM,EAAE,UAAU;CAClB,MAAM,QAAQ,MAAM,MAAM,SAAS,QAAQ,CAAC;CAC5C,MAAM,QAAQ,MAAM,MAAM,SAAS,QAAQ,CAAC;CAC5C,MAAM,UAAU,MAAM,MAAM;CAC5B,MAAM,YACJ,UAAU,IACN,aAAa,MAAM,UAAU,QAAQ,oBAAoB,YAAY,IAAI,KAAK,QAC9E;CACN,OAAO,KAAK,MAAM,MAAM,WAAW,MAAM,MAAM,QAAQ,kBAAkB,MAAM,MAAM,KAAK,YAAY,MAAM,QAAQ;AACtH;AAEA,SAAS,WAAW,OAAgC;CAClD,IAAI,CAAC,MAAM,QAAQ,OAAO;CAC1B,MAAM,QAAQ,MAAM,OAAO;CAC3B,MAAM,YACJ,UAAU,OACN,KACA,MAAM,aAAa,SACjB,kBAAkB,MAAM,aACxB,aAAa,MAAM;CAC3B,OAAO,qBAAqB,MAAM,OAAO,OAAO,GAAG;AACrD;AAEA,SAAS,SAAS,MAA0B;CAC1C,MAAM,OAAO,KAAK,WAAW,aAAa,SAAS,KAAK,SAAS;CACjE,OAAO,GAAG,KAAK,OAAO,IAAI,KAAK,UAAU,cAAc,KAAK;AAC9D;AAEA,SAAS,YAAY,MAA0B;CAC7C,MAAM,WAAW,KAAK,UAAU,GAAG,EAAE;CACrC,IAAI,CAAC,UAAU,OAAO;CAEtB,OAAO,GADO,SAAS,UAAU,OAAO,sBAAsB,eAAe,SAAS,KAAK,EAC3E,KAAK,SAAS,KAAK,IAAI,SAAS;AAClD;;AAGA,SAAS,OAAO,UAAwB,WAA4C;CAClF,IAAI,SAAS,UAAU,MAAM,OAAO,OAAO;CAC3C,OAAO,cAAc,aAAa,SAAS,QAAQ,CAAC,SAAS;AAC/D;;;;AAKA,SAAS,eAAe,UAAgC;CACtD,MAAM,QAAQ,MAAc,GAAG,EAAE,OAAO,MAAM,IAAI,KAAK;CACvD,IAAI,SAAS,WAAW,QAAQ,OAAO,YAAY,KAAK,SAAS,KAAK,EAAE;CACxE,IAAI,SAAS,eACX,OAAO,4CAA4C,KAAK,SAAS,KAAK,EAAE;CAC1E,MAAM,QACJ,SAAS,UAAU,OAAO,UAAU,SAAS,SAAS,IAAI,MAAM,MAAM,SAAS,MAAM,QAAQ,CAAC;CAChG,IAAI,SAAS,WAAW,gBACtB,OAAO,KAAK,MAAM,IAAI,SAAS,MAAM,MAAM,iBAAiB;CAE9D,MAAM,WAAW,SAAS,WACtB,KAAK,SAAS,SAAS,EAAE,CAAC,QAAQ,CAAC,EAAE,IAAI,SAAS,SAAS,EAAE,CAAC,QAAQ,CAAC,EAAE,KACzE;CACJ,IAAI,SAAS,WAAW,eAEtB,OAAO,KAAK,QAAQ,SAAS,kBADf,SAAS,eAAe,OAAO,SAAS,SAAS,WAAW,YAAY,CAAC,EAClC,IAAI,KAAK,SAAS,KAAK,EAAE;CAEhF,OAAO,KAAK,QAAQ,SAAS,IAAI,KAAK,SAAS,KAAK,EAAE;AACxD"}

package/dist/{sequential-Bb_pdTqG.d.ts → sequential-B9p6uoV8.d.ts}

@@ -113,6 +113,13 @@ interface SequentialCrossingHorizon {
   readonly decisionThreshold: number;
   readonly maxPairs: number;
 }
+/**
+ * Compute the minimum pair count at which even perfect, all-at-bound data can
+ * reach the evidence and decision thresholds. The calculation intentionally
+ * calls the canonical sequence implementation rather than maintaining a
+ * second approximation that can drift from its bet schedule.
+ */
+declare function sequentialCrossingHorizon(opts?: SequentialCrossingHorizonOptions): SequentialCrossingHorizon;
 interface InterimReleaseConfidenceInput {
   /**
    * One delta series per candidate (paired deltas vs comparator). Order
@@ -157,5 +164,5 @@ interface InterimReleaseConfidence {
  * every campaign tick — the recommendation is anytime-valid.
  */
 declare function evaluateInterimReleaseConfidence(input: InterimReleaseConfidenceInput): InterimReleaseConfidence;
-export { PairedEvalueStep as a, SequentialDecision as c, PairedEvalueSequence as i, evaluateInterimReleaseConfidence as l, InterimReleaseConfidenceInput as n, SequentialCrossingHorizon as o, PairedEvalueOptions as r, SequentialCrossingHorizonOptions as s, InterimReleaseConfidence as t, pairedEvalueSequence as u };
-//# sourceMappingURL=sequential-Bb_pdTqG.d.ts.map
+export { PairedEvalueStep as a, SequentialDecision as c, sequentialCrossingHorizon as d, PairedEvalueSequence as i, evaluateInterimReleaseConfidence as l, InterimReleaseConfidenceInput as n, SequentialCrossingHorizon as o, PairedEvalueOptions as r, SequentialCrossingHorizonOptions as s, InterimReleaseConfidence as t, pairedEvalueSequence as u };
+//# sourceMappingURL=sequential-B9p6uoV8.d.ts.map

package/dist/{sequential-Bb_pdTqG.d.ts.map → sequential-B9p6uoV8.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"sequential-Bb_pdTqG.d.ts","names":[],"sources":["../src/sequential.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuCY;UAEK;;;;;;EAMf;;EAEA;;;;;;EAMA;IAAS;IAAa;;;EAEtB;;UAGe;;EAEf;EACA;;EAEA;;EAEA;;EAEA;EACA;;EAEA,UAAU;;UAGK;EACf,OAAO;;EAEP,eAAe;;EAEf;;EAEA;;;;;;;;;;;iBAYc,qBACd,kBACA,OAAM,sBACL;;UA0Ec,yCACP,KAAK;;EAEb;;;;;;;;;;;;UAae;WACN;WACA;WACA;WACA;WACA;;UAgDM;;;;;EAKf,aAAa;IAAQ;IAAqB;;EAC1C;EACA;EACA;IAAS;IAAa;;;UAGP;EACf,YAAY;IACV;IACA,UAAU;IACV;IACA;IACA;IACA;IACA;IACA;;;;;;;EAOF;IAAkB,UAAU;IAAoB;;;;;;;;;iBASlC,iCACd,OAAO,gCACN"}
+{"version":3,"file":"sequential-B9p6uoV8.d.ts","names":[],"sources":["../src/sequential.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuCY;UAEK;;;;;;EAMf;;EAEA;;;;;;EAMA;IAAS;IAAa;;;EAEtB;;UAGe;;EAEf;EACA;;EAEA;;EAEA;;EAEA;EACA;;EAEA,UAAU;;UAGK;EACf,OAAO;;EAEP,eAAe;;EAEf;;EAEA;;;;;;;;;;;iBAYc,qBACd,kBACA,OAAM,sBACL;;UA0Ec,yCACP,KAAK;;EAEb;;;;;;;;;;;;UAae;WACN;WACA;WACA;WACA;WACA;;;;;;;;iBAWK,0BACd,OAAM,mCACL;UAmCc;;;;;EAKf,aAAa;IAAQ;IAAqB;;EAC1C;EACA;EACA;IAAS;IAAa;;;UAGP;EACf,YAAY;IACV;IACA,UAAU;IACV;IACA;IACA;IACA;IACA;IACA;;;;;;;EAOF;IAAkB,UAAU;IAAoB;;;;;;;;;iBASlC,iCACd,OAAO,gCACN"}

package/dist/{sequential-Bjs5roiK.js → sequential-CAksw6EU.js}

@@ -68,6 +68,36 @@ function pairedEvalueSequence(deltas, opts = {}) {
 		clipped
 	};
 }
+const MAX_SEQUENTIAL_CROSSING_PAIRS = 1e6;
+/**
+* Compute the minimum pair count at which even perfect, all-at-bound data can
+* reach the evidence and decision thresholds. The calculation intentionally
+* calls the canonical sequence implementation rather than maintaining a
+* second approximation that can drift from its bet schedule.
+*/
+function sequentialCrossingHorizon(opts = {}) {
+	const bound = opts.bound ?? 1;
+	const alpha = opts.alpha ?? .05;
+	const initialBetShrinkage = opts.initialBetShrinkage ?? .5;
+	const maxPairs = opts.maxPairs ?? 1e4;
+	assertSequentialScalarConfiguration(bound, alpha, initialBetShrinkage, "sequentialCrossingHorizon");
+	if (!Number.isSafeInteger(maxPairs) || maxPairs < 1) throw new Error("sequentialCrossingHorizon: maxPairs must be a positive safe integer");
+	if (maxPairs > MAX_SEQUENTIAL_CROSSING_PAIRS) throw new Error(`sequentialCrossingHorizon: maxPairs must be <= ${MAX_SEQUENTIAL_CROSSING_PAIRS}`);
+	const sequence = pairedEvalueSequence(Array(maxPairs).fill(bound), {
+		bound,
+		alpha,
+		initialBetShrinkage
+	});
+	const { evidenceThreshold, decisionThreshold } = sequentialThresholds(alpha);
+	const evidencePairs = sequence.steps.find((step) => step.evalue >= evidenceThreshold)?.t ?? null;
+	return Object.freeze({
+		evidencePairs,
+		decisionPairs: sequence.decisionFiredAt,
+		evidenceThreshold,
+		decisionThreshold,
+		maxPairs
+	});
+}
 /**
 * Run interim sequential analyses across many candidates at once,
 * preserving the time-uniform α guarantee for each candidate's series and
@@ -154,6 +184,6 @@ function empiricalBernsteinCs(sum, sumSq, n, bound, alpha) {
 		high: mean + radius
 	};
 }
-export { pairedEvalueSequence as n, evaluateInterimReleaseConfidence as t };
+export { pairedEvalueSequence as n, sequentialCrossingHorizon as r, evaluateInterimReleaseConfidence as t };
 
-//# sourceMappingURL=sequential-Bjs5roiK.js.map
+//# sourceMappingURL=sequential-CAksw6EU.js.map

package/dist/{sequential-Bjs5roiK.js.map → sequential-CAksw6EU.js.map}

@@ -1 +1 @@
-{"version":3,"file":"sequential-Bjs5roiK.js","names":[],"sources":["../src/sequential.ts"],"sourcesContent":["/**\n * Always-valid sequential evaluation.\n *\n * `researchReport` assumes a single pre-specified analysis. Real\n * consumers run campaigns weekly / nightly / per-PR; each new run silently\n * inflates the false-discovery rate, because the BH-FDR guarantee is for\n * the *first* look, not the 47th. Without time-uniform inference,\n * launch-decision teams either (a) don't peek, which forfeits the cost\n * advantage of stop-when-decisive, or (b) peek and pretend they didn't,\n * which forfeits scientific validity.\n *\n * This module ships **e-value-based confidence sequences** for paired\n * bounded outcomes. The methodology is the predictable plug-in betting\n * martingale of Waudby-Smith & Ramdas (2024) — provably valid at *any*\n * stopping time. Concretely:\n *\n *   For paired deltas D_1, D_2, … ∈ [-c, c] with the null H_0: E[D] ≤ 0,\n *   a betting fraction λ_i is chosen using only D_{1..i-1} (predictable\n *   plug-in), and the running e-value is\n *\n *     E_t = ∏_{i=1}^{t} (1 + λ_i · D_i)\n *\n *   E_t is a non-negative martingale under H_0 with E[E_t] ≤ 1, so by\n *   Ville's inequality, P(∃ t : E_t ≥ 1/α) ≤ α — we can reject the null\n *   at any time without inflating the type-I error.\n *\n * Combined with `runEvalCampaign`, every consumer running rolling\n * campaigns gains the ability to ship the moment evidence is decisive,\n * stop-early on dead-on-arrival variants, and accumulate evidence across\n * partial runs without spending the FDR budget. No new sweep is wasted.\n *\n * References:\n *   - Howard, S. R., Ramdas, A., McAuliffe, J., Sekhon, J. (2021).\n *     Time-uniform, nonparametric, nonasymptotic confidence sequences.\n *     Annals of Statistics, 49(2), 1055–1080.\n *   - Waudby-Smith, I., Ramdas, A. (2024). Estimating means of bounded\n *     random variables by betting. JRSS B, 86(1), 1–27.\n */\n\nexport type SequentialDecision = 'promote_now' | 'continue' | 'reject_now' | 'equivalent'\n\nexport interface PairedEvalueOptions {\n  /**\n   * Bound on |delta|. Default 1 (matching most score scales). Must satisfy\n   * c > 0; deltas outside [-c, c] are clipped with a warning attached to\n   * the return value.\n   */\n  bound?: number\n  /** Target Type-I error. Default 0.05. */\n  alpha?: number\n  /**\n   * Region of Practical Equivalence on the *mean* paired delta. When\n   * supplied, the verdict can return `'equivalent'` once the running\n   * confidence sequence on the mean is fully contained in [low, high].\n   */\n  rope?: { low: number; high: number }\n  /** Initial bet shrinkage (0 < scale ≤ 1). Default 0.5 — empirically robust. */\n  initialBetShrinkage?: number\n}\n\nexport interface PairedEvalueStep {\n  /** 1-indexed observation count. */\n  t: number\n  delta: number\n  /** Running e-value E_t = ∏ (1 + λ_i · D_i). */\n  evalue: number\n  /** Time-uniform p-value at stopping time t. */\n  pValue: number\n  /** Lower bound of the empirical Bernstein confidence sequence at level 1-α. */\n  csLow: number\n  csHigh: number\n  /** Verdict at this stopping time. */\n  decision: SequentialDecision\n}\n\nexport interface PairedEvalueSequence {\n  steps: PairedEvalueStep[]\n  /** The decision at the final step. */\n  finalDecision: SequentialDecision\n  /** Index (1-based) at which a non-`continue` decision first fired, or null. */\n  decisionFiredAt: number | null\n  /** True if any deltas were clipped to [-bound, bound]. */\n  clipped: boolean\n}\n\n/**\n * Run the paired e-value sequence over an in-order delta stream.\n *\n * Use for *streaming* / interim analyses: pass the deltas you have so\n * far, get the verdict at every prefix length. The decision is\n * monotone-stable in the sense that once `'reject_now'` or `'promote_now'`\n * fires, the verdict at later steps remains decisive (the e-value is a\n * non-negative martingale; once it crosses the threshold, it's crossed).\n */\nexport function pairedEvalueSequence(\n  deltas: number[],\n  opts: PairedEvalueOptions = {},\n): PairedEvalueSequence {\n  const c = opts.bound ?? 1\n  const alpha = opts.alpha ?? 0.05\n  const initialShrink = opts.initialBetShrinkage ?? 0.5\n  const rope = opts.rope ?? null\n  assertSequentialScalarConfiguration(c, alpha, initialShrink, 'pairedEvalueSequence')\n  if (rope && !(Number.isFinite(rope.low) && Number.isFinite(rope.high) && rope.low <= rope.high)) {\n    throw new Error('pairedEvalueSequence: rope must satisfy low ≤ high')\n  }\n  const { decisionThreshold } = sequentialThresholds(alpha)\n\n  const steps: PairedEvalueStep[] = []\n  let clipped = false\n  let evalue = 1\n  let decisionFiredAt: number | null = null\n\n  // Running statistics (using only D_{1..i-1} for the bet → predictable plug-in).\n  let sum = 0\n  let sumSq = 0\n  let count = 0\n\n  for (let i = 0; i < deltas.length; i++) {\n    let d = deltas[i]!\n    if (!Number.isFinite(d)) {\n      throw new Error(`pairedEvalueSequence: delta[${i}] must be finite`)\n    }\n    if (d < -c || d > c) {\n      d = Math.max(-c, Math.min(c, d))\n      clipped = true\n    }\n\n    // Predictable plug-in bet (positive λ tests for E[D] > 0; we run a two-sided\n    // test by tracking the symmetric e-value via |bet|).\n    // λ_i ∝ mean / (variance + bound^2). Shrink early to avoid overbetting.\n    const muHat = count === 0 ? 0 : sum / count\n    const varHat = count === 0 ? c * c : Math.max(1e-12, sumSq / count - muHat * muHat)\n    const t = i + 1\n    const shrink = initialShrink * Math.min(1, count / 32) // anneal toward 1\n    let lambda = (muHat / (varHat + c * c)) * shrink\n    // Clip to ensure 1 + λ·D > 0 for all |D| ≤ c (so the e-value stays non-negative).\n    const lambdaMax = 0.99 / c\n    if (lambda > lambdaMax) lambda = lambdaMax\n    if (lambda < -lambdaMax) lambda = -lambdaMax\n\n    evalue = evalue * (1 + lambda * d)\n    if (!Number.isFinite(evalue) || evalue < 0) evalue = 0\n\n    sum += d\n    sumSq += d * d\n    count += 1\n\n    const pValue = Math.min(1, 1 / Math.max(evalue, 1e-300))\n\n    // Empirical Bernstein confidence sequence on the mean. Howard et al.\n    // (2021), Theorem 4.4 with σ̂² the running sample variance and a\n    // calibration constant tuned for two-sided coverage at level 1 - α.\n    const cs = empiricalBernsteinCs(sum, sumSq, count, c, alpha)\n\n    let decision: SequentialDecision = 'continue'\n    if (rope && cs.low >= rope.low && cs.high <= rope.high) decision = 'equivalent'\n    else if (evalue >= decisionThreshold && muHat > 0) decision = 'promote_now'\n    else if (evalue >= decisionThreshold && muHat < 0) decision = 'reject_now'\n    else if (rope && cs.high < rope.low) decision = 'reject_now'\n\n    if (decision !== 'continue' && decisionFiredAt === null) decisionFiredAt = t\n\n    steps.push({ t, delta: d, evalue, pValue, csLow: cs.low, csHigh: cs.high, decision })\n  }\n\n  const finalDecision = steps.length === 0 ? 'continue' : steps[steps.length - 1]!.decision\n  return { steps, finalDecision, decisionFiredAt, clipped }\n}\n\n/** Configuration for the best-case reachability preflight. */\nexport interface SequentialCrossingHorizonOptions\n  extends Pick<PairedEvalueOptions, 'alpha' | 'bound' | 'initialBetShrinkage'> {\n  /** Maximum pairs to simulate before returning `null`. Default 10,000. */\n  maxPairs?: number\n}\n\n/**\n * Best-case horizons under the exact betting policy used by\n * {@link pairedEvalueSequence}.\n *\n * `evidencePairs` is the first all-at-bound pair count whose e-value reaches\n * `1/alpha`. `decisionPairs` is the first count whose actual two-sided\n * sequence verdict fires (`2/alpha` in the current policy). A design whose\n * pair cap is below either relevant horizon is undecidable by construction and\n * should be refused before model spend.\n */\nexport interface SequentialCrossingHorizon {\n  readonly evidencePairs: number | null\n  readonly decisionPairs: number | null\n  readonly evidenceThreshold: number\n  readonly decisionThreshold: number\n  readonly maxPairs: number\n}\n\nconst MAX_SEQUENTIAL_CROSSING_PAIRS = 1_000_000\n\n/**\n * Compute the minimum pair count at which even perfect, all-at-bound data can\n * reach the evidence and decision thresholds. The calculation intentionally\n * calls the canonical sequence implementation rather than maintaining a\n * second approximation that can drift from its bet schedule.\n */\nexport function sequentialCrossingHorizon(\n  opts: SequentialCrossingHorizonOptions = {},\n): SequentialCrossingHorizon {\n  const bound = opts.bound ?? 1\n  const alpha = opts.alpha ?? 0.05\n  const initialBetShrinkage = opts.initialBetShrinkage ?? 0.5\n  const maxPairs = opts.maxPairs ?? 10_000\n  assertSequentialScalarConfiguration(\n    bound,\n    alpha,\n    initialBetShrinkage,\n    'sequentialCrossingHorizon',\n  )\n  if (!Number.isSafeInteger(maxPairs) || maxPairs < 1) {\n    throw new Error('sequentialCrossingHorizon: maxPairs must be a positive safe integer')\n  }\n  if (maxPairs > MAX_SEQUENTIAL_CROSSING_PAIRS) {\n    throw new Error(\n      `sequentialCrossingHorizon: maxPairs must be <= ${MAX_SEQUENTIAL_CROSSING_PAIRS}`,\n    )\n  }\n  const sequence = pairedEvalueSequence(Array<number>(maxPairs).fill(bound), {\n    bound,\n    alpha,\n    initialBetShrinkage,\n  })\n  const { evidenceThreshold, decisionThreshold } = sequentialThresholds(alpha)\n  const evidencePairs = sequence.steps.find((step) => step.evalue >= evidenceThreshold)?.t ?? null\n  return Object.freeze({\n    evidencePairs,\n    decisionPairs: sequence.decisionFiredAt,\n    evidenceThreshold,\n    decisionThreshold,\n    maxPairs,\n  })\n}\n\nexport interface InterimReleaseConfidenceInput {\n  /**\n   * One delta series per candidate (paired deltas vs comparator). Order\n   * within a series is the order the campaigns were run.\n   */\n  deltaSeries: Array<{ candidateId: string; deltas: number[] }>\n  alpha?: number\n  bound?: number\n  rope?: { low: number; high: number }\n}\n\nexport interface InterimReleaseConfidence {\n  candidates: Array<{\n    candidateId: string\n    decision: SequentialDecision\n    decisionFiredAt: number | null\n    finalEvalue: number\n    finalPValue: number\n    pairs: number\n    csLow: number\n    csHigh: number\n  }>\n  /**\n   * Campaign-level recommendation: pick the strongest 'promote_now', else\n   * 'continue' if any candidate is still live, else 'reject_now' if every\n   * candidate is dead, else 'equivalent'.\n   */\n  recommendation: { decision: SequentialDecision; candidateId: string | null }\n}\n\n/**\n * Run interim sequential analyses across many candidates at once,\n * preserving the time-uniform α guarantee for each candidate's series and\n * synthesising a campaign-level recommendation. Designed to be called on\n * every campaign tick — the recommendation is anytime-valid.\n */\nexport function evaluateInterimReleaseConfidence(\n  input: InterimReleaseConfidenceInput,\n): InterimReleaseConfidence {\n  const candidates = input.deltaSeries.map((s) => {\n    const seq = pairedEvalueSequence(s.deltas, {\n      alpha: input.alpha,\n      bound: input.bound,\n      rope: input.rope,\n    })\n    const last = seq.steps[seq.steps.length - 1]\n    return {\n      candidateId: s.candidateId,\n      decision: seq.finalDecision,\n      decisionFiredAt: seq.decisionFiredAt,\n      finalEvalue: last?.evalue ?? 1,\n      finalPValue: last?.pValue ?? 1,\n      pairs: seq.steps.length,\n      csLow: last?.csLow ?? Number.NEGATIVE_INFINITY,\n      csHigh: last?.csHigh ?? Number.POSITIVE_INFINITY,\n    }\n  })\n\n  const promote = candidates.find((c) => c.decision === 'promote_now')\n  if (promote)\n    return {\n      candidates,\n      recommendation: { decision: 'promote_now', candidateId: promote.candidateId },\n    }\n  const live = candidates.find((c) => c.decision === 'continue')\n  if (live) return { candidates, recommendation: { decision: 'continue', candidateId: null } }\n  const equiv = candidates.find((c) => c.decision === 'equivalent')\n  if (equiv)\n    return {\n      candidates,\n      recommendation: { decision: 'equivalent', candidateId: equiv.candidateId },\n    }\n  return { candidates, recommendation: { decision: 'reject_now', candidateId: null } }\n}\n\n// ── Internals ────────────────────────────────────────────────────────────\n\nfunction assertSequentialScalarConfiguration(\n  bound: number,\n  alpha: number,\n  initialBetShrinkage: number,\n  context: string,\n): void {\n  if (!Number.isFinite(bound) || bound <= 0) {\n    throw new Error(`${context}: bound must be a finite number > 0`)\n  }\n  if (!Number.isFinite(alpha) || alpha <= 0 || alpha >= 1) {\n    throw new Error(`${context}: alpha must be a finite number in (0,1)`)\n  }\n  if (\n    !Number.isFinite(initialBetShrinkage) ||\n    initialBetShrinkage <= 0 ||\n    initialBetShrinkage > 1\n  ) {\n    throw new Error(`${context}: initialBetShrinkage must be a finite number in (0,1]`)\n  }\n}\n\nfunction sequentialThresholds(alpha: number): {\n  evidenceThreshold: number\n  decisionThreshold: number\n} {\n  return { evidenceThreshold: 1 / alpha, decisionThreshold: 2 / alpha }\n}\n\n/**\n * Empirical Bernstein confidence sequence on the mean of bounded variables.\n * Adapted from Howard et al. (2021) §4.4. Provides a time-uniform CI on\n * the running mean; valid at every stopping time.\n */\nfunction empiricalBernsteinCs(\n  sum: number,\n  sumSq: number,\n  n: number,\n  bound: number,\n  alpha: number,\n): { low: number; high: number } {\n  if (n === 0) return { low: -bound, high: bound }\n  const mean = sum / n\n  const variance = Math.max(0, sumSq / n - mean * mean)\n  // Iterated-log calibration constant. The 1.7 exponent matches the\n  // recommended choice in Howard et al. for two-sided coverage at level\n  // 1 - α with mild log-corrections; tightening further requires a\n  // tuned mixture and is out of scope.\n  const psi = Math.log(2 / alpha) + 1.7 * Math.log(Math.log(Math.max(Math.E, n)) + 1)\n  const radius = Math.sqrt((2 * variance * psi) / n) + (3 * bound * psi) / n\n  return { low: mean - radius, high: mean + radius }\n}\n"],"mappings":"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"}
+{"version":3,"file":"sequential-CAksw6EU.js","names":[],"sources":["../src/sequential.ts"],"sourcesContent":["/**\n * Always-valid sequential evaluation.\n *\n * `researchReport` assumes a single pre-specified analysis. Real\n * consumers run campaigns weekly / nightly / per-PR; each new run silently\n * inflates the false-discovery rate, because the BH-FDR guarantee is for\n * the *first* look, not the 47th. Without time-uniform inference,\n * launch-decision teams either (a) don't peek, which forfeits the cost\n * advantage of stop-when-decisive, or (b) peek and pretend they didn't,\n * which forfeits scientific validity.\n *\n * This module ships **e-value-based confidence sequences** for paired\n * bounded outcomes. The methodology is the predictable plug-in betting\n * martingale of Waudby-Smith & Ramdas (2024) — provably valid at *any*\n * stopping time. Concretely:\n *\n *   For paired deltas D_1, D_2, … ∈ [-c, c] with the null H_0: E[D] ≤ 0,\n *   a betting fraction λ_i is chosen using only D_{1..i-1} (predictable\n *   plug-in), and the running e-value is\n *\n *     E_t = ∏_{i=1}^{t} (1 + λ_i · D_i)\n *\n *   E_t is a non-negative martingale under H_0 with E[E_t] ≤ 1, so by\n *   Ville's inequality, P(∃ t : E_t ≥ 1/α) ≤ α — we can reject the null\n *   at any time without inflating the type-I error.\n *\n * Combined with `runEvalCampaign`, every consumer running rolling\n * campaigns gains the ability to ship the moment evidence is decisive,\n * stop-early on dead-on-arrival variants, and accumulate evidence across\n * partial runs without spending the FDR budget. No new sweep is wasted.\n *\n * References:\n *   - Howard, S. R., Ramdas, A., McAuliffe, J., Sekhon, J. (2021).\n *     Time-uniform, nonparametric, nonasymptotic confidence sequences.\n *     Annals of Statistics, 49(2), 1055–1080.\n *   - Waudby-Smith, I., Ramdas, A. (2024). Estimating means of bounded\n *     random variables by betting. JRSS B, 86(1), 1–27.\n */\n\nexport type SequentialDecision = 'promote_now' | 'continue' | 'reject_now' | 'equivalent'\n\nexport interface PairedEvalueOptions {\n  /**\n   * Bound on |delta|. Default 1 (matching most score scales). Must satisfy\n   * c > 0; deltas outside [-c, c] are clipped with a warning attached to\n   * the return value.\n   */\n  bound?: number\n  /** Target Type-I error. Default 0.05. */\n  alpha?: number\n  /**\n   * Region of Practical Equivalence on the *mean* paired delta. When\n   * supplied, the verdict can return `'equivalent'` once the running\n   * confidence sequence on the mean is fully contained in [low, high].\n   */\n  rope?: { low: number; high: number }\n  /** Initial bet shrinkage (0 < scale ≤ 1). Default 0.5 — empirically robust. */\n  initialBetShrinkage?: number\n}\n\nexport interface PairedEvalueStep {\n  /** 1-indexed observation count. */\n  t: number\n  delta: number\n  /** Running e-value E_t = ∏ (1 + λ_i · D_i). */\n  evalue: number\n  /** Time-uniform p-value at stopping time t. */\n  pValue: number\n  /** Lower bound of the empirical Bernstein confidence sequence at level 1-α. */\n  csLow: number\n  csHigh: number\n  /** Verdict at this stopping time. */\n  decision: SequentialDecision\n}\n\nexport interface PairedEvalueSequence {\n  steps: PairedEvalueStep[]\n  /** The decision at the final step. */\n  finalDecision: SequentialDecision\n  /** Index (1-based) at which a non-`continue` decision first fired, or null. */\n  decisionFiredAt: number | null\n  /** True if any deltas were clipped to [-bound, bound]. */\n  clipped: boolean\n}\n\n/**\n * Run the paired e-value sequence over an in-order delta stream.\n *\n * Use for *streaming* / interim analyses: pass the deltas you have so\n * far, get the verdict at every prefix length. The decision is\n * monotone-stable in the sense that once `'reject_now'` or `'promote_now'`\n * fires, the verdict at later steps remains decisive (the e-value is a\n * non-negative martingale; once it crosses the threshold, it's crossed).\n */\nexport function pairedEvalueSequence(\n  deltas: number[],\n  opts: PairedEvalueOptions = {},\n): PairedEvalueSequence {\n  const c = opts.bound ?? 1\n  const alpha = opts.alpha ?? 0.05\n  const initialShrink = opts.initialBetShrinkage ?? 0.5\n  const rope = opts.rope ?? null\n  assertSequentialScalarConfiguration(c, alpha, initialShrink, 'pairedEvalueSequence')\n  if (rope && !(Number.isFinite(rope.low) && Number.isFinite(rope.high) && rope.low <= rope.high)) {\n    throw new Error('pairedEvalueSequence: rope must satisfy low ≤ high')\n  }\n  const { decisionThreshold } = sequentialThresholds(alpha)\n\n  const steps: PairedEvalueStep[] = []\n  let clipped = false\n  let evalue = 1\n  let decisionFiredAt: number | null = null\n\n  // Running statistics (using only D_{1..i-1} for the bet → predictable plug-in).\n  let sum = 0\n  let sumSq = 0\n  let count = 0\n\n  for (let i = 0; i < deltas.length; i++) {\n    let d = deltas[i]!\n    if (!Number.isFinite(d)) {\n      throw new Error(`pairedEvalueSequence: delta[${i}] must be finite`)\n    }\n    if (d < -c || d > c) {\n      d = Math.max(-c, Math.min(c, d))\n      clipped = true\n    }\n\n    // Predictable plug-in bet (positive λ tests for E[D] > 0; we run a two-sided\n    // test by tracking the symmetric e-value via |bet|).\n    // λ_i ∝ mean / (variance + bound^2). Shrink early to avoid overbetting.\n    const muHat = count === 0 ? 0 : sum / count\n    const varHat = count === 0 ? c * c : Math.max(1e-12, sumSq / count - muHat * muHat)\n    const t = i + 1\n    const shrink = initialShrink * Math.min(1, count / 32) // anneal toward 1\n    let lambda = (muHat / (varHat + c * c)) * shrink\n    // Clip to ensure 1 + λ·D > 0 for all |D| ≤ c (so the e-value stays non-negative).\n    const lambdaMax = 0.99 / c\n    if (lambda > lambdaMax) lambda = lambdaMax\n    if (lambda < -lambdaMax) lambda = -lambdaMax\n\n    evalue = evalue * (1 + lambda * d)\n    if (!Number.isFinite(evalue) || evalue < 0) evalue = 0\n\n    sum += d\n    sumSq += d * d\n    count += 1\n\n    const pValue = Math.min(1, 1 / Math.max(evalue, 1e-300))\n\n    // Empirical Bernstein confidence sequence on the mean. Howard et al.\n    // (2021), Theorem 4.4 with σ̂² the running sample variance and a\n    // calibration constant tuned for two-sided coverage at level 1 - α.\n    const cs = empiricalBernsteinCs(sum, sumSq, count, c, alpha)\n\n    let decision: SequentialDecision = 'continue'\n    if (rope && cs.low >= rope.low && cs.high <= rope.high) decision = 'equivalent'\n    else if (evalue >= decisionThreshold && muHat > 0) decision = 'promote_now'\n    else if (evalue >= decisionThreshold && muHat < 0) decision = 'reject_now'\n    else if (rope && cs.high < rope.low) decision = 'reject_now'\n\n    if (decision !== 'continue' && decisionFiredAt === null) decisionFiredAt = t\n\n    steps.push({ t, delta: d, evalue, pValue, csLow: cs.low, csHigh: cs.high, decision })\n  }\n\n  const finalDecision = steps.length === 0 ? 'continue' : steps[steps.length - 1]!.decision\n  return { steps, finalDecision, decisionFiredAt, clipped }\n}\n\n/** Configuration for the best-case reachability preflight. */\nexport interface SequentialCrossingHorizonOptions\n  extends Pick<PairedEvalueOptions, 'alpha' | 'bound' | 'initialBetShrinkage'> {\n  /** Maximum pairs to simulate before returning `null`. Default 10,000. */\n  maxPairs?: number\n}\n\n/**\n * Best-case horizons under the exact betting policy used by\n * {@link pairedEvalueSequence}.\n *\n * `evidencePairs` is the first all-at-bound pair count whose e-value reaches\n * `1/alpha`. `decisionPairs` is the first count whose actual two-sided\n * sequence verdict fires (`2/alpha` in the current policy). A design whose\n * pair cap is below either relevant horizon is undecidable by construction and\n * should be refused before model spend.\n */\nexport interface SequentialCrossingHorizon {\n  readonly evidencePairs: number | null\n  readonly decisionPairs: number | null\n  readonly evidenceThreshold: number\n  readonly decisionThreshold: number\n  readonly maxPairs: number\n}\n\nconst MAX_SEQUENTIAL_CROSSING_PAIRS = 1_000_000\n\n/**\n * Compute the minimum pair count at which even perfect, all-at-bound data can\n * reach the evidence and decision thresholds. The calculation intentionally\n * calls the canonical sequence implementation rather than maintaining a\n * second approximation that can drift from its bet schedule.\n */\nexport function sequentialCrossingHorizon(\n  opts: SequentialCrossingHorizonOptions = {},\n): SequentialCrossingHorizon {\n  const bound = opts.bound ?? 1\n  const alpha = opts.alpha ?? 0.05\n  const initialBetShrinkage = opts.initialBetShrinkage ?? 0.5\n  const maxPairs = opts.maxPairs ?? 10_000\n  assertSequentialScalarConfiguration(\n    bound,\n    alpha,\n    initialBetShrinkage,\n    'sequentialCrossingHorizon',\n  )\n  if (!Number.isSafeInteger(maxPairs) || maxPairs < 1) {\n    throw new Error('sequentialCrossingHorizon: maxPairs must be a positive safe integer')\n  }\n  if (maxPairs > MAX_SEQUENTIAL_CROSSING_PAIRS) {\n    throw new Error(\n      `sequentialCrossingHorizon: maxPairs must be <= ${MAX_SEQUENTIAL_CROSSING_PAIRS}`,\n    )\n  }\n  const sequence = pairedEvalueSequence(Array<number>(maxPairs).fill(bound), {\n    bound,\n    alpha,\n    initialBetShrinkage,\n  })\n  const { evidenceThreshold, decisionThreshold } = sequentialThresholds(alpha)\n  const evidencePairs = sequence.steps.find((step) => step.evalue >= evidenceThreshold)?.t ?? null\n  return Object.freeze({\n    evidencePairs,\n    decisionPairs: sequence.decisionFiredAt,\n    evidenceThreshold,\n    decisionThreshold,\n    maxPairs,\n  })\n}\n\nexport interface InterimReleaseConfidenceInput {\n  /**\n   * One delta series per candidate (paired deltas vs comparator). Order\n   * within a series is the order the campaigns were run.\n   */\n  deltaSeries: Array<{ candidateId: string; deltas: number[] }>\n  alpha?: number\n  bound?: number\n  rope?: { low: number; high: number }\n}\n\nexport interface InterimReleaseConfidence {\n  candidates: Array<{\n    candidateId: string\n    decision: SequentialDecision\n    decisionFiredAt: number | null\n    finalEvalue: number\n    finalPValue: number\n    pairs: number\n    csLow: number\n    csHigh: number\n  }>\n  /**\n   * Campaign-level recommendation: pick the strongest 'promote_now', else\n   * 'continue' if any candidate is still live, else 'reject_now' if every\n   * candidate is dead, else 'equivalent'.\n   */\n  recommendation: { decision: SequentialDecision; candidateId: string | null }\n}\n\n/**\n * Run interim sequential analyses across many candidates at once,\n * preserving the time-uniform α guarantee for each candidate's series and\n * synthesising a campaign-level recommendation. Designed to be called on\n * every campaign tick — the recommendation is anytime-valid.\n */\nexport function evaluateInterimReleaseConfidence(\n  input: InterimReleaseConfidenceInput,\n): InterimReleaseConfidence {\n  const candidates = input.deltaSeries.map((s) => {\n    const seq = pairedEvalueSequence(s.deltas, {\n      alpha: input.alpha,\n      bound: input.bound,\n      rope: input.rope,\n    })\n    const last = seq.steps[seq.steps.length - 1]\n    return {\n      candidateId: s.candidateId,\n      decision: seq.finalDecision,\n      decisionFiredAt: seq.decisionFiredAt,\n      finalEvalue: last?.evalue ?? 1,\n      finalPValue: last?.pValue ?? 1,\n      pairs: seq.steps.length,\n      csLow: last?.csLow ?? Number.NEGATIVE_INFINITY,\n      csHigh: last?.csHigh ?? Number.POSITIVE_INFINITY,\n    }\n  })\n\n  const promote = candidates.find((c) => c.decision === 'promote_now')\n  if (promote)\n    return {\n      candidates,\n      recommendation: { decision: 'promote_now', candidateId: promote.candidateId },\n    }\n  const live = candidates.find((c) => c.decision === 'continue')\n  if (live) return { candidates, recommendation: { decision: 'continue', candidateId: null } }\n  const equiv = candidates.find((c) => c.decision === 'equivalent')\n  if (equiv)\n    return {\n      candidates,\n      recommendation: { decision: 'equivalent', candidateId: equiv.candidateId },\n    }\n  return { candidates, recommendation: { decision: 'reject_now', candidateId: null } }\n}\n\n// ── Internals ────────────────────────────────────────────────────────────\n\nfunction assertSequentialScalarConfiguration(\n  bound: number,\n  alpha: number,\n  initialBetShrinkage: number,\n  context: string,\n): void {\n  if (!Number.isFinite(bound) || bound <= 0) {\n    throw new Error(`${context}: bound must be a finite number > 0`)\n  }\n  if (!Number.isFinite(alpha) || alpha <= 0 || alpha >= 1) {\n    throw new Error(`${context}: alpha must be a finite number in (0,1)`)\n  }\n  if (\n    !Number.isFinite(initialBetShrinkage) ||\n    initialBetShrinkage <= 0 ||\n    initialBetShrinkage > 1\n  ) {\n    throw new Error(`${context}: initialBetShrinkage must be a finite number in (0,1]`)\n  }\n}\n\nfunction sequentialThresholds(alpha: number): {\n  evidenceThreshold: number\n  decisionThreshold: number\n} {\n  return { evidenceThreshold: 1 / alpha, decisionThreshold: 2 / alpha }\n}\n\n/**\n * Empirical Bernstein confidence sequence on the mean of bounded variables.\n * Adapted from Howard et al. (2021) §4.4. Provides a time-uniform CI on\n * the running mean; valid at every stopping time.\n */\nfunction empiricalBernsteinCs(\n  sum: number,\n  sumSq: number,\n  n: number,\n  bound: number,\n  alpha: number,\n): { low: number; high: number } {\n  if (n === 0) return { low: -bound, high: bound }\n  const mean = sum / n\n  const variance = Math.max(0, sumSq / n - mean * mean)\n  // Iterated-log calibration constant. The 1.7 exponent matches the\n  // recommended choice in Howard et al. for two-sided coverage at level\n  // 1 - α with mild log-corrections; tightening further requires a\n  // tuned mixture and is out of scope.\n  const psi = Math.log(2 / alpha) + 1.7 * Math.log(Math.log(Math.max(Math.E, n)) + 1)\n  const radius = Math.sqrt((2 * variance * psi) / n) + (3 * bound * psi) / n\n  return { low: mean - radius, high: mean + radius }\n}\n"],"mappings":"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"}

package/dist/{sequential-BPbvgzfe.js → sequential-CqG6aLWS.js}

@@ -1,7 +1,7 @@
 import { u as manifestContentDigest } from "./agent-profile-cell-CT5JYueM.js";
+import { t as eProcess } from "./statistics-DCZIC-qT.js";
 import { t as mulberry32 } from "./random-DrzcgC7F.js";
-import { t as eProcess } from "./sequential-eprocess-C1YLwFaz.js";
-import { n as aggregatePairedHoldout, o as pairHoldout } from "./statistical-heldout-NBxC7jGo.js";
+import { n as aggregatePairedHoldout, o as pairHoldout } from "./statistical-heldout-D6i58CJ5.js";
 // src/campaign/gates/sequential.ts
 /**
 * Anytime-valid sequential promotion gate — an e-process (betting
@@ -337,4 +337,4 @@ function sequentialDecide(options = {}) {
 }
 export { sequentialPairedGate as n, sequentialDecide as t };
 
-//# sourceMappingURL=sequential-BPbvgzfe.js.map
+//# sourceMappingURL=sequential-CqG6aLWS.js.map