@tangle-network/agent-eval 0.86.0 → 0.90.0

package/dist/campaign/index.d.ts

@@ -1,32 +1,33 @@
 import { A as AnalyzeTracesOptions, a as AnalyzeTracesInput, b as AnalyzeTracesResult } from '../analyst-C8HHvfJp.js';
-import { S as Scenario, M as MutableSurface, b as DispatchContext, a as JudgeConfig, I as ImprovementDriver, q as ProposeContext, J as JudgeScore, L as LabeledScenarioStore, r as LabeledScenarioWrite, s as LabeledScenarioSampleArgs, t as LabeledScenarioRecord, u as LabelTrust, v as LabeledScenarioSource, g as CampaignResult, i as CodeSurface } from '../types-D7lLRYe9.js';
-export { C as CampaignAggregates, d as CampaignArtifactWriter, e as CampaignCellResult, f as CampaignCostMeter, w as CampaignTokenUsage, h as CampaignTraceWriter, D as DispatchFn, G as Gate, j as GateContext, c as GateDecision, k as GateResult, l as GenerationCandidate, m as GenerationRecord, x as JudgeAggregate, n as JudgeDimension, o as Mutator, O as OptimizerConfig, P as ParetoParent, y as ProposedCandidate, R as RedactionStatus, z as ScenarioAggregate, p as SessionScript, T as TraceSpan, A as isProposedCandidate, B as labelTrustRank } from '../types-D7lLRYe9.js';
-import { b as RunCampaignOptions, c as RunImprovementLoopOptions, C as CampaignStorage } from '../run-improvement-loop-CNqQckTj.js';
-export { e as GepaDriverConstraints, G as GepaDriverOptions, O as OpenAutoPrOptions, h as OpenAutoPrResult, a as RunImprovementLoopResult, R as RunOptimizationOptions, j as RunOptimizationResult, k as countSentenceEdits, l as defaultRenderDiff, m as extractH2Sections, f as fsCampaignStorage, g as gepaDriver, i as inMemoryCampaignStorage, o as openAutoPr, r as runCampaign, d as runImprovementLoop, n as runOptimization, s as surfaceHash } from '../run-improvement-loop-CNqQckTj.js';
-export { A as AxisEvidence, a as AxisVerdict, B as BuildEvidenceVectorOptions, k as BuildLoopProvenanceArgs, D as DefaultProductionGateOptions, l as EmitLoopProvenanceArgs, m as EmitLoopProvenanceResult, E as EvidenceVector, b as EvolutionaryDriverOptions, H as HeldOutGateOptions, n as LoopProvenanceBackend, o as LoopProvenanceCandidate, L as LoopProvenanceRecord, O as ObjectiveSource, P as ParetoSignificanceGateOptions, c as PromotionObjective, d as PromotionPolicy, R as RunEvalOptions, e as buildEvidenceVector, q as buildLoopProvenanceRecord, f as composeGate, g as defaultProductionGate, s as emitLoopProvenance, h as evolutionaryDriver, i as heldOutGate, t as loopProvenanceSpans, p as paretoPolicy, j as paretoSignificanceGate, u as provenanceRecordPath, v as provenanceSpansPath, r as runEval, w as surfaceContentHash } from '../provenance-DPpNIOJD.js';
-import { L as LlmClientOptions } from '../llm-client-CuUg2Mn3.js';
-import { c as TraceAnalystKindSpec } from '../kind-factory-CVecZZG_.js';
-import { c as AnalystFinding } from '../types-Cu3u_x59.js';
-import { a as PairedBootstrapResult } from '../statistics-CnC1FMbx.js';
-import { A as AgentProfile, B as BackendIntegrityReport, C as CompletionRequirement, R as RuntimeEventLike, a as CompletionVerdict, P as ProducedState, b as CorrectnessChecker } from '../agent-profile-D0PBIWlV.js';
-import { A as AgentEvalError } from '../errors-Dwqw-T_m.js';
-import { a as RunSplitTag, R as RunRecord } from '../run-record-De9VarXR.js';
+import { S as Scenario, M as MutableSurface, b as DispatchContext, a as JudgeConfig, I as ImprovementDriver, q as ProposeContext, m as GenerationRecord, G as Gate, J as JudgeScore, L as LabeledScenarioStore, r as LabeledScenarioWrite, s as LabeledScenarioSampleArgs, t as LabeledScenarioRecord, u as LabelTrust, v as LabeledScenarioSource, g as CampaignResult, i as CodeSurface } from '../types-BU-7W85F.js';
+export { C as CampaignAggregates, d as CampaignArtifactWriter, e as CampaignCellResult, f as CampaignCostMeter, w as CampaignTokenUsage, h as CampaignTraceWriter, D as DispatchFn, j as GateContext, c as GateDecision, k as GateResult, l as GenerationCandidate, x as JudgeAggregate, n as JudgeDimension, o as Mutator, O as OptimizerConfig, P as ParetoParent, y as ProposedCandidate, R as RedactionStatus, z as ScenarioAggregate, p as SessionScript, T as TraceSpan, A as isProposedCandidate, B as labelTrustRank } from '../types-BU-7W85F.js';
+import { b as RunCampaignOptions, c as RunImprovementLoopOptions, C as CampaignStorage } from '../run-improvement-loop-5z_l5zDz.js';
+export { e as GepaDriverConstraints, G as GepaDriverOptions, O as OpenAutoPrOptions, h as OpenAutoPrResult, a as RunImprovementLoopResult, R as RunOptimizationOptions, j as RunOptimizationResult, k as countSentenceEdits, l as defaultRenderDiff, m as extractH2Sections, f as fsCampaignStorage, g as gepaDriver, i as inMemoryCampaignStorage, o as openAutoPr, r as runCampaign, d as runImprovementLoop, n as runOptimization, s as surfaceHash } from '../run-improvement-loop-5z_l5zDz.js';
+export { A as AxisEvidence, a as AxisVerdict, B as BuildEvidenceVectorOptions, k as BuildLoopProvenanceArgs, D as DefaultProductionGateOptions, l as EmitLoopProvenanceArgs, m as EmitLoopProvenanceResult, E as EvidenceVector, b as EvolutionaryDriverOptions, H as HeldOutGateOptions, n as LoopProvenanceBackend, o as LoopProvenanceCandidate, L as LoopProvenanceRecord, O as ObjectiveSource, P as ParetoSignificanceGateOptions, c as PromotionObjective, d as PromotionPolicy, R as RunEvalOptions, e as buildEvidenceVector, q as buildLoopProvenanceRecord, f as composeGate, g as defaultProductionGate, s as emitLoopProvenance, h as evolutionaryDriver, i as heldOutGate, t as loopProvenanceSpans, p as paretoPolicy, j as paretoSignificanceGate, u as provenanceRecordPath, v as provenanceSpansPath, r as runEval, w as surfaceContentHash } from '../provenance-LnqRT0sS.js';
+import { L as LlmClientOptions } from '../llm-client-BeEcAokY.js';
+import { T as TraceAnalystKindSpec } from '../kind-factory-5b7xXXOr.js';
+import { c as AnalystFinding } from '../types-2VVIL04s.js';
+import { S as SignedManifest, A as AgentProfile, B as BackendIntegrityReport, C as CompletionRequirement, R as RuntimeEventLike, a as CompletionVerdict, P as ProducedState, b as CorrectnessChecker } from '../pre-registration-DELOEJ8v.js';
+import { E as EProcessState, a as PairedBootstrapResult } from '../statistics-C7PozGrZ.js';
+import { A as AgentEvalError } from '../errors-CzMUYo7b.js';
+import { a as RunSplitTag, R as RunRecord } from '../run-record-e7vj1uZQ.js';
 import '@ax-llm/ax';
 import '../store-C1YxJDEK.js';
-import '../red-team-DW9Ca_tj.js';
-import '../dataset-B2kL-fSM.js';
+import '../red-team-BXHil6c8.js';
+import '../dataset-BbGkaN2I.js';
 import '../store-CKUAgsJz.js';
 import '../schema-m0gsnbt3.js';
 import '../pareto-E-pembql.js';
 import '../hosted/index.js';
-import '../insight-report-3ADTfClO.js';
-import '../summary-report-Db0dDSWP.js';
+import '../insight-report-BBwvOh6x.js';
+import '../summary-report-DGmUucwQ.js';
 import '../failure-cluster-CL7IVgkJ.js';
-import '../judge-calibration-DilmB3Ml.js';
+import '../judge-calibration-0p2QcWNE.js';
 import '../raw-provider-sink-C46HDghv.js';
 import 'zod';
 import '../types-Croy5h7V.js';
 import '@tangle-network/tcloud';
+import '../verdict-C9MlYujm.js';
 
 /**
  * @experimental
@@ -464,6 +465,152 @@ interface TraceAnalystDriverOptions {
 /** Wrap agent-eval's trace-analyst registry as an ImprovementDriver (prompt-tier). */
 declare function traceAnalystDriver(opts: TraceAnalystDriverOptions): ImprovementDriver;
 
+/**
+ * @experimental
+ *
+ * Anytime-valid sequential promotion gate — an e-process (betting
+ * test-martingale, see `eProcess` in `statistics.ts`) over paired
+ * per-scenario deltas, so a campaign stops the MOMENT evidence decides
+ * instead of burning a fixed-n budget. Decisions remain valid at any
+ * data-dependent stopping time (Ville's inequality), which is exactly what
+ * fixed-n machinery cannot offer: peeking at a bootstrap CI after every
+ * observation and stopping on the first significant peek inflates type-I
+ * error far beyond alpha.
+ *
+ * REPLACES, never layers on, a fixed-n gate. Running `heldoutSignificance`
+ * or `paretoSignificanceGate` repeatedly on a growing sample and stopping
+ * early is optional stopping no matter how it is dressed up; this gate is
+ * the valid way to stop early. Use one or the other per evidence stream.
+ *
+ * Pre-registration binding: anytime validity holds only for the
+ * PRE-REGISTERED statistic. When a `SignedManifest` is bound, the gate takes
+ * alpha from `manifest.alpha`, the observation budget from
+ * `manifest.preRegisteredN`, orients deltas by `manifest.direction`, and
+ * shifts the null boundary by `manifest.minEffect` — re-deciding the same
+ * stream under different parameters after seeing data would reopen optional
+ * stopping under a fancier name. The manifest's content hash is verified at
+ * construction (sync, same `sha256-content` scheme as `signManifest`).
+ *
+ * Non-iid caveat (stated honestly): the supermartingale guarantee needs each
+ * delta's conditional mean under H0 to stay ≤ the null boundary given the
+ * past — exchangeable scenario deltas suffice. Scenario streams ordered by
+ * difficulty or by scenario family violate this; `decide(ctx)` therefore
+ * shuffles the paired deltas with a SEEDED permutation by default (the
+ * permutation is data-independent, so bet predictability is preserved).
+ * Stratified betting (per-stratum λ) is future work, not implemented here.
+ */
+
+type SequentialDecision = 'promote' | 'continue' | 'undecided-at-maxN';
+interface SequentialObservation {
+    decision: SequentialDecision;
+    /** Current e-value (the betting wealth) against H0. */
+    eValue: number;
+    /** Paired deltas consumed so far. */
+    n: number;
+    /** Names the decision basis. For 'undecided-at-maxN' it states explicitly
+     *  that exhausting the budget is NOT evidence of no effect. */
+    reason: string;
+}
+interface SequentialPairedGateOptions {
+    /** Type-I budget. With `preRegistration` bound this MUST match
+     *  `manifest.alpha` (conflict throws). Default 0.05. */
+    alpha?: number;
+    /** Minimum paired deltas before a promote may fire. The stopping rule is
+     *  "first n ≥ minN with e-value ≥ 1/alpha" — still a valid stopping time.
+     *  Default 5. */
+    minN?: number;
+    /** Pre-registered observation budget. Required unless `preRegistration`
+     *  supplies it via `preRegisteredN` (conflict throws). */
+    maxN?: number;
+    /** Bet truncation forwarded to `eProcess`. Default 0.5. */
+    maxBet?: number;
+    /** Bound on |delta| in the judge's native scale; deltas are mapped to
+     *  x = (d/scale + 1)/2 ∈ [0,1]. A delta outside ±scale throws (use
+     *  `detectScale` to pick 1 vs 100 BEFORE streaming). Default 1. */
+    scale?: number;
+    /** Seed for the data-independent shuffle of paired deltas in `decide(ctx)`
+     *  (exchangeability guard). Default 1337. */
+    shuffleSeed?: number;
+    /** Bind the pre-registered hypothesis. Verified (content hash) at
+     *  construction; alpha/maxN/direction/minEffect come FROM the manifest. */
+    preRegistration?: SignedManifest;
+    /** Override the gate name in reports. */
+    name?: string;
+}
+interface SequentialPairedGate<TArtifact = unknown, TScenario extends Scenario = Scenario> extends Gate<TArtifact, TScenario> {
+    /** Streaming entry point: feed one paired per-scenario delta
+     *  (candidate − baseline, native scale). Each gate instance carries ONE
+     *  observe-stream; `decide(ctx)` runs on its own fresh stream and never
+     *  consumes or advances this one. 'promote' is sticky; observing past the
+     *  pre-registered maxN throws (extending a finished stream after seeing
+     *  the result reopens optional stopping — start a NEW pre-registered
+     *  test). */
+    observe(delta: number): SequentialObservation;
+    /** Read-only snapshot of the observe-stream. */
+    state(): EProcessState & {
+        decision: SequentialDecision;
+    };
+}
+/**
+ * Anytime-valid sequential paired gate. Conforms to the existing `Gate`
+ * contract (`decide(ctx)` consumes candidate vs baseline judge scores via
+ * `pairHoldout` — same pairing granularity as the fixed-n gates: full cellId,
+ * never scenarioId) and adds a streaming `observe(delta)` entry for campaigns
+ * that score cells incrementally and want to stop mid-stream.
+ *
+ * Decision mapping onto the substrate's five-valued `GateDecision`:
+ *   - 'promote'            → 'ship'
+ *   - 'continue'           → 'need_more_work' (stream ended before maxN with
+ *                            the e-value undecided — more reps could decide)
+ *   - 'undecided-at-maxN'  → 'hold', with the reason stating it is NOT
+ *                            evidence of no effect (never a silent default)
+ */
+declare function sequentialPairedGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(options: SequentialPairedGateOptions): SequentialPairedGate<TArtifact, TScenario>;
+interface SequentialDecideOptions {
+    /** Type-I budget for the early-stop evidence. Default 0.05. */
+    alpha?: number;
+    /** Minimum paired deltas before a stop may fire. Default 5. */
+    minN?: number;
+    /** Bet truncation forwarded to `eProcess`. Default 0.5. */
+    maxBet?: number;
+    /** Bound on |per-scenario composite delta|. Default 1. */
+    scale?: number;
+}
+interface SequentialDecideFn {
+    (args: {
+        history: GenerationRecord[];
+    }): {
+        stop: boolean;
+        reason?: string;
+    };
+    /** Read-only snapshot of the accumulated e-process (observability + tests). */
+    state(): EProcessState;
+}
+/**
+ * `ImprovementDriver.decide` adapter — stops the optimization loop the moment
+ * the e-process decides the loop has produced a real improvement, instead of
+ * always running `maxGenerations`.
+ *
+ * Stream: for each generation g ≥ 1, the per-scenario composite deltas of
+ * generation g's top candidate vs the generation-0 top candidate (the
+ * incumbent the loop set out to beat), paired by scenarioId. H0: no proposed
+ * surface improves any scenario's expected composite over the incumbent —
+ * under it every delta has conditional mean ≤ 0 and the e-process is valid.
+ * Once wealth ≥ 1/alpha the loop stops and hands the winner to the promotion
+ * gate (which re-scores on HELD-OUT data — this adapter only spends the
+ * exploration budget, it never promotes).
+ *
+ * Honesty caveats: (1) the incumbent's scores are measured once and shared
+ * across all generations' deltas, so type-I control is exact only insofar as
+ * those scores approximate the incumbent's true per-scenario means (more reps
+ * → tighter); (2) an UNDECIDED process never stops the loop — absence of a
+ * crossing is NOT evidence of no effect, so the loop simply runs its normal
+ * course. Calling the adapter repeatedly with a growing history consumes each
+ * generation exactly once (re-feeding an already-seen record would double-count
+ * evidence).
+ */
+declare function sequentialDecide(options?: SequentialDecideOptions): SequentialDecideFn;
+
 /**
  * @experimental
  *
@@ -1192,4 +1339,4 @@ declare function gitWorktreeAdapter(opts: GitWorktreeAdapterOptions): WorktreeAd
  *  as a ref under the adapter's worktree dir. */
 declare function resolveWorktreePath(surface: CodeSurface, worktreeDir?: string): string;
 
-export { type AcceptedEdit, type AceDriverOptions, type AnalystArtifact, type AnalystScenario, type ApplySkillPatchResult, type BuildAnalystSurfaceDispatchOptions, type CampaignBreakdown, CampaignResult, CampaignStorage, CodeSurface, type CompareDriversOptions, type DimensionRegression, DispatchContext, type DriverComparison, type DriverEntry, type DriverPairwise, type DriverScore, type FailureModeRecallJudgeOptions, FsLabeledScenarioStore, type FsLabeledScenarioStoreOptions, type GitWorktreeAdapterOptions, type HaloDriverOptions, type HeldoutSignificance, type HeldoutSignificanceOptions, ImprovementDriver, JudgeConfig, JudgeScore, LabelTrust, LabeledScenarioRecord, LabeledScenarioSampleArgs, LabeledScenarioSource, LabeledScenarioStore, LabeledScenarioStoreError, LabeledScenarioWrite, type MemoryCurationDriverOptions, MutableSurface, type OptimizerEntryConfig, type PairedHoldout, type PlaybackContext, type PlaybackDriver, type PlaybackStep, type ProfileDispatchFn, ProfileMatrixError, type ProfileSummary, ProposeContext, type ProposePatchesArgs, type RejectedEdit, RunCampaignOptions, RunImprovementLoopOptions, type RunProfileMatrixOptions, type RunProfileMatrixResult, type RunSkillOptOptions, type RunSkillOptResult, Scenario, type ScenarioRollup, type ScoreboardRenderOptions, type ScoreboardRow, type ScoreboardSummary, type SkillOptDriver, type SkillOptDriverOptions, type SkillOptEpochRecord, type SkillOptEvidence, type SkillPatch, type SkillPatchOp, SkillPatchParseError, type SkillPatchRejection, type TraceAnalystDriverOptions, type UserStory, type UserStoryVerdict, type Worktree, type WorktreeAdapter, WorktreeAdapterError, aceDriver, applySkillPatch, buildAnalystSurfaceDispatch, campaignBreakdown, campaignMeanComposite, compareDrivers, detectScale, dimensionRegressions, failureModeRecallJudge, gepaParetoEntry, gepaReflectionEntry, gitWorktreeAdapter, haloDriver, heldoutSignificance, makePlaybackDispatch, memoryCurationDriver, pairHoldout, parseSkillPatchResponse, patchEditCount, renderScoreboardMarkdown, resolveWorktreePath, runProfileMatrix, runSkillOpt, scoreUserStory, scoreboardSummary, skillOptDriver, skillOptEntry, traceAnalystDriver, userStoryScoreboard };
+export { type AcceptedEdit, type AceDriverOptions, type AnalystArtifact, type AnalystScenario, type ApplySkillPatchResult, type BuildAnalystSurfaceDispatchOptions, type CampaignBreakdown, CampaignResult, CampaignStorage, CodeSurface, type CompareDriversOptions, type DimensionRegression, DispatchContext, type DriverComparison, type DriverEntry, type DriverPairwise, type DriverScore, type FailureModeRecallJudgeOptions, FsLabeledScenarioStore, type FsLabeledScenarioStoreOptions, Gate, GenerationRecord, type GitWorktreeAdapterOptions, type HaloDriverOptions, type HeldoutSignificance, type HeldoutSignificanceOptions, ImprovementDriver, JudgeConfig, JudgeScore, LabelTrust, LabeledScenarioRecord, LabeledScenarioSampleArgs, LabeledScenarioSource, LabeledScenarioStore, LabeledScenarioStoreError, LabeledScenarioWrite, type MemoryCurationDriverOptions, MutableSurface, type OptimizerEntryConfig, type PairedHoldout, type PlaybackContext, type PlaybackDriver, type PlaybackStep, type ProfileDispatchFn, ProfileMatrixError, type ProfileSummary, ProposeContext, type ProposePatchesArgs, type RejectedEdit, RunCampaignOptions, RunImprovementLoopOptions, type RunProfileMatrixOptions, type RunProfileMatrixResult, type RunSkillOptOptions, type RunSkillOptResult, Scenario, type ScenarioRollup, type ScoreboardRenderOptions, type ScoreboardRow, type ScoreboardSummary, type SequentialDecideFn, type SequentialDecideOptions, type SequentialDecision, type SequentialObservation, type SequentialPairedGate, type SequentialPairedGateOptions, type SkillOptDriver, type SkillOptDriverOptions, type SkillOptEpochRecord, type SkillOptEvidence, type SkillPatch, type SkillPatchOp, SkillPatchParseError, type SkillPatchRejection, type TraceAnalystDriverOptions, type UserStory, type UserStoryVerdict, type Worktree, type WorktreeAdapter, WorktreeAdapterError, aceDriver, applySkillPatch, buildAnalystSurfaceDispatch, campaignBreakdown, campaignMeanComposite, compareDrivers, detectScale, dimensionRegressions, failureModeRecallJudge, gepaParetoEntry, gepaReflectionEntry, gitWorktreeAdapter, haloDriver, heldoutSignificance, makePlaybackDispatch, memoryCurationDriver, pairHoldout, parseSkillPatchResponse, patchEditCount, renderScoreboardMarkdown, resolveWorktreePath, runProfileMatrix, runSkillOpt, scoreUserStory, scoreboardSummary, sequentialDecide, sequentialPairedGate, skillOptDriver, skillOptEntry, traceAnalystDriver, userStoryScoreboard };

package/dist/campaign/index.js

@@ -10,12 +10,12 @@ import {
   paretoPolicy,
   paretoSignificanceGate,
   runEval
-} from "../chunk-OTYQPHPL.js";
+} from "../chunk-6SOJM3VR.js";
 import {
   agentProfileHash,
   extractProducedState,
   verifyCompletion
-} from "../chunk-YGYXHNAQ.js";
+} from "../chunk-FIUKOSWI.js";
 import {
   buildLoopProvenanceRecord,
   campaignBreakdown,
@@ -37,14 +37,14 @@ import {
   runOptimization,
   surfaceContentHash,
   surfaceHash
-} from "../chunk-BABOZOSN.js";
+} from "../chunk-ZFIBGEOL.js";
 import {
   assertRealBackend,
   fsCampaignStorage,
   inMemoryCampaignStorage,
   runCampaign,
   summarizeBackendIntegrity
-} from "../chunk-ZZ2HOPME.js";
+} from "../chunk-TWS7AZEY.js";
 import {
   estimateCost,
   isModelPriced
@@ -53,24 +53,31 @@ import {
   AnalystRegistry,
   DEFAULT_TRACE_ANALYST_KINDS,
   createTraceAnalystKind
-} from "../chunk-VIDQF3F5.js";
-import "../chunk-YV7J7X5N.js";
+} from "../chunk-D3V5B42D.js";
+import "../chunk-5HRORJQY.js";
 import {
   callLlm
 } from "../chunk-CVVHBFGN.js";
+import "../chunk-45EEMHTC.js";
 import {
+  eProcess,
+  mulberry32,
   pairedBootstrap
-} from "../chunk-IDVBLYCY.js";
+} from "../chunk-LMZQ2Z4U.js";
 import "../chunk-GGE4NNQT.js";
 import {
-  OtlpFileTraceStore,
   analyzeTraces
-} from "../chunk-VUINJM5M.js";
+} from "../chunk-UHMJT4T7.js";
+import {
+  OtlpFileTraceStore
+} from "../chunk-QAY5UIJO.js";
 import "../chunk-PC4UYEBM.js";
 import {
   validateRunRecord
 } from "../chunk-KWRRMR3J.js";
-import "../chunk-VSMTAMNK.js";
+import {
+  canonicalize
+} from "../chunk-VSMTAMNK.js";
 import {
   AgentEvalError
 } from "../chunk-3BFEG2F6.js";
@@ -708,8 +715,274 @@ ${report.slice(0, 800)}`,
   });
 }
 
-// src/campaign/labeled-store/fs-adapter.ts
+// src/campaign/gates/sequential.ts
 import { createHash } from "crypto";
+function verifyManifestSync(m) {
+  if (m.algo !== void 0 && m.algo !== "sha256-content") {
+    throw new Error(`sequentialPairedGate: unrecognized manifest hash algo '${m.algo}'`);
+  }
+  const { contentHash, algo: _algo, ...rest } = m;
+  void _algo;
+  const bytes = JSON.stringify(canonicalize(rest));
+  const hash = createHash("sha256").update(bytes, "utf8").digest("hex");
+  return hash === contentHash;
+}
+function resolveConfig(opts) {
+  const m = opts.preRegistration;
+  let alpha;
+  let maxN;
+  let direction;
+  let minEffect;
+  if (m) {
+    if (!verifyManifestSync(m)) {
+      throw new Error(
+        `sequentialPairedGate: pre-registration manifest '${m.id}' content hash mismatch (tampered)`
+      );
+    }
+    if (opts.alpha !== void 0 && opts.alpha !== m.alpha) {
+      throw new Error(
+        `sequentialPairedGate: alpha ${opts.alpha} conflicts with pre-registered alpha ${m.alpha} \u2014 the registered statistic is the only one anytime validity covers`
+      );
+    }
+    if (opts.maxN !== void 0 && opts.maxN !== m.preRegisteredN) {
+      throw new Error(
+        `sequentialPairedGate: maxN ${opts.maxN} conflicts with pre-registered N ${m.preRegisteredN}`
+      );
+    }
+    alpha = m.alpha;
+    maxN = m.preRegisteredN;
+    direction = m.direction;
+    minEffect = m.minEffect;
+  } else {
+    alpha = opts.alpha ?? 0.05;
+    if (opts.maxN === void 0) {
+      throw new Error(
+        "sequentialPairedGate: maxN is required (or bind a preRegistration manifest whose preRegisteredN is the budget) \u2014 an unbounded stream has no pre-registered budget"
+      );
+    }
+    maxN = opts.maxN;
+    direction = "increase";
+    minEffect = 0;
+  }
+  const scale = opts.scale ?? 1;
+  if (!Number.isFinite(scale) || scale <= 0) {
+    throw new Error(`sequentialPairedGate: scale must be > 0, got ${scale}`);
+  }
+  if (!Number.isInteger(maxN) || maxN < 1) {
+    throw new Error(`sequentialPairedGate: maxN must be a positive integer, got ${maxN}`);
+  }
+  const minN = opts.minN ?? 5;
+  if (!Number.isInteger(minN) || minN < 1 || minN > maxN) {
+    throw new Error(
+      `sequentialPairedGate: minN must be an integer in [1, maxN=${maxN}], got ${minN}`
+    );
+  }
+  if (!Number.isFinite(minEffect) || minEffect < 0 || minEffect >= scale) {
+    throw new Error(
+      `sequentialPairedGate: minEffect must be in [0, scale=${scale}), got ${minEffect}`
+    );
+  }
+  const nullMean = 0.5 + minEffect / (2 * scale);
+  return {
+    alpha,
+    minN,
+    maxN,
+    maxBet: opts.maxBet ?? 0.5,
+    scale,
+    shuffleSeed: opts.shuffleSeed ?? 1337,
+    direction,
+    nullMean,
+    minEffect
+  };
+}
+function makeStream(cfg) {
+  const proc = eProcess({ alpha: cfg.alpha, maxBet: cfg.maxBet, nullMean: cfg.nullMean });
+  const threshold = 1 / cfg.alpha;
+  let terminal;
+  return {
+    observe(delta) {
+      if (terminal === "undecided-at-maxN") {
+        throw new Error(
+          `sequentialPairedGate: pre-registered maxN=${cfg.maxN} exhausted \u2014 extending the stream after seeing the result reopens optional stopping; start a NEW pre-registered test`
+        );
+      }
+      if (!Number.isFinite(delta) || Math.abs(delta) > cfg.scale) {
+        throw new Error(
+          `sequentialPairedGate: delta ${delta} outside \xB1scale=${cfg.scale} \u2014 pass the judge's native scale explicitly (detectScale helps pick 1 vs 100)`
+        );
+      }
+      const d = cfg.direction === "decrease" ? -delta : delta;
+      const step = proc.update((d / cfg.scale + 1) / 2);
+      if (terminal === void 0 && step.n >= cfg.minN && step.wealth >= threshold) {
+        terminal = "promote";
+      }
+      if (terminal === "promote") {
+        return {
+          decision: "promote",
+          eValue: step.wealth,
+          n: step.n,
+          reason: `e-value ${step.wealth.toFixed(2)} \u2265 1/\u03B1=${threshold.toFixed(2)} at n=${step.n} (minN=${cfg.minN}): the paired improvement exceeds ${cfg.minEffect} at anytime-valid level \u03B1=${cfg.alpha}`
+        };
+      }
+      if (step.n >= cfg.maxN) {
+        terminal = "undecided-at-maxN";
+        return {
+          decision: "undecided-at-maxN",
+          eValue: step.wealth,
+          n: step.n,
+          reason: `undecided at pre-registered maxN=${cfg.maxN} (e-value ${step.wealth.toFixed(2)} < 1/\u03B1=${threshold.toFixed(2)}). This is NOT evidence of no effect \u2014 the effect may be real but smaller than this budget can detect; re-register with a larger N to test that`
+        };
+      }
+      return {
+        decision: "continue",
+        eValue: step.wealth,
+        n: step.n,
+        reason: `e-value ${step.wealth.toFixed(2)} < 1/\u03B1=${threshold.toFixed(2)} at n=${step.n}/${cfg.maxN} \u2014 keep observing`
+      };
+    },
+    state() {
+      return { ...proc.state(), decision: terminal ?? "continue" };
+    }
+  };
+}
+function seededShuffle(items, seed) {
+  const rng = mulberry32(seed);
+  for (let i = items.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1));
+    const tmp = items[i];
+    items[i] = items[j];
+    items[j] = tmp;
+  }
+  return items;
+}
+function sequentialPairedGate(options) {
+  const cfg = resolveConfig(options);
+  const name = options.name ?? "sequentialPairedGate";
+  const manifest = options.preRegistration;
+  const observeStream = makeStream(cfg);
+  return {
+    name,
+    observe(delta) {
+      return observeStream.observe(delta);
+    },
+    state() {
+      return observeStream.state();
+    },
+    async decide(ctx) {
+      if (!ctx.baselineJudgeScores) {
+        throw new Error(
+          `${name}: ctx.baselineJudgeScores is required \u2014 falling back to the candidate's own scores would compare the candidate against itself (delta 0, silent no-op)`
+        );
+      }
+      const scenarioIds = new Set(ctx.scenarios.map((s) => s.id));
+      const paired = pairHoldout(
+        ctx.judgeScores,
+        ctx.baselineJudgeScores,
+        scenarioIds,
+        (s) => s.composite
+      );
+      const deltas = paired.after.map((a, i) => a - paired.before[i]);
+      seededShuffle(deltas, cfg.shuffleSeed);
+      const stream = makeStream(cfg);
+      let last;
+      for (const d of deltas) {
+        last = stream.observe(d);
+        if (last.decision !== "continue") break;
+      }
+      const detail = {
+        ...stream.state(),
+        minN: cfg.minN,
+        maxN: cfg.maxN,
+        scale: cfg.scale,
+        shuffleSeed: cfg.shuffleSeed,
+        direction: cfg.direction,
+        minEffect: cfg.minEffect,
+        pairedN: deltas.length,
+        preRegisteredId: manifest?.id,
+        metric: manifest?.metric
+      };
+      const meanDelta = deltas.length === 0 ? void 0 : deltas.reduce((s, d) => s + d, 0) / deltas.length;
+      if (last === void 0) {
+        return {
+          decision: "need_more_work",
+          reasons: [`${name}: no paired holdout observations \u2014 nothing to test`],
+          contributingGates: [{ name, passed: false, detail }]
+        };
+      }
+      const decision = last.decision === "promote" ? "ship" : last.decision === "continue" ? "need_more_work" : "hold";
+      return {
+        decision,
+        reasons: [`${name}: ${last.reason}`],
+        contributingGates: [{ name, passed: decision === "ship", detail }],
+        delta: meanDelta
+      };
+    }
+  };
+}
+function sequentialDecide(options = {}) {
+  const alpha = options.alpha ?? 0.05;
+  const minN = options.minN ?? 5;
+  const scale = options.scale ?? 1;
+  if (!Number.isFinite(scale) || scale <= 0) {
+    throw new Error(`sequentialDecide: scale must be > 0, got ${scale}`);
+  }
+  const proc = eProcess({ alpha, maxBet: options.maxBet ?? 0.5, nullMean: 0.5 });
+  const threshold = 1 / alpha;
+  let processedGenerations = 0;
+  let reference;
+  let stopped;
+  const topCandidate = (record) => {
+    if (record.candidates.length === 0) {
+      throw new Error(
+        `sequentialDecide: generation ${record.generationIndex} has no candidates \u2014 cannot extract a top candidate`
+      );
+    }
+    return record.candidates.reduce((best, c) => c.composite > best.composite ? c : best);
+  };
+  const decide = ({ history }) => {
+    if (stopped) return stopped;
+    if (history.length === 0) return { stop: false };
+    if (reference === void 0) {
+      reference = new Map(
+        topCandidate(history[0]).scenarios.map((s) => [s.scenarioId, s.composite])
+      );
+    }
+    for (let g = Math.max(1, processedGenerations); g < history.length; g++) {
+      const top = topCandidate(history[g]);
+      const byScenario = new Map(top.scenarios.map((s) => [s.scenarioId, s.composite]));
+      for (const [scenarioId, refComposite] of reference) {
+        const candComposite = byScenario.get(scenarioId);
+        if (candComposite === void 0) {
+          throw new Error(
+            `sequentialDecide: generation ${history[g].generationIndex} top candidate is missing scenario '${scenarioId}' \u2014 generations must score the same scenario set to pair`
+          );
+        }
+        const delta = candComposite - refComposite;
+        if (!Number.isFinite(delta) || Math.abs(delta) > scale) {
+          throw new Error(
+            `sequentialDecide: paired delta ${delta} outside \xB1scale=${scale} on scenario '${scenarioId}' \u2014 pass the composite scale explicitly`
+          );
+        }
+        const step = proc.update((delta / scale + 1) / 2);
+        if (step.n >= minN && step.wealth >= threshold) {
+          stopped = {
+            stop: true,
+            reason: `sequential e-process decided at generation ${history[g].generationIndex}: e-value ${step.wealth.toFixed(2)} \u2265 1/\u03B1=${threshold.toFixed(2)} after n=${step.n} paired deltas vs the generation-0 incumbent \u2014 the improvement is real at \u03B1=${alpha}; stop exploring and promote via the gate`
+          };
+          processedGenerations = history.length;
+          return stopped;
+        }
+      }
+    }
+    processedGenerations = history.length;
+    return { stop: false };
+  };
+  decide.state = () => proc.state();
+  return decide;
+}
+
+// src/campaign/labeled-store/fs-adapter.ts
+import { createHash as createHash2 } from "crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync as writeFileSync2 } from "fs";
 import { join as join2 } from "path";
 var LabeledScenarioStoreError = class extends Error {
@@ -908,7 +1181,7 @@ function matchesFilter(record, args, source) {
   return true;
 }
 function sha256(input) {
-  return createHash("sha256").update(input).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(input).digest("hex").slice(0, 16);
 }
 function appendLine(path, line) {
   if (existsSync(path)) {
@@ -1364,7 +1637,7 @@ function renderScoreboardMarkdown(rows, opts = {}) {
 }
 
 // src/campaign/presets/run-profile-matrix.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { join as join3 } from "path";
 var ProfileMatrixError = class extends AgentEvalError {
   constructor(message) {
@@ -1375,7 +1648,7 @@ function sanitize(id) {
   return id.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function sha(input) {
-  return createHash2("sha256").update(JSON.stringify(input)).digest("hex");
+  return createHash3("sha256").update(JSON.stringify(input)).digest("hex");
 }
 function mean2(xs) {
   return xs.length === 0 ? 0 : xs.reduce((a, b) => a + b, 0) / xs.length;
@@ -1700,6 +1973,8 @@ export {
   runSkillOpt,
   scoreUserStory,
   scoreboardSummary,
+  sequentialDecide,
+  sequentialPairedGate,
   skillOptDriver,
   skillOptEntry,
   surfaceContentHash,