@tangle-network/agent-eval 0.86.0 → 0.89.0

package/dist/index.d.ts

@@ -1,30 +1,32 @@
-export { A as ActionExecutionPolicy, a as ActionPolicyDecision, C as ControlRunToRunRecordOptions, L as LlmJsonCall, b as LlmReviewerConfig, P as ProposeFn, c as ProposeInput, d as ProposeOutput, e as ProposeReviewConfig, f as ProposeReviewControlAction, g as ProposeReviewControlConfig, h as ProposeReviewControlResult, i as ProposeReviewControlState, j as ProposeReviewReport, k as ProposeReviewShot, R as Review, l as ReviewFn, m as ReviewInput, n as ReviewMemoryEntry, o as ReviewMemoryStore, p as RunEvidenceMetadata, V as Verification, q as VerifyFn, r as controlFailureClassFromVerification, s as controlRunToRunRecord, t as createLlmReviewer, u as evaluateActionPolicy, v as inMemoryReviewStore, w as jsonlReviewStore, x as runProposeReview, y as runProposeReviewAsControlLoop, z as scoreFromEvals } from './control-GeE8OhpN.js';
-import { R as RunRecord, a as RunSplitTag } from './run-record-De9VarXR.js';
-export { e as AGENT_PROFILE_KINDS, A as AgentProfileCell, d as AgentProfileCellInput, f as AgentProfileCellSchemaVersion, g as AgentProfileCellValidationError, h as AgentProfileDimensionValue, i as AgentProfileHarness, j as AgentProfileJson, k as AgentProfileKind, l as AgentProfileSource, m as AgentProfileSourceInput, J as JudgeScoresRecord, c as RunJudgeMetadata, n as RunOutcome, o as RunRecordValidationError, b as RunTokenUsage, S as SandboxAgentProfileLike, p as agentProfileCellHashMaterial, q as agentProfileCellKey, r as assertRunAgentProfileCell, s as buildAgentProfileCell, t as buildSandboxAgentProfileCell, u as groupRunsByAgentProfileCell, v as isRunRecord, w as parseRunRecordSafe, x as requireAgentProfileCell, y as roundTripRunRecord, z as toAgentProfileJson, B as validateAgentProfileCell, C as validateRunRecord, D as verifyAgentProfileCell } from './run-record-De9VarXR.js';
-export { B as BehavioralMetrics, z as ConceptComplexity, A as ConceptFinding, E as ConceptSpec, G as ConceptWeightStrategy, C as CreateAnalystAiConfig, H as DEFAULT_COMPLEXITY_WEIGHTS, D as DEFAULT_TRACE_ANALYST_KINDS, b as DefaultAnalystRegistryOptions, c as DiffPolicy, F as FAILURE_MODE_KIND_SPEC, f as FindingSubject, g as FindingSubjectKind, i as FindingsDiff, j as FindingsStore, I as IMPROVEMENT_KIND_SPEC, k as KNOWLEDGE_GAP_KIND_SPEC, l as KNOWLEDGE_POISONING_KIND_SPEC, P as PersistedFinding, J as SEMANTIC_CONCEPT_JUDGE_VERSION, m as SKILL_USAGE_ANALYST, a as SemanticConceptJudgeInput, S as SemanticConceptJudgeOptions, L as SemanticConceptJudgeResult, n as SkillUsageAnalyst, M as SuboptimalCode, N as SuboptimalSignal, r as buildDefaultAnalystRegistry, O as computeTraceMetrics, t as createAnalystAi, Q as createSemanticConceptJudge, u as defaultIsMaterial, v as diffFindings, R as runSemanticConceptJudge } from './semantic-concept-judge-DIEgr_6v.js';
-import { l as ChatRequest, p as CreateChatClientOpts } from './types-Cu3u_x59.js';
-export { A as Analyst, a as AnalystContext, g as AnalystCost, c as AnalystFinding, i as AnalystInputKind, j as AnalystRequirements, f as AnalystRunEvent, e as AnalystRunInputs, d as AnalystRunResult, b as AnalystRunSummary, h as AnalystSeverity, k as ChatCallOpts, C as ChatClient, m as ChatResponse, n as ChatTransport, o as CliBridgeTransportOpts, D as DirectProviderTransportOpts, E as EvidenceRef, M as MockTransportOpts, R as RouterTransportOpts, S as SandboxSdkTransportOpts, q as computeFindingId, r as createChatClient, s as makeFinding } from './types-Cu3u_x59.js';
-export { C as CreateTraceAnalystKindOpts, a as RawAnalystFinding, T as TraceAnalystGolden, c as TraceAnalystKindSpec, d as createTraceAnalystKind, r as renderPriorFindings } from './kind-factory-CVecZZG_.js';
-export { A as AnalystHooks, a as AnalystRegistry, b as AnalystRegistryOptions, B as BudgetPolicy, R as RegistryRunOpts } from './registry-DrEQ3Luj.js';
+export { A as ActionExecutionPolicy, a as ActionPolicyDecision, C as ControlRunToRunRecordOptions, L as LlmJsonCall, b as LlmReviewerConfig, P as ProposeFn, c as ProposeInput, d as ProposeOutput, e as ProposeReviewConfig, f as ProposeReviewControlAction, g as ProposeReviewControlConfig, h as ProposeReviewControlResult, i as ProposeReviewControlState, j as ProposeReviewReport, k as ProposeReviewShot, R as Review, l as ReviewFn, m as ReviewInput, n as ReviewMemoryEntry, o as ReviewMemoryStore, p as RunEvidenceMetadata, V as Verification, q as VerifyFn, r as controlFailureClassFromVerification, s as controlRunToRunRecord, t as createLlmReviewer, u as evaluateActionPolicy, v as inMemoryReviewStore, w as jsonlReviewStore, x as runProposeReview, y as runProposeReviewAsControlLoop, z as scoreFromEvals } from './control-_Qb7skHX.js';
+import { R as RunRecord, a as RunSplitTag } from './run-record-e7vj1uZQ.js';
+export { e as AGENT_PROFILE_KINDS, A as AgentProfileCell, d as AgentProfileCellInput, f as AgentProfileCellSchemaVersion, g as AgentProfileCellValidationError, h as AgentProfileDimensionValue, i as AgentProfileHarness, j as AgentProfileJson, k as AgentProfileKind, l as AgentProfileSource, m as AgentProfileSourceInput, J as JudgeScoresRecord, c as RunJudgeMetadata, n as RunOutcome, o as RunRecordValidationError, b as RunTokenUsage, S as SandboxAgentProfileLike, p as agentProfileCellHashMaterial, q as agentProfileCellKey, r as assertRunAgentProfileCell, s as buildAgentProfileCell, t as buildSandboxAgentProfileCell, u as groupRunsByAgentProfileCell, v as isRunRecord, w as parseRunRecordSafe, x as requireAgentProfileCell, y as roundTripRunRecord, z as toAgentProfileJson, B as validateAgentProfileCell, C as validateRunRecord, D as verifyAgentProfileCell } from './run-record-e7vj1uZQ.js';
+export { B as BehavioralMetrics, x as ConceptComplexity, y as ConceptFinding, z as ConceptSpec, A as ConceptWeightStrategy, C as CreateAnalystAiConfig, E as DEFAULT_COMPLEXITY_WEIGHTS, D as DEFAULT_TRACE_ANALYST_KINDS, b as DiffPolicy, F as FAILURE_MODE_KIND_SPEC, e as FindingSubject, f as FindingSubjectKind, h as FindingsDiff, i as FindingsStore, I as IMPROVEMENT_KIND_SPEC, j as KNOWLEDGE_GAP_KIND_SPEC, k as KNOWLEDGE_POISONING_KIND_SPEC, P as PersistedFinding, G as SEMANTIC_CONCEPT_JUDGE_VERSION, l as SKILL_USAGE_ANALYST, a as SemanticConceptJudgeInput, S as SemanticConceptJudgeOptions, H as SemanticConceptJudgeResult, m as SkillUsageAnalyst, J as SuboptimalCode, L as SuboptimalSignal, M as computeTraceMetrics, r as createAnalystAi, N as createSemanticConceptJudge, s as defaultIsMaterial, t as diffFindings, O as runSemanticConceptJudge } from './semantic-concept-judge-Dn8Z6KEG.js';
+import { l as ChatRequest, p as CreateChatClientOpts } from './types-2VVIL04s.js';
+export { A as Analyst, a as AnalystContext, g as AnalystCost, c as AnalystFinding, i as AnalystInputKind, j as AnalystRequirements, f as AnalystRunEvent, e as AnalystRunInputs, d as AnalystRunResult, b as AnalystRunSummary, h as AnalystSeverity, k as ChatCallOpts, C as ChatClient, m as ChatResponse, n as ChatTransport, o as CliBridgeTransportOpts, D as DirectProviderTransportOpts, E as EvidenceRef, M as MockTransportOpts, R as RouterTransportOpts, S as SandboxSdkTransportOpts, q as computeFindingId, r as createChatClient, s as makeFinding } from './types-2VVIL04s.js';
+export { a as AnalystHooks, A as AnalystRegistry, c as AnalystRegistryOptions, B as BudgetPolicy, D as DefaultAnalystRegistryOptions, R as RegistryRunOpts, b as buildDefaultAnalystRegistry } from './default-registry-zoGHUQEH.js';
+export { C as CreateTraceAnalystKindOpts, a as RawAnalystFinding, c as TraceAnalystGolden, T as TraceAnalystKindSpec, d as createTraceAnalystKind, r as renderPriorFindings } from './kind-factory-5b7xXXOr.js';
 import { TCloud } from '@tangle-network/tcloud';
 import { B as BenchmarkRunnerConfig, S as Scenario, c as BenchmarkReport, P as ProductClientConfig, C as CheckResult, T as TestResult, d as PersonaConfig, D as DriverResult, e as DriverState, b as JudgeFn, f as CollectedArtifacts, g as ScenarioResult, h as TurnMetrics, i as ScenarioFile, j as CompletionCriterion } from './types-Croy5h7V.js';
 export { A as ArtifactCheck, k as ArtifactResult, E as EvalResult, F as FeedbackPattern, l as JudgeConfig, a as JudgeInput, m as JudgeRubric, J as JudgeScore, n as PersonaRigor, R as RouteMap, o as RubricDimension, p as Turn, q as TurnResult } from './types-Croy5h7V.js';
 export { c as ControlActionFailureMode, d as ControlActionOutcome, e as ControlBudget, f as ControlContext, g as ControlDecision, C as ControlEvalResult, a as ControlRunResult, h as ControlRuntimeConfig, i as ControlRuntimeError, j as ControlSeverity, b as ControlStep, k as ControlStopPolicies, S as StopDecision, l as allCriticalPassed, o as objectiveEval, r as runAgentControlLoop, s as stopOnNoProgress, m as stopOnRepeatedAction, n as subjectiveEval } from './control-runtime-DuFBYg7A.js';
-import { A as AgentEvalError } from './errors-Dwqw-T_m.js';
-export { a as AgentEvalErrorCode, C as CaptureIntegrityError, b as ConfigError, J as JudgeError, N as NotFoundError, R as ReplayError, V as ValidationError, c as VerificationError } from './errors-Dwqw-T_m.js';
-import { b as FeedbackLabel, F as FeedbackTrajectoryStore, a as FeedbackTrajectory } from './feedback-trajectory-B3rErRsh.js';
-export { c as FeedbackArtifactType, d as FeedbackAttempt, e as FeedbackLabelKind, f as FeedbackLabelSource, g as FeedbackOptimizerRow, h as FeedbackOutcome, i as FeedbackReplayAdapter, j as FeedbackReplayResult, k as FeedbackSeverity, l as FeedbackSplitPolicy, m as FeedbackTask, n as FeedbackTrajectoryFilter, o as FileSystemFeedbackTrajectoryStore, I as InMemoryFeedbackTrajectoryStore, P as PreferenceMemoryEntry, p as ProposedSideEffect, q as assignFeedbackSplit, r as controlRunToFeedbackTrajectory, s as createFeedbackTrajectory, t as feedbackTrajectoriesToDatasetScenarios, u as feedbackTrajectoriesToOptimizerRows, v as feedbackTrajectoryToDatasetScenario, w as feedbackTrajectoryToOptimizerRow, x as parseFeedbackTrajectoriesJsonl, y as renderPreferenceMemoryMarkdown, z as replayFeedbackTrajectories, A as replayFeedbackTrajectory, B as serializeFeedbackTrajectoriesJsonl, C as summarizePreferenceMemory, D as withAssignedFeedbackSplit } from './feedback-trajectory-B3rErRsh.js';
-import { A as AgentProfile$1 } from './agent-profile-D0PBIWlV.js';
-export { c as ArtifactCheckArtifact, d as ArtifactEventLike, e as ArtifactValidator, f as BackendIntegrityError, B as BackendIntegrityReport, C as CompletionRequirement, a as CompletionVerdict, b as CorrectnessChecker, L as LlmCorrectnessCheckerOpts, g as ProducedProposal, P as ProducedState, h as ProposalEventLike, i as RequirementCheck, R as RuntimeEventLike, S as SatisfiedBy, T as TaskGold, j as ToolCallEventLike, V as ValidationContext, k as ValidationIssue, l as ValidationResult, m as agentProfileHash, n as assertRealBackend, o as byteLengthRange, p as composeValidators, q as containsAll, r as createLlmCorrectnessChecker, s as createTokenRecallChecker, t as extractProducedState, u as jsonHasKeys, v as parseCorrectnessResponse, w as regexMatch, x as summarizeBackendIntegrity, y as verifyCompletion } from './agent-profile-D0PBIWlV.js';
+import { A as AgentEvalError, J as JudgeError, a as ConfigError } from './errors-CzMUYo7b.js';
+export { b as AgentEvalErrorCode, C as CaptureIntegrityError, N as NotFoundError, R as ReplayError, V as ValidationError, c as VerificationError } from './errors-CzMUYo7b.js';
+import { b as FeedbackLabel, F as FeedbackTrajectoryStore, a as FeedbackTrajectory } from './feedback-trajectory-D9OVLrg9.js';
+export { c as FeedbackArtifactType, d as FeedbackAttempt, e as FeedbackLabelKind, f as FeedbackLabelSource, g as FeedbackOptimizerRow, h as FeedbackOutcome, i as FeedbackReplayAdapter, j as FeedbackReplayResult, k as FeedbackSeverity, l as FeedbackSplitPolicy, m as FeedbackTask, n as FeedbackTrajectoryFilter, o as FileSystemFeedbackTrajectoryStore, I as InMemoryFeedbackTrajectoryStore, P as PreferenceMemoryEntry, p as ProposedSideEffect, q as assignFeedbackSplit, r as controlRunToFeedbackTrajectory, s as createFeedbackTrajectory, t as feedbackTrajectoriesToDatasetScenarios, u as feedbackTrajectoriesToOptimizerRows, v as feedbackTrajectoryToDatasetScenario, w as feedbackTrajectoryToOptimizerRow, x as parseFeedbackTrajectoriesJsonl, y as renderPreferenceMemoryMarkdown, z as replayFeedbackTrajectories, A as replayFeedbackTrajectory, B as serializeFeedbackTrajectoriesJsonl, C as summarizePreferenceMemory, D as withAssignedFeedbackSplit } from './feedback-trajectory-D9OVLrg9.js';
+import { b as CorrectnessChecker, A as AgentProfile$1 } from './pre-registration-DELOEJ8v.js';
+export { c as ArtifactCheckArtifact, d as ArtifactEventLike, e as ArtifactValidator, f as BackendIntegrityError, B as BackendIntegrityReport, C as CompletionRequirement, a as CompletionVerdict, H as HypothesisManifest, g as HypothesisResult, L as LlmCorrectnessCheckerOpts, h as ProducedProposal, P as ProducedState, i as ProposalEventLike, j as RequirementCheck, R as RuntimeEventLike, k as SatisfiedBy, S as SignedManifest, l as SignedManifestAlgo, T as TaskGold, m as ToolCallEventLike, V as ValidationContext, n as ValidationIssue, o as ValidationResult, p as agentProfileHash, q as assertRealBackend, r as byteLengthRange, s as canonicalize, t as completionVerdict, u as composeValidators, v as containsAll, w as createLlmCorrectnessChecker, x as createTokenRecallChecker, y as evaluateHypothesis, z as extractProducedState, D as hashJson, E as jsonHasKeys, F as parseCorrectnessResponse, G as regexMatch, I as signManifest, J as summarizeBackendIntegrity, K as verifyCompletion, M as verifyManifest } from './pre-registration-DELOEJ8v.js';
 export { DataAcquisitionPlan, KnowledgeAcquisitionMode, KnowledgeBundle, KnowledgeFallbackPolicy, KnowledgeFreshness, KnowledgeImportance, KnowledgeReadinessReport, KnowledgeRecommendedAction, KnowledgeRequirement, KnowledgeRequirementCategory, KnowledgeResponsibleSurface, KnowledgeSensitivity, ScoreKnowledgeReadinessOptions, UserQuestion, acquisitionPlansForKnowledgeGaps, blockingKnowledgeEval, knowledgeReadinessTracePayload, scoreKnowledgeReadiness, userQuestionsForKnowledgeGaps } from './knowledge/index.js';
-import { h as ReleaseConfidenceThresholds, f as ReleaseConfidenceScorecard } from './release-report-hlNtD12q.js';
-export { A as ActionableSideInfo, o as AsiSeverity, B as BootstrapOptions, a as BootstrapResult, J as JudgeReplayGateArgs, R as ReleaseConfidenceAxis, b as ReleaseConfidenceAxisName, c as ReleaseConfidenceInput, d as ReleaseConfidenceIssue, e as ReleaseConfidenceMetrics, g as ReleaseConfidenceStatus, i as ReleaseTraceEvidence, j as RenderReleaseReportOptions, V as Verdict, k as assertReleaseConfidence, l as bootstrapCi, m as evaluateReleaseConfidence, n as judgeReplayGate, r as renderReleaseReport } from './release-report-hlNtD12q.js';
-export { C as CliffsMagnitude, c as CorpusAgreementOptions, d as CorpusAgreementPerDimension, e as CorpusAgreementReport, f as CorpusScoreRecord, P as PairedBootstrapOptions, a as PairedBootstrapResult, W as WeightedCompositeInput, g as WeightedCompositeResult, b as benjaminiHochberg, h as bonferroni, i as cliffsDelta, j as cohensD, k as confidenceInterval, l as corpusInterRaterAgreement, m as corpusInterRaterAgreementFromJudgeScores, n as interRaterReliability, o as interpretCliffs, q as mannWhitneyU, r as normalizeScores, p as pairedBootstrap, s as pairedMde, t as pairedTTest, u as partialCredit, v as requiredSampleSize, x as weightedComposite, y as weightedMean, w as wilcoxonSignedRank } from './statistics-CnC1FMbx.js';
+import { h as ReleaseConfidenceThresholds, f as ReleaseConfidenceScorecard } from './release-report-euXIV_Sk.js';
+export { A as ActionableSideInfo, o as AsiSeverity, B as BootstrapOptions, a as BootstrapResult, J as JudgeReplayGateArgs, R as ReleaseConfidenceAxis, b as ReleaseConfidenceAxisName, c as ReleaseConfidenceInput, d as ReleaseConfidenceIssue, e as ReleaseConfidenceMetrics, g as ReleaseConfidenceStatus, i as ReleaseTraceEvidence, j as RenderReleaseReportOptions, V as Verdict, k as assertReleaseConfidence, l as bootstrapCi, m as evaluateReleaseConfidence, n as judgeReplayGate, r as renderReleaseReport } from './release-report-euXIV_Sk.js';
+export { c as CliffsMagnitude, d as CorpusAgreementOptions, e as CorpusAgreementPerDimension, C as CorpusAgreementReport, f as CorpusScoreRecord, g as EProcess, h as EProcessOptions, E as EProcessState, i as EProcessStep, P as PairedBootstrapOptions, a as PairedBootstrapResult, W as WeightedCompositeInput, j as WeightedCompositeResult, b as benjaminiHochberg, k as bonferroni, l as cliffsDelta, m as cohensD, n as confidenceInterval, o as corpusInterRaterAgreement, q as corpusInterRaterAgreementFromJudgeScores, r as eProcess, s as interRaterReliability, t as interpretCliffs, u as mannWhitneyU, v as mulberry32, x as normalizeScores, p as pairedBootstrap, y as pairedMde, z as pairedTTest, A as partialCredit, B as requiredSampleSize, D as weightedComposite, F as weightedMean, w as wilcoxonSignedRank } from './statistics-C7PozGrZ.js';
 import { a as AnalyzeTracesInput, A as AnalyzeTracesOptions, b as AnalyzeTracesResult } from './analyst-C8HHvfJp.js';
 export { c as AnalyzeTracesTurnSnapshot, d as analyzeTraces } from './analyst-C8HHvfJp.js';
 import { OtelExporter, OtelExportConfig } from './traces.js';
 export { CaptureFetchContext, CaptureFetchOptions, ExportableSpan, ExtractedUsage, FlattenOtlpOptions, OTEL_AGENT_EVAL_SCOPE, OtlpExport, OtlpFileTraceStore, OtlpFileTraceStoreOptions, OtlpFlatLine, OtlpResourceSpans, OtlpSpan, OtlpToRunRecordsOptions, OtlpTraceRunRecord, ProjectedOtlpSpan, ReplayCache, ReplayCacheEntry, ReplayCacheMissError, ReplayCacheStats, ReplayFetchOptions, SpanNotFoundError, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_SUBAGENT_DESCRIPTION, TraceAggregate, TraceAnalystHookOptions, TraceFileMissingError, TraceInsightContext, TraceInsightFinding, TraceInsightPanelRole, TraceInsightPromptInput, TraceInsightQualityGate, TraceInsightQuestion, TraceInsightReadiness, TraceInsightSuite, TraceInsightTask, TraceNotFoundError, TraceStoreSource, TraceStoreToOtlpOptions, TracesToOtlpResult, asNumber, asString, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, captureFetchToRawSink, convertTraceStoresToOtlp, createOtelExporter, createOtelTracingStore, createReplayFetch, defaultTraceInsightPanel, describeTraceInsightScope, domainEvidencePattern, exportRunAsOtlp, extractOtlpAttributes, extractUsage, extractUsageFromResponse, extractUsageFromSse, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, inferDomainKeywords, inferOtlpKind, iterateRawCalls, otelRunCompleteHook, otlpToRunRecords, otlpToTraceRunRecords, planTraceInsightQuestions, projectOtlpFlatLine, readOtlpStatus, scoreTraceInsightReadiness, stringField, tokenizeDomainWords, traceAnalystFunctionGroup, traceAnalystOnRunComplete } from './traces.js';
 export { D as DEFAULT_TRACE_ANALYST_BUDGETS, b as DatasetOverview, E as ErrorCluster, Q as QueryTracesPage, S as SearchSpanResult, c as SearchTraceResult, d as SpanMatchRecord, e as TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, T as TraceAnalysisStore, f as TraceAnalystByteBudgets, g as TraceAnalystFilters, a as TraceAnalystSpan, h as TraceAnalystSpanKind, i as TraceAnalystSpanStatus, j as TraceAnalystTraceSummary, V as ViewSpansResult, k as ViewTraceOversized, l as ViewTraceResult } from './store-C1YxJDEK.js';
+import { a as JudgeConfig, S as Scenario$1, G as Gate, J as JudgeScore } from './types-BU-7W85F.js';
+import { A as AnalyzeRunsOptions } from './analyze-runs-DwCEkpO_.js';
 import { S as SteeringBundle } from './harness-optimizer-EnEnQPsr.js';
 export { D as DEFAULT_HARNESS_OBJECTIVES, H as HarnessAdapter, a as HarnessExperimentConfig, b as HarnessExperimentResult, c as HarnessIntervention, d as HarnessRunRequest, e as HarnessRunResult, f as HarnessScenario, g as HarnessSelection, h as HarnessVariant, i as HarnessVariantReport, M as MeasurementPolicy, j as SteeringDelta, k as SteeringRolePrompt, W as WorkflowTopology, m as mergeSteeringBundle, r as renderSteeringText, l as runHarnessExperiment, s as selectHarnessVariant, n as summarizeHarnessResults } from './harness-optimizer-EnEnQPsr.js';
 import { S as SandboxDriver, H as HarnessConfig, a as SandboxHarnessResult } from './test-graded-scenario-BdVaPyHT.js';
@@ -33,7 +35,7 @@ import { b as RunScoreWeights, R as RunScore } from './run-critic-BAIjX99r.js';
 export { D as DEFAULT_RUN_SCORE_WEIGHTS, c as RunCritic, d as RunCriticOptions, a as RunTrace, e as aggregateRunScore, f as clamp01 } from './run-critic-BAIjX99r.js';
 import { T as TraceEmitter } from './emitter-DEZwY14K.js';
 export { R as RunCompleteHook, a as RunCompleteHookContext, S as SpanHandle, b as TraceEmitterOptions, l as llmSpanFromProvider } from './emitter-DEZwY14K.js';
-export { b as RunIntegrityError, R as RunIntegrityExpectations, c as RunIntegrityIssue, d as RunIntegrityIssueCode, a as RunIntegrityReport, e as assertRunCaptured, t as throwIfRunIncomplete } from './integrity-CJzrpUua.js';
+export { b as RunIntegrityError, R as RunIntegrityExpectations, c as RunIntegrityIssue, d as RunIntegrityIssueCode, a as RunIntegrityReport, e as assertRunCaptured, t as throwIfRunIncomplete } from './integrity-VJ9A7aST.js';
 export { a as aggregateLlm, b as argHash, g as groupBy, j as judgeSpans, l as llmSpans, r as runFailureClass, c as runsForScenario, t as toolSpans } from './query-CqTxMwDw.js';
 export { F as FileSystemRawProviderSink, a as FileSystemRawProviderSinkOptions, I as InMemoryRawProviderSink, b as InMemoryRawProviderSinkOptions, N as NoopRawProviderSink, P as ProviderRedactor, c as RawProviderDirection, d as RawProviderEvent, R as RawProviderSink, e as RawProviderSinkFilter, f as defaultProviderRedactor, p as providerFromBaseUrl } from './raw-provider-sink-C46HDghv.js';
 export { D as DEFAULT_REDACTION_RULES, b as REDACTION_VERSION, a as RedactionReport, R as RedactionRule, r as redactString, c as redactValue } from './redact-B40YG2M_.js';
@@ -42,31 +44,35 @@ export { A as Artifact, E as EventKind, i as FAILURE_CLASSES, F as FailureClass,
 import { T as TraceStore, R as RunFilter } from './store-CKUAgsJz.js';
 export { E as EventFilter, F as FileSystemTraceStore, a as FileSystemTraceStoreOptions, I as InMemoryTraceStore, S as SpanFilter } from './store-CKUAgsJz.js';
 export { D as DEFAULT_FAILURE_RULES, b as FailureClassification, c as FailureContext, d as FailureRule, e as classifyFailure } from './failure-cluster-CL7IVgkJ.js';
-export { P as ProjectRuntimeTrajectoryEvidenceOptions, a as RuntimeTrajectoryEvidenceProjection, b as RuntimeTrajectoryEvidenceSummary, c as RuntimeTrajectoryHookEvent, R as RuntimeTrajectoryRecord, d as RuntimeTrajectoryRunRecord, p as parseRuntimeTrajectoryHookEvent, e as projectRuntimeTrajectoryEvidence } from './runtime-trajectory-BLRiaifm.js';
+export { P as ProjectRuntimeTrajectoryEvidenceOptions, a as RuntimeTrajectoryEvidenceProjection, b as RuntimeTrajectoryEvidenceSummary, c as RuntimeTrajectoryHookEvent, R as RuntimeTrajectoryRecord, d as RuntimeTrajectoryRunRecord, p as parseRuntimeTrajectoryHookEvent, e as projectRuntimeTrajectoryEvidence } from './runtime-trajectory-BDgfGZSr.js';
 import { a as BaselineReport } from './baseline-DE36-Np7.js';
 export { B as BaselineOptions, M as MetricSamples, b as MetricVerdict, T as ToolStats, d as ToolUseMetrics, e as ToolUseOptions, f as compareToBaseline, c as computeToolUseMetrics, i as iqr, w as welchsTTest } from './baseline-DE36-Np7.js';
-import { T as Trajectory, a as TrajectoryStep } from './trajectory-GEdXJCL5.js';
+import { a as TrajectoryStep, T as Trajectory } from './trajectory-GEdXJCL5.js';
 export { b as buildTrajectory } from './trajectory-GEdXJCL5.js';
+import { b as ChannelRollup, C as CostLedger } from './cost-ledger-DuSqlw5B.js';
+export { a as CostChannel, c as CostLedgerEntry, d as CostLedgerSummary, e as CostResult, f as CostUsage, g as costForUsage, m as modelPriceKey } from './cost-ledger-DuSqlw5B.js';
 export { D as Direction, O as Objective, P as ParetoResult, c as crowdingDistance, d as dominates, p as paretoFrontier, a as paretoFrontierWithCrowding, s as scalarScore } from './pareto-E-pembql.js';
-export { D as DefaultVerdict } from './verdict-CeEgtjyI.js';
-import { a as DatasetScenario, b as Dataset } from './dataset-B2kL-fSM.js';
-export { d as DatasetDifficulty, c as DatasetManifest, e as DatasetProvenance, D as DatasetSplit, H as HoldoutLockedError, S as SliceOptions, h as hashScenarios } from './dataset-B2kL-fSM.js';
-export { b as CalibrationResult, c as CandidateScore, a as ContinuousAgreement, C as ContinuousAgreementOptions, d as ContinuousCalibrationResult, G as GoldenItem, P as PositionalBiasResult, S as SelfPreferenceResult, V as VerbosityBiasResult, e as calibrateJudge, f as calibrateJudgeContinuous, g as continuousAgreement, p as positionalBias, s as selfPreference, v as verbosityBias } from './judge-calibration-DilmB3Ml.js';
-export { D as DEFAULT_RED_TEAM_CORPUS, R as RedTeamCase, a as RedTeamCategory, b as RedTeamFinding, c as RedTeamPayload, d as RedTeamReport, r as redTeamDataset, e as redTeamReport, s as scoreRedTeamOutput, t as toolNamesForRun } from './red-team-DW9Ca_tj.js';
+export { S as SeriesConvergenceOptions, a as SeriesConvergenceResult, b as analyzeSeries } from './series-convergence-D5OWMBg6.js';
+import { D as DefaultVerdict } from './verdict-C9MlYujm.js';
+import { a as DatasetScenario, b as Dataset } from './dataset-BbGkaN2I.js';
+export { d as DatasetDifficulty, c as DatasetManifest, e as DatasetProvenance, D as DatasetSplit, H as HoldoutLockedError, S as SliceOptions, h as hashScenarios } from './dataset-BbGkaN2I.js';
+export { a as CalibrationResult, c as CandidateScore, C as ContinuousAgreement, d as ContinuousAgreementOptions, b as ContinuousCalibrationResult, G as GoldenItem, P as PositionalBiasResult, S as SelfPreferenceResult, V as VerbosityBiasResult, e as calibrateJudge, f as calibrateJudgeContinuous, g as continuousAgreement, p as positionalBias, s as selfPreference, v as verbosityBias } from './judge-calibration-0p2QcWNE.js';
+export { D as DEFAULT_RED_TEAM_CORPUS, R as RedTeamCase, a as RedTeamCategory, b as RedTeamFinding, c as RedTeamPayload, d as RedTeamReport, r as redTeamDataset, e as redTeamReport, s as scoreRedTeamOutput, t as toolNamesForRun } from './red-team-BXHil6c8.js';
+export { c as CounterfactualContext, C as CounterfactualMutation, d as CounterfactualResult, b as CounterfactualRunner, a as attributeCounterfactuals, r as runCounterfactual } from './counterfactual-Dwibr5IW.js';
 import { a as PrmGrader } from './rubric-BOfxn4ja.js';
 export { EuRiskClass, GovernanceContext, GovernanceFinding, GovernanceReport, UseCaseSignals, classifyEuAiRisk, euAiActReport, nistAiRmfReport, renderMarkdown, soc2Report, summarize } from './governance/index.js';
-import { b as Layer, S as Severity, L as LayerResult, c as VerifyContext } from './multi-layer-verifier-DlWCXuxL.js';
-export { F as Finding, d as LayerStatus, M as MultiLayerVerifier, a as VerificationReport, V as VerifyOptions, g as gradeSemanticStatus } from './multi-layer-verifier-DlWCXuxL.js';
-import { L as LlmClientOptions } from './llm-client-CuUg2Mn3.js';
-export { d as LlmCallError, b as LlmCallRequest, c as LlmCallResult, e as LlmClient, f as LlmMessage, g as LlmRouteAssertionError, a as LlmRouteRequirements, h as LlmUsage, i as assertLlmRoute, j as backoffMs, k as callLlm, l as callLlmJson, m as isTransientLlmError, p as probeLlm, s as stripFencedJson } from './llm-client-CuUg2Mn3.js';
-export { B as BENCHMARK_SPLIT_SEED, a as BenchmarkAdapter, b as BenchmarkDatasetItem, c as BenchmarkEvaluation, d as benchmarkDeterministicSplit, i as benchmarks } from './index-DE3RXAXD.js';
-export { C as CallbackResearcher, d as CallbackResearcherOptions, e as CampaignFactoryParams, f as CampaignIntegrityPolicy, g as CampaignRunContext, h as CampaignRunOutcome, i as CampaignRunner, j as CampaignScenario, k as CampaignVariant, c as EvalCampaignOptions, b as EvalCampaignResult, E as ExperimentPlan, a as ExperimentResult, l as FailedRun, F as FailureMode, N as NoopResearcher, R as Researcher, S as SteeringChange, r as runEvalCampaign } from './researcher-BLPHBbNV.js';
-export { G as GainDistributionBin, a as GainDistributionFigureSpec, b as GainDistributionOptions, m as GateDecision, n as GateEvidence, H as HeldOutGate, o as HeldOutGateConfig, q as HeldOutGateRejectionCode, P as ParetoFigureSpec, c as ParetoPoint, R as RESEARCH_REPORT_HARD_PAIR_FLOOR, d as ResearchReport, e as ResearchReportCandidate, f as ResearchReportDecision, g as ResearchReportMethodology, h as ResearchReportOptions, i as ResearchReportRecommendation, S as SummaryTable, j as SummaryTableOptions, k as SummaryTableRow, l as gainHistogram, p as paretoChart, r as researchReport, s as summaryTable } from './summary-report-Db0dDSWP.js';
+import { b as Layer, S as Severity, L as LayerResult, c as VerifyContext } from './multi-layer-verifier-DUZXrPDA.js';
+export { F as Finding, d as LayerStatus, M as MultiLayerVerifier, a as VerificationReport, V as VerifyOptions, g as gradeSemanticStatus } from './multi-layer-verifier-DUZXrPDA.js';
+import { L as LlmClientOptions } from './llm-client-BeEcAokY.js';
+export { d as LlmCallError, b as LlmCallRequest, c as LlmCallResult, e as LlmClient, f as LlmMessage, g as LlmRouteAssertionError, a as LlmRouteRequirements, h as LlmUsage, i as assertLlmRoute, j as backoffMs, k as callLlm, l as callLlmJson, m as isTransientLlmError, p as probeLlm, s as stripFencedJson } from './llm-client-BeEcAokY.js';
+export { B as BENCHMARK_SPLIT_SEED, a as BenchmarkAdapter, b as BenchmarkDatasetItem, c as BenchmarkEvaluation, d as benchmarkDeterministicSplit, i as benchmarks } from './index-Bx3gZ8xl.js';
+export { C as CallbackResearcher, d as CallbackResearcherOptions, e as CampaignFactoryParams, f as CampaignIntegrityPolicy, g as CampaignRunContext, h as CampaignRunOutcome, i as CampaignRunner, j as CampaignScenario, k as CampaignVariant, c as EvalCampaignOptions, b as EvalCampaignResult, E as ExperimentPlan, a as ExperimentResult, l as FailedRun, F as FailureMode, N as NoopResearcher, R as Researcher, S as SteeringChange, r as runEvalCampaign } from './researcher-DE6Gpnb4.js';
+export { G as GainDistributionBin, a as GainDistributionFigureSpec, b as GainDistributionOptions, m as GateDecision, n as GateEvidence, H as HeldOutGate, o as HeldOutGateConfig, q as HeldOutGateRejectionCode, P as ParetoFigureSpec, c as ParetoPoint, R as RESEARCH_REPORT_HARD_PAIR_FLOOR, d as ResearchReport, e as ResearchReportCandidate, f as ResearchReportDecision, g as ResearchReportMethodology, h as ResearchReportOptions, i as ResearchReportRecommendation, S as SummaryTable, j as SummaryTableOptions, k as SummaryTableRow, l as gainHistogram, p as paretoChart, r as researchReport, s as summaryTable } from './summary-report-DGmUucwQ.js';
 export { I as InterimReleaseConfidence, a as InterimReleaseConfidenceInput, P as PairedEvalueOptions, b as PairedEvalueSequence, c as PairedEvalueStep, S as SequentialDecision, e as evaluateInterimReleaseConfidence, p as pairedEvalueSequence } from './sequential-5iSVfzl2.js';
-import { S as Scenario$1, a as JudgeConfig, G as Gate } from './types-D7lLRYe9.js';
-import { e as GepaDriverConstraints, a as RunImprovementLoopResult } from './run-improvement-loop-CNqQckTj.js';
+import { e as GepaDriverConstraints, a as RunImprovementLoopResult } from './run-improvement-loop-5z_l5zDz.js';
 import '@ax-llm/ax';
 import 'zod';
+import './insight-report-BBwvOh6x.js';
 import './outcome-store-rnXLEqSn.js';
 
 /**
@@ -533,33 +539,76 @@ declare class CrossFamilyError extends Error {
  */
 declare function assertCrossFamily(models: string[], opts?: AssertCrossFamilyOptions): JudgeFamily[];
 
+/**
+ * A judge's LLM response could not be parsed into scored dimensions.
+ * Thrown instead of fabricating a `{ dimension: 'parse_error', score: 0 }`
+ * row — a synthetic zero is indistinguishable from a real low score
+ * downstream. Carries the raw response for forensics. Callers (executor,
+ * ensemble wrappers) catch this per-judge and record a failed judge.
+ */
+declare class JudgeParseError extends JudgeError {
+    /** Name of the judge whose response failed to parse. */
+    readonly judgeName: string;
+    /** The raw (truncated) model response that failed to parse. */
+    readonly raw: string;
+    constructor(judgeName: string, raw: string, options?: {
+        cause?: unknown;
+    });
+}
 /**
  * Create a domain expert judge with a configurable domain.
  *
  * The judge evaluates professional accuracy and depth.
+ *
+ * @deprecated Legacy `JudgeFn` factory tied to the fixed gpt-4o prompt shape.
+ * Build judges as campaign `JudgeConfig`s (src/campaign/types.ts) — or
+ * multi-model panels via `ensembleJudge` (src/judge-panel.ts) — which are
+ * pluggable, fail-loud, and drive the campaign/improvement-loop engines.
  */
 declare function createDomainExpertJudge(domain: string): JudgeFn;
 /**
  * Code execution judge — evaluates whether code blocks are valid and runnable.
+ *
+ * @deprecated Legacy `JudgeFn` factory tied to the fixed gpt-4o prompt shape.
+ * Build judges as campaign `JudgeConfig`s (src/campaign/types.ts) — or
+ * multi-model panels via `ensembleJudge` (src/judge-panel.ts).
  */
 declare const codeExecutionJudge: JudgeFn;
 /**
  * Coherence judge — evaluates multi-turn consistency and progression.
+ *
+ * @deprecated Legacy `JudgeFn` factory tied to the fixed gpt-4o prompt shape.
+ * Build judges as campaign `JudgeConfig`s (src/campaign/types.ts) — or
+ * multi-model panels via `ensembleJudge` (src/judge-panel.ts).
  */
 declare const coherenceJudge: JudgeFn;
 /**
  * Adversarial judge — red-teams agent responses.
+ *
+ * @deprecated Legacy `JudgeFn` factory tied to the fixed gpt-4o prompt shape.
+ * Build judges as campaign `JudgeConfig`s (src/campaign/types.ts) — or
+ * multi-model panels via `ensembleJudge` (src/judge-panel.ts).
  */
 declare const adversarialJudge: JudgeFn;
 /**
  * Create a custom judge with a fully custom prompt.
+ *
+ * @deprecated Legacy `JudgeFn` factory tied to the fixed gpt-4o prompt shape.
+ * Build judges as campaign `JudgeConfig`s (src/campaign/types.ts) — or
+ * multi-model panels via `ensembleJudge` (src/judge-panel.ts).
  */
 declare function createCustomJudge(name: string, systemPrompt: string, opts?: {
     model?: string;
     temperature?: number;
     maxTokens?: number;
 }): JudgeFn;
-/** Default judge set (domain must be provided for domain expert) */
+/**
+ * Default judge set (domain must be provided for domain expert)
+ *
+ * @deprecated Legacy `JudgeFn` factory tied to the fixed gpt-4o prompt shape.
+ * Build judges as campaign `JudgeConfig`s (src/campaign/types.ts) — or
+ * multi-model panels via `ensembleJudge` (src/judge-panel.ts).
+ */
 declare function defaultJudges(domain: string): JudgeFn[];
 
 interface LiveProofArtifact {
@@ -980,6 +1029,59 @@ declare class DualAgentBench {
     run(config: DualAgentBenchConfig): Promise<DualAgentReport>;
 }
 
+/**
+ * Eval primitives as agent tools — `makeEvalTools` packages the substrate's
+ * judge / completion / analysis entry points as JSON-Schema tool definitions
+ * an LLM agent loop can call. The host closes over the live config (judge
+ * panels, the correctness checker, analyst registry); the agent passes only
+ * data over the wire.
+ *
+ * Three tools, each present only when its config section is supplied:
+ *   - `run_judges`        — score an artifact with the configured `JudgeConfig`s
+ *   - `verify_completion` — gold-spec requirement check → `CompletionVerdict`
+ *   - `analyze_runs`      — `RunRecord[]` (inline or from a file) → `InsightReport`
+ *
+ * `toOpenAiTool` converts a definition to the OpenAI function-tool wire shape.
+ */
+
+/** One agent-callable tool. `parameters` is a JSON Schema (draft-07+) object. */
+interface EvalToolDef {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    handler: (args: unknown, ctx?: {
+        signal?: AbortSignal;
+    }) => Promise<unknown>;
+}
+interface MakeEvalToolsConfig {
+    /** Judges available to `run_judges`. Omit to exclude the tool. */
+    judges?: Array<JudgeConfig<unknown>>;
+    /** Host-side correctness checker for `verify_completion` (the third
+     *  `verifyCompletion` argument — a function, so it cannot cross the wire).
+     *  Omit to exclude the tool. */
+    completion?: {
+        checkCorrectness: CorrectnessChecker;
+    };
+    /** `analyzeRuns` options minus `runs` (runs arrive as tool args, inline or
+     *  via `path`). Omit to exclude the tool. */
+    analyze?: Omit<AnalyzeRunsOptions, 'runs'>;
+}
+/** OpenAI function-tool wire shape for an `EvalToolDef`. */
+declare function toOpenAiTool(def: EvalToolDef): {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+};
+/**
+ * Build the eval toolset for the supplied config. Only sections present in
+ * `cfg` produce tools, so the agent's tool list mirrors what the host
+ * actually wired. Handlers fail loud on malformed args — no silent defaults.
+ */
+declare function makeEvalTools(cfg: MakeEvalToolsConfig): EvalToolDef[];
+
 /**
  * Judge-ensemble reducer — folds N independent judge verdicts on the same
  * artifact into one aggregate score.
@@ -1006,6 +1108,12 @@ interface JudgeVerdict<D extends string = string> {
     rationale?: string;
     /** Optional reported cost — summed across ALL verdicts (failed included). */
     costUsd?: number;
+    /** Optional per-dimension reasoning/evidence. Carried through to
+     *  `EnsembleAggregate.verdicts` verbatim — never folded into the math. */
+    detail?: Partial<Record<D, {
+        reasoning?: string;
+        evidence?: string;
+    }>>;
 }
 /** The aggregated ensemble result. */
 interface EnsembleAggregate<D extends string = string> {
@@ -1023,6 +1131,9 @@ interface EnsembleAggregate<D extends string = string> {
     costUsd: number;
     /** First non-empty survivor rationale, or `'llm-judge'`. */
     rationale: string;
+    /** The input verdicts, verbatim — drill-down to raw scores, `detail`
+     *  reasoning/evidence, and per-verdict cost without re-running judges. */
+    verdicts: JudgeVerdict<D>[];
 }
 /**
  * Reduce per-judge verdicts to one aggregate. Generic over the rubric: pass the
@@ -1037,6 +1148,139 @@ interface EnsembleAggregate<D extends string = string> {
  */
 declare function aggregateJudgeVerdicts<D extends string>(verdicts: readonly JudgeVerdict<D>[], dimensionKeys: readonly D[], weights?: Partial<Record<D, number>>): EnsembleAggregate<D>;
 
+/**
+ * Wrap a single judge LLM call with retry, optional fallback-model
+ * rotation, exponential backoff, and a typed `JudgeRetryOutcome`. Callers
+ * MUST inspect `succeeded` before using `value`; on failure the library
+ * returns `value: null` rather than substituting a default, so a judge
+ * abort cannot silently corrupt a downstream composite.
+ *
+ * Reporting contract: callers ship `TrialResult.judgeSucceeded = succeeded`
+ * and `TrialResult.judgeAttempts = attempts` so `aggregateTrialsByMode`
+ * with `mode: 'exclude-failed'` drops the trial.
+ */
+/** Retry policy for judge LLM calls. */
+interface JudgeRetryPolicy {
+    /** Max attempts per model. Default 3 (one initial + two retries). */
+    maxAttempts?: number;
+    /** Per-attempt timeout in ms. Default 300_000. */
+    timeoutMs?: number;
+    /**
+     * Models to try, in order. The first model is the primary; subsequent
+     * models are fallbacks invoked only when ALL retries on the previous
+     * model have been exhausted. Example: `['claude-code/sonnet', 'kimi-code/k2p6']`
+     * runs claude-code up to maxAttempts times, then falls back to kimi.
+     * If omitted, the caller's judge function controls model selection and
+     * the retries apply to that single model.
+     */
+    models?: readonly string[];
+    /** Exponential backoff function, default `attempt → min(500 * 2^attempt, 16_000)`. */
+    backoffMs?: (attempt: number) => number;
+    /**
+     * Predicate deciding whether an error should trigger a retry. Defaults to
+     * `isTransientLlmError` — the package-wide classifier shared with
+     * `callLlm` — which retries aborts/timeouts, network faults, HTTP/2
+     * transport faults, and any `LlmCallError` with status in {429,502,503,504}.
+     * JSON-parse and schema-rejection errors are NOT retriable (the model
+     * needs prompt adjustment, not another shot).
+     */
+    isRetryable?: (err: unknown) => boolean;
+}
+/** Outcome of a wrapped judge invocation. */
+interface JudgeRetryOutcome<T> {
+    /** The judge's returned value when `succeeded === true`. */
+    value: T | null;
+    /** True iff one of the attempts completed without throwing. */
+    succeeded: boolean;
+    /** Total attempts made across all models. */
+    attempts: number;
+    /** Which model the successful attempt used (when succeeded). */
+    modelUsed?: string;
+    /** Last error captured when `succeeded === false`. */
+    error?: Error;
+    /** Per-attempt error log for forensics. */
+    attemptErrors: Array<{
+        attempt: number;
+        model: string;
+        error: string;
+    }>;
+}
+/**
+ * Wrap a judge call with retry + fallback-model + typed outcome semantics.
+ *
+ * The `judgeFn` signature is `(model: string, signal: AbortSignal) => Promise<T>`.
+ * The signal will be aborted at `timeoutMs`. Callers should pass the signal
+ * to their underlying fetch/SDK call so the abort actually fires.
+ *
+ * Returns a typed outcome — callers MUST inspect `succeeded` before using
+ * `value`. The library refuses to default to a silent zero score because a
+ * synthetic zero is indistinguishable from a real low score downstream.
+ */
+declare function withJudgeRetry<T>(judgeFn: (model: string, signal: AbortSignal) => Promise<T>, policy?: JudgeRetryPolicy): Promise<JudgeRetryOutcome<T>>;
+
+/**
+ * Multi-model judge panel — `ensembleJudge` builds a campaign `JudgeConfig`
+ * that fans one artifact out to K judge models and reduces their verdicts
+ * through `aggregateJudgeVerdicts` (src/judge-ensemble.ts).
+ *
+ * The panel is the fail-loud composition of the substrate's existing judge
+ * primitives:
+ *   - `assertCrossFamily` (construction-time) — a single-family panel is
+ *     correlated bias, not independent signal.
+ *   - `withJudgeRetry` (per model, opt-in) — transient-fault retry with a
+ *     typed outcome; a judge that exhausts retries is recorded as failed,
+ *     never folded into a zero.
+ *   - `aggregateJudgeVerdicts` — the pure reducer; throws when EVERY judge
+ *     failed so a silent zero can't reach the gate.
+ *
+ * The returned `JudgeScore` is on the campaign [0,1] scale and carries the
+ * ensemble extras (`maxDisagreement`, `failedJudges`, `perJudge`) declared
+ * on the canonical `JudgeScore` in src/campaign/types.ts.
+ */
+
+interface EnsembleJudgeOptions<D extends string> {
+    /** Judge name — becomes the returned `JudgeConfig.name`. */
+    name: string;
+    /** Rubric dimensions every model scores. Keys of the verdict's `perDimension`. */
+    dimensions: D[];
+    /** Judge model ids — one `scoreWith` call per entry. List a model twice to
+     *  sample it twice (votes are suffix-keyed `model#2` so none overwrite). */
+    models: string[];
+    /**
+     * Score the artifact with one model. Throw (or reject) on failure — the
+     * panel records that model as a failed judge; it is never folded into a
+     * zero. Verdict scores are clamped to [0,1] by the reducer.
+     */
+    scoreWith: (model: string, input: {
+        artifact: unknown;
+        scenario?: unknown;
+    }) => Promise<JudgeVerdict<D>>;
+    /**
+     * Per-model retry policy, applied via `withJudgeRetry`. The panel's
+     * `models` list drives the fan-out, so `retry.models` (the fallback
+     * rotation) is overridden to each panel model in turn.
+     */
+    retry?: JudgeRetryPolicy;
+    /** Enforce `assertCrossFamily` over `models` at construction. Default true.
+     *  Opt out only for deliberate single-family panels (e.g. self-consistency
+     *  sampling of one model). */
+    crossFamily?: boolean;
+    /** Composite weights forwarded to `aggregateJudgeVerdicts`: a partial map
+     *  selects AND weights exactly the named dimensions. Omit for uniform. */
+    weights?: Partial<Record<D, number>>;
+}
+/**
+ * Build a campaign-shaped `JudgeConfig` whose `score()` runs every panel
+ * model in parallel and reduces the surviving verdicts to one canonical
+ * `JudgeScore` in [0,1].
+ *
+ * Failure semantics: a model whose `scoreWith` throws (or exhausts `retry`)
+ * lands in `failedJudges` and is excluded from the means. When EVERY model
+ * fails, `aggregateJudgeVerdicts` throws — the campaign engine records a
+ * failed cell instead of averaging a fabricated zero.
+ */
+declare function ensembleJudge<D extends string>(opts: EnsembleJudgeOptions<D>): JudgeConfig<unknown>;
+
 type SandboxJudgeKind = 'compiler' | 'test' | 'linter' | 'security';
 interface SandboxJudgeSpec {
     id: string;
@@ -1275,118 +1519,6 @@ declare class BudgetGuard {
     get state(): Record<keyof BudgetSpec, number>;
 }
 
-/**
- * CostLedger — per-run token + USD accounting with an explicit `costUnknown`
- * axis, folded over the substrate's pricing resolver.
- *
- * `estimateCost` already resolves a model id to a price (exact table, then
- * family regex) and warns-once on a miss, but it returns 0 for an unpriced
- * model — indistinguishable downstream from a genuinely free run. Four
- * consumers re-wrap it to surface that distinction (physim's `costForUsage` /
- * `modelPriceKey` is the cleanest), and to bucket spend by "channel" (the
- * logical role of the call: agent / judge / verifier / …) so a dashboard can
- * answer "how much did judging cost vs the agent itself?".
- *
- * This is the canonical version. `modelPriceKey` exposes the resolver's verdict
- * as a stable key (or null). `CostLedger` folds usage records into per-channel
- * and total rollups, tracks `unpricedModels` so a $0 is never mistaken for a
- * measured zero, and computes cost-per-completed-task.
- */
-/** Logical role of an LLM call. Free-form union — consumers add their own
- *  channels; the rollup keys on whatever string is supplied. */
-type CostChannel = 'agent' | 'judge' | 'verifier' | 'analyst' | 'driver' | (string & {});
-interface CostUsage {
-    inputTokens: number;
-    outputTokens: number;
-    cachedTokens?: number;
-}
-/**
- * Resolve a model id to the stable pricing key the substrate's `MODEL_PRICING`
- * / family resolver would use, or null when the id is unpriced. A non-null
- * return means `estimateCost` will produce a real number for this id; null
- * means any cost computed is `costUnknown` and the 0 must not aggregate as a
- * measured cost.
- */
-declare function modelPriceKey(model: string): string | null;
-interface CostResult {
-    costUsd: number;
-    /** True when `model` has no pricing — the 0 is "not priced", NOT "free". */
-    costUnknown: boolean;
-}
-/**
- * Cost for one usage record. Resolves pricing via the substrate resolver and
- * flags `costUnknown` when the model is unpriced so the 0 is observable rather
- * than silently emitted as a measured cost. Cached tokens are billed at the
- * model's input rate when present (no separate cache-discount table — callers
- * that need provider-specific cache pricing supply `actualCostUsd` upstream).
- */
-declare function costForUsage(model: string, usage: CostUsage): CostResult;
-interface CostLedgerEntry extends CostUsage {
-    model: string;
-    channel: CostChannel;
-    costUsd: number;
-    costUnknown: boolean;
-    /** Override the estimate with an observed provider cost. */
-    actualCostUsd?: number;
-    /** Free-form tags (scenario id, variant id, round, …). */
-    tags?: Record<string, string>;
-    timestamp: number;
-}
-interface ChannelRollup {
-    channel: CostChannel;
-    calls: number;
-    inputTokens: number;
-    outputTokens: number;
-    cachedTokens: number;
-    costUsd: number;
-    /** Calls whose model was unpriced (their costUsd is 0-but-unknown). */
-    unpricedCalls: number;
-}
-interface CostLedgerSummary {
-    totalCalls: number;
-    inputTokens: number;
-    outputTokens: number;
-    cachedTokens: number;
-    totalCostUsd: number;
-    /** Per-channel breakdown, sorted by channel name. */
-    byChannel: ChannelRollup[];
-    /** Distinct unpriced model ids seen — non-empty means totalCostUsd is a
-     *  lower bound (some calls priced to an unknown 0). */
-    unpricedModels: string[];
-    /** True when no unpriced model was charged — totalCostUsd is then exact. */
-    fullyPriced: boolean;
-}
-/**
- * Append-only ledger of LLM spend for a single run. Record each call with its
- * channel; read per-channel and total rollups plus the unpriced-model set.
- * Pure accounting — no I/O. The `markCompleted` / `costPerCompletedTask` pair
- * answers "dollars per finished task", the metric every optimizer's
- * quality-vs-cost tradeoff needs.
- */
-declare class CostLedger {
-    private readonly entries;
-    private completedTasks;
-    /**
-     * Record one LLM call. The cost is computed from pricing unless
-     * `actualCostUsd` is supplied (a finite observed cost from the provider
-     * response), in which case `costUnknown` is false regardless of pricing.
-     */
-    record(input: {
-        model: string;
-        channel: CostChannel;
-        usage: CostUsage;
-        actualCostUsd?: number;
-        tags?: Record<string, string>;
-        timestamp?: number;
-    }): CostLedgerEntry;
-    /** Increment the completed-task counter (used for cost-per-completed-task). */
-    markCompleted(count?: number): void;
-    list(): CostLedgerEntry[];
-    summary(): CostLedgerSummary;
-    /** Total spend divided by completed tasks; null when nothing completed. */
-    costPerCompletedTask(): number | null;
-}
-
 /**
  * Cost tracker — token + USD accounting per scenario and per run.
  *
@@ -2107,38 +2239,6 @@ declare function diffScorecard(scorecard: Scorecard, opts?: DiffScorecardOptions
  */
 declare function formatScorecardDiff(diff: ScorecardDiff): string;
 
-/**
- * Series convergence — detects whether a sequence of scalar measurements
- * is stabilizing, drifting, or noisy.
- *
- * Lifted from ADC convergence.ts. The per-turn `ConvergenceTracker` is
- * about progress *within* a single run; this module is about drift
- * *across* runs (e.g. "are my nightly eval scores stabilizing?").
- *
- * Three signals:
- *   - stabilized: last K values have low variance (< epsilon) — done
- *   - drifting:   recent trend is monotonic and beyond noise — regressing or improving
- *   - noisy:      neither — keep iterating, but flag as untrustworthy for gating
- */
-interface SeriesConvergenceOptions {
-    /** Window size for "recent" analysis (default 5). */
-    window?: number;
-    /** Coefficient-of-variation threshold below which the window is stabilized (default 0.05 = 5%). */
-    stableCv?: number;
-    /** Minimum monotone run length to call drift (default 3). */
-    driftRun?: number;
-}
-interface SeriesConvergenceResult {
-    state: 'stabilized' | 'drifting-up' | 'drifting-down' | 'noisy' | 'insufficient-data';
-    windowMean: number;
-    windowCv: number;
-    /** Longest monotonic run at the tail of the series (positive for up, negative for down). */
-    tailRun: number;
-    /** True when n ≥ window AND windowCv ≤ stableCv. */
-    stable: boolean;
-}
-declare function analyzeSeries(values: number[], options?: SeriesConvergenceOptions): SeriesConvergenceResult;
-
 /**
  * SLO gates — quantified pass/fail primitives beyond score thresholds.
  *
@@ -2338,6 +2438,185 @@ interface UiFinding {
     createdAt?: string;
 }
 
+/**
+ * Trace contracts — finite-trace temporal assertions over span sequences.
+ *
+ * Five LTLf operators over one ordered span sequence — `always(p)`,
+ * `never(p)`, `eventually(p)`, `precedes(a, b)`, `neverUnless(p, prior)` —
+ * deterministic and judge-free. No nesting: each rule is one operator over
+ * flat `SpanPredicate`s; compose richer checks with multiple rules.
+ *
+ * A built `TraceContract` is a serializable plain object (RegExp matchers
+ * are normalized to `SerializedRegex`), so ONE contract definition is
+ * dual-use:
+ *
+ *   - recorded eval traces — `evaluateTraceContract(contract, await
+ *     store.spans({ runId }))`, or via the behavior DSL:
+ *     `expectAgent(store, runId).toSatisfyContract(contract)`.
+ *   - the production OTLP stream — `ExportableSpan`s flattened by
+ *     `trace/otel-bridge` satisfy `ContractSpan` structurally. A production
+ *     monitor implements `OtelExporter`, buffers `exportSpan` payloads per
+ *     trace, and runs `checkTraceContracts(buffer, contracts)` on flush:
+ *
+ *       const buffer: ContractSpan[] = []
+ *       const monitor: OtelExporter = {
+ *         exportSpan: (s) => { buffer.push(s) },
+ *         flush: async () => {
+ *           const { allValid, verdicts } = checkTraceContracts(buffer, contracts)
+ *           if (!allValid) alert(verdicts)
+ *         },
+ *         shutdown: async () => {},
+ *       }
+ *       const store = createOtelTracingStore(inner, monitor, runId)
+ *
+ * `custom` predicate functions are the one non-serializable escape hatch:
+ * the builder stamps `requiresCustom: true` (which DOES survive JSON) so a
+ * deserialized contract that lost its function fails loud at evaluation
+ * instead of silently weakening.
+ *
+ * Naming: the root barrel exports ci-gate's threshold-contract
+ * `evaluateContract`, so the evaluators here are `evaluateTraceContract` /
+ * `checkTraceContracts`.
+ */
+
+/**
+ * Minimal structural span the checker reads. Both the eval-side `Span`
+ * (trace/schema) and the OTLP-flattened `ExportableSpan` (trace/otel-export)
+ * satisfy it; any other producer only needs these fields.
+ */
+interface ContractSpan {
+    spanId?: string;
+    name?: string;
+    kind?: string;
+    startedAt?: number;
+    status?: string;
+    error?: string;
+    /** Typed field on eval-side ToolSpans; OTLP flattenings drop it (see
+     *  `tool` matching order in {@link matchSpan}). */
+    toolName?: string;
+    attributes?: Record<string, unknown>;
+}
+/** JSON-safe RegExp form — what the builder normalizes RegExp matchers to. */
+interface SerializedRegex {
+    $regex: string;
+    flags: string;
+}
+type TextMatcher = string | RegExp | SerializedRegex;
+/**
+ * Proposition over one span. All specified fields must match (AND).
+ * At least one field is required — an empty predicate would match every
+ * span and is rejected.
+ *
+ * `tool` resolution order covers both span shapes: `span.toolName` (typed
+ * ToolSpan) → `attributes['tool.name']` / `attributes['toolName']`
+ * (OTLP-flat attribute conventions) → `span.name` when `kind === 'tool'`
+ * (otel-bridge's `ExportableSpan`, which drops `toolName`).
+ *
+ * `attr` values match by strict equality, or regex-test when the value is a
+ * RegExp/SerializedRegex and the attribute is a string. Structured attribute
+ * values need `custom`.
+ */
+interface SpanPredicate {
+    name?: TextMatcher;
+    tool?: TextMatcher;
+    attr?: Record<string, unknown>;
+    custom?: (span: ContractSpan) => boolean;
+    /** Stamped by the builder when `custom` is present. Survives JSON while
+     *  the function does not, so evaluation of a deserialized contract throws
+     *  instead of silently dropping the check. */
+    requiresCustom?: true;
+}
+type ContractRuleKind = 'always' | 'never' | 'eventually' | 'precedes' | 'neverUnless';
+interface ContractRule {
+    kind: ContractRuleKind;
+    /** Unique within the contract — keys the per-rule score. */
+    label: string;
+    /** Subject predicate for always / never / eventually / neverUnless. */
+    p?: SpanPredicate;
+    /** precedes: the required precondition. */
+    a?: SpanPredicate;
+    /** precedes: the guarded match — every b-match needs an earlier a-match. */
+    b?: SpanPredicate;
+    /** neverUnless: the authorizing earlier match. */
+    prior?: SpanPredicate;
+}
+/** Serializable plain object — `traceContract(name)....build()` output. */
+interface TraceContract {
+    name: string;
+    rules: ContractRule[];
+}
+interface ContractViolation {
+    rule: string;
+    spanId?: string;
+    detail: string;
+}
+interface ContractVerdict extends DefaultVerdict {
+    /** Contract name — keys this verdict in multi-contract reports. */
+    contract: string;
+    valid: boolean;
+    /** Fraction of rules passing, in [0, 1]. */
+    score: number;
+    /** Per-rule 0|1 keyed by rule label. */
+    scores: Record<string, number>;
+    violations: ContractViolation[];
+}
+interface ContractCheckResult {
+    verdicts: ContractVerdict[];
+    allValid: boolean;
+}
+/** Test one span against one predicate. All specified fields must match. */
+declare function matchSpan(span: ContractSpan, predicate: SpanPredicate): boolean;
+declare class TraceContractBuilder {
+    private readonly name;
+    private readonly rules;
+    constructor(name: string);
+    /** Every span in the trace must satisfy `p`. */
+    always(p: SpanPredicate, label?: string): this;
+    /** No span in the trace may satisfy `p`. */
+    never(p: SpanPredicate, label?: string): this;
+    /** At least one span in the trace must satisfy `p`. */
+    eventually(p: SpanPredicate, label?: string): this;
+    /** Every `b`-match must have a strictly earlier `a`-match. */
+    precedes(a: SpanPredicate, b: SpanPredicate, label?: string): this;
+    /** Every `p`-match is a violation unless a strictly earlier `prior`-match exists. */
+    neverUnless(p: SpanPredicate, prior: SpanPredicate, label?: string): this;
+    build(): TraceContract;
+    private add;
+}
+declare function traceContract(name: string): TraceContractBuilder;
+/**
+ * Evaluate one contract over a span sequence. Pure and synchronous — works
+ * on `Span[]` from a TraceStore, `ExportableSpan[]` from the otel-bridge
+ * flattening, or any array satisfying `ContractSpan`.
+ */
+declare function evaluateTraceContract(contract: TraceContract, spans: readonly ContractSpan[]): ContractVerdict;
+/**
+ * Evaluate many contracts over one span sequence. Throws on an empty
+ * contract list — `allValid: true` over zero contracts is a silent pass.
+ */
+declare function checkTraceContracts(spans: readonly ContractSpan[], contracts: readonly TraceContract[]): ContractCheckResult;
+interface ContractJudgeOptions<TArtifact, TScenario extends Scenario$1 = Scenario$1> {
+    /**
+     * Project the span sequence out of a cell's artifact. `JudgeConfig.score`
+     * receives only `{ artifact, scenario, signal }` (src/campaign/types.ts) —
+     * spans are NOT reachable generically — so the consumer supplies this
+     * explicit extraction (e.g. dispatch writes spans into the artifact, or
+     * closes over a per-cell TraceStore read).
+     */
+    spans: (input: {
+        artifact: TArtifact;
+        scenario: TScenario;
+    }) => readonly ContractSpan[];
+    /** Judge name in campaign reports. Default 'trace-contracts'. */
+    name?: string;
+}
+/**
+ * Adapt trace contracts to a campaign `JudgeConfig`. One judge dimension per
+ * contract (key = contract name, value = its rule-pass fraction); composite
+ * is the mean across contracts. Deterministic — no LLM call.
+ */
+declare function contractJudge<TArtifact, TScenario extends Scenario$1 = Scenario$1>(contracts: readonly TraceContract[], opts: ContractJudgeOptions<TArtifact, TScenario>): JudgeConfig<TArtifact, TScenario>;
+
 /**
  * Behavior DSL — pytest-style assertions over a run's trajectory.
  *
@@ -2376,6 +2655,9 @@ declare class BehaviorAssertion {
         toolCalls?: number;
         llmTurns?: number;
     }): Expectation;
+    /** Evaluate a finite-trace temporal contract (`traceContract(...)`) over
+     *  this run's span sequence. See `trace-contracts.ts` for the operators. */
+    toSatisfyContract(contract: TraceContract): Expectation;
     toNeverCall(toolName: string): Expectation;
 }
 declare class CallExpectation implements Expectation {
@@ -2816,86 +3098,6 @@ declare function promptBisect(options: {
     offendingParagraphIndex?: number;
 }>;
 
-/**
- * Counterfactual replay — "what would have happened if we'd changed
- * exactly one thing at turn N?"
- *
- * The framework does NOT drive the agent — it sets up the replay
- * context (prior spans, prior state, mutation spec) and records the
- * resulting divergence. Consumers supply an `executeFrom(ctx)` callback
- * that runs their agent starting from turn N with the mutation applied.
- *
- * Counterfactual runs are recorded as a new Run with `layer='meta'` and
- * `parentRunId = originalRunId`, so downstream diff + correlation
- * pipelines see them natively.
- */
-
-type CounterfactualMutation = {
-    kind: 'swap-model';
-    at: number;
-    newModel: string;
-} | {
-    kind: 'swap-tool-result';
-    at: number;
-    newResult: unknown;
-} | {
-    kind: 'truncate-after';
-    at: number;
-} | {
-    kind: 'inject-system-message';
-    at: number;
-    content: string;
-} | {
-    kind: 'custom';
-    at: number;
-    describe: string;
-    apply: (step: TrajectoryStep) => TrajectoryStep;
-};
-interface CounterfactualContext {
-    originalRunId: string;
-    originalTrajectory: Trajectory;
-    /** Steps up to (but not including) the mutation point — the prefix the
-     *  replayed agent inherits as its prior conversation/tool history. */
-    prefix: TrajectoryStep[];
-    mutation: CounterfactualMutation;
-    /** Pre-applied mutation on the step at `mutation.at`. Consumers use this
-     *  as the FIRST step the replayed agent emits (they decide whether to
-     *  re-emit it or continue from there). */
-    mutatedStep: TrajectoryStep;
-}
-interface CounterfactualResult {
-    counterfactualRunId: string;
-    originalRunId: string;
-    mutation: CounterfactualMutation;
-    /** Structured delta summary — caller can extend via scoring. */
-    delta: {
-        originalOutcomeScore: number | null;
-        counterfactualOutcomeScore: number | null;
-        deltaScore: number | null;
-    };
-}
-interface CounterfactualRunner {
-    /**
-     * Execute the agent from `ctx.prefix` with the mutation applied.
-     * MUST emit spans into the provided emitter so they become part of
-     * the counterfactual run. MUST call emitter.endRun() with a verdict.
-     */
-    executeFrom: (ctx: CounterfactualContext, emitter: TraceEmitter) => Promise<void>;
-}
-declare function runCounterfactual(store: TraceStore, originalRunId: string, mutation: CounterfactualMutation, runner: CounterfactualRunner): Promise<CounterfactualResult>;
-/**
- * Aggregate a batch of counterfactuals into a simple attribution table:
- * which mutation kinds move outcomes most? (Useful when you run a grid
- * over the same trajectory — swap-model at every llm span, swap-tool
- * at every tool span — and want a ranked summary.)
- */
-declare function attributeCounterfactuals(results: CounterfactualResult[]): Array<{
-    mutationKind: CounterfactualMutation['kind'];
-    n: number;
-    meanAbsDelta: number;
-    meanSignedDelta: number;
-}>;
-
 /**
  * Full cross-trace diff — align two trajectories step-by-step, report
  * per-step score deltas, attribute a variant's total outcome lead to
@@ -2951,131 +3153,6 @@ interface CrossTraceDiffOptions {
 }
 declare function crossTraceDiff(store: TraceStore, runA: string, runB: string, options?: CrossTraceDiffOptions): Promise<CrossTraceDiff>;
 
-/**
- * Pre-registered hypotheses — declare what you're testing BEFORE the
- * run, check it AFTER. Prevents p-hacking, optional stopping, and the
- * "we ran until it looked good" failure mode.
- *
- * Manifest is a plain JSON-friendly object. Sign it with a content hash
- * + timestamp; the registered record becomes immutable. Post-run,
- * evaluate the manifest against observed results — the library refuses
- * to let you re-interpret a different metric as the declared one.
- */
-interface HypothesisManifest {
-    id: string;
-    /** Human prose — goes into the audit trail. */
-    hypothesis: string;
-    /** Metric the hypothesis claims to move. */
-    metric: string;
-    /** 'increase' = candidate should score higher than baseline; 'decrease' = lower. */
-    direction: 'increase' | 'decrease';
-    /** Minimum effect size to count (same units as the metric). */
-    minEffect: number;
-    /** Alpha threshold. */
-    alpha: number;
-    /** Target statistical power at which sample size was pre-computed. */
-    power: number;
-    /** Declared N per arm before running. */
-    preRegisteredN: number;
-    /** ISO8601 timestamp the manifest was registered. */
-    registeredAt: string;
-    /** Optional identifiers to tie into the trace corpus. */
-    baselineLabel?: string;
-    candidateLabel?: string;
-}
-/**
- * Identifier for the hashing scheme used to produce `contentHash`.
- *
- * `'sha256-content'` — sha256 hex over the canonicalized manifest with
- * the `contentHash` and `algo` fields stripped. Held as a string union
- * so future schemes can be added without breaking parsers; SignedManifest
- * values without `algo` deserialize cleanly because the field is optional.
- */
-type SignedManifestAlgo = 'sha256-content';
-interface SignedManifest extends HypothesisManifest {
-    /** sha256 hex of canonicalized manifest (everything except contentHash and algo). */
-    contentHash: string;
-    /**
-     * Algorithm string describing how `contentHash` was produced.
-     *
-     * Optional on the type so serialized manifests without it still parse,
-     * but ALWAYS populated by {@link signManifest}. Consumers that want to
-     * enforce a known algorithm should reject manifests where this field
-     * is missing or unrecognized.
-     */
-    algo?: SignedManifestAlgo;
-}
-interface HypothesisResult {
-    manifest: SignedManifest;
-    observedN: number;
-    observedEffect: number;
-    observedPValue: number;
-    /** True iff the observed effect hits the pre-declared direction with
-     *  magnitude ≥ minEffect AND p < alpha. */
-    confirmed: boolean;
-    /** Enumerated reasons the hypothesis was rejected (each a machine-tag). */
-    rejectionReasons: Array<'wrong_direction' | 'effect_too_small' | 'not_significant' | 'undersampled'>;
-    notes?: string;
-}
-/**
- * Deterministic JSON canonicalization — sort object keys recursively.
- *
- * Two semantically-equal objects produce byte-identical canonicalized output;
- * this is what makes a content-hash stable across encoders, key insertion
- * orders, and runtime versions. Exported for any consumer that needs the same
- * canonicalization guarantee outside the manifest-signing path (e.g., signing
- * an artifact bundle, hashing a dataset version, etc.).
- */
-declare function canonicalize(v: unknown): unknown;
-/**
- * SHA-256 hex (full 64 chars) over the canonicalized JSON encoding of `obj`.
- *
- * The same primitive `signManifest` and `verifyManifest` are built on, exposed
- * directly so consumers signing arbitrary structured content (artifact bundles,
- * production packets, dataset manifests, etc.) don't have to re-derive
- * canonicalize+sha256 from scratch.
- *
- * Stable across:
- *   - object key insertion order (canonicalization sorts keys recursively)
- *   - encoder choice (UTF-8 via TextEncoder, fixed)
- *   - runtime (uses the Web Crypto subtle digest, present in Node ≥18 and browsers)
- *
- * Named `hashJson` to disambiguate from `prompt-registry.ts`'s `hashContent`,
- * which takes a string input and returns a truncated 12-char prompt id.
- * Use `hashJson` when you mean "canonicalize then hash."
- *
- * @example
- *   const hash = await hashJson({ id: '1', kind: 'spec' })
- *   // 'a3f1...' (64 hex chars)
- */
-declare function hashJson<T>(obj: T): Promise<string>;
-/**
- * Sign a manifest with a SHA-256 content hash.
- *
- * The hash covers the canonicalized manifest with the `contentHash`
- * and `algo` fields stripped; this lets verifiers re-sign the rest and
- * compare. Returned manifest always carries `algo: 'sha256-content'`
- * so downstream consumers can identify the scheme; manifests without
- * `algo` still verify because it is stripped before hashing on both sides.
- */
-declare function signManifest(m: HypothesisManifest): Promise<SignedManifest>;
-/**
- * Verify that a signed manifest has not been tampered with.
- *
- * Strips `contentHash` and `algo` before re-signing so manifests without
- * `algo` verify identically to ones that carry it.
- */
-declare function verifyManifest(m: SignedManifest): Promise<boolean>;
-/**
- * Evaluate a pre-registered hypothesis against observed results.
- * Mechanical — no re-interpretation permitted.
- */
-declare function evaluateHypothesis(manifest: SignedManifest, observed: {
-    n: number;
-    effect: number;
-    pValue: number;
-}): Promise<HypothesisResult>;
-
 /**
  * Active learning — agent-as-scenario-author.
  *
@@ -4502,76 +4579,6 @@ declare function precision<T>(goldens: GoldenSpec[], candidates: T[], options?:
     text?: (candidate: T) => string;
 }): number;
 
-/**
- * Wrap a single judge LLM call with retry, optional fallback-model
- * rotation, exponential backoff, and a typed `JudgeRetryOutcome`. Callers
- * MUST inspect `succeeded` before using `value`; on failure the library
- * returns `value: null` rather than substituting a default, so a judge
- * abort cannot silently corrupt a downstream composite.
- *
- * Reporting contract: callers ship `TrialResult.judgeSucceeded = succeeded`
- * and `TrialResult.judgeAttempts = attempts` so `aggregateTrialsByMode`
- * with `mode: 'exclude-failed'` drops the trial.
- */
-/** Retry policy for judge LLM calls. */
-interface JudgeRetryPolicy {
-    /** Max attempts per model. Default 3 (one initial + two retries). */
-    maxAttempts?: number;
-    /** Per-attempt timeout in ms. Default 300_000. */
-    timeoutMs?: number;
-    /**
-     * Models to try, in order. The first model is the primary; subsequent
-     * models are fallbacks invoked only when ALL retries on the previous
-     * model have been exhausted. Example: `['claude-code/sonnet', 'kimi-code/k2p6']`
-     * runs claude-code up to maxAttempts times, then falls back to kimi.
-     * If omitted, the caller's judge function controls model selection and
-     * the retries apply to that single model.
-     */
-    models?: readonly string[];
-    /** Exponential backoff function, default `attempt → min(500 * 2^attempt, 16_000)`. */
-    backoffMs?: (attempt: number) => number;
-    /**
-     * Predicate deciding whether an error should trigger a retry. Defaults to
-     * `isTransientLlmError` — the package-wide classifier shared with
-     * `callLlm` — which retries aborts/timeouts, network faults, HTTP/2
-     * transport faults, and any `LlmCallError` with status in {429,502,503,504}.
-     * JSON-parse and schema-rejection errors are NOT retriable (the model
-     * needs prompt adjustment, not another shot).
-     */
-    isRetryable?: (err: unknown) => boolean;
-}
-/** Outcome of a wrapped judge invocation. */
-interface JudgeRetryOutcome<T> {
-    /** The judge's returned value when `succeeded === true`. */
-    value: T | null;
-    /** True iff one of the attempts completed without throwing. */
-    succeeded: boolean;
-    /** Total attempts made across all models. */
-    attempts: number;
-    /** Which model the successful attempt used (when succeeded). */
-    modelUsed?: string;
-    /** Last error captured when `succeeded === false`. */
-    error?: Error;
-    /** Per-attempt error log for forensics. */
-    attemptErrors: Array<{
-        attempt: number;
-        model: string;
-        error: string;
-    }>;
-}
-/**
- * Wrap a judge call with retry + fallback-model + typed outcome semantics.
- *
- * The `judgeFn` signature is `(model: string, signal: AbortSignal) => Promise<T>`.
- * The signal will be aborted at `timeoutMs`. Callers should pass the signal
- * to their underlying fetch/SDK call so the abort actually fires.
- *
- * Returns a typed outcome — callers MUST inspect `succeeded` before using
- * `value`. The library refuses to default to a silent zero score because a
- * synthetic zero is indistinguishable from a real low score downstream.
- */
-declare function withJudgeRetry<T>(judgeFn: (model: string, signal: AbortSignal) => Promise<T>, policy?: JudgeRetryPolicy): Promise<JudgeRetryOutcome<T>>;
-
 /**
  * LockedJsonlAppender — mutex-serialized JSONL append helper for arbitrary
  * payloads. The reference-replay store does the same thing for typed
@@ -5268,4 +5275,259 @@ declare namespace index {
   export { type index_AgentProfile as AgentProfile, type index_AgentProfileSection as AgentProfileSection, index_BASELINE_ROLES as BASELINE_ROLES, type index_BaselineRoleKey as BaselineRoleKey, type index_ProfileSkill as ProfileSkill, index_applyDomainPatch as applyDomainPatch, index_baselineProfile as baselineProfile, index_baselineProfileFromRole as baselineProfileFromRole, index_engineerRole as engineerRole, index_generalistRole as generalistRole, index_prodProfile as prodProfile, index_profileToSurface as profileToSurface, index_renderProfile as renderProfile, index_researcherRole as researcherRole, index_sectionHash as sectionHash };
 }
 
-export { type ActiveLearningOptions, type AdapterRun, AgentDriver, type AgentDriverConfig, AgentEvalError, AgentProfile$1 as AgentProfile, type AgreementResult, type AlignmentOp, AnalyzeTracesInput, AnalyzeTracesOptions, AnalyzeTracesResult, type AntiSlopConfig, type AntiSlopIssue, type AntiSlopReport, type AssertCrossFamilyOptions, type AssertSingleBackendOptions, type AutoPrClient, AxGepaSteeringOptimizer, type AxSteeringOptimizerConfig, type BackendDescriptor, BaselineReport, BehaviorAssertion, BenchmarkReport, BenchmarkRunner, BenchmarkRunnerConfig, type BisectOptions, type BisectResult, type BisectStep, BudgetBreachError, BudgetGuard, BudgetLedgerEntry, BudgetSpec, type BuildAgreementJudgeOptions, CallExpectation, type CanaryAlert, type CanaryKind, type CanaryLeak, type CanaryOptions, type CanaryReport, type CanarySeverity, type CandidateComparison, type CandidateScenario, type CausalAttributionReport, type CellVerdict, type ChannelRollup, ChatRequest, CheckResult, CollectedArtifacts, type CommandRunner, type CompareLabels, CompletionCriterion, type ContinuityCheck, type ContinuityCheckResult, type ContinuityReport, type ContinuitySnapshotPair, type ContractMetric, type ContractReport, ConvergenceTracker, type CostChannel, type CostEntry, CostLedger, type CostLedgerEntry, type CostLedgerSummary, type CostResult, type CostSummary, CostTracker, type CostUsage, type CounterfactualContext, type CounterfactualMutation, type CounterfactualResult, type CounterfactualRunner, CreateChatClientOpts, type CreateDefaultReviewerOptions, type CreateExperimentInput, type CreateSandboxPoolOpts, CrossFamilyError, type CrossTraceDiff, type CrossTraceDiffOptions, DEFAULT_AGENT_SLOS, DEFAULT_FINDERS, DEFAULT_MUTATION_PRIMITIVES, DEFAULT_MUTATORS, DEFAULT_PR_REVIEW_SCORE_WEIGHTS, DEFAULT_SEVERITY_WEIGHTS, Dataset, DatasetScenario, type DecideNextUserTurnOpts, type DeployFamily, type DeployGateLayerInput, type DeployRunResult, type DeployRunner, type DescriptionLengthCandidate, type DescriptionLengthConfig, type DescriptionLengthDecision, type DescriptionLengthEvidence, DescriptionLengthGate, type DescriptionLengthRejectionCode, type DiffScorecardOptions, type DirEntry, type DiscoverPersonasOptions, type DiscoveredPersona, DriverResult, DriverState, DualAgentBench, type DualAgentBenchConfig, type DualAgentReport, type DualAgentRound, type DualAgentScenario, type DualAgentScenarioResult, ERROR_COUNT_PATTERNS, type EnsembleAggregate, type ErrorCountPattern, EvalTraceStore, type EvolutionRound, type ExecutorConfig, type Expectation, type Experiment, type ExperimentProvenance, type ExperimentRep, type ExperimentStats, type ExperimentStore, ExperimentTracker, type ExperimentTrackerOptions, type ExperimentVerdict, type ExportedRewardModel, type ExtractOptions, type ExtractResult, type FactorContribution, type FactorialCell, FeedbackLabel, FeedbackTrajectory, FeedbackTrajectoryStore, type FieldAgreementSpec, type FileChange, type FlowAction, type FlowLayerEnv, type FlowLayerFactoryInput, type FlowRunner, type FlowRunnerStepResult, type FlowSpec, type FlowStep, type GhCliClientOptions, type GoldScenario, type GoldSplit, type GoldenSeverity, type GoldenSpec, HarnessConfig, type HeldOutPartition, HoldoutAuditor, type HttpGithubClientOptions, type HypothesisManifest, type HypothesisResult, INTENT_MATCH_JUDGE_VERSION, type ImageData, type ImprovementThresholds, type ImprovementVerdictResult, InMemoryWorkspaceInspector, type InferenceScorer, type InspectorContext, type IntentMatchInput, type IntentMatchOptions, type IntentMatchResult, type InteractionContribution, type JudgeFamily, type JudgeFleetOptions, JudgeFn, type JudgeReplayResult, type JudgeRetryOutcome, type JudgeRetryPolicy, JudgeRunner, type JudgeVerdict, type KeywordConceptSpec, type KeywordCoverageFinding, type KeywordCoverageOptions, type KeywordCoverageResult, type LangfuseEnvelope, type LangfuseGeneration, type LangfuseScore, Layer, LayerResult, type LiveProofArtifact, type LiveProofConfig, type LiveProofContext, type LiveProofResult, LlmClientOptions, LlmSpan, LockedJsonlAppender, MODEL_PRICING, type MatchResult, type MatcherResult, type MergeOptions, MetricsCollector, type ModelPreflight, ModelsUnreachableError, type MuffledFinder, type MuffledFinding, type MultiToolchainLayerConfig, type Mutator, Mutex, type Oracle, type OracleObservation, type OracleReport, type OracleResult, type OrthogonalityInput, type OrthogonalityResult, OtelExportConfig, OtelExporter, type OtelPipelineHandle, type OtelPipelineOptions, PairwiseSteeringOptimizer, type ParaphraseRobustnessScenarioInput, type ParaphraseRobustnessScenarioResult, type ParseStudentLabel, type PartitionHeldOutOptions, PersonaConfig, type Playbook, type PlaybookEntry, type PoolSlot, type PrReviewAuditCase, type PrReviewBenchmarkSummary, type PrReviewComment, type PrReviewMatchedFinding, type PrReviewOutcome, type PrReviewReferenceFinding, type PrReviewScore, type PrReviewScoreWeights, type PrReviewSeverity, type PrReviewSource, type PreflightModelsOptions, type PreflightOutcome, ProductClient, ProductClientConfig, type PromptHandle, PromptRegistry, type ProposeAutomatedPullRequestInput, type ProposeAutomatedPullRequestResult, type ProvenanceReader, type RecordRunsOptions, type ReferenceMatchResult, type ReferenceReplayAdapter, type ReferenceReplayAdapterFn, type ReferenceReplayAdapterLike, type ReferenceReplayAggregate, type ReferenceReplayCandidate, type ReferenceReplayCase, type ReferenceReplayCaseRun, type ReferenceReplayExecutionScenario, type ReferenceReplayItem, type ReferenceReplayMatch, type ReferenceReplayMatchStrategy, type ReferenceReplayMatcher, type ReferenceReplayPromotionDecision, type ReferenceReplayPromotionPolicy, type ReferenceReplayRun, type ReferenceReplayRunContext, type ReferenceReplayRunOptions, type ReferenceReplayRunStore, type ReferenceReplayScenario, type ReferenceReplayScenarioScore, type ReferenceReplayScore, type ReferenceReplayScoreOptions, type ReferenceReplaySplit, type ReferenceReplaySplitComparison, type ReferenceReplaySteeringRowsOptions, type ReflectionContext, type ReflectionProposal, ReleaseConfidenceScorecard, ReleaseConfidenceThresholds, type RenderStudentPrompt, type RepoRef, type ReviewerMemoryEntry, type ReviewerOutput, type ReviewerPromptInput, type ReviewerSoftFailDefaults, type ReviewerVerificationSummary, type RobustnessResult, Run, type RunCommandInput, type RunCommandResult, type RunDistillationOptions, type RunDistillationResult, RunFilter, RunRecord, type RunRecordBackend, type RunRecordFilter, RunScore, RunScoreWeights, RunSplitTag, SandboxDriver, SandboxHarnessResult, type SandboxJudgeKind, type SandboxJudgeResult, type SandboxJudgeSpec, type SandboxPool, type ScanOptions, Scenario, type ScenarioCost, ScenarioFile, ScenarioRegistry, ScenarioResult, type Scorecard, type ScorecardCell, type ScorecardCellDiff, type ScorecardDiff, type ScorecardEntry, type ScorecardLogLine, type ScoredTarget, type SelfPlayOptions, type SelfPlayProposer, type SelfPlayScorer, type SeriesConvergenceOptions, type SeriesConvergenceResult, Severity, type SignedManifest, type SignedManifestAlgo, type SingleBackendDivergence, SingleBackendError, type SingleBackendField, type SingleBackendReport, type Slo, type SloCheckResult, type SloComparator, type SloReport, type SloSeverity, type SlopCategory, type SlotFactory, type SplitGoldOptions, SteeringBundle, type SteeringOptimizationResult, type SteeringOptimizationRow, type SteeringOptimizationSelector, type SteeringOptimizerBackend, type SteeringOptimizerConfig, type StepAttribution, type SynthesisReason, type SynthesisTarget, TestResult, type ThresholdContract, TokenCounter, type TokenSpec, TraceEmitter, TraceStore, type TracedAnalystOptions, type TracedJudgeOptions, Trajectory, TrajectoryStep, type TrialTrace, TurnMetrics, UI_FINDING_SEVERITIES, UI_LENSES, UNIVERSAL_FINDERS, type UiFinding, type UiFindingScreenshot, type UiFindingSeverity, type UiLens, VerifyContext, type VisualDiffOptions, type VisualDiffResult, type ViteDeployRunnerInput, type WorkspaceAssertion, type WorkspaceAssertionResult, type WorkspaceInspector, type WorkspaceSnapshot, type WranglerDeployRunnerInput, adversarialJudge, aggregateJudgeVerdicts, aggregatePrReviewScore, analyzeAntiSlop, analyzeSeries, appendScorecard, assertCrossFamily, assertModelsServed, assertSingleBackend, assignHeldOutTag, attributeCounterfactuals, bisect, buildAgreementJudge, buildDriverSystemPrompt, buildReflectionPrompt, buildReviewerPrompt, canaryLeakView, canonicalize, causalAttribution, checkBehavioralCanary, checkCanaries, checkSlos, codeExecutionJudge, coherenceJudge, collectionPreserved, commentsForSource, commitBisect, compareReferenceReplay, compilerJudge, computeExperimentStats, costForUsage, createAntiSlopJudge, createCustomJudge, createDefaultReviewer, createDomainExpertJudge, createIntentMatchJudge, createSandboxPool, crossTraceDiff, dataDescriptionBits, decideNextUserTurn, decideReferenceReplayPromotion, decideReferenceReplayRunPromotion, defaultJudges, defaultParseStudentLabel, defaultReferenceReplayMatcher, defaultRenderStudentPrompt, deployGateLayer, diffScorecard, discoverPersonas, distillPlaybook, estimateCost, estimateTokens, evaluateContract, evaluateHypothesis, evaluateOracles, executeScenario, expectAgent, exportRewardModel, extractAssetUrls, extractErrorCount, fieldAgreement, fileContains, fileExists, fileExperimentStore, findAutoMatchNoExpectation, findConstructorCwdDropped, findFallbackToPass, findLiteralTruePass, findSkipCountsAsPass, flowLayer, fnv1a32, formatBenchmarkReport, formatDriverReport, formatFindings, formatScorecardDiff, ghCliClient, gitProvenanceReader, precision as goldenPrecision, hashContent, hashJson, hashToUnit, htmlContainsElement, httpGithubClient, improvementVerdict, inMemoryExperimentStore, inMemoryReferenceReplayStore, inMemoryRunRecordBackend, isModelPriced, isOtelConfigured, jsonShape, jsonlReferenceReplayStore, jsonlRunRecordBackend, judgeFamily, keyPreserved, linterJudge, loadGoldScenarios, loadScorecard, loadScorerFromGrader, localCommandRunner, lowercaseMutator, matchGoldens, mergeLayerResults, modelDescriptionBits, modelPriceKey, multiToolchainLayer, notBlocked, paraphraseRobustness, paraphraseRobustnessScenarios, parseGoldJsonl, parseReflectionResponse, partitionHeldOut, passOrthogonality, pixelDeltaRatio, politenessPrefixMutator, preflightModels, printDriverSummary, index as profile, promptBisect, proposeAutomatedPullRequest, proposeSynthesisTargets, recordRuns, recordRunsToScorecard, referenceReplayRunsToSteeringRows, referenceReplayScenarioToRunScore, regexMatches, renderMarkdownReport, renderPlaybookMarkdown, replayScorerOverCorpus, replayTraceThroughJudge, resetLockedAppendersForTesting, resolveModelPricing, rowCount, rowWhere, runAssertions, runBehavioralCanaries, runCanaries, runCounterfactual, runDistillation, runE2EWorkflow, runExpectations, runIntentMatchJudge, runJudgeFleet, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runLiveProof, runReferenceReplay, runScore, runSelfPlay, scanForMuffledGates, scoreContinuity, scorePrReviewComments, scorePrReviewSource, scoreReferenceReplay, securityJudge, sentenceReorderMutator, signManifest, splitGold, statusAdvanced, summarizePrReviewBenchmark, testJudge, textInSnapshot, toLangfuseEnvelope, toPrometheusText, traceJudge, traceJudgeEnsemble, tracedAnalyzeTraces, typoMutator, urlContains, verifyManifest, visualDiff, viteDeployRunner, weightedRecall, whitespaceCollapseMutator, withJudgeRetry, withOtelPipeline, wranglerDeployRunner };
+/**
+ * Program cost report — a thin projection over `CostLedger.summary()` that
+ * adds the per-model rollup the summary lacks, plus `attachCostToReport`, the
+ * one way every artifact (capsules, campaign results, diagnose reports) gets
+ * its cost stamp.
+ *
+ * Honesty contract carried through from the ledger: `total.unknownEntries`
+ * and `perModel[].unpriced` surface the costUnknown axis — a $0 from an
+ * unpriced model is a lower bound, never a measured zero.
+ */
+
+interface ModelCostRollup {
+    model: string;
+    usd: number;
+    entries: number;
+    /** ≥1 entry for this model was costUnknown — `usd` is a lower bound. An
+     *  `actualCostUsd` override clears the flag for that entry (the dollars are
+     *  observed, even when the model has no pricing). */
+    unpriced: boolean;
+}
+interface CostReport {
+    /** Per-channel breakdown — `CostLedgerSummary.byChannel` verbatim. */
+    perChannel: ChannelRollup[];
+    total: {
+        usd: number;
+        /** Entries whose cost was unknown — non-zero means `usd` is a lower bound. */
+        unknownEntries: number;
+    };
+    /** Per-model spend, sorted by model id. */
+    perModel: ModelCostRollup[];
+}
+/** Project a ledger into the program cost report. Pure — no I/O, no clock. */
+declare function costReport(ledger: CostLedger): CostReport;
+/**
+ * Stamp a report-shaped object with its cost projection under the `cost` key.
+ * Generic so capsules, campaign results, and diagnose reports all stamp the
+ * same way. Throws when the report already carries a `cost` key — silently
+ * overwriting an existing stamp would corrupt the artifact's provenance.
+ */
+declare function attachCostToReport<R extends object>(report: R, ledger: CostLedger): R & {
+    cost: CostReport;
+};
+
+/**
+ * ModelSeats — the program's model seating chart.
+ *
+ * One object names which model fills each role in an eval program: the worker
+ * under evaluation, the judge panel, the analyst, the reflection/driver model,
+ * and the verifier. Re-tiering an entire program (economy ↔ frontier) is one
+ * swapped object instead of a hunt through call sites.
+ *
+ * Wiring points — consumers thread seats; this module implements none of them
+ * (those files belong to other surfaces):
+ *  - `judges`     → `ensembleJudge({ models: seats.judges, … })` (src/judge-panel.ts)
+ *                   and the `JudgeConfig`s handed to `makeEvalTools({ judges })`
+ *                   (src/eval-tools.ts).
+ *  - `reflection` → `selfImprove({ llm: { model: seats.reflection } })` — the
+ *                   `gepaDriver` reflection model (src/contract/self-improve.ts);
+ *                   same seat for any custom `ImprovementDriver`'s LLM.
+ *  - `worker`     → the dispatch model the agent itself calls — the model an
+ *                   `AgentProfile` declares.
+ *  - `analyst`    → the LLM behind `analyzeRuns` / analyst-registry kinds.
+ *  - `verifier`   → completion-verifier / objective-checker model.
+ *  - campaign cells thread `judges` + driver models the same way; that wiring
+ *    lands with the campaign surface, not here.
+ *
+ * `resolveSeat` is the only read path: an unset seat with no explicit fallback
+ * throws — a model id is a budget decision, never a silent default.
+ */
+
+interface ModelSeats {
+    /** The model under evaluation — what the agent itself dispatches with. */
+    worker?: string;
+    /** Judge-panel model ids — thread into `ensembleJudge({ models })`. */
+    judges?: string[];
+    /** Analyst model — `analyzeRuns` / analyst-registry LLM calls. */
+    analyst?: string;
+    /** Reflection/driver model — `gepaDriver` mutation proposals. */
+    reflection?: string;
+    /** Verifier model — completion/objective checking. */
+    verifier?: string;
+}
+type SeatName = keyof ModelSeats;
+type SeatPresetName = keyof typeof seatPresets;
+/**
+ * Tier presets — plain data, swap or spread freely.
+ *
+ * `economy` uses the fleet-policy ids: every id resolves through the
+ * substrate's family pricing (no costUnknown axis) and the judge trio spans
+ * three provider families (moonshot / deepseek / openai), so it passes
+ * `assertCrossFamily` as-is.
+ *
+ * `frontier` is deliberately EMPTY: entitled frontier ids vary per router
+ * account, and a hardcoded claude/gpt-5 id 401s on keys that lack it. Supply
+ * your own: `{ ...seatPresets.frontier, worker: '<your-frontier-id>', … }` —
+ * `resolveSeat` throws on every seat you haven't filled.
+ */
+declare const seatPresets: Record<'economy' | 'frontier', ModelSeats>;
+/** Thrown by `resolveSeat` when a seat is unset and no fallback was given. */
+declare class SeatUnsetError extends ConfigError {
+    readonly seat: SeatName;
+    constructor(seat: SeatName);
+}
+/**
+ * Read one seat. Blank strings and empty arrays count as unset (env-var
+ * plumbing produces them); malformed values (non-string seat, non-array or
+ * blank-entry `judges`) throw `ValidationError`. When the seat is unset, an
+ * explicit `fallback` is returned (`[fallback]` for `judges` — a one-model
+ * panel); without one, `SeatUnsetError`.
+ */
+declare function resolveSeat(seats: ModelSeats, seat: 'judges', fallback?: string): string[];
+declare function resolveSeat(seats: ModelSeats, seat: Exclude<SeatName, 'judges'>, fallback?: string): string;
+declare function resolveSeat(seats: ModelSeats, seat: SeatName, fallback?: string): string | string[];
+
+/**
+ * Reproducibility attestation for any serializable report object.
+ *
+ * `attest()` binds a report to its content address (sha-256 over canonical
+ * JSON) plus the provenance needed to reproduce it: model versions, seeds,
+ * price-table hash, code SHA, inputs hash. `verifyAttestation()` recomputes
+ * the address and answers "is this the exact report that provenance
+ * describes?" — any single-field tamper changes the hash.
+ *
+ * Layering: content-addressing is the substrate's job; cryptographic SIGNING
+ * (who vouches for the attestation, key management, transparency logs) is the
+ * consumer's layer on top. An `AttestedReport` is a stable byte-identical
+ * payload a consumer can sign — the substrate never holds keys.
+ *
+ * Generic by design: the report parameter is ANY value `canonicalJson`
+ * accepts (campaign results, fuzz capsules, scorecards, cost ledgers). Do not
+ * couple this module to a specific report schema.
+ */
+/** Hash scheme identifier carried by every attestation. A verifier rejects
+ *  unknown algorithms instead of guessing. */
+declare const ATTESTATION_ALGORITHM: "sha256/canonical-json";
+interface AttestationProvenance {
+    /** Every model involved in producing the report, name → version/id. */
+    modelVersions: Record<string, string>;
+    /** RNG seeds the run was driven by, when seeded. */
+    seeds?: number[];
+    /** Content hash of the price table used for cost figures — cost numbers
+     *  are only reproducible against the same prices. */
+    priceTableHash?: string;
+    /** Git SHA of the code that produced the report. */
+    codeSha: string;
+    /** Content hash of the input set (scenarios, dataset manifest, ...). */
+    inputsHash?: string;
+    /** ISO-8601 timestamp, caller-supplied — the substrate stays clock-free
+     *  so attestation is deterministic and testable. */
+    createdAt: string;
+}
+interface AttestedReport {
+    /** Hex sha-256 over the canonical JSON of the report. */
+    reportHash: string;
+    provenance: AttestationProvenance;
+    algorithm: typeof ATTESTATION_ALGORITHM;
+}
+interface AttestationVerification {
+    valid: boolean;
+    /** Populated iff `valid` is false — names the exact mismatch. */
+    reason?: string;
+}
+/**
+ * Content-address a report and bind it to its provenance. Throws (via
+ * `canonicalJson`) if the report contains undefined / function / symbol /
+ * non-finite numbers — a report that cannot be unambiguously serialized
+ * cannot be attested.
+ */
+declare function attest(report: unknown, provenance: AttestationProvenance): AttestedReport;
+/**
+ * Verify a report against its attestation. Returns a typed outcome rather
+ * than throwing: an unverifiable report (e.g. one that no longer
+ * canonicalizes) is a verification failure with the cause in `reason`, not a
+ * crash — verifiers run in pipelines that must record WHY, not die.
+ */
+declare function verifyAttestation(report: unknown, attested: AttestedReport): AttestationVerification;
+
+/**
+ * Content-addressed judge-verdict caching.
+ *
+ * LAW: cache JUDGE VERDICTS only — judging the same artifact with the same
+ * judge+rubric is pure. NEVER cache agent rollouts. (A router that cached
+ * identical fanout prompts silently destroyed best-of-N diversity; rollout
+ * caching reintroduces that failure class. Judging has no diversity to
+ * destroy — same artifact + same rubric ⇒ same verdict is the desired
+ * property, not a bug.)
+ *
+ * The cache key is a sha-256 over the canonical JSON of everything that can
+ * change a verdict: the artifact content, the scenario id, the judge name,
+ * the full dimension list (key + description — the description IS the rubric
+ * text shown to the judge), and a caller-supplied `judgeVersion`.
+ * `judgeVersion` is REQUIRED: a judge whose prompt/model/ensemble changes
+ * without a version bump would otherwise silently serve stale verdicts.
+ *
+ * Strict canonicalization (`canonicalJson`) throws on undefined / function /
+ * symbol / non-finite numbers — an artifact that cannot be unambiguously
+ * serialized cannot be content-addressed, and coercing it would let two
+ * different artifacts collide on one key.
+ */
+
+/**
+ * Stable JSON stringify: object keys sorted recursively, so two semantically
+ * equal values produce byte-identical output regardless of key insertion
+ * order. Throws on undefined / function / symbol / NaN / ±Infinity / bigint /
+ * Map / Set — anything JSON.stringify would coerce or drop silently.
+ *
+ * Distinct from `pre-registration.ts`'s `canonicalize`/`hashJson`, which are
+ * permissive (coercion allowed) and async (web-crypto). Use THIS pair when a
+ * hash collision or silent coercion would corrupt a cache key or attestation.
+ */
+declare function canonicalJson(value: unknown): string;
+/** Hex sha-256 over `canonicalJson(value)`. The content address used by the
+ *  verdict cache and report attestation. */
+declare function contentHash(value: unknown): string;
+/** Pluggable verdict store. Sync or async on both legs — `cachedJudge`
+ *  awaits the results either way. */
+interface VerdictCacheStore {
+    get(key: string): Promise<JudgeScore | undefined> | JudgeScore | undefined;
+    set(key: string, score: JudgeScore): Promise<void> | void;
+}
+/** Process-local Map-backed store. */
+declare function inMemoryVerdictCache(): VerdictCacheStore;
+/**
+ * JSONL-file-backed store: the full file is loaded into an in-memory index at
+ * construction; every `set` appends one line synchronously (durable before
+ * the verdict is returned). A corrupt or malformed line throws at load with
+ * file:line — a skipped line would silently re-judge (cost) or, worse, mask
+ * a half-written file that needs operator attention.
+ */
+declare function fileVerdictCache(path: string): VerdictCacheStore;
+interface VerdictCacheStats {
+    hits: number;
+    misses: number;
+}
+interface CachedJudgeOptions {
+    /** REQUIRED — part of the cache key. Bump on any change to the judge's
+     *  prompt, model, ensemble, or scoring logic; silent judge upgrades must
+     *  never serve stale verdicts. */
+    judgeVersion: string;
+}
+/** The wrapped judge: same `JudgeConfig` seam, plus hit/miss observability. */
+type CachedJudge<TArtifact, TScenario extends Scenario$1 = Scenario$1> = JudgeConfig<TArtifact, TScenario> & {
+    stats(): VerdictCacheStats;
+};
+/**
+ * Wrap a `JudgeConfig` so repeat judgments of the same artifact are served
+ * from the store instead of re-invoking `score()`. The wrapper is generic
+ * over the judge's own type parameters and preserves `appliesTo` — it is a
+ * drop-in replacement anywhere a `JudgeConfig` is accepted.
+ *
+ * A judge that throws is NOT cached: the error propagates and the next
+ * attempt re-judges (caching a failure would pin a transient outage forever).
+ */
+declare function cachedJudge<TArtifact, TScenario extends Scenario$1 = Scenario$1>(judge: JudgeConfig<TArtifact, TScenario>, store: VerdictCacheStore, options: CachedJudgeOptions): CachedJudge<TArtifact, TScenario>;
+
+export { ATTESTATION_ALGORITHM, type ActiveLearningOptions, type AdapterRun, AgentDriver, type AgentDriverConfig, AgentEvalError, AgentProfile$1 as AgentProfile, type AgreementResult, type AlignmentOp, AnalyzeTracesInput, AnalyzeTracesOptions, AnalyzeTracesResult, type AntiSlopConfig, type AntiSlopIssue, type AntiSlopReport, type AssertCrossFamilyOptions, type AssertSingleBackendOptions, type AttestationProvenance, type AttestationVerification, type AttestedReport, type AutoPrClient, AxGepaSteeringOptimizer, type AxSteeringOptimizerConfig, type BackendDescriptor, BaselineReport, BehaviorAssertion, BenchmarkReport, BenchmarkRunner, BenchmarkRunnerConfig, type BisectOptions, type BisectResult, type BisectStep, BudgetBreachError, BudgetGuard, BudgetLedgerEntry, BudgetSpec, type BuildAgreementJudgeOptions, type CachedJudge, type CachedJudgeOptions, CallExpectation, type CanaryAlert, type CanaryKind, type CanaryLeak, type CanaryOptions, type CanaryReport, type CanarySeverity, type CandidateComparison, type CandidateScenario, type CausalAttributionReport, type CellVerdict, ChannelRollup, ChatRequest, CheckResult, CollectedArtifacts, type CommandRunner, type CompareLabels, CompletionCriterion, ConfigError, type ContinuityCheck, type ContinuityCheckResult, type ContinuityReport, type ContinuitySnapshotPair, type ContractCheckResult, type ContractJudgeOptions, type ContractMetric, type ContractReport, type ContractRule, type ContractRuleKind, type ContractSpan, type ContractVerdict, type ContractViolation, ConvergenceTracker, CorrectnessChecker, type CostEntry, CostLedger, type CostReport, type CostSummary, CostTracker, CreateChatClientOpts, type CreateDefaultReviewerOptions, type CreateExperimentInput, type CreateSandboxPoolOpts, CrossFamilyError, type CrossTraceDiff, type CrossTraceDiffOptions, DEFAULT_AGENT_SLOS, DEFAULT_FINDERS, DEFAULT_MUTATION_PRIMITIVES, DEFAULT_MUTATORS, DEFAULT_PR_REVIEW_SCORE_WEIGHTS, DEFAULT_SEVERITY_WEIGHTS, Dataset, DatasetScenario, type DecideNextUserTurnOpts, DefaultVerdict, type DeployFamily, type DeployGateLayerInput, type DeployRunResult, type DeployRunner, type DescriptionLengthCandidate, type DescriptionLengthConfig, type DescriptionLengthDecision, type DescriptionLengthEvidence, DescriptionLengthGate, type DescriptionLengthRejectionCode, type DiffScorecardOptions, type DirEntry, type DiscoverPersonasOptions, type DiscoveredPersona, DriverResult, DriverState, DualAgentBench, type DualAgentBenchConfig, type DualAgentReport, type DualAgentRound, type DualAgentScenario, type DualAgentScenarioResult, ERROR_COUNT_PATTERNS, type EnsembleAggregate, type EnsembleJudgeOptions, type ErrorCountPattern, type EvalToolDef, EvalTraceStore, type EvolutionRound, type ExecutorConfig, type Expectation, type Experiment, type ExperimentProvenance, type ExperimentRep, type ExperimentStats, type ExperimentStore, ExperimentTracker, type ExperimentTrackerOptions, type ExperimentVerdict, type ExportedRewardModel, type ExtractOptions, type ExtractResult, type FactorContribution, type FactorialCell, FeedbackLabel, FeedbackTrajectory, FeedbackTrajectoryStore, type FieldAgreementSpec, type FileChange, type FlowAction, type FlowLayerEnv, type FlowLayerFactoryInput, type FlowRunner, type FlowRunnerStepResult, type FlowSpec, type FlowStep, type GhCliClientOptions, type GoldScenario, type GoldSplit, type GoldenSeverity, type GoldenSpec, HarnessConfig, type HeldOutPartition, HoldoutAuditor, type HttpGithubClientOptions, INTENT_MATCH_JUDGE_VERSION, type ImageData, type ImprovementThresholds, type ImprovementVerdictResult, InMemoryWorkspaceInspector, type InferenceScorer, type InspectorContext, type IntentMatchInput, type IntentMatchOptions, type IntentMatchResult, type InteractionContribution, JudgeError, type JudgeFamily, type JudgeFleetOptions, JudgeFn, JudgeParseError, type JudgeReplayResult, type JudgeRetryOutcome, type JudgeRetryPolicy, JudgeRunner, type JudgeVerdict, type KeywordConceptSpec, type KeywordCoverageFinding, type KeywordCoverageOptions, type KeywordCoverageResult, type LangfuseEnvelope, type LangfuseGeneration, type LangfuseScore, Layer, LayerResult, type LiveProofArtifact, type LiveProofConfig, type LiveProofContext, type LiveProofResult, LlmClientOptions, LlmSpan, LockedJsonlAppender, MODEL_PRICING, type MakeEvalToolsConfig, type MatchResult, type MatcherResult, type MergeOptions, MetricsCollector, type ModelCostRollup, type ModelPreflight, type ModelSeats, ModelsUnreachableError, type MuffledFinder, type MuffledFinding, type MultiToolchainLayerConfig, type Mutator, Mutex, type Oracle, type OracleObservation, type OracleReport, type OracleResult, type OrthogonalityInput, type OrthogonalityResult, OtelExportConfig, OtelExporter, type OtelPipelineHandle, type OtelPipelineOptions, PairwiseSteeringOptimizer, type ParaphraseRobustnessScenarioInput, type ParaphraseRobustnessScenarioResult, type ParseStudentLabel, type PartitionHeldOutOptions, PersonaConfig, type Playbook, type PlaybookEntry, type PoolSlot, type PrReviewAuditCase, type PrReviewBenchmarkSummary, type PrReviewComment, type PrReviewMatchedFinding, type PrReviewOutcome, type PrReviewReferenceFinding, type PrReviewScore, type PrReviewScoreWeights, type PrReviewSeverity, type PrReviewSource, type PreflightModelsOptions, type PreflightOutcome, ProductClient, ProductClientConfig, type PromptHandle, PromptRegistry, type ProposeAutomatedPullRequestInput, type ProposeAutomatedPullRequestResult, type ProvenanceReader, type RecordRunsOptions, type ReferenceMatchResult, type ReferenceReplayAdapter, type ReferenceReplayAdapterFn, type ReferenceReplayAdapterLike, type ReferenceReplayAggregate, type ReferenceReplayCandidate, type ReferenceReplayCase, type ReferenceReplayCaseRun, type ReferenceReplayExecutionScenario, type ReferenceReplayItem, type ReferenceReplayMatch, type ReferenceReplayMatchStrategy, type ReferenceReplayMatcher, type ReferenceReplayPromotionDecision, type ReferenceReplayPromotionPolicy, type ReferenceReplayRun, type ReferenceReplayRunContext, type ReferenceReplayRunOptions, type ReferenceReplayRunStore, type ReferenceReplayScenario, type ReferenceReplayScenarioScore, type ReferenceReplayScore, type ReferenceReplayScoreOptions, type ReferenceReplaySplit, type ReferenceReplaySplitComparison, type ReferenceReplaySteeringRowsOptions, type ReflectionContext, type ReflectionProposal, ReleaseConfidenceScorecard, ReleaseConfidenceThresholds, type RenderStudentPrompt, type RepoRef, type ReviewerMemoryEntry, type ReviewerOutput, type ReviewerPromptInput, type ReviewerSoftFailDefaults, type ReviewerVerificationSummary, type RobustnessResult, Run, type RunCommandInput, type RunCommandResult, type RunDistillationOptions, type RunDistillationResult, RunFilter, RunRecord, type RunRecordBackend, type RunRecordFilter, RunScore, RunScoreWeights, RunSplitTag, SandboxDriver, SandboxHarnessResult, type SandboxJudgeKind, type SandboxJudgeResult, type SandboxJudgeSpec, type SandboxPool, type ScanOptions, Scenario, type ScenarioCost, ScenarioFile, ScenarioRegistry, ScenarioResult, type Scorecard, type ScorecardCell, type ScorecardCellDiff, type ScorecardDiff, type ScorecardEntry, type ScorecardLogLine, type ScoredTarget, type SeatName, type SeatPresetName, SeatUnsetError, type SelfPlayOptions, type SelfPlayProposer, type SelfPlayScorer, type SerializedRegex, Severity, type SingleBackendDivergence, SingleBackendError, type SingleBackendField, type SingleBackendReport, type Slo, type SloCheckResult, type SloComparator, type SloReport, type SloSeverity, type SlopCategory, type SlotFactory, type SpanPredicate, type SplitGoldOptions, SteeringBundle, type SteeringOptimizationResult, type SteeringOptimizationRow, type SteeringOptimizationSelector, type SteeringOptimizerBackend, type SteeringOptimizerConfig, type StepAttribution, type SynthesisReason, type SynthesisTarget, TestResult, type TextMatcher, type ThresholdContract, TokenCounter, type TokenSpec, type TraceContract, TraceContractBuilder, TraceEmitter, TraceStore, type TracedAnalystOptions, type TracedJudgeOptions, Trajectory, TrajectoryStep, type TrialTrace, TurnMetrics, UI_FINDING_SEVERITIES, UI_LENSES, UNIVERSAL_FINDERS, type UiFinding, type UiFindingScreenshot, type UiFindingSeverity, type UiLens, type VerdictCacheStats, type VerdictCacheStore, VerifyContext, type VisualDiffOptions, type VisualDiffResult, type ViteDeployRunnerInput, type WorkspaceAssertion, type WorkspaceAssertionResult, type WorkspaceInspector, type WorkspaceSnapshot, type WranglerDeployRunnerInput, adversarialJudge, aggregateJudgeVerdicts, aggregatePrReviewScore, analyzeAntiSlop, appendScorecard, assertCrossFamily, assertModelsServed, assertSingleBackend, assignHeldOutTag, attachCostToReport, attest, bisect, buildAgreementJudge, buildDriverSystemPrompt, buildReflectionPrompt, buildReviewerPrompt, cachedJudge, canaryLeakView, canonicalJson, causalAttribution, checkBehavioralCanary, checkCanaries, checkSlos, checkTraceContracts, codeExecutionJudge, coherenceJudge, collectionPreserved, commentsForSource, commitBisect, compareReferenceReplay, compilerJudge, computeExperimentStats, contentHash, contractJudge, costReport, createAntiSlopJudge, createCustomJudge, createDefaultReviewer, createDomainExpertJudge, createIntentMatchJudge, createSandboxPool, crossTraceDiff, dataDescriptionBits, decideNextUserTurn, decideReferenceReplayPromotion, decideReferenceReplayRunPromotion, defaultJudges, defaultParseStudentLabel, defaultReferenceReplayMatcher, defaultRenderStudentPrompt, deployGateLayer, diffScorecard, discoverPersonas, distillPlaybook, ensembleJudge, estimateCost, estimateTokens, evaluateContract, evaluateOracles, evaluateTraceContract, executeScenario, expectAgent, exportRewardModel, extractAssetUrls, extractErrorCount, fieldAgreement, fileContains, fileExists, fileExperimentStore, fileVerdictCache, findAutoMatchNoExpectation, findConstructorCwdDropped, findFallbackToPass, findLiteralTruePass, findSkipCountsAsPass, flowLayer, fnv1a32, formatBenchmarkReport, formatDriverReport, formatFindings, formatScorecardDiff, ghCliClient, gitProvenanceReader, precision as goldenPrecision, hashContent, hashToUnit, htmlContainsElement, httpGithubClient, improvementVerdict, inMemoryExperimentStore, inMemoryReferenceReplayStore, inMemoryRunRecordBackend, inMemoryVerdictCache, isModelPriced, isOtelConfigured, jsonShape, jsonlReferenceReplayStore, jsonlRunRecordBackend, judgeFamily, keyPreserved, linterJudge, loadGoldScenarios, loadScorecard, loadScorerFromGrader, localCommandRunner, lowercaseMutator, makeEvalTools, matchGoldens, matchSpan, mergeLayerResults, modelDescriptionBits, multiToolchainLayer, notBlocked, paraphraseRobustness, paraphraseRobustnessScenarios, parseGoldJsonl, parseReflectionResponse, partitionHeldOut, passOrthogonality, pixelDeltaRatio, politenessPrefixMutator, preflightModels, printDriverSummary, index as profile, promptBisect, proposeAutomatedPullRequest, proposeSynthesisTargets, recordRuns, recordRunsToScorecard, referenceReplayRunsToSteeringRows, referenceReplayScenarioToRunScore, regexMatches, renderMarkdownReport, renderPlaybookMarkdown, replayScorerOverCorpus, replayTraceThroughJudge, resetLockedAppendersForTesting, resolveModelPricing, resolveSeat, rowCount, rowWhere, runAssertions, runBehavioralCanaries, runCanaries, runDistillation, runE2EWorkflow, runExpectations, runIntentMatchJudge, runJudgeFleet, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runLiveProof, runReferenceReplay, runScore, runSelfPlay, scanForMuffledGates, scoreContinuity, scorePrReviewComments, scorePrReviewSource, scoreReferenceReplay, seatPresets, securityJudge, sentenceReorderMutator, splitGold, statusAdvanced, summarizePrReviewBenchmark, testJudge, textInSnapshot, toLangfuseEnvelope, toOpenAiTool, toPrometheusText, traceContract, traceJudge, traceJudgeEnsemble, tracedAnalyzeTraces, typoMutator, urlContains, verifyAttestation, visualDiff, viteDeployRunner, weightedRecall, whitespaceCollapseMutator, withJudgeRetry, withOtelPipeline, wranglerDeployRunner };