@tangle-network/agent-eval 0.192.0 → 0.193.2

package/dist/{index-DNVzu9Vv.d.ts.map → index-DWQNDqPd.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-DNVzu9Vv.d.ts","names":[],"sources":["../src/contract/measured-comparison.ts","../src/contract/profile-measured-comparison.ts","../src/contract/intake/run-record-dir.ts","../src/contract/eval-reporting-suite.ts","../src/contract/intake/agent-trace.ts","../src/contract/intake/code-agent-observation.ts","../src/contract/intake/code-agent-session.ts","../src/contract/intake/code-agent-store.ts","../src/contract/intake/feedback-table.ts","../src/contract/intake/otel-spans.ts"],"mappings":"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"}
+{"version":3,"file":"index-DWQNDqPd.d.ts","names":[],"sources":["../src/contract/measured-comparison.ts","../src/contract/profile-measured-comparison.ts","../src/contract/intake/run-record-dir.ts","../src/contract/eval-reporting-suite.ts","../src/contract/intake/agent-trace.ts","../src/contract/intake/code-agent-observation.ts","../src/contract/intake/code-agent-session.ts","../src/contract/intake/code-agent-store.ts","../src/contract/intake/feedback-table.ts","../src/contract/intake/otel-spans.ts"],"mappings":"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"}

package/dist/index.d.ts

@@ -9,15 +9,15 @@ import { a as ContinuousCalibrationResult, d as calibrateJudgeContinuous, f as c
 import { a as CorpusAgreementPerDimension, c as corpusInterRaterAgreement, i as CorpusAgreementOptions, l as corpusInterRaterAgreementFromJudgeScores, n as SeriesConvergenceResult, o as CorpusAgreementReport, r as analyzeSeries, s as CorpusScoreRecord, t as SeriesConvergenceOptions, u as interRaterReliability } from "./series-convergence-DY7ha0kx.js";
 import { a as partialCredit, c as spearmanR, d as weightedMean, i as confidenceInterval, l as summarizeNumberSeries, n as WeightedCompositeInput, o as pearsonR, r as WeightedCompositeResult, s as ranks, t as SeriesDistribution, u as weightedComposite } from "./descriptive-B2iPaT9J.js";
 import { n as bonferroni, r as holm, t as benjaminiHochberg } from "./multiplicity-DIWHvysC.js";
-import { A as PairArmsOptions, Bt as RiskDifferenceResult, C as hashJson, Ct as verifyAttestation, D as ComparePairedArmsOptions, F as PairedCorrectness, Ft as EProcessStep, Gt as pairedRiskDifference, Ht as isBinaryOutcomeVector, I as PairedMetricDelta, It as eProcess, Jt as passAtK, Kt as pairedRiskDifferenceExact, L as comparePairedArms, Lt as ExactRiskDifferenceResult, M as PairRunRecordsResult, Mt as EProcess, N as PairedArmRow, Nt as EProcessOptions, O as MatchedPair, P as PairedArmsComparison, Pt as EProcessState, R as pairArms, Rt as McNemarResult, St as attest, Ut as mcnemar, Vt as ScoreRiskDifferenceResult, Wt as pairedBinaryScale, Yt as wilson, bt as AttestationVerification, et as Objective, j as PairArmsResult, k as MatchedRunRecordPair, nt as dominates, qt as pairedRiskDifferenceScore, rt as paretoFrontier, tt as ParetoResult, vt as ATTESTATION_ALGORITHM, w as manifestContentDigest, xt as AttestedReport, yt as AttestationProvenance, z as pairRunRecords, zt as ProportionInterval } from "./statistical-heldout-C1Ej5Ce8.js";
+import { A as PairArmsOptions, Bt as RiskDifferenceResult, C as hashJson, Ct as verifyAttestation, D as ComparePairedArmsOptions, F as PairedCorrectness, Ft as EProcessStep, Gt as pairedRiskDifference, Ht as isBinaryOutcomeVector, I as PairedMetricDelta, It as eProcess, Jt as passAtK, Kt as pairedRiskDifferenceExact, L as comparePairedArms, Lt as ExactRiskDifferenceResult, M as PairRunRecordsResult, Mt as EProcess, N as PairedArmRow, Nt as EProcessOptions, O as MatchedPair, P as PairedArmsComparison, Pt as EProcessState, R as pairArms, Rt as McNemarResult, St as attest, Ut as mcnemar, Vt as ScoreRiskDifferenceResult, Wt as pairedBinaryScale, Yt as wilson, bt as AttestationVerification, et as Objective, j as PairArmsResult, k as MatchedRunRecordPair, nt as dominates, qt as pairedRiskDifferenceScore, rt as paretoFrontier, tt as ParetoResult, vt as ATTESTATION_ALGORITHM, w as manifestContentDigest, xt as AttestedReport, yt as AttestationProvenance, z as pairRunRecords, zt as ProportionInterval } from "./statistical-heldout-D-xBpbrd.js";
 import { _ as pairedSignTest, a as PairedPromotionDecision, c as BOOTSTRAP_GATE_MIN_N, d as PairedBootstrapResult, f as PairedSignTestResult, g as pairedDeltaTieFraction, h as pairedBootstrap, i as PairedMcNemarEvidence, l as DECISION_PAIRED_DELTA_STATISTIC, m as SignTestAlternative, n as PairedDecisionShape, o as PairedPromotionDecisionOptions, p as PairedTTestResult, r as PairedDecisionStatistic, s as decidePairedPromotion, t as PairedDecisionMethod, u as PairedBootstrapOptions, v as pairedTTest } from "./paired-promotion-decision-DPKz8ZnF.js";
 import { a as requiredPairedSampleSize, i as pairedMde, n as mcnemarPower, o as requiredSampleSize, r as mcnemarRequiredN, t as mulberry32 } from "./random-DGEyr3zG.js";
 import { C as RankTestMethod, D as WilcoxonSignedRankResult, E as WILCOXON_EXACT_MAX_N, O as mannWhitneyU, S as MannWhitneyResult, T as RankTestOptions, _ as bootstrapCi, a as ReleaseConfidenceIssue, b as MANN_WHITNEY_EXACT_MAX_STATES, f as evaluateReleaseConfidence, g as Verdict, i as ReleaseConfidenceInput, k as wilcoxonSignedRank, m as BootstrapResult, o as ReleaseConfidenceMetrics, p as BootstrapOptions, s as ReleaseConfidenceScorecard, t as ActionableSideInfo, u as ReleaseTraceEvidence, w as RankTestMethodRequest, x as MANN_WHITNEY_EXACT_MAX_WORK, y as DEFAULT_PERMUTATIONS } from "./release-confidence-CkoXFx9I.js";
-import { R as Scenario$1, S as JudgeConfig, _ as GateDecision, a as CampaignResult, w as JudgeScore$1 } from "./types-C1CAD70_.js";
-import { $r as redTeamDataset, At as RuntimeEventLike, Bt as SatisfiedBy, Dt as summarizeBackendIntegrity, Et as assertRealBackend, Fo as RunCampaignOptions, Ft as CorrectnessChecker, Ht as completionVerdict, Io as runCampaign, It as LlmCorrectnessCheckerOpts, Jr as DEFAULT_RED_TEAM_CORPUS, Lt as ProducedProposal, Mt as extractProducedState, No as CampaignCellFailureReceipt, Nt as CompletionRequirement, Ot as ArtifactEventLike, Po as CampaignCellRetryPolicy, Pt as CompletionVerdict, Qr as RedTeamReport, Rt as ProducedState, Tt as BackendIntegrityReport, Ut as createLlmCorrectnessChecker, Vt as TaskGold, Wt as verifyCompletion, Xr as RedTeamCategory, Yr as RedTeamCase, Zr as RedTeamFinding, ai as CanaryOptions, da as LlmJudgeOptions, ei as redTeamReport, fa as llmJudge, ga as transientDispatchFailure, ha as quotaExhaustedUntil, ii as CanaryKind, jt as ToolCallEventLike, kt as ProposalEventLike, ni as CanaryAlert, oi as CanaryReport, ri as CanaryEvaluation, si as runCanaries, ti as scoreRedTeamOutput, wt as BackendIntegrityError, zt as RequirementCheck } from "./index-DwQxdWve.js";
 import { a as RunFilter, i as InMemoryTraceStore, n as FileSystemTraceStore, o as SpanFilter, s as TraceStore, t as EventFilter } from "./store-C4avFjIi.js";
 import { a as MintedRolloutLine } from "./schema-B5LtYvn9.js";
 import { a as mintRolloutRows, c as ScorePreference, i as RolloutSearchLineage, n as MintRolloutResult, t as MintRolloutOptions } from "./mint-C9Lojt1V.js";
+import { R as Scenario$1, S as JudgeConfig, _ as GateDecision, a as CampaignResult, w as JudgeScore$1 } from "./types-BWwRXofp.js";
+import { Ao as runCampaign, Bt as extractProducedState, Ca as quotaExhaustedUntil, Do as CampaignCellFailureReceipt, Ft as summarizeBackendIntegrity, Gt as ProducedProposal, Ht as CompletionVerdict, It as ArtifactEventLike, Jt as SatisfiedBy, Kt as ProducedState, Lt as ProposalEventLike, Mt as BackendIntegrityError, Nt as BackendIntegrityReport, Oo as CampaignCellRetryPolicy, Pt as assertRealBackend, Qt as verifyCompletion, Rt as RuntimeEventLike, Ut as CorrectnessChecker, Vt as CompletionRequirement, Wt as LlmCorrectnessCheckerOpts, Xt as completionVerdict, Yt as TaskGold, Zt as createLlmCorrectnessChecker, ai as RedTeamFinding, ba as llmJudge, ci as redTeamReport, di as CanaryEvaluation, fi as CanaryKind, hi as runCanaries, ii as RedTeamCategory, ko as RunCampaignOptions, li as scoreRedTeamOutput, mi as CanaryReport, ni as DEFAULT_RED_TEAM_CORPUS, oi as RedTeamReport, pi as CanaryOptions, qt as RequirementCheck, ri as RedTeamCase, si as redTeamDataset, ui as CanaryAlert, wa as transientDispatchFailure, ya as LlmJudgeOptions, zt as ToolCallEventLike } from "./index-DMPLG226.js";
 import { a as ProfileAxisSpec, c as expandProfileAxes, i as HarnessType, l as harnessAxisOf, n as CODING_HARNESSES, o as agentProfileHash, r as HARNESS_NATIVE_MODEL, s as agentProfileId, t as AgentProfile } from "./agent-profile-DDfIjdyS.js";
 import { i as DatasetSplit, n as DatasetManifest, r as DatasetScenario, t as Dataset } from "./dataset-DQqhOCPt.js";
 import { C as defineEquivalenceCheck, S as buildEquivalenceRecord, _ as StrategyChecker, a as CheckerIdentity, b as VerificationStrategyProfile, c as EquivalenceCheckDefinition, d as EquivalenceCheckerInput, f as EquivalenceCheckerResult, g as EquivalenceRecord, h as EquivalenceProtocolError, i as equivalenceVerdict, l as EquivalenceCheckSpec, m as EquivalenceObligationStatus, n as VerdictCertification, o as CheckerOutcome, p as EquivalenceObligation, r as certificationEvidenceDigest, s as EquivalenceArm, t as DefaultVerdict, u as EquivalenceChecker, v as VERIFICATION_STRATEGIES, w as runEquivalenceCheck, x as VerificationStrategySource, y as VERIFICATION_STRATEGY_SOURCES } from "./verdict-E4eRNf7-.js";
@@ -27,20 +27,20 @@ import { a as FAILURE_BLAME, c as FailureContext, d as INFRA_FAILURE_BLAMES, f a
 import { d as InsightReport, i as analyzeRuns, t as AnalyzeRunsOptions } from "./analyze-runs-CPiKLJFs.js";
 import { i as ExactAnalystRunEvent, l as ExactCapableAnalyst, o as ExactAnalystRunResult } from "./exact-types-KGxBWH4b.js";
 import { c as RegistryRunOpts, i as BudgetPolicy, n as AnalystRegistry, r as AnalystRegistryOptions, s as ExactRegistryRunOpts } from "./registry-Bu3lNole.js";
-import { _ as SelfImproveMethodResult, a as DefinedAgentEval, c as SelfImproveMethodOptions, d as SelfImproveProposerOptions, f as SelfImproveProposerResult, g as SelfImproveMethodProvenance, h as selfImprove, i as DefineAgentEvalOptions, l as SelfImproveOptions, n as AgentEvalEvaluateOptions, o as defineAgentEval, p as SelfImproveResult, r as AgentEvalImproveOptions, s as SelfImproveBudget, t as AgentEvalAgent, u as SelfImproveProgressEvent } from "./define-agent-eval-DcludNJS.js";
-import { a as createTraceAnalyst, i as TraceAnalystDefinition, n as buildDefaultAnalystRegistry, r as CreateTraceAnalystOptions, t as DefaultAnalystRegistryOptions } from "./default-registry-DdqA_-_o.js";
-import { i as TraceAnalysisEngineResult, l as RawAnalystFinding, n as TraceAnalysisEngine, t as DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS } from "./engine-C1DIAEpn.js";
-import { A as SemanticConceptJudgeInput, C as DspyRlmTraceEngineOptions, D as ConceptFinding, E as createChatTraceEngine, M as SemanticConceptJudgeResult, N as runSemanticConceptJudge, O as ConceptSpec, T as ChatTraceEngineOptions, _ as FindingSubject, a as FAILURE_MODE_KIND_SPEC, d as FindingsStore, f as PersistedFinding, j as SemanticConceptJudgeOptions, k as SEMANTIC_CONCEPT_JUDGE_VERSION, l as DiffPolicy, m as diffFindings, t as DEFAULT_TRACE_ANALYST_KINDS, u as FindingsDiff, v as FindingSubjectKind, w as createDspyRlmTraceEngine } from "./index-DBoXFaz0.js";
-import { i as BenchmarkEvaluation } from "./types-ByZslIlr.js";
+import { _ as SelfImproveMethodResult, a as DefinedAgentEval, c as SelfImproveMethodOptions, d as SelfImproveProposerOptions, f as SelfImproveProposerResult, g as SelfImproveMethodProvenance, h as selfImprove, i as DefineAgentEvalOptions, l as SelfImproveOptions, n as AgentEvalEvaluateOptions, o as defineAgentEval, p as SelfImproveResult, r as AgentEvalImproveOptions, s as SelfImproveBudget, t as AgentEvalAgent, u as SelfImproveProgressEvent } from "./define-agent-eval-DQJvVa1P.js";
+import { a as createTraceAnalyst, i as TraceAnalystDefinition, n as buildDefaultAnalystRegistry, r as CreateTraceAnalystOptions, t as DefaultAnalystRegistryOptions } from "./default-registry-C3HTE08O.js";
+import { i as TraceAnalysisEngineResult, l as RawAnalystFinding, n as TraceAnalysisEngine, t as DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS } from "./engine-DjRV55F9.js";
+import { A as SemanticConceptJudgeInput, C as DspyRlmTraceEngineOptions, D as ConceptFinding, E as createChatTraceEngine, M as SemanticConceptJudgeResult, N as runSemanticConceptJudge, O as ConceptSpec, T as ChatTraceEngineOptions, _ as FindingSubject, a as FAILURE_MODE_KIND_SPEC, d as FindingsStore, f as PersistedFinding, j as SemanticConceptJudgeOptions, k as SEMANTIC_CONCEPT_JUDGE_VERSION, l as DiffPolicy, m as diffFindings, t as DEFAULT_TRACE_ANALYST_KINDS, u as FindingsDiff, v as FindingSubjectKind, w as createDspyRlmTraceEngine } from "./index-0jEtpSM7.js";
+import { i as BenchmarkEvaluation } from "./types-qoxUfKQg.js";
 import { a as SpanHandle, n as CaptureWrite, o as TraceEmitter, s as TraceEmitterOptions, t as CaptureErrorHandler } from "./emitter-HcCmFQl_.js";
 import { n as SandboxDriver } from "./sandbox-harness-BlSOu4LX.js";
-import { S as shareAllowed, b as redactForShare, d as ShareSafetyVerdict, f as assessShareSafety, i as RedactOptions, o as RedactionProfile, r as REDACTION_VERSION, s as RedactionReport, u as ShareSafetyStatus, x as redactText, y as redact } from "./redact-CopuMxll.js";
+import { S as shareAllowed, b as redactForShare, d as ShareSafetyVerdict, f as assessShareSafety, i as RedactOptions, o as RedactionProfile, r as REDACTION_VERSION, s as RedactionReport, u as ShareSafetyStatus, x as redactText, y as redact } from "./redact-Cveoq6fJ.js";
 import { a as PairedEvalueStep, c as SequentialDecision, i as PairedEvalueSequence, l as evaluateInterimReleaseConfidence, n as InterimReleaseConfidenceInput, r as PairedEvalueOptions, t as InterimReleaseConfidence, u as pairedEvalueSequence } from "./sequential-BhsrMupG.js";
 import { n as TrajectoryStep, r as buildTrajectory, t as Trajectory } from "./trajectory-Y1fmdlw7.js";
 import { a as runCounterfactual, i as CounterfactualRunner, n as CounterfactualMutation, r as CounterfactualResult, t as CounterfactualContext } from "./counterfactual-CPaWN99-.js";
 import { A as AnalystFindingDigest, B as ControlRunResult, C as createFeedbackTrajectory, D as renderPreferenceMemoryMarkdown, E as feedbackTrajectoryToOptimizerRow, F as ControlActionOutcome, G as StopDecision, H as ControlRuntimeError, I as ControlBudget, J as subjectiveEval, K as objectiveEval, L as ControlContext, M as AnalystRunDigest, N as analystFindingDigest, O as summarizePreferenceMemory, P as analystRunDigest, R as ControlDecision, S as controlRunToFeedbackTrajectory, T as feedbackTrajectoriesToOptimizerRows, U as ControlSeverity, V as ControlRuntimeConfig, W as ControlStep, _ as PreferenceMemoryEntry, a as FeedbackLabel, b as analystRunToReviewRequests, c as FeedbackOptimizerRow, d as FeedbackTask, f as FeedbackTrajectory, g as InMemoryFeedbackTrajectoryStore, h as FileSystemFeedbackTrajectoryStore, i as FeedbackAttempt, j as AnalystReviewDecision, k as withAssignedFeedbackSplit, l as FeedbackOutcome, m as FeedbackTrajectoryStore, n as AnalystReviewRequest, o as FeedbackLabelKind, p as FeedbackTrajectoryFilter, q as runAgentControlLoop, r as FeedbackArtifactType, s as FeedbackLabelSource, t as AnalystFeedbackTrajectoryOptions, u as FeedbackSplitPolicy, v as ProposedSideEffect, w as feedbackTrajectoriesToDatasetScenarios, x as assignFeedbackSplit, y as analystRunToFeedbackTrajectory, z as ControlEvalResult } from "./feedback-trajectory-BXCGTRkz.js";
 import { y as OUTPUT_VALUE } from "./attribute-vocabulary-CcXqHODT.js";
-import { C as inferDomainKeywords, H as captureFetchToRawSink, I as OtlpExport, J as extractUsageFromSse, K as extractUsage, M as AnalyzeTracesResult, N as analyzeTraces, O as scoreTraceInsightReadiness, P as OtlpFlatLine, R as OtlpSpan, S as domainEvidencePattern, W as ExtractedUsage, g as TraceInsightSuite, h as TraceInsightReadiness, k as tokenizeDomainWords, n as toolSpansToTraceAnalysisStore, o as otlpTextToTraceAnalysisStore, r as OtlpFileTraceStore, v as buildTraceInsightContext, x as describeTraceInsightScope, y as buildTraceInsightPrompt, z as exportRunAsOtlp } from "./store-tool-spans-ByLdU26j.js";
+import { C as inferDomainKeywords, H as captureFetchToRawSink, I as OtlpExport, J as extractUsageFromSse, K as extractUsage, M as AnalyzeTracesResult, N as analyzeTraces, O as scoreTraceInsightReadiness, P as OtlpFlatLine, R as OtlpSpan, S as domainEvidencePattern, W as ExtractedUsage, g as TraceInsightSuite, h as TraceInsightReadiness, k as tokenizeDomainWords, n as toolSpansToTraceAnalysisStore, o as otlpTextToTraceAnalysisStore, r as OtlpFileTraceStore, v as buildTraceInsightContext, x as describeTraceInsightScope, y as buildTraceInsightPrompt, z as exportRunAsOtlp } from "./store-tool-spans-BxrfuU2t.js";
 import { a as RunIntegrityReport, o as assertRunCaptured, t as RunIntegrityError } from "./integrity-CaeNeusS.js";
 import { c as judgeSpans, f as runsForScenario, i as argHash } from "./query-DBUQhehH.js";
 import { a as SteeringChange, c as CampaignRunContext, d as CampaignVariant, f as EvalCampaignOptions, h as runEvalCampaign, i as Researcher, l as CampaignRunOutcome, m as FailedRun, n as ExperimentResult, o as CampaignFactoryParams, p as EvalCampaignResult, r as FailureMode, s as CampaignIntegrityPolicy, t as ExperimentPlan, u as CampaignScenario } from "./researcher-DojEMb7E.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { i as JudgeError, o as NotFoundError, r as ConfigError, s as ValidationError, t as AgentEvalError } from "./errors-Dngq5h35.js";
+import { i as JudgeError, n as CaptureIntegrityError, o as NotFoundError, r as ConfigError, s as ValidationError, t as AgentEvalError } from "./errors-Dngq5h35.js";
 import { a as hashCanonical, r as canonicalString } from "./canonical-BsZVgBhW.js";
-import { a as CODING_HARNESSES, c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, n as completionVerdict, o as HARNESS_NATIVE_MODEL, r as createLlmCorrectnessChecker, s as agentProfileHash, t as extractProducedState, u as expandProfileAxes } from "./produced-state-CVmCPQDJ.js";
+import { a as CODING_HARNESSES, c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, n as completionVerdict, o as HARNESS_NATIVE_MODEL, r as createLlmCorrectnessChecker, s as agentProfileHash, t as extractProducedState, u as expandProfileAxes } from "./produced-state-B2AhDRnq.js";
 import { c as groupRunsByAgentProfileCell, d as validateAgentProfileCell, f as verifyAgentProfileCell, h as manifestContentDigest, i as agentProfileCellKey, m as hashJson, r as agentProfileCellHashMaterial, s as buildAgentProfileCell, t as AGENT_PROFILE_KINDS, u as toAgentProfileJson } from "./agent-profile-cell-DcFW4vOc.js";
 import { t as mulberry32 } from "./random-Dn5fPWkt.js";
 import { a as spearmanR, c as weightedMean, i as ranks, n as partialCredit, o as summarizeNumberSeries, r as pearsonR, s as weightedComposite, t as confidenceInterval } from "./descriptive-1V17A-qa.js";
@@ -13,20 +13,21 @@ import { _ as passAtK, a as MANN_WHITNEY_EXACT_MAX_STATES, c as mannWhitneyU, d
 import { a as pairedSignTest, i as pairedDeltaTieFraction, n as DECISION_PAIRED_DELTA_STATISTIC, o as pairedTTest, r as pairedBootstrap, t as BOOTSTRAP_GATE_MIN_N } from "./paired-tests-C8iCsioC.js";
 import { t as eProcess } from "./sequential-eprocess-D1jKoihe.js";
 import { n as iqr, r as welchsTTest } from "./baseline-BC-eBZ7U.js";
-import { i as pairedDeltaTest, n as pairedDecisionShape, r as minimumPairsForPairedDeltaTest, t as decidePairedPromotion } from "./paired-promotion-decision-6cn3bLc3.js";
+import { n as pairedDeltaTest, t as minimumPairsForPairedDeltaTest } from "./paired-delta-test-BF-FEP8V.js";
+import { n as pairedDecisionShape, t as decidePairedPromotion } from "./paired-promotion-decision-DTKl6-G8.js";
 import { a as isToolSpan, i as isLlmSpan, r as isJudgeSpan, t as FAILURE_CLASSES } from "./schema-CSf6qWgZ.js";
 import { d as runsForScenario, r as argHash, s as judgeSpans } from "./query-DlV0pdx4.js";
-import { r as checkCanaries, t as analyzeRuns } from "./analyze-runs-SCSWYpy0.js";
+import { r as checkCanaries, t as analyzeRuns } from "./analyze-runs-B6gv7vAT.js";
 import { r as observedSplitScore, t as isRealnessGated } from "./reward-nw2xZGZG.js";
 import { a as parseRunRecordSafe, c as runTaskScore, i as modelHasSnapshot, l as searchCellRunId, n as UNKNOWN_MODEL, o as roundTripRunRecord, r as isRunRecord, s as runCostFloorUsd, t as RunRecordValidationError, u as validateRunRecord } from "./run-record-BRlM99rX.js";
 import { a as summaryTable, n as gainHistogram, r as paretoChart } from "./summary-report-BMvou2oZ.js";
 import { n as contentHash, r as fileVerdictCache, t as canonicalJson } from "./verdict-cache-BQEsVy9n.js";
-import { $ as scoreRedTeamOutput, G as paretoFrontier, Q as redTeamReport, W as dominates, X as DEFAULT_RED_TEAM_CORPUS, Z as redTeamDataset, a as transientDispatchFailure, et as runCanaries, i as quotaExhaustedUntil, o as aggregateRunScore, ot as runCampaign, s as clamp01, t as llmJudge } from "./llm-judge-Z6MkTkd0.js";
+import { $ as redTeamDataset, K as dominates, Q as DEFAULT_RED_TEAM_CORPUS, U as pairedPromotionPower, W as requiredPairsForPairedPromotion, a as transientDispatchFailure, ct as runCampaign, et as redTeamReport, i as quotaExhaustedUntil, nt as runCanaries, o as aggregateRunScore, q as paretoFrontier, s as clamp01, t as llmJudge, tt as scoreRedTeamOutput } from "./llm-judge-Cififl_V.js";
 import { a as resolveModelPricing, i as isModelPriced, n as estimateCost, r as estimateTokens, t as MODEL_PRICING } from "./metrics-DOMpkoeb.js";
 import { a as CostLedgerPersistenceError, c as costForTokenPricing, i as CostLedger, l as costForUsage, n as CostCallConflictError, o as CostReceiptCaptureError, r as CostCeilingReachedError, s as CostReservationExceededError, t as CostAccountingIncompleteError, u as modelPriceKey } from "./cost-ledger-_IbkejCF.js";
-import { B as assertRealBackend, F as surfaceContentHash, T as parseReflectionResponse, V as summarizeBackendIntegrity, c as ATTESTATION_ALGORITHM, l as attest, u as verifyAttestation, w as buildReflectionPrompt, z as BackendIntegrityError } from "./campaign-evidence-DcQiYhJI.js";
-import { d as redactForShare, f as redactText, n as REDACTION_VERSION, p as shareAllowed, r as assessShareSafety, u as redact } from "./redact-B7rt9Zot.js";
-import { r as selfImprove, t as defineAgentEval } from "./define-agent-eval-DQuos3Aw.js";
+import { B as assertRealBackend, F as surfaceContentHash, T as parseReflectionResponse, V as summarizeBackendIntegrity, c as ATTESTATION_ALGORITHM, l as attest, u as verifyAttestation, w as buildReflectionPrompt, z as BackendIntegrityError } from "./campaign-evidence-DJc60F9C.js";
+import { d as redactForShare, f as redactText, n as REDACTION_VERSION, p as shareAllowed, r as assessShareSafety, u as redact } from "./redact-Dk1ZdJEm.js";
+import { r as selfImprove, t as defineAgentEval } from "./define-agent-eval-qxAPjMSL.js";
 import { n as equivalenceVerdict, t as certificationEvidenceDigest } from "./verdict-DhPoXApk.js";
 import { t as TraceEmitter } from "./emitter-DbMXUIVP.js";
 import { t as buildTrajectory } from "./trajectory-D_7rLrvE.js";
@@ -35,26 +36,26 @@ import { G as DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS, U as parseFindingSubject, h a
 import { _ as completedAnalystReviewQuality, b as validateAnalystReviewDecisions, c as FAILURE_MODE_KIND_SPEC, g as assertUniqueFindingIds, h as analystRunDigest, i as DEFAULT_TRACE_ANALYST_KINDS, m as analystFindingDigest, n as AnalystRegistry, t as buildDefaultAnalystRegistry, v as readAnalystReview, y as snapshotAnalystRun } from "./default-registry-xMLX160E.js";
 import { OUTPUT_VALUE } from "./trace-attributes.js";
 import { r as extractUsageFromSse, t as extractUsage } from "./extract-usage-DFATEuWW.js";
-import { n as InMemoryRawProviderSink, r as NoopRawProviderSink, t as FileSystemRawProviderSink } from "./raw-provider-sink-DYh4Bszw.js";
-import { S as exportRunAsOtlp, T as captureFetchToRawSink, _ as tokenizeDomainWords, d as inferDomainKeywords, g as scoreTraceInsightReadiness, l as describeTraceInsightScope, n as toolSpansToTraceAnalysisStore, o as buildTraceInsightContext, s as buildTraceInsightPrompt, u as domainEvidencePattern, v as analyzeTraces } from "./store-tool-spans-BcC_5ef-.js";
+import { n as InMemoryRawProviderSink, r as NoopRawProviderSink, t as FileSystemRawProviderSink } from "./raw-provider-sink-CXuOhLvT.js";
+import { S as exportRunAsOtlp, T as captureFetchToRawSink, _ as tokenizeDomainWords, d as inferDomainKeywords, g as scoreTraceInsightReadiness, l as describeTraceInsightScope, n as toolSpansToTraceAnalysisStore, o as buildTraceInsightContext, s as buildTraceInsightPrompt, u as domainEvidencePattern, v as analyzeTraces } from "./store-tool-spans-BaGakFc2.js";
 import { n as assertRunCaptured, t as RunIntegrityError } from "./integrity-BFP4kjGj.js";
 import { n as InMemoryTraceStore, t as FileSystemTraceStore } from "./store-DNe_Uv1Q.js";
 import { t as packageVersion$1 } from "./package-version-D7lQHt_-.js";
 import { a as classifyFailure, i as INFRA_FAILURE_BLAMES, o as classifyFailureReason, r as FAILURE_BLAME, s as failureBlame, t as DEFAULT_FAILURE_REASON_RULES } from "./failure-taxonomy-CjabTATj.js";
 import { n as runBoundedProcess, t as DEFAULT_BOUNDED_PROCESS_TIMEOUT_MS } from "./bounded-process-BBZob7vl.js";
-import { t as runEvalCampaign } from "./eval-campaign-CwsBn0Gm.js";
+import { t as runEvalCampaign } from "./eval-campaign-CXT2WYUe.js";
 import "./rollout-B-XBReTC.js";
 import { t as mintRolloutRows } from "./mint-iCD-W43s.js";
 import { n as pairedEvalueSequence, t as evaluateInterimReleaseConfidence } from "./sequential-CzK5DarL.js";
-import { S as judgeFamily, _ as assertServedModels, b as CrossFamilyError, d as stripFencedJson, f as ModelSubstitutionError, h as assertServedModel, i as backoffMs, l as isTransientLlmError, m as assertCrossFamilyServed, o as costReceiptFromLlm, p as ServedCrossFamilyError, r as LlmResponseError, s as costReceiptFromLlmError, t as LlmCallError, u as maximumChargeForLlmRequest, v as checkServedModel, x as assertCrossFamily, y as servedModelAcceptable } from "./llm-client-KYQBh9C8.js";
-import { n as paidJsonChat } from "./chat-json-call-CXHBvUz8.js";
+import { S as judgeFamily, _ as assertServedModels, b as CrossFamilyError, d as stripFencedJson, f as ModelSubstitutionError, h as assertServedModel, i as backoffMs, l as isTransientLlmError, m as assertCrossFamilyServed, o as costReceiptFromLlm, p as ServedCrossFamilyError, r as LlmResponseError, s as costReceiptFromLlmError, t as LlmCallError, u as maximumChargeForLlmRequest, v as checkServedModel, x as assertCrossFamily, y as servedModelAcceptable } from "./llm-client-c_bKHTXz.js";
+import { n as paidJsonChat } from "./chat-json-call-DnlDjpco.js";
 import { i as makeProposalFinding, n as computeFindingId, r as makeFinding } from "./types-CW5b90JH.js";
-import { t as createDspyRlmTraceEngine } from "./dspy-rlm-engine-BX34vPVY.js";
-import { a as diffFindings, n as runSemanticConceptJudge, o as createChatTraceEngine, r as FindingsStore, t as SEMANTIC_CONCEPT_JUDGE_VERSION } from "./semantic-concept-judge-Bg-560H0.js";
+import { t as createDspyRlmTraceEngine } from "./dspy-rlm-engine-k_QdEBZo.js";
+import { a as diffFindings, n as runSemanticConceptJudge, o as createChatTraceEngine, r as FindingsStore, t as SEMANTIC_CONCEPT_JUDGE_VERSION } from "./semantic-concept-judge-Bh5lvKGg.js";
 import { t as analyzeSeries } from "./series-convergence-CjO2QdRW.js";
 import { i as otlpTextToTraceAnalysisStore, n as OtlpFileTraceStore } from "./store-otlp-BPowgPm6.js";
 import { n as evaluateReleaseConfidence, r as bootstrapCi } from "./release-confidence-XQm_xjhR.js";
-import { t as createChatClient } from "./chat-client-B_ItsSBw.js";
+import { t as createChatClient } from "./chat-client-CJORSG_J.js";
 import { createHash } from "node:crypto";
 import { accessSync, appendFileSync, constants, cpSync, existsSync, mkdirSync, promises, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
@@ -1357,7 +1358,7 @@ function assertPredicate(value, where) {
 	]) if (p[field] !== void 0) assertMatcher(p[field], `${where} "${field}"`);
 	if (p.kind !== void 0 && !SPAN_KINDS.includes(p.kind)) throw new ValidationError(`${where}: "kind" must be one of ${SPAN_KINDS.join(", ")}`);
 	if (p.attr !== void 0 && (p.attr === null || typeof p.attr !== "object" || Array.isArray(p.attr))) throw new ValidationError(`${where}: "attr" must be a plain object`);
-	for (const [key, expected] of Object.entries(p.attr ?? {})) if (isSerializedRegex(expected)) assertMatcher(expected, `${where} attr "${key}"`);
+	for (const [key, expected] of Object.entries(p.attr ?? {})) if (expected !== null && typeof expected === "object") assertMatcher(expected, `${where} attr "${key}"`);
 	if (p.not !== void 0) assertPredicate(p.not, `${where} "not"`);
 	if (p.requiresCustom && typeof p.custom !== "function") throw new ValidationError(`${where}: rule was built with a custom predicate function, which does not survive JSON serialization — re-attach \`custom\` after deserializing or drop the rule`);
 	const hasAttr = p.attr !== void 0 && Object.keys(p.attr).length > 0;
@@ -1370,7 +1371,7 @@ function predicateMatches(span, p) {
 	if (p.model !== void 0 && !matchText(spanModel(span), p.model)) return false;
 	if (p.attr !== void 0) for (const [key, expected] of Object.entries(p.attr)) {
 		const actual = span.attributes?.[key];
-		if (isRegexValue(expected)) {
+		if (isRegexValue(expected) || isOneOfMatcher(expected)) {
 			if (!matchText(typeof actual === "string" ? actual : void 0, expected)) return false;
 		} else if (actual !== expected) return false;
 	}
@@ -1812,6 +1813,33 @@ function traceContract(name) {
 function spanRef(span, index) {
 	return span.spanId ?? `#${index}`;
 }
+/**
+* Whether this trace shows any sign that spans of `kind` are actually
+* captured, independent of whether any span happens to match a given rule's
+* predicate. A `never`, `atMost`, `tokensAtMost` or `retrySafe` rule that
+* targets TOOL or LLM spans and finds zero matches cannot otherwise tell "no
+* calls happened" from "calls were not recorded": an exporter that silently
+* drops a span kind makes `forbidden`, `allowed`, `maxCalls` and `retries`
+* checks on that kind pass vacuously. Evidence is: a span of that kind
+* anywhere in the trace, or — for TOOL — a recorded offered-tool set
+* (`gen_ai.tool.definitions`), which proves the capture pipeline ran even on
+* a turn that called no tool.
+*/
+function hasCaptureEvidence(spans, kind) {
+	if (spans.some((span) => contractSpanKind(span) === kind)) return true;
+	if (kind === "TOOL") return spans.some((span) => spanOfferedTools(span).recorded);
+	return false;
+}
+/** Only `TOOL`/`LLM`-scoped predicates have capture evidence to check. */
+function capturedKindOf(p) {
+	return p.kind === "TOOL" || p.kind === "LLM" ? p.kind : void 0;
+}
+function requireCaptureEvidence(spans, p, rule, situation) {
+	const kind = capturedKindOf(p);
+	if (kind === void 0) return;
+	if (hasCaptureEvidence(spans, kind)) return;
+	throw new CaptureIntegrityError(`rule '${rule}': ${situation} and the trace has no ${kind} capture evidence (no ${kind} span` + (kind === "TOOL" ? `, no ${TOOL_DEFINITIONS_ATTR}` : "") + `) — cannot tell whether ${describePredicate(p)} never happened or was never recorded`);
+}
 function indexed(spans, p) {
 	const out = [];
 	spans.forEach((span, i) => {
@@ -2065,7 +2093,9 @@ function checkRetrySafe(rule, spans) {
 	const out = [];
 	const groups = /* @__PURE__ */ new Map();
 	const unseen = /* @__PURE__ */ new Map();
-	for (const call of toolSpans(spans)) {
+	const calls = toolSpans(spans);
+	if (calls.length === 0 && !hasCaptureEvidence(spans, "TOOL")) throw new CaptureIntegrityError(`rule '${rule.label}': retrySafe found 0 TOOL spans and the trace has no TOOL capture evidence (no TOOL span, no ${TOOL_DEFINITIONS_ATTR}) — cannot tell whether no reads or writes happened or the trace lost its TOOL spans`);
+	for (const call of calls) {
 		const name = contractSpanToolName(call.span);
 		if (name === void 0) {
 			out.push({
@@ -2181,11 +2211,15 @@ function checkRule(rule, ctx) {
 			spanId: span.spanId,
 			detail: `span ${spanRef(span, i)} ("${span.name ?? ""}") fails always(${describePredicate(rule.p)})`
 		}]);
-		case "never": return indexed(spans, rule.p).map(({ span, ref }) => ({
-			rule: rule.label,
-			spanId: span.spanId,
-			detail: `span ${ref} ("${span.name ?? ""}") matches never(${describePredicate(rule.p)})`
-		}));
+		case "never": {
+			const matches = indexed(spans, rule.p);
+			if (matches.length === 0) requireCaptureEvidence(spans, rule.p, rule.label, `never(${describePredicate(rule.p)}) matched 0 spans`);
+			return matches.map(({ span, ref }) => ({
+				rule: rule.label,
+				spanId: span.spanId,
+				detail: `span ${ref} ("${span.name ?? ""}") matches never(${describePredicate(rule.p)})`
+			}));
+		}
 		case "eventually": return spans.some((span) => predicateMatches(span, rule.p)) ? [] : [{
 			rule: rule.label,
 			detail: `no span matches eventually(${describePredicate(rule.p)}) over ${spans.length} span(s)`
@@ -2208,6 +2242,7 @@ function checkRule(rule, ctx) {
 		case "neverUnless": return orderViolations(rule.label, indexed(spans, rule.prior), indexed(spans, rule.p), rule.order ?? "start-order", `${describePredicate(rule.p)} without an earlier ${describePredicate(rule.prior)}`);
 		case "atMost": {
 			const matches = indexed(spans, rule.p);
+			if (matches.length === 0) requireCaptureEvidence(spans, rule.p, rule.label, `atMost(${describePredicate(rule.p)}) matched 0 spans`);
 			return matches.length <= rule.max ? [] : [{
 				rule: rule.label,
 				spanId: matches[rule.max]?.span.spanId,
@@ -2216,6 +2251,7 @@ function checkRule(rule, ctx) {
 		}
 		case "tokensAtMost": {
 			const matches = indexed(spans, rule.p);
+			if (matches.length === 0) requireCaptureEvidence(spans, rule.p, rule.label, `tokensAtMost(${describePredicate(rule.p)}) matched 0 spans`);
 			const unknown = matches.find((m) => spanTotalTokens(m.span) === void 0);
 			if (unknown) return [{
 				rule: rule.label,
@@ -9077,290 +9113,6 @@ function isObject(v) {
 	return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 //#endregion
-//#region src/paired-promotion-power.ts
-/**
-* @module
-* Joint power of a configured {@link decidePairedPromotion} call, computed by
-* running that call on data drawn from a registered alternative.
-*
-* Why a simulation and not a formula: `decidePairedPromotion` is not one test.
-* It routes by sample size (exact sign test below `BOOTSTRAP_GATE_MIN_N`,
-* paired bootstrap at or above it) and by shape (Tango's score interval on a
-* two-point outcome), and on top of the deciding interval it applies a
-* sufficiency floor, a zero-width refusal and McNemar's exact veto. A
-* preregistration usually seals two such calls, a continuous primary and a
-* pass/fail veto drawn from the same episodes, and promotes only when both
-* promote. The sample size at which THAT procedure reaches a target power is
-* not the power of any one channel: the sign-test power at n can be 0.8 while
-* the promotion probability is well below it because the veto binds
-* (agent-eval#785). Closed forms exist for single channels only, and each one
-* shipped here under-sized the call it stood in for (`mcnemarRequiredN` is
-* Lachin's normal approximation, 0.65 exact power where it promised 0.8 at 14
-* pairs; `requiredPairedSampleSize` sizes a paired t the procedure never runs).
-* So the only faithful power is the procedure's own promotion rate under the
-* alternative, and that is what this module computes: draw n pairs from the
-* registered law, run every configured call on them exactly as the caller
-* will, repeat, count.
-*
-* The alternative is DECLARATIVE and serializable, never a sampler function,
-* so a preregistration can seal it as bytes: a mixture of cells, each with a
-* probability, an optional pass/fail outcome per arm for the binary calls,
-* and a law for the candidate-minus-baseline delta on the continuous scale.
-* Drawing the cell first and the delta given the cell is what makes the two
-* channels one joint law rather than two marginals.
-*
-* Everything is seeded (`mulberry32`), so a sizing is reproducible from its
-* inputs, and every estimate carries its Monte Carlo standard error and a
-* Wilson interval: a power read at 0.80 from 1,000 simulations is 0.80 ± 0.013.
-*/
-/**
-* Joint power of the configured calls at `n` under the registered alternative:
-* the fraction of simulated data sets on which every call promotes.
-*/
-function pairedPromotionPower(options) {
-	const n = options.n;
-	if (!Number.isInteger(n) || n < 1) throw new Error(`pairedPromotionPower: n must be a positive integer, got ${n}`);
-	const simulations = options.simulations ?? 1e3;
-	if (!Number.isInteger(simulations) || simulations < 1) throw new Error(`pairedPromotionPower: simulations must be a positive integer, got ${simulations}`);
-	const seed = options.seed ?? 1;
-	if (!Number.isFinite(seed)) throw new Error(`pairedPromotionPower: seed must be finite, got ${seed}`);
-	const calls = validateCalls(options.calls);
-	const alternative = validateAlternative(options.alternative, calls);
-	const rng = mulberry32(seed);
-	let promotions = 0;
-	let refusals = 0;
-	const perCall = calls.map(() => ({
-		promote: 0,
-		insufficient: 0,
-		indeterminate: 0,
-		exactTestVetoes: 0,
-		hold: 0,
-		methods: /* @__PURE__ */ new Map()
-	}));
-	for (let s = 0; s < simulations; s++) {
-		const pairs = drawPairs(alternative, n, rng);
-		let all = true;
-		let anyRefusal = false;
-		for (let c = 0; c < calls.length; c++) {
-			const call = calls[c];
-			const decision = runCall(call, pairs, n);
-			const tally = perCall[c];
-			tally.methods.set(decision.method, (tally.methods.get(decision.method) ?? 0) + 1);
-			if (decision.promote) tally.promote++;
-			else {
-				if (!decision.sufficient) tally.insufficient++;
-				if (decision.indeterminate) tally.indeterminate++;
-				if (decision.exactTestVetoes) tally.exactTestVetoes++;
-				if (decision.sufficient && !decision.indeterminate && !decision.exactTestVetoes) tally.hold++;
-			}
-			if (!decision.promote) all = false;
-			if (!decision.sufficient || decision.indeterminate || decision.exactTestVetoes) anyRefusal = true;
-		}
-		if (all) promotions++;
-		else if (anyRefusal) refusals++;
-	}
-	const power = promotions / simulations;
-	const interval = wilson(promotions, simulations, .95);
-	return {
-		n,
-		simulations,
-		seed,
-		power,
-		standardError: Math.sqrt(power * (1 - power) / simulations),
-		low: interval.lower,
-		high: interval.upper,
-		refuse: refusals / simulations,
-		hold: (simulations - promotions - refusals) / simulations,
-		calls: perCall.map((tally, c) => ({
-			outcome: calls[c].outcome,
-			promote: tally.promote / simulations,
-			insufficient: tally.insufficient / simulations,
-			indeterminate: tally.indeterminate / simulations,
-			exactTestVetoes: tally.exactTestVetoes / simulations,
-			hold: tally.hold / simulations,
-			methods: Object.fromEntries([...tally.methods.entries()].map(([method, count]) => [method, count / simulations]))
-		}))
-	};
-}
-/**
-* First n at which {@link pairedPromotionPower} reaches the target, scanning
-* every n from `minPairs` upward. Both the point-estimate answer and the
-* confirmed lower-bound answer are returned; the scan runs until the latter is
-* reached (so the curve past `n` is retained) or `maxPairs` is exhausted. A
-* candidate selected by the scan's bound is certified only by an independent
-* simulation at that n on a different seed; a candidate that fails it is
-* recorded and the scan continues.
-*/
-function requiredPairsForPairedPromotion(options) {
-	const target = options.target ?? .8;
-	if (!Number.isFinite(target) || target <= 0 || target >= 1) throw new Error(`requiredPairsForPairedPromotion: target must be in (0,1), got ${target}`);
-	const minPairs = options.minPairs ?? 1;
-	const maxPairs = options.maxPairs ?? 200;
-	if (!Number.isInteger(minPairs) || minPairs < 1) throw new Error(`requiredPairsForPairedPromotion: minPairs must be a positive integer, got ${minPairs}`);
-	if (!Number.isInteger(maxPairs) || maxPairs < minPairs) throw new Error(`requiredPairsForPairedPromotion: maxPairs must be an integer >= minPairs, got ${maxPairs}`);
-	const seed = options.seed ?? 1;
-	const curve = [];
-	const rejected = [];
-	let n = null;
-	let nAtLowerBound = null;
-	let confirmation = null;
-	for (let candidate = minPairs; candidate <= maxPairs; candidate++) {
-		const result = pairedPromotionPower({
-			n: candidate,
-			alternative: options.alternative,
-			calls: options.calls,
-			simulations: options.simulations,
-			seed
-		});
-		curve.push(result);
-		if (n === null && result.power >= target) n = candidate;
-		if (result.low >= target) {
-			const check = pairedPromotionPower({
-				n: candidate,
-				alternative: options.alternative,
-				calls: options.calls,
-				simulations: options.simulations,
-				seed: confirmationSeed(seed, candidate)
-			});
-			if (check.low >= target) {
-				nAtLowerBound = candidate;
-				confirmation = check;
-				break;
-			}
-			rejected.push(check);
-		}
-	}
-	return {
-		target,
-		n,
-		nAtLowerBound,
-		confirmation,
-		curve,
-		rejected
-	};
-}
-/** A seed for the confirmation at `n` that never equals the scan seed. */
-function confirmationSeed(seed, n) {
-	return (Math.imul((seed | 0) ^ 2654435769, 2246822507) + Math.imul(n, 3266489909) | 1) >>> 0;
-}
-function drawPairs(alternative, n, rng) {
-	const baseline = alternative.baseline ?? {
-		kind: "point",
-		value: 0
-	};
-	const control = new Array(n);
-	const candidate = new Array(n);
-	const controlPass = new Array(n);
-	const candidatePass = new Array(n);
-	for (let i = 0; i < n; i++) {
-		const cell = drawCell(alternative.cells, rng);
-		const base = drawValue(baseline, rng);
-		control[i] = base;
-		candidate[i] = base + drawValue(cell.delta, rng);
-		controlPass[i] = cell.pass?.control ?? false;
-		candidatePass[i] = cell.pass?.treatment ?? false;
-	}
-	return {
-		control,
-		candidate,
-		controlPass,
-		candidatePass
-	};
-}
-function drawCell(cells, rng) {
-	const u = rng();
-	let cumulative = 0;
-	for (const cell of cells) {
-		cumulative += cell.probability;
-		if (u < cumulative) return cell;
-	}
-	return cells[cells.length - 1];
-}
-function drawValue(law, rng) {
-	switch (law.kind) {
-		case "point": return law.value;
-		case "atoms": {
-			const u = rng();
-			let cumulative = 0;
-			for (const atom of law.atoms) {
-				cumulative += atom.probability;
-				if (u < cumulative) return atom.value;
-			}
-			return law.atoms[law.atoms.length - 1].value;
-		}
-		case "normal": {
-			const u1 = 1 - rng();
-			const u2 = rng();
-			return law.mean + law.sd * Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-		}
-	}
-}
-function runCall(call, pairs, n) {
-	const options = {
-		minPairs: n,
-		...call.options
-	};
-	if (call.outcome === "pass") {
-		const scale = call.options.binaryScale;
-		return decidePairedPromotion(pairs.controlPass.map((p) => p ? scale : 0), pairs.candidatePass.map((p) => p ? scale : 0), options);
-	}
-	return decidePairedPromotion(pairs.control, pairs.candidate, options);
-}
-function validateCalls(calls) {
-	if (!Array.isArray(calls) || calls.length === 0) throw new Error("pairedPromotionPower: at least one call is required");
-	calls.forEach((call, i) => {
-		if (call.outcome !== "delta" && call.outcome !== "pass") throw new Error(`pairedPromotionPower: calls[${i}].outcome must be 'delta' or 'pass'`);
-		if (call.options === null || typeof call.options !== "object") throw new Error(`pairedPromotionPower: calls[${i}].options must be an object`);
-		if (call.options.minPairs !== void 0 && (!Number.isInteger(call.options.minPairs) || call.options.minPairs < 1)) throw new Error(`pairedPromotionPower: calls[${i}].options.minPairs must be a positive integer`);
-		if (call.outcome === "pass") {
-			const scale = call.options.binaryScale;
-			if (scale === void 0 || !Number.isFinite(scale) || scale <= 0) throw new Error(`pairedPromotionPower: calls[${i}] is a 'pass' call and must declare a finite positive options.binaryScale`);
-			if (call.options.continuous) throw new Error(`pairedPromotionPower: calls[${i}] is a 'pass' call; continuous cannot accompany it`);
-			if (call.options.statistic === "median") throw new Error(`pairedPromotionPower: calls[${i}] is a 'pass' call; binaryScale requires the mean statistic, not median`);
-		} else if (call.options.binaryScale !== void 0) throw new Error(`pairedPromotionPower: calls[${i}] is a 'delta' call and cannot declare binaryScale; use a 'pass' call for a two-point outcome`);
-	});
-	return calls;
-}
-function validateAlternative(alternative, calls) {
-	if (!alternative || !Array.isArray(alternative.cells) || alternative.cells.length === 0) throw new Error("pairedPromotionPower: alternative.cells must be a non-empty array");
-	const needsPass = calls.some((call) => call.outcome === "pass");
-	let total = 0;
-	alternative.cells.forEach((cell, i) => {
-		if (!Number.isFinite(cell.probability) || cell.probability < 0) throw new Error(`pairedPromotionPower: cells[${i}].probability must be a finite number >= 0`);
-		total += cell.probability;
-		if (needsPass) {
-			if (!cell.pass || typeof cell.pass.control !== "boolean" || typeof cell.pass.treatment !== "boolean") throw new Error(`pairedPromotionPower: cells[${i}].pass must give control and treatment booleans when a 'pass' call is configured`);
-		}
-		validateLaw(cell.delta, `cells[${i}].delta`);
-	});
-	if (Math.abs(total - 1) > 1e-9) throw new Error(`pairedPromotionPower: cell probabilities must sum to 1, got ${total}`);
-	if (alternative.baseline !== void 0) validateLaw(alternative.baseline, "baseline");
-	return alternative;
-}
-function validateLaw(law, where) {
-	if (!law || typeof law !== "object") throw new Error(`pairedPromotionPower: ${where} must be a law object`);
-	switch (law.kind) {
-		case "point":
-			if (!Number.isFinite(law.value)) throw new Error(`pairedPromotionPower: ${where}.value must be finite`);
-			return;
-		case "atoms": {
-			if (!Array.isArray(law.atoms) || law.atoms.length === 0) throw new Error(`pairedPromotionPower: ${where}.atoms must be a non-empty array`);
-			let total = 0;
-			law.atoms.forEach((atom, i) => {
-				if (!Number.isFinite(atom.value)) throw new Error(`pairedPromotionPower: ${where}.atoms[${i}].value must be finite`);
-				if (!Number.isFinite(atom.probability) || atom.probability < 0) throw new Error(`pairedPromotionPower: ${where}.atoms[${i}].probability must be a finite number >= 0`);
-				total += atom.probability;
-			});
-			if (Math.abs(total - 1) > 1e-9) throw new Error(`pairedPromotionPower: ${where}.atoms probabilities must sum to 1, got ${total}`);
-			return;
-		}
-		case "normal":
-			if (!Number.isFinite(law.mean) || !Number.isFinite(law.sd) || law.sd < 0) throw new Error(`pairedPromotionPower: ${where} needs a finite mean and a finite sd >= 0`);
-			return;
-		default: throw new Error(`pairedPromotionPower: ${where}.kind must be 'point', 'atoms' or 'normal'`);
-	}
-}
-//#endregion
 //#region src/treatment-gate.ts
 /**
 * Core predicate. Gated (treatment-not-applied) ONLY when telemetry was