@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/registry-oJeeI4-a.d.ts

@@ -0,0 +1,178 @@
+import { c as CostLedgerHandle } from "./cost-ledger-DbQdN3nO.js";
+import { p as ChatClient } from "./types-Cx3YUh2r.js";
+import { c as AnalystRunInputs, i as AnalystFinding, l as AnalystRunResult, n as AnalystContext, s as AnalystRunEvent, t as Analyst, u as AnalystRunSummary } from "./types-DLQx4mKU.js";
+import { i as ExactAnalystRunEvent, o as ExactAnalystRunResult, u as ExactExecutionComponentIdentity } from "./exact-types-BH1twmAJ.js";
+//#region src/analyst/registry.d.ts
+interface AnalystHooks {
+  /** Legacy runs may mutate ctx; exact runs provide a frozen observational context. */
+  onBeforeAnalyze?(args: {
+    analyst: Analyst;
+    ctx: AnalystContext;
+    runId: string;
+  }): void | Promise<void>;
+  /** After every analyst (ok | failed | skipped). Use for telemetry, ingestion, rotation. */
+  onAfterAnalyze?(args: {
+    analyst: Analyst;
+    summary: AnalystRunSummary;
+    findings: AnalystFinding[];
+    runId: string;
+  }): void | Promise<void>;
+  /**
+   * On analyst exception. Hook MAY return findings to convert the
+   * error into structured findings; the summary still reports 'failed'.
+   * Return void to keep the default empty-findings behavior.
+   */
+  onError?(args: {
+    analyst: Analyst;
+    error: Error;
+    runId: string;
+  }): AnalystFinding[] | undefined | Promise<AnalystFinding[] | undefined>;
+  /** Once after registry.run() completes. Use for final aggregation, persistence. */
+  onComplete?(args: {
+    result: AnalystRunResult;
+  }): void | Promise<void>;
+}
+interface BudgetPolicy {
+  /** Overall USD cap across the registry.run(). */
+  totalUsd?: number;
+  /** Per-analyst weight for the default allocator. Missing ids get weight 1. */
+  weights?: Record<string, number>;
+  /**
+   * Custom allocator — receives the analyst, remaining/total budget, and
+   * the count of analysts that will run. Returns the per-analyst budget
+   * (or undefined only when the run has no overall cap). Overrides weights
+   * when set.
+   */
+  allocate?: (args: {
+    analyst: Analyst;
+    totalUsd: number | undefined;
+    remainingUsd: number | undefined;
+    runningCount: number;
+  }) => number | undefined;
+}
+interface AnalystRegistryOptions {
+  /** Shared chat client passed to every LLM analyst via AnalystContext. */
+  chat?: ChatClient;
+  /** Logger callback. Defaults to a no-op. */
+  log?: (msg: string, fields?: Record<string, unknown>) => void;
+  /** Hooks invoked around analyze() — observability + customization seam. */
+  hooks?: AnalystHooks;
+  /** Required identity/config when `runExact` applies `hooks`. */
+  hooksIdentity?: ExactExecutionComponentIdentity;
+  /** Default budget when run() doesn't override. */
+  defaultBudget?: BudgetPolicy;
+  /** Required identity/config when `runExact` provides `chat`. */
+  chatIdentity?: ExactExecutionComponentIdentity;
+}
+interface RegistryRunOpts {
+  /** Restrict to a subset of registered analysts by id. */
+  only?: string[];
+  /** Skip these analysts even if registered. Useful for cheap iteration. */
+  skip?: string[];
+  /** Budget policy — totalUsd + optional weights/allocator. Falls back to options.defaultBudget. */
+  budget?: BudgetPolicy;
+  /** Active-work cap for the complete registry run. Model receipt settlement may follow. */
+  timeoutMs?: number;
+  /** Abort signal — forwarded into every analyst's context. */
+  signal?: AbortSignal;
+  /** Shared paid-call account forwarded to every analyst. */
+  costLedger?: CostLedgerHandle;
+  /** Attribution phase for calls written to `costLedger`. */
+  costPhase?: string;
+  /** Tags echoed into AnalystContext.tags — useful for tracking environment/version in findings. */
+  tags?: Record<string, string>;
+  /**
+   * Prior-run findings made available as retrieval context to every
+   * analyst via `ctx.priorFindings`. The registry forwards the slice
+   * whose `analyst_id` matches each registered analyst so a kind sees
+   * only its own history. Pass `{ '*': findings }` to broadcast to
+   * every analyst (useful when several kinds share the same historical
+   * context). For findings from this run, use `chainFindings` instead.
+   */
+  priorFindings?: ReadonlyArray<AnalystFinding> | Record<string, ReadonlyArray<AnalystFinding>>;
+  /**
+   * Pass findings produced earlier in this registry run to each later analyst
+   * via `ctx.upstreamFindings`. Registration order is dependency order.
+   * Disabled by default because independent analyst suites must opt in.
+   */
+  chainFindings?: boolean;
+}
+/** A caller-selected allocation rule for an exact analyst run. */
+type ExactAnalystBudgetPolicy = {
+  readonly kind: 'equal';
+  readonly totalUsd: number;
+} | {
+  readonly kind: 'weighted';
+  readonly totalUsd: number;
+  /** One explicit weight for every selected analyst id. */
+  readonly weights: Readonly<Record<string, number>>;
+};
+/**
+ * Complete per-run analyst policy.
+ *
+ * Every field is required. `null` explicitly disables an optional resource or context channel.
+ * `analystIds` is execution order; it is not filtered through registry insertion order.
+ * Missing-input behavior is explicit so callers cannot accidentally inherit it by omission.
+ * Exact runs are serial; more elaborate scheduling belongs in the caller's runtime.
+ */
+interface ExactRegistryRunOpts {
+  readonly analystIds: readonly string[];
+  readonly budget: ExactAnalystBudgetPolicy | null;
+  readonly totalTimeoutMs: number | null;
+  readonly signal: AbortSignal | null;
+  readonly costLedger: CostLedgerHandle | null;
+  readonly costLedgerIdentity: ExactExecutionComponentIdentity | null;
+  readonly costPhase: string | null;
+  readonly tags: Readonly<Record<string, string>> | null;
+  readonly priorFindings: ReadonlyArray<AnalystFinding> | Readonly<Record<string, ReadonlyArray<AnalystFinding>>> | null;
+  readonly chainFindings: boolean;
+  readonly missingInputMode: 'skip' | 'abort';
+  readonly applyRegistryHooks: boolean;
+  readonly useRegistryChat: boolean;
+}
+/** A post-start exact-run failure; completed work remains attached for accounting and review. */
+declare class ExactAnalystRunExecutionError extends Error {
+  readonly name: string;
+  readonly result: ExactAnalystRunResult;
+  constructor(message: string, result: ExactAnalystRunResult, options?: ErrorOptions);
+}
+declare class AnalystRegistry {
+  private readonly analysts;
+  private readonly options;
+  constructor(options?: AnalystRegistryOptions);
+  register(analyst: Analyst): void;
+  list(): ReadonlyArray<{
+    id: string;
+    description: string;
+    version: string;
+    cost: Analyst['cost'];
+  }>;
+  run(runId: string, inputs: AnalystRunInputs, runOpts?: RegistryRunOpts): Promise<AnalystRunResult>;
+  /** Run exactly the ordered analysts and complete policy supplied by the caller. */
+  runExact(runId: string, inputs: AnalystRunInputs, runOpts: ExactRegistryRunOpts): Promise<ExactAnalystRunResult>;
+  /** Streaming counterpart to {@link runExact}. */
+  runExactStream(runId: string, inputs: AnalystRunInputs, runOpts: ExactRegistryRunOpts): AsyncGenerator<ExactAnalystRunEvent, void, void>;
+  /**
+   * Streaming counterpart to `run()`. Emits `AnalystRunEvent` values
+   * in real time — `run-started`, then per-analyst `skipped` /
+   * `started` / `completed`, then a terminal `run-completed` whose
+   * payload is the full `AnalystRunResult`. UIs use this to render
+   * progress; persistence consumers use `run()` and read the result.
+   *
+   * Hooks (`onBeforeAnalyze` / `onAfterAnalyze` / `onError` /
+   * `onComplete`) fire as before — streaming is additive, not a hook
+   * replacement.
+   */
+  runStream(runId: string, inputs: AnalystRunInputs, runOpts?: RegistryRunOpts): AsyncGenerator<AnalystRunEvent, void, void>;
+  private normalizeLegacyPlan;
+  private normalizeExactPlan;
+  private executePlanStream;
+  private selectAnalysts;
+  private selectExactAnalysts;
+  private routeInput;
+}
+/** Validate the canonical exact-run policy before any analyst can start. */
+declare function assertExactRegistryRunOpts(value: unknown): asserts value is ExactRegistryRunOpts;
+//#endregion
+export { ExactAnalystBudgetPolicy as a, RegistryRunOpts as c, BudgetPolicy as i, assertExactRegistryRunOpts as l, AnalystRegistry as n, ExactAnalystRunExecutionError as o, AnalystRegistryOptions as r, ExactRegistryRunOpts as s, AnalystHooks as t };
+//# sourceMappingURL=registry-oJeeI4-a.d.ts.map

package/dist/registry-oJeeI4-a.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-oJeeI4-a.d.ts","names":[],"sources":["../src/analyst/registry.ts"],"mappings":";;;;;UAqDiB;;EAEf,iBAAiB;IACf,SAAS;IACT,KAAK;IACL;aACS;;EAEX,gBAAgB;IACd,SAAS;IACT,SAAS;IACT,UAAU;IACV;aACS;;;;;;EAMX,SAAS;IACP,SAAS;IACT,OAAO;IACP;MACE,+BAA+B,QAAQ;;EAE3C,YAAY;IAAQ,QAAQ;aAA4B;;UAGzC;;EAEf;;EAEA,UAAU;;;;;;;EAOV,YAAY;IACV,SAAS;IACT;IACA;IACA;;;UAIa;;EAEf,OAAO;;EAEP,OAAO,aAAa,SAAS;;EAE7B,QAAQ;;EAER,gBAAgB;;EAEhB,gBAAgB;;EAEhB,eAAe;;UAGA;;EAEf;;EAEA;;EAEA,SAAS;;EAET;;EAEA,SAAS;;EAET,aAAa;;EAEb;;EAEA,OAAO;;;;;;;;;EASP,gBAAgB,cAAc,kBAAkB,eAAe,cAAc;;;;;;EAM7E;;;KAIU;WAEG;WACA;;WAGA;WACA;;WAEA,SAAS,SAAS;;;;;;;;;;UAWhB;WACN;WACA,QAAQ;WACR;WACA,QAAQ;WACR,YAAY;WACZ,oBAAoB;WACpB;WACA,MAAM,SAAS;WACf,eACL,cAAc,kBACd,SAAS,eAAe,cAAc;WAEjC;WACA;WACA;WACA;;;cAqCE,sCAAsC;WACxC;WACA,QAAQ;EAEjB,YAAY,iBAAiB,QAAQ,uBAAuB,UAAU;;cAU3D;mBACM;mBACA;EAEjB,YAAY,UAAS;EAIrB,SAAS,SAAS;EAsBlB,QAAQ;IACN;IACA;IACA;IACA,MAAM;;EAUF,IACJ,eACA,QAAQ,kBACR,UAAS,kBACR,QAAQ;;EAUL,SACJ,eACA,QAAQ,kBACR,SAAS,uBACR,QAAQ;;EAQJ,eACL,eACA,QAAQ,kBACR,SAAS,uBACR,eAAe;;;;;;;;;;;;EAmBX,UACL,eACA,QAAQ,kBACR,UAAS,kBACR,eAAe;UAIV;UA8BA;UAwFO;UA2aP;UAaA;UAUA;;;iBAiGM,2BAA2B,yBAAyB,SAAS"}

package/dist/{release-report-DA2BCu5a.d.ts → release-confidence-BFRE5WSp.d.ts}

@@ -1,7 +1,182 @@
 import { o as FailureClass } from "./schema-BtVldJ3T.js";
-import { a as RunRecord, s as RunSplitTag } from "./run-record-CF4Dwpxr.js";
-import { a as DatasetScenario, o as DatasetSplit, r as DatasetManifest } from "./dataset-C8xaLXdY.js";
-import { x as GateDecision } from "./summary-report-BNR7DWTj.js";
+import { a as RunRecord, s as RunSplitTag } from "./run-record-CKiihE6f.js";
+import { i as DatasetSplit, n as DatasetManifest, r as DatasetScenario } from "./dataset-CJjKqQfA.js";
+import { b as GateDecision } from "./summary-report-CaL-Hnxt.js";
+//#region src/statistics/rank-tests.d.ts
+/** How a rank test's p-value was actually computed. */
+type RankTestMethod = 'exact' | 'permutation' | 'asymptotic';
+/**
+ * What the caller asks for. `'auto'` selects `'exact'` inside the enumeration
+ * threshold and `'permutation'` above it, and never selects `'asymptotic'`.
+ */
+type RankTestMethodRequest = 'auto' | 'exact' | 'asymptotic';
+interface RankTestOptions {
+  /** Default `'auto'`. `'asymptotic'` inside the exact-feasible range throws. */
+  method?: RankTestMethodRequest;
+  /** Resamples on the Monte Carlo permutation path. Default 100000. */
+  permutations?: number;
+  /** Seed for the permutation path. Omitted ⇒ derived from the data itself, so
+   *  the result is reproducible either way. */
+  seed?: number;
+}
+/** Maximum dynamic-programming cells used by an exact two-sample rank test. */
+declare const MANN_WHITNEY_EXACT_MAX_STATES = 8192;
+/** Maximum inner-loop transitions used by an exact two-sample rank test. */
+declare const MANN_WHITNEY_EXACT_MAX_WORK = 250000;
+/** Non-zero differences up to which the signed-rank null is enumerated exactly. */
+declare const WILCOXON_EXACT_MAX_N = 20;
+/** Resamples used when a rank test falls back to Monte Carlo permutation. */
+declare const DEFAULT_PERMUTATIONS = 100000;
+interface MannWhitneyResult {
+  /** `min(U_a, U_b)` — the conventional reported statistic. */
+  u: number;
+  /** U for sample `a`. Carries the direction of the effect, which `u` discards. */
+  uA: number;
+  /** Two-sided p-value. */
+  p: number;
+  /** How `p` was computed. */
+  method: RankTestMethod;
+  /** Smallest two-sided p this design can produce. `p` can never be below it. */
+  pFloor: number;
+}
+/**
+ * Mann-Whitney U — two independent samples, no distributional assumption.
+ *
+ * Exact conditional (permutation) p by default when the dynamic program fits
+ * {@link MANN_WHITNEY_EXACT_MAX_STATES} cells and
+ * {@link MANN_WHITNEY_EXACT_MAX_WORK} transitions, seeded Monte Carlo
+ * permutation above those limits. This keeps imbalanced designs such as 1+24
+ * exact without admitting expensive balanced designs merely because they have
+ * the same total size. Throws on non-finite input and on `method:
+ * 'asymptotic'` where an exact answer is available. Empty input yields `p = 1,
+ * pFloor = 1` — no design, no attainable evidence.
+ */
+declare function mannWhitneyU(a: number[], b: number[], opts?: RankTestOptions): MannWhitneyResult;
+interface WilcoxonSignedRankResult {
+  /** W⁺, the rank sum of the positive differences. (scipy reports
+   *  `min(W⁺, W⁻)`; compare statistics only after converting.) */
+  w: number;
+  /** Two-sided p-value. */
+  p: number;
+  /** How `p` was computed. */
+  method: RankTestMethod;
+  /** Smallest two-sided p this design can produce. */
+  pFloor: number;
+  /** Non-zero differences — zero differences are dropped and carry no rank. */
+  nNonZero: number;
+}
+/**
+ * Wilcoxon signed-rank — paired, no distributional assumption on the deltas.
+ *
+ * Exact conditional (sign-flip) p by default at `n ≤
+ * {@link WILCOXON_EXACT_MAX_N}` non-zero differences, seeded Monte Carlo
+ * permutation above it. Throws on non-finite input and on `method:
+ * 'asymptotic'` where an exact answer is available.
+ *
+ * `n` is the count of NON-ZERO differences: exact ties are dropped before
+ * ranking, so a run of tied pairs shrinks the design and raises `pFloor`.
+ * All-tied input yields `p = 1, pFloor = 1` — no attainable evidence, which
+ * `pFloor` states rather than leaving `p = 1` to be read as a measured null.
+ */
+declare function wilcoxonSignedRank(before: number[], after: number[], opts?: RankTestOptions): WilcoxonSignedRankResult;
+//#endregion
+//#region src/promotion-gate.d.ts
+/**
+ * Bootstrap-CI promotion gate.
+ *
+ * In any iterative-improvement loop (GEPA, prompt evolution, dataset
+ * curation), the question is "did this generation actually improve, or are
+ * we celebrating noise?". With small N and noisy outcomes, point-estimate
+ * deltas lie. Bootstrap confidence intervals tell the operator whether the
+ * delta is real before code or prompts get promoted.
+ *
+ * This module is pure functions — no I/O, no model calls. Easy to unit-test
+ * and to compose into any verdict gate.
+ *
+ * Default gate:
+ *   - Bootstrap mean baseline vs candidate (1k resamples).
+ *   - Compute the delta distribution; pass if the lower CI bound > 0.
+ *   - Tunable confidence (default 95%) and resample count.
+ *
+ * Verdict semantics intentionally match the existing `experiments.jsonl`
+ * vocabulary:
+ *   - ADVANCE: candidate's CI lower bound > baseline mean (real win)
+ *   - KEEP:    overlap, but candidate point estimate >= baseline (neutral)
+ *   - REVERT:  candidate's CI upper bound < baseline mean (real regression)
+ *   - INCONCLUSIVE: not enough samples or CI straddles zero with no signal
+ */
+type Verdict = 'ADVANCE' | 'KEEP' | 'REVERT' | 'INCONCLUSIVE';
+interface BootstrapResult {
+  baselineMean: number;
+  candidateMean: number;
+  /** candidateMean - baselineMean, point estimate. */
+  delta: number;
+  /** Lower bound of the (1 - alpha) CI on the delta. */
+  ciLower: number;
+  /** Upper bound of the (1 - alpha) CI on the delta. */
+  ciUpper: number;
+  /** Number of bootstrap resamples used. */
+  iterations: number;
+  alpha: number;
+  verdict: Verdict;
+}
+interface BootstrapOptions {
+  /** Confidence level alpha (default 0.05 → 95% CI). */
+  alpha?: number;
+  /** Number of resamples (default 1000). */
+  iterations?: number;
+  /**
+   * Minimum total samples (baseline + candidate) below which we always
+   * return INCONCLUSIVE — bootstrap with too few samples is meaningless.
+   * Default 6 (combined).
+   */
+  minTotalSamples?: number;
+  /** RNG seed for reproducibility. Default: Math.random. */
+  seed?: number;
+}
+/**
+ * Compute the bootstrap CI on (candidateMean - baselineMean) and a verdict.
+ *
+ * Uses simple percentile bootstrap on the difference of resampled means.
+ * That's the standard non-parametric primitive — no distributional
+ * assumptions, robust to skew, easy to reason about.
+ */
+declare function bootstrapCi(baseline: number[], candidate: number[], options?: BootstrapOptions): BootstrapResult;
+/**
+ * Judge-replay promotion gate.
+ *
+ * The cheap inner-loop judge that drives an evolution run is by definition
+ * fast and noisy. When you're about to promote a winning variant to the
+ * canonical default, you want a STRONGER judge (a more expensive model, a
+ * human grader, a separately-trained reward model) to confirm the win
+ * generalises beyond the inner loop.
+ *
+ * This helper takes raw winner + baseline outputs, scores both through the
+ * stronger judge, and applies `bootstrapCi`. ADVANCE means the stronger
+ * judge agrees the winner is real with the configured confidence. Doesn't
+ * matter what shape your "output" is — pass a string, an object, anything
+ * the judge can read.
+ */
+interface JudgeReplayGateArgs<TOutput> {
+  baselineOutputs: TOutput[];
+  candidateOutputs: TOutput[];
+  /** Stronger judge — async to allow LLM calls. Return a 0..N scalar score. */
+  judge: (output: TOutput) => Promise<number> | number;
+  alpha?: number;
+  iterations?: number;
+  /** RNG seed for reproducibility. */
+  seed?: number;
+  /** Maximum concurrent judge calls. Default 4. */
+  judgeConcurrency?: number;
+}
+/**
+ * Confirm a candidate's win with a stronger judge: score baseline and candidate outputs independently, then bootstrap a CI to verify the lift generalises beyond the inner loop.
+ */
+declare function judgeReplayGate<TOutput>(args: JudgeReplayGateArgs<TOutput>): Promise<BootstrapResult & {
+  baselineSamples: number;
+  candidateSamples: number;
+}>;
+//#endregion
 //#region src/release-confidence.d.ts
 /** Severity of an actionable finding attached to a run/trace. */
 type AsiSeverity = 'info' | 'warning' | 'error' | 'critical';
@@ -133,112 +308,5 @@ interface ReleaseConfidenceScorecard {
 declare function evaluateReleaseConfidence(input: ReleaseConfidenceInput): ReleaseConfidenceScorecard;
 declare function assertReleaseConfidence(input: ReleaseConfidenceInput): ReleaseConfidenceScorecard;
 //#endregion
-//#region src/promotion-gate.d.ts
-/**
- * Bootstrap-CI promotion gate.
- *
- * In any iterative-improvement loop (GEPA, prompt evolution, dataset
- * curation), the question is "did this generation actually improve, or are
- * we celebrating noise?". With small N and noisy outcomes, point-estimate
- * deltas lie. Bootstrap confidence intervals tell the operator whether the
- * delta is real before code or prompts get promoted.
- *
- * This module is pure functions — no I/O, no model calls. Easy to unit-test
- * and to compose into any verdict gate.
- *
- * Default gate:
- *   - Bootstrap mean baseline vs candidate (1k resamples).
- *   - Compute the delta distribution; pass if the lower CI bound > 0.
- *   - Tunable confidence (default 95%) and resample count.
- *
- * Verdict semantics intentionally match the existing `experiments.jsonl`
- * vocabulary:
- *   - ADVANCE: candidate's CI lower bound > baseline mean (real win)
- *   - KEEP:    overlap, but candidate point estimate >= baseline (neutral)
- *   - REVERT:  candidate's CI upper bound < baseline mean (real regression)
- *   - INCONCLUSIVE: not enough samples or CI straddles zero with no signal
- */
-type Verdict = 'ADVANCE' | 'KEEP' | 'REVERT' | 'INCONCLUSIVE';
-interface BootstrapResult {
-  baselineMean: number;
-  candidateMean: number;
-  /** candidateMean - baselineMean, point estimate. */
-  delta: number;
-  /** Lower bound of the (1 - alpha) CI on the delta. */
-  ciLower: number;
-  /** Upper bound of the (1 - alpha) CI on the delta. */
-  ciUpper: number;
-  /** Number of bootstrap resamples used. */
-  iterations: number;
-  alpha: number;
-  verdict: Verdict;
-}
-interface BootstrapOptions {
-  /** Confidence level alpha (default 0.05 → 95% CI). */
-  alpha?: number;
-  /** Number of resamples (default 1000). */
-  iterations?: number;
-  /**
-   * Minimum total samples (baseline + candidate) below which we always
-   * return INCONCLUSIVE — bootstrap with too few samples is meaningless.
-   * Default 6 (combined).
-   */
-  minTotalSamples?: number;
-  /** RNG seed for reproducibility. Default: Math.random. */
-  seed?: number;
-}
-/**
- * Compute the bootstrap CI on (candidateMean - baselineMean) and a verdict.
- *
- * Uses simple percentile bootstrap on the difference of resampled means.
- * That's the standard non-parametric primitive — no distributional
- * assumptions, robust to skew, easy to reason about.
- */
-declare function bootstrapCi(baseline: number[], candidate: number[], options?: BootstrapOptions): BootstrapResult;
-/**
- * Judge-replay promotion gate.
- *
- * The cheap inner-loop judge that drives an evolution run is by definition
- * fast and noisy. When you're about to promote a winning variant to the
- * canonical default, you want a STRONGER judge (a more expensive model, a
- * human grader, a separately-trained reward model) to confirm the win
- * generalises beyond the inner loop.
- *
- * This helper takes raw winner + baseline outputs, scores both through the
- * stronger judge, and applies `bootstrapCi`. ADVANCE means the stronger
- * judge agrees the winner is real with the configured confidence. Doesn't
- * matter what shape your "output" is — pass a string, an object, anything
- * the judge can read.
- */
-interface JudgeReplayGateArgs<TOutput> {
-  baselineOutputs: TOutput[];
-  candidateOutputs: TOutput[];
-  /** Stronger judge — async to allow LLM calls. Return a 0..N scalar score. */
-  judge: (output: TOutput) => Promise<number> | number;
-  alpha?: number;
-  iterations?: number;
-  /** RNG seed for reproducibility. */
-  seed?: number;
-  /** Maximum concurrent judge calls. Default 4. */
-  judgeConcurrency?: number;
-}
-/**
- * Confirm a candidate's win with a stronger judge: score baseline and candidate outputs independently, then bootstrap a CI to verify the lift generalises beyond the inner loop.
- */
-declare function judgeReplayGate<TOutput>(args: JudgeReplayGateArgs<TOutput>): Promise<BootstrapResult & {
-  baselineSamples: number;
-  candidateSamples: number;
-}>;
-//#endregion
-//#region src/release-report.d.ts
-interface RenderReleaseReportOptions {
-  title?: string;
-  runs?: readonly RunRecord[];
-  comparator?: string;
-  traceAnalystFindings?: readonly string[];
-  nextActions?: readonly string[];
-}
-declare function renderReleaseReport(scorecard: ReleaseConfidenceScorecard, options?: RenderReleaseReportOptions): string;
-//#endregion
-export { ReleaseConfidenceStatus as _, JudgeReplayGateArgs as a, assertReleaseConfidence as b, judgeReplayGate as c, ReleaseConfidenceAxis as d, ReleaseConfidenceAxisName as f, ReleaseConfidenceScorecard as g, ReleaseConfidenceMetrics as h, BootstrapResult as i, ActionableSideInfo as l, ReleaseConfidenceIssue as m, renderReleaseReport as n, Verdict as o, ReleaseConfidenceInput as p, BootstrapOptions as r, bootstrapCi as s, RenderReleaseReportOptions as t, AsiSeverity as u, ReleaseConfidenceThresholds as v, evaluateReleaseConfidence as x, ReleaseTraceEvidence as y };
-//# sourceMappingURL=release-report-DA2BCu5a.d.ts.map
+export { RankTestMethod as C, WilcoxonSignedRankResult as D, WILCOXON_EXACT_MAX_N as E, mannWhitneyU as O, MannWhitneyResult as S, RankTestOptions as T, bootstrapCi as _, ReleaseConfidenceIssue as a, MANN_WHITNEY_EXACT_MAX_STATES as b, ReleaseConfidenceStatus as c, assertReleaseConfidence as d, evaluateReleaseConfidence as f, Verdict as g, JudgeReplayGateArgs as h, ReleaseConfidenceInput as i, wilcoxonSignedRank as k, ReleaseConfidenceThresholds as l, BootstrapResult as m, ReleaseConfidenceAxis as n, ReleaseConfidenceMetrics as o, BootstrapOptions as p, ReleaseConfidenceAxisName as r, ReleaseConfidenceScorecard as s, ActionableSideInfo as t, ReleaseTraceEvidence as u, judgeReplayGate as v, RankTestMethodRequest as w, MANN_WHITNEY_EXACT_MAX_WORK as x, DEFAULT_PERMUTATIONS as y };
+//# sourceMappingURL=release-confidence-BFRE5WSp.d.ts.map

package/dist/release-confidence-BFRE5WSp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-confidence-BFRE5WSp.d.ts","names":[],"sources":["../src/statistics/rank-tests.ts","../src/promotion-gate.ts","../src/release-confidence.ts"],"mappings":";;;;;;KA4BY;;;;;KAMA;UAEK;;EAEf,SAAS;;EAET;;;EAGA;;;cAIW;;cAEA;;cAEA;;cAEA;UAEI;;EAEf;;EAEA;;EAEA;;EAEA,QAAQ;;EAER;;;;;;;;;;;;;;iBAec,aACd,aACA,aACA,OAAM,kBACL;UAuFc;;;EAGf;;EAEA;;EAEA,QAAQ;;EAER;;EAEA;;;;;;;;;;;;;;;iBAgBc,mBACd,kBACA,iBACA,OAAM,kBACL;;;;;;;;;;;;;;;;;;;;;;;;;;;KCjLS;UAEK;EACf;EACA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA,SAAS;;UAGM;;EAEf;;EAEA;;;;;;EAMA;;EAEA;;;;;;;;;iBAUc,YACd,oBACA,qBACA,UAAS,mBACR;;;;;;;;;;;;;;;;UAsHc,oBAAoB;EACnC,iBAAiB;EACjB,kBAAkB;;EAElB,QAAQ,QAAQ,YAAY;EAC5B;EACA;;EAEA;;EAEA;;;;;iBAMoB,gBAAgB,SACpC,MAAM,oBAAoB,WACzB,QAAQ;EAAoB;EAAyB;;;;;KCtL5C;;UAGK;;EAEf;;EAEA;EACA,WAAW;;EAEX;;EAEA;;EAEA;;EAEA;EACA,WAAW;;KAGD;KACA;UAQK;EACf;EACA;EACA,QAAQ;EACR;EACA;EACA;EACA;EACA;;EAEA,eAAe;EACf,MAAM;EACN,WAAW;;UAGI;;EAEf;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA,UAAU;EACV,qBAAqB;EACrB,gBAAgB;EAChB,kBAAkB;EAClB,eAAe;EACf,aAAa;;UAGE;EACf,MAAM;EACN,QAAQ;EACR;EACA;;UAGe;EACf,MAAM;EACN;EACA;EACA;;UAGe;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,aAAa,OAAO;EACpB,cAAc;EACd,oBAAoB,QAAQ,OAAO;EACnC,0BAA0B;;;;;;;EAO1B;;UAGe;EACf;EACA;EACA;EACA,QAAQ;EACR;EACA,MAAM;EACN,QAAQ;EACR,SAAS;EACT,SAAS;EACT,cAAc;EACd;;iBAkBc,0BACd,OAAO,yBACN;iBA4Ha,wBAAwB,OAAO,yBAAyB"}