@tangle-network/agent-eval 0.85.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 } 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, a as RunSplitTag, 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, 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, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, inferDomainKeywords, inferOtlpKind, iterateRawCalls, otelRunCompleteHook, otlpToRunRecords, otlpToTraceRunRecords, planTraceInsightQuestions, projectOtlpFlatLine, readOtlpStatus, scoreTraceInsightReadiness, stringField, tokenizeDomainWords, traceAnalystFunctionGroup, traceAnalystOnRunComplete } 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;
@@ -1351,6 +1595,291 @@ interface CostSummary {
     costPerCompletedTaskUsd: number | null;
 }
 
+/**
+ * EvalTraceStore — JSONL save / query / compare over the analysis-time
+ * `RunRecord` row.
+ *
+ * `FileSystemTraceStore` (in `./trace/store`) persists the rich TraceSchema-v1
+ * span corpus — runs, spans, events, artifacts — the runtime emits live. That
+ * is NOT the thing three consumers hand-roll in `tests/eval/lib/trace-store.ts`.
+ * What they hand-roll is the *analysis* layer: append each finished run as one
+ * JSONL line keyed by scenario/candidate, then query it ("every run where score
+ * < 50"), pick the best run for a scenario (few-shot seeding), and compare two
+ * candidates on matched scenarios.
+ *
+ * The substrate already has the canonical analysis-time row — `RunRecord` — so
+ * this is that query/compare API expressed over `RunRecord[]`, with a
+ * JSONL-backed store. It does NOT fork `FileSystemTraceStore`; it sits beside it
+ * for the analysis projection.
+ */
+
+/** The score the query/compare layer ranks on: holdout when present (the
+ *  gated number), else search. Throws when a record carries neither — a
+ *  RunRecord is invalid without at least one, but a hand-built object might. */
+declare function runScore(record: RunRecord): number;
+interface RunRecordFilter {
+    experimentId?: string;
+    candidateId?: string;
+    scenarioId?: string;
+    model?: string;
+    splitTag?: RunSplitTag;
+    /** Inclusive lower bound on `runScore`. */
+    minScore?: number;
+    /** Inclusive upper bound on `runScore`. */
+    maxScore?: number;
+    /** Match a single tag in `outcome.raw` by exact numeric value. */
+    rawEquals?: {
+        key: string;
+        value: number;
+    };
+    /** Custom predicate, ANDed with the structured filters. */
+    where?: (record: RunRecord) => boolean;
+}
+interface CandidateComparison {
+    a: string;
+    b: string;
+    /** Scenario ids present for BOTH candidates — the paired comparison set. */
+    pairedScenarioIds: string[];
+    /** Mean `runScore` for candidate a over the paired scenarios. */
+    meanA: number;
+    /** Mean `runScore` for candidate b over the paired scenarios. */
+    meanB: number;
+    /** meanB − meanA. Positive ⇒ b scored higher on the matched scenarios. */
+    meanDelta: number;
+    /** Scenarios where b beat a (strictly), tied, and a beat b. */
+    bWins: number;
+    ties: number;
+    aWins: number;
+}
+/**
+ * Backing persistence for `EvalTraceStore`. The in-memory store is the default;
+ * the JSONL file store appends one validated `RunRecord` per line. Both keep an
+ * append order so `getBest` / `compareRuns` are reproducible.
+ */
+interface RunRecordBackend {
+    append(record: RunRecord): Promise<void>;
+    load(): Promise<RunRecord[]>;
+}
+declare function inMemoryRunRecordBackend(initial?: RunRecord[]): RunRecordBackend;
+/**
+ * JSONL-backed store at `path`, one `RunRecord` per line. Malformed lines fail
+ * loud on load (a corrupt corpus must not silently shrink the analysis set);
+ * pass `skipInvalid` only for forensics on a known-bad file.
+ */
+declare function jsonlRunRecordBackend(path: string, opts?: {
+    skipInvalid?: boolean;
+}): RunRecordBackend;
+/**
+ * Query / compare layer over a `RunRecord` corpus. Append finished runs, query
+ * with a structured filter, take the best run for a scenario, and compare two
+ * candidates on their matched scenarios. Persistence is injected via
+ * `RunRecordBackend` (in-memory by default, JSONL file via
+ * `jsonlRunRecordBackend`).
+ */
+declare class EvalTraceStore {
+    private readonly backend;
+    constructor(backend?: RunRecordBackend);
+    /** Validate and append one run. Throws on an invalid record — the corpus
+     *  stays paper-grade. */
+    append(record: RunRecord): Promise<void>;
+    all(): Promise<RunRecord[]>;
+    query(filter?: RunRecordFilter): Promise<RunRecord[]>;
+    /**
+     * Highest-scoring run for a scenario (optionally restricted to a candidate).
+     * Returns null when no run matches. Ties resolve to the earliest-appended run
+     * so the result is stable.
+     */
+    getBest(scenarioId: string, opts?: {
+        candidateId?: string;
+        splitTag?: RunSplitTag;
+    }): Promise<RunRecord | null>;
+    /**
+     * Compare two candidates on the scenarios they BOTH ran. When a candidate
+     * ran a scenario more than once, its best `runScore` for that scenario is
+     * used. Throws when there is no paired scenario — an unpaired "comparison" is
+     * not one.
+     */
+    compareRuns(candidateA: string, candidateB: string): Promise<CandidateComparison>;
+}
+
+/**
+ * Experiment tracker — git-provenanced experiment log with N-rep stats and a
+ * KEEP / REGRESSION / NOISE verdict against a parent.
+ *
+ * Every loop the fleet runs reduces to the same question: "I ran the candidate
+ * N times — is the median measurably better than the parent, or is the delta
+ * inside the noise band?" The hand-rolled copies bake a fixed score scale
+ * (percentage points), a fixed store path (`.evolve/experiments-v2.json`), and
+ * `execSync('git …')` straight into the module. This is the canonical version:
+ * provenance and persistence are injected, thresholds are configurable, and the
+ * stats + verdict are pure functions you can unit-test without a git repo or a
+ * filesystem.
+ *
+ * Stats per experiment: median / mean / min / max / iqr / stddev / passRate /
+ * n, plus a `stable` flag (`iqr < iqrUnstableAbove && stddev < stddevUnstableAbove`).
+ *
+ * Verdict against a parent (both must have `n >= minRepsForVerdict`):
+ *   - NOISE       — the candidate is too unstable to judge (`!stable`)
+ *   - KEEP        — `medianDelta >  keepThreshold`
+ *   - REGRESSION  — `medianDelta < -regressionThreshold`
+ *   - NOISE       — otherwise (delta inside the band)
+ * With no parent (or insufficient reps) the verdict is the neutral ITERATE.
+ */
+/** Verdict for one experiment relative to its parent. ITERATE is the neutral
+ *  "keep collecting reps / no parent to compare against" state. */
+type ExperimentVerdict = 'KEEP' | 'ITERATE' | 'NOISE' | 'REGRESSION';
+/** Git provenance for the working tree an experiment was run from. */
+interface ExperimentProvenance {
+    /** Commit sha (short or full — the tracker does not interpret it). */
+    commit: string;
+    /** First line of the commit message. */
+    message: string;
+    /** Files changed vs the parent commit, or a marker like 'uncommitted'. */
+    changedFiles: string[];
+}
+/** A single repetition of an experiment, carrying the score the verdict is
+ *  computed on plus any free-form per-rep metrics the consumer wants kept. */
+interface ExperimentRep {
+    /** 0-indexed repetition number within the experiment. */
+    rep: number;
+    /** The score this rep is judged on (same scale as the thresholds). */
+    score: number;
+    /** ISO timestamp the rep completed. */
+    timestamp: string;
+    /** Whether this rep passed the consumer's own gate — folded into `passRate`. */
+    passed?: boolean;
+    /** Free-form numeric metrics retained for later analysis. */
+    metrics?: Record<string, number>;
+}
+interface ExperimentStats {
+    median: number;
+    mean: number;
+    min: number;
+    max: number;
+    /** Inter-quartile range of the rep scores. */
+    iqr: number;
+    /** Population standard deviation of the rep scores. */
+    stddev: number;
+    /** Fraction of reps with `passed === true`, over reps that set `passed`.
+     *  null when no rep declared a pass/fail outcome. */
+    passRate: number | null;
+    /** Number of reps. */
+    n: number;
+    /** True when the sample is tight enough to trust for a verdict. */
+    stable: boolean;
+}
+interface Experiment {
+    /** Stable id for the experiment. */
+    id: string;
+    /** Free-form label / config descriptor. */
+    label: string;
+    /** Git provenance captured when the experiment was created. */
+    provenance: ExperimentProvenance;
+    /** Parent experiment id this candidate is compared against, if any. */
+    parentId?: string;
+    /** One-line summary of what changed from the parent. */
+    changeSummary: string;
+    reps: ExperimentRep[];
+    stats: ExperimentStats;
+    verdict: ExperimentVerdict;
+    /** ISO timestamp the experiment was created. */
+    createdAt: string;
+}
+interface ImprovementThresholds {
+    /** medianDelta strictly above this ⇒ KEEP. Default 5. */
+    keepThreshold?: number;
+    /** medianDelta strictly below the negative of this ⇒ REGRESSION. Default 5. */
+    regressionThreshold?: number;
+    /** iqr at or above this ⇒ unstable. Default 10. */
+    iqrUnstableAbove?: number;
+    /** stddev at or above this ⇒ unstable. Default Infinity (iqr-only stability). */
+    stddevUnstableAbove?: number;
+    /** Reps required on BOTH candidate and parent before a verdict is rendered.
+     *  Default 3. */
+    minRepsForVerdict?: number;
+}
+interface ImprovementVerdictResult {
+    verdict: ExperimentVerdict;
+    /** candidate.median − parent.median; null when no parent or insufficient reps. */
+    medianDelta: number | null;
+    /** Human-readable reason for the verdict — for dashboards and logs. */
+    reason: string;
+}
+/**
+ * Compute the N-rep statistics for a set of reps. Pure — no I/O. The `stable`
+ * flag is the trust gate the verdict depends on: a sample whose spread exceeds
+ * the configured bounds can't distinguish a real delta from run-to-run noise.
+ */
+declare function computeExperimentStats(reps: ExperimentRep[], thresholds?: ImprovementThresholds): ExperimentStats;
+/**
+ * Verdict for a candidate against its parent. Pure — operates on already-computed
+ * stats. KEEP/REGRESSION require both sides to have `>= minRepsForVerdict` reps
+ * AND the candidate to be `stable`; otherwise the result is NOISE (unstable) or
+ * ITERATE (not enough reps / no parent).
+ */
+declare function improvementVerdict(candidate: ExperimentStats, parent: ExperimentStats | null, thresholds?: ImprovementThresholds): ImprovementVerdictResult;
+/** Reads git provenance for the working tree. Inject a fake in tests; the
+ *  default implementation shells out to `git`. */
+type ProvenanceReader = () => ExperimentProvenance | Promise<ExperimentProvenance>;
+/** Persistence seam for the experiment log. Inject in-memory in tests; the
+ *  filesystem implementation is `fileExperimentStore`. */
+interface ExperimentStore {
+    load(): Promise<Experiment[]>;
+    save(experiments: Experiment[]): Promise<void>;
+}
+/**
+ * Default provenance reader: `git rev-parse HEAD`, the subject line, and the
+ * files changed vs `HEAD~1`. Fail-loud — a tracker that silently logs
+ * `commit: 'unknown'` corrupts the provenance the whole point of the log is to
+ * carry. When the working tree genuinely has no parent commit, pass an override.
+ */
+declare const gitProvenanceReader: ProvenanceReader;
+/** In-memory store — the default when no persistence is wanted (tests, ephemeral
+ *  runs). State lives on the instance. */
+declare function inMemoryExperimentStore(initial?: Experiment[]): ExperimentStore;
+/** Filesystem store — a single JSON array at `path`, created on first save. */
+declare function fileExperimentStore(path: string): ExperimentStore;
+interface ExperimentTrackerOptions {
+    store?: ExperimentStore;
+    provenanceReader?: ProvenanceReader;
+    thresholds?: ImprovementThresholds;
+    /** Clock seam for deterministic timestamps in tests. Default `Date.now`. */
+    now?: () => number;
+}
+interface CreateExperimentInput {
+    id: string;
+    label: string;
+    changeSummary: string;
+    parentId?: string;
+    /** Override provenance instead of reading from git (e.g. CI metadata). */
+    provenance?: ExperimentProvenance;
+}
+/**
+ * Stateful tracker over an `ExperimentStore`. Create an experiment (provenance
+ * is captured once), append reps as they complete (stats + verdict recompute on
+ * every append), and read the log back for a dashboard. All persistence and git
+ * access flow through the injected seams, so the tracker is fully testable
+ * without a repo or disk.
+ */
+declare class ExperimentTracker {
+    private readonly store;
+    private readonly provenanceReader;
+    private readonly thresholds;
+    private readonly now;
+    constructor(options?: ExperimentTrackerOptions);
+    create(input: CreateExperimentInput): Promise<Experiment>;
+    /** Append a rep (its `rep` index defaults to the current rep count) and
+     *  recompute stats + verdict. Returns the updated experiment. */
+    addRep(experimentId: string, rep: Omit<ExperimentRep, 'rep' | 'timestamp'> & {
+        rep?: number;
+        timestamp?: string;
+    }): Promise<Experiment>;
+    get(experimentId: string): Promise<Experiment | undefined>;
+    list(): Promise<Experiment[]>;
+    /** Full verdict (not just the enum) for an experiment vs its parent. */
+    verdictFor(experimentId: string): Promise<ImprovementVerdictResult>;
+}
+
 /**
  * muffled-gate-scanner — test helper that greps consumer source for
  * gate + measurement anti-patterns and fails with file:line locations.
@@ -1508,6 +2037,76 @@ interface OracleReport {
 /** Run all oracles against one observation and aggregate. */
 declare function evaluateOracles(obs: OracleObservation, oracles: Oracle[]): OracleReport;
 
+/**
+ * Deterministic held-out partitioning over stable ids.
+ *
+ * A promotion gate's paired-delta math needs a fixed partition: the same
+ * scenario id lands in the same bucket forever, regardless of when it ran or
+ * which loop emitted the record — otherwise the gate has nothing paired to
+ * compare against. Picking one global split per run is wrong: every run then
+ * stamps either ALL search or ALL holdout, and no id is ever observed on both
+ * sides. Per-id deterministic hashing fixes that.
+ *
+ * Two consumers hand-roll this (agent-builder's `deterministicSplit` and the
+ * frontier persona-splitter). The substrate already has a 3-way benchmark
+ * `deterministicSplit` in `./benchmarks`; this is the generic, validated batch
+ * partitioner: it takes a list of ids, splits them by a stable FNV-1a hash, and
+ * fails loud when the inputs can't support a trustworthy held-out comparison
+ * (duplicate ids, or a holdout set below the significance floor).
+ */
+/** 32-bit FNV-1a hash. Stable, allocation-free, deterministic across runtimes —
+ *  the same id+seed maps to the same bucket on every machine and process. */
+declare function fnv1a32(input: string): number;
+/** Map an id+seed to the half-open unit interval [0, 1) deterministically. */
+declare function hashToUnit(id: string, seed: string): number;
+interface PartitionHeldOutOptions {
+    /** Partition seed. Bumping it reshuffles every assignment — do that only when
+     *  the corpus/policy changes meaningfully so old and new records can't pair.
+     *  Default 'held-out-v1'. */
+    seed?: string;
+    /** Fraction routed to the held-out bucket, in (0, 1). Default 0.5. */
+    holdoutFraction?: number;
+    /**
+     * Minimum held-out ids required for the split to be admissible. Below this,
+     * a paired comparison has too few observations to be significant, so the
+     * partition throws rather than hand back an underpowered holdout. Default 1
+     * (only the empty-holdout degenerate case is rejected). Raise it to enforce
+     * real statistical power. */
+    minHoldout?: number;
+    /** Same floor for the search side. Default 1. */
+    minSearch?: number;
+}
+interface HeldOutPartition {
+    /** Ids the optimizer is allowed to read/optimize against. */
+    search: string[];
+    /** Ids reserved for gated, held-out evaluation. */
+    holdout: string[];
+    seed: string;
+    holdoutFraction: number;
+}
+/**
+ * Assign a single id to `'search'` or `'holdout'` deterministically. Same
+ * `(id, seed)` always returns the same tag — the invariant the gate relies on.
+ * Use this in a `splitTag:` field literal when stamping records one at a time;
+ * use `partitionHeldOut` when you have the whole id list up front and want the
+ * validated disjoint split.
+ */
+declare function assignHeldOutTag(id: string, options?: {
+    seed?: string;
+    holdoutFraction?: number;
+}): 'search' | 'holdout';
+/**
+ * Partition a list of stable ids into disjoint `search` / `holdout` sets by a
+ * deterministic hash. Fail-loud:
+ *   - empty input throws,
+ *   - duplicate ids throw (a dup would be observed on both sides, double-counting),
+ *   - a holdout (or search) set below its floor throws (underpowered comparison).
+ *
+ * Order within each bucket follows the input order, so the result is stable and
+ * reproducible.
+ */
+declare function partitionHeldOut(ids: string[], options?: PartitionHeldOutOptions): HeldOutPartition;
+
 /**
  * @stable
  *
@@ -1640,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.
  *
@@ -1871,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.
  *
@@ -1909,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 {
@@ -2349,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
@@ -2484,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.
  *
@@ -4035,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
@@ -4801,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 CandidateScenario, type CausalAttributionReport, type CellVerdict, ChatRequest, CheckResult, CollectedArtifacts, type CommandRunner, type CompareLabels, CompletionCriterion, type ContinuityCheck, type ContinuityCheckResult, type ContinuityReport, type ContinuitySnapshotPair, type ContractMetric, type ContractReport, ConvergenceTracker, type CostEntry, type CostSummary, CostTracker, type CounterfactualContext, type CounterfactualMutation, type CounterfactualResult, type CounterfactualRunner, CreateChatClientOpts, type CreateDefaultReviewerOptions, 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, type EvolutionRound, type ExecutorConfig, type Expectation, 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, HoldoutAuditor, type HttpGithubClientOptions, type HypothesisManifest, type HypothesisResult, INTENT_MATCH_JUDGE_VERSION, type ImageData, 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, 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 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, RunScore, RunScoreWeights, 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, attributeCounterfactuals, bisect, buildAgreementJudge, buildDriverSystemPrompt, buildReflectionPrompt, buildReviewerPrompt, canaryLeakView, canonicalize, causalAttribution, checkBehavioralCanary, checkCanaries, checkSlos, codeExecutionJudge, coherenceJudge, collectionPreserved, commentsForSource, commitBisect, compareReferenceReplay, compilerJudge, 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, findAutoMatchNoExpectation, findConstructorCwdDropped, findFallbackToPass, findLiteralTruePass, findSkipCountsAsPass, flowLayer, formatBenchmarkReport, formatDriverReport, formatFindings, formatScorecardDiff, ghCliClient, precision as goldenPrecision, hashContent, hashJson, htmlContainsElement, httpGithubClient, inMemoryReferenceReplayStore, isModelPriced, isOtelConfigured, jsonShape, jsonlReferenceReplayStore, judgeFamily, keyPreserved, linterJudge, loadGoldScenarios, loadScorecard, loadScorerFromGrader, localCommandRunner, lowercaseMutator, matchGoldens, mergeLayerResults, modelDescriptionBits, multiToolchainLayer, notBlocked, paraphraseRobustness, paraphraseRobustnessScenarios, parseGoldJsonl, parseReflectionResponse, 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, 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 };