@tangle-network/agent-eval 0.27.0 → 0.28.0

package/dist/index.d.ts

@@ -1,168 +1,234 @@
-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-CBShYYA6.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-rJhEDdpy.js';
+import { AxAIService, AxFunction } from '@ax-llm/ax';
+import { S as Severity, M as MultiLayerVerifier, a as VerifyOptions, L as Layer, b as LayerResult, c as VerifyContext } from './multi-layer-verifier-BNi4-8lR.js';
+export { F as Finding, d as LayerStatus, V as VerificationReport, g as gradeSemanticStatus } from './multi-layer-verifier-BNi4-8lR.js';
+import { R as Run$1, S as Span, b as TraceEvent, A as Artifact$1, B as BudgetLedgerEntry, T as TraceStore, g as BudgetSpec, l as RunFilter, L as LlmSpan } from './store-BP5be6s7.js';
+export { h as EventFilter, E as EventKind, i as FAILURE_CLASSES, F as FailureClass, j as FileSystemTraceStore, k as FileSystemTraceStoreOptions, G as GenericSpan, I as InMemoryTraceStore, J as JudgeSpan, M as Message, e as RetrievalSpan, m as RunLayer, n as RunStatus, f as SandboxSpan, o as SpanBase, p as SpanFilter, d as SpanKind, q as SpanStatus, r as TRACE_SCHEMA_VERSION, a as ToolSpan, s as isJudgeSpan, t as isLlmSpan, u as isRetrievalSpan, v as isSandboxSpan, w as isToolSpan } from './store-BP5be6s7.js';
+import { L as LlmClientOptions, m as LlmCallRequest, n as LlmCallResult } from './researcher-ClDX3KZx.js';
+export { C as CallbackResearcher, a as CallbackResearcherOptions, b as CampaignFactoryParams, c as CampaignIntegrityPolicy, d as CampaignRunContext, e as CampaignRunOutcome, f as CampaignRunner, g as CampaignScenario, h as CampaignVariant, E as EvalCampaignOptions, i as EvalCampaignResult, j as ExperimentPlan, k as ExperimentResult, F as FailedRun, l as FailureMode, o as LlmCallError, p as LlmClient, q as LlmMessage, s as LlmRouteAssertionError, t as LlmRouteRequirements, u as LlmUsage, N as NoopResearcher, R as Researcher, S as SteeringChange, v as assertLlmRoute, w as callLlm, x as callLlmJson, y as probeLlm, r as runEvalCampaign, z as stripFencedJson } from './researcher-ClDX3KZx.js';
+import { T as TraceAnalysisStore, A as AnalyzeTracesOptions } from './replay-BX5Fm8en.js';
+export { g as DEFAULT_REDACTION_RULES, O as OTEL_AGENT_EVAL_SCOPE, i as OtlpExport, j as OtlpResourceSpans, k as OtlpSpan, R as REDACTION_VERSION, l as RedactionReport, m as RedactionRule, n as ReplayCache, o as ReplayCacheEntry, p as ReplayCacheMissError, q as ReplayCacheStats, r as ReplayFetchOptions, C as createReplayFetch, E as exportRunAsOtlp, F as iterateRawCalls, G as redactString, H as redactValue } from './replay-BX5Fm8en.js';
 import { TCloud } from '@tangle-network/tcloud';
-import { C as ControlEvalResult } from './control-runtime-BuJHoLg0.js';
-export { c as ControlActionFailureMode, d as ControlActionOutcome, e as ControlBudget, f as ControlContext, g as ControlDecision, 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-BuJHoLg0.js';
+import { R as RunRecord, a as RunSplitTag } from './run-record-CqzahIbx.js';
+export { c as RunJudgeMetadata, d as RunOutcome, e as RunRecordValidationError, b as RunTokenUsage, i as isRunRecord, p as parseRunRecordSafe, r as roundTripRunRecord, v as validateRunRecord } from './run-record-CqzahIbx.js';
+import { z } from 'zod';
+import { C as ControlEvalResult } from './control-runtime-BRdQ0wrx.js';
+export { c as ControlActionFailureMode, d as ControlActionOutcome, e as ControlBudget, f as ControlContext, g as ControlDecision, 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-BRdQ0wrx.js';
 import { A as AgentEvalError } from './errors-BZ9sTdz7.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-BZ9sTdz7.js';
-import { b as FeedbackLabel, n as FeedbackTrajectoryStore, l as FeedbackTrajectory } from './feedback-trajectory-DfFdrraJ.js';
-export { F as FeedbackArtifactType, a as FeedbackAttempt, c as FeedbackLabelKind, d as FeedbackLabelSource, e as FeedbackOptimizerRow, f as FeedbackOutcome, g as FeedbackReplayAdapter, h as FeedbackReplayResult, i as FeedbackSeverity, j as FeedbackSplitPolicy, k as FeedbackTask, m 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-DfFdrraJ.js';
-import { A as ActionableSideInfo, h as MultiShotRunner, j as MultiShotScorer, c as MultiShotMutateAdapter, a4 as HeldOutGateConfig, E as EvolvableVariant, m as MultiShotTrialResult, e as MultiShotOptimizationResult, a3 as GateDecision, a5 as Objective, a6 as ParetoResult, V as VariantAggregate, t as TrialResult, o as MutateAdapter, T as TrialCache } from './summary-report-DZVXOCK_.js';
-export { a as AsiSeverity, D as DEFAULT_MUTATION_PRIMITIVES, a7 as Direction, C as GainDistributionBin, F as GainDistributionFigureSpec, H as GainDistributionOptions, a8 as GateEvidence, G as GenerationReport, a9 as HeldOutGate, aa as HeldOutGateRejectionCode, I as InMemoryTrialCache, M as MultiShotGateConfig, b as MultiShotGateResult, d as MultiShotOptimizationConfig, f as MultiShotRun, g as MultiShotRunInput, i as MultiShotScore, k as MultiShotSplit, l as MultiShotTrace, n as MultiShotVariant, J as ParetoFigureSpec, K as ParetoPoint, P as PromptEvolutionConfig, p as PromptEvolutionEvent, q as PromptEvolutionResult, L as RESEARCH_REPORT_HARD_PAIR_FLOOR, R as ReflectionContext, r as ReflectionProposal, N as ResearchReport, O as ResearchReportCandidate, Q as ResearchReportDecision, U as ResearchReportMethodology, W as ResearchReportOptions, X as ResearchReportRecommendation, S as ScenarioAggregate, s as ScoreAdapter, Y as SummaryTable, Z as SummaryTableOptions, _ as SummaryTableRow, u as TrialTrace, v as buildReflectionPrompt, ab as crowdingDistance, w as defaultMultiShotObjectives, ac as dominates, $ as gainHistogram, a0 as paretoChart, ad as paretoFrontier, ae as paretoFrontierWithCrowding, x as parseReflectionResponse, a1 as researchReport, y as runMultiShotOptimization, z as runPromptEvolution, af as scalarScore, a2 as summaryTable, B as trialTraceFromMultiShotTrial } from './summary-report-DZVXOCK_.js';
+import { b as FeedbackLabel, n as FeedbackTrajectoryStore, l as FeedbackTrajectory } from './feedback-trajectory-j0nJFgC6.js';
+export { F as FeedbackArtifactType, a as FeedbackAttempt, c as FeedbackLabelKind, d as FeedbackLabelSource, e as FeedbackOptimizerRow, f as FeedbackOutcome, g as FeedbackReplayAdapter, h as FeedbackReplayResult, i as FeedbackSeverity, j as FeedbackSplitPolicy, k as FeedbackTask, m 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-j0nJFgC6.js';
+import { A as ActionableSideInfo, h as MultiShotRunner, j as MultiShotScorer, c as MultiShotMutateAdapter, a4 as HeldOutGateConfig, E as EvolvableVariant, m as MultiShotTrialResult, e as MultiShotOptimizationResult, a3 as GateDecision, a5 as Objective, a6 as ParetoResult, V as VariantAggregate, t as TrialResult, o as MutateAdapter, T as TrialCache } from './summary-report-jrSGb2xZ.js';
+export { a as AsiSeverity, D as DEFAULT_MUTATION_PRIMITIVES, a7 as Direction, C as GainDistributionBin, F as GainDistributionFigureSpec, H as GainDistributionOptions, a8 as GateEvidence, G as GenerationReport, a9 as HeldOutGate, aa as HeldOutGateRejectionCode, I as InMemoryTrialCache, M as MultiShotGateConfig, b as MultiShotGateResult, d as MultiShotOptimizationConfig, f as MultiShotRun, g as MultiShotRunInput, i as MultiShotScore, k as MultiShotSplit, l as MultiShotTrace, n as MultiShotVariant, J as ParetoFigureSpec, K as ParetoPoint, P as PromptEvolutionConfig, p as PromptEvolutionEvent, q as PromptEvolutionResult, L as RESEARCH_REPORT_HARD_PAIR_FLOOR, R as ReflectionContext, r as ReflectionProposal, N as ResearchReport, O as ResearchReportCandidate, Q as ResearchReportDecision, U as ResearchReportMethodology, W as ResearchReportOptions, X as ResearchReportRecommendation, S as ScenarioAggregate, s as ScoreAdapter, Y as SummaryTable, Z as SummaryTableOptions, _ as SummaryTableRow, u as TrialTrace, v as buildReflectionPrompt, ab as crowdingDistance, w as defaultMultiShotObjectives, ac as dominates, $ as gainHistogram, a0 as paretoChart, ad as paretoFrontier, ae as paretoFrontierWithCrowding, x as parseReflectionResponse, a1 as researchReport, y as runMultiShotOptimization, z as runPromptEvolution, af as scalarScore, a2 as summaryTable, B as trialTraceFromMultiShotTrial } from './summary-report-jrSGb2xZ.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 { i as ReleaseConfidenceThresholds, g as ReleaseConfidenceScorecard } from './release-report-wfUySN5F.js';
-export { B as BootstrapOptions, a as BootstrapResult, J as JudgeReplayGateArgs, P as PairedBootstrapOptions, b as PairedBootstrapResult, R as ReleaseConfidenceAxis, c as ReleaseConfidenceAxisName, d as ReleaseConfidenceInput, e as ReleaseConfidenceIssue, f as ReleaseConfidenceMetrics, h as ReleaseConfidenceStatus, j as ReleaseTraceEvidence, k as RenderReleaseReportOptions, V as Verdict, l as assertReleaseConfidence, m as bhAdjust, n as bootstrapCi, o as evaluateReleaseConfidence, p as judgeReplayGate, q as pairedBootstrap, r as pairedWilcoxon, s as releaseTraceEvidenceFromMultiShotTrials, t as renderReleaseReport } from './release-report-wfUySN5F.js';
-import { a as FailureCluster } from './failure-cluster-C2EGSDiT.js';
-export { D as DEFAULT_FAILURE_RULES, b as FailureClassification, c as FailureContext, d as FailureRule, e as classifyFailure } from './failure-cluster-C2EGSDiT.js';
-import { a as RunSplitTag, R as RunRecord } from './run-record-CqzahIbx.js';
-export { c as RunJudgeMetadata, d as RunOutcome, e as RunRecordValidationError, b as RunTokenUsage, i as isRunRecord, p as parseRunRecordSafe, r as roundTripRunRecord, v as validateRunRecord } from './run-record-CqzahIbx.js';
-import { T as TraceStore, R as Run$1, S as Span, b as TraceEvent, A as Artifact$1, B as BudgetLedgerEntry, g as BudgetSpec, h as RunFilter, L as LlmSpan } from './store-Db2Bv8Cf.js';
-export { i as EventFilter, E as EventKind, j as FAILURE_CLASSES, F as FailureClass, k as FileSystemTraceStore, l as FileSystemTraceStoreOptions, G as GenericSpan, I as InMemoryTraceStore, J as JudgeSpan, M as Message, e as RetrievalSpan, m as RunLayer, n as RunStatus, f as SandboxSpan, o as SpanBase, p as SpanFilter, d as SpanKind, q as SpanStatus, r as TRACE_SCHEMA_VERSION, a as ToolSpan, s as isJudgeSpan, t as isLlmSpan, u as isRetrievalSpan, v as isSandboxSpan, w as isToolSpan } from './store-Db2Bv8Cf.js';
-import { S as SandboxDriver, H as HarnessConfig, a as SandboxHarnessResult } from './test-graded-scenario-B2kWEdh9.js';
-export { D as DockerSandboxDriver, c as SandboxHarness, d as SandboxResult, e as SubprocessSandboxDriver, f as SubprocessSandboxDriverOptions, g as TestGradedRunOptions, b as TestGradedRunResult, T as TestGradedScenario, h as TestOutputParser, i as composeParsers, j as jestTestParser, p as pytestTestParser, r as runTestGradedScenario, v as vitestTestParser } from './test-graded-scenario-B2kWEdh9.js';
-import { T as TraceEmitter } from './emitter-DP_cSSiw.js';
-export { R as RunCompleteHook, a as RunCompleteHookContext, S as SpanHandle, b as TraceEmitterOptions, l as llmSpanFromProvider } from './emitter-DP_cSSiw.js';
-export { F as FileSystemRawProviderSink, d as FileSystemRawProviderSinkOptions, I as InMemoryRawProviderSink, e as InMemoryRawProviderSinkOptions, N as NoopRawProviderSink, P as ProviderRedactor, f as RawProviderDirection, c as RawProviderEvent, R as RawProviderSink, g as RawProviderSinkFilter, h as RunIntegrityError, a as RunIntegrityExpectations, i as RunIntegrityIssue, j as RunIntegrityIssueCode, b as RunIntegrityReport, k as assertRunCaptured, l as defaultProviderRedactor, p as providerFromBaseUrl, t as throwIfRunIncomplete } from './integrity-DK2EBVZC.js';
-export { D as DEFAULT_REDACTION_RULES, O as OTEL_AGENT_EVAL_SCOPE, a as OtlpExport, b as OtlpResourceSpans, c as OtlpSpan, R as REDACTION_VERSION, d as RedactionReport, e as RedactionRule, f as ReplayCache, g as ReplayCacheEntry, h as ReplayCacheMissError, i as ReplayCacheStats, j as ReplayFetchOptions, k as createReplayFetch, l as exportRunAsOtlp, m as iterateRawCalls, r as redactString, n as redactValue } from './replay-BL96gCEP.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-DODUYdPg.js';
-import { a as BaselineReport } from './baseline-4R5deP0N.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-4R5deP0N.js';
-import { T as Trajectory, a as TrajectoryStep } from './trajectory-CnoBo-JY.js';
-export { b as buildTrajectory } from './trajectory-CnoBo-JY.js';
+import { i as ReleaseConfidenceThresholds, g as ReleaseConfidenceScorecard } from './release-report-PWhGlpfO.js';
+export { B as BootstrapOptions, a as BootstrapResult, J as JudgeReplayGateArgs, P as PairedBootstrapOptions, b as PairedBootstrapResult, R as ReleaseConfidenceAxis, c as ReleaseConfidenceAxisName, d as ReleaseConfidenceInput, e as ReleaseConfidenceIssue, f as ReleaseConfidenceMetrics, h as ReleaseConfidenceStatus, j as ReleaseTraceEvidence, k as RenderReleaseReportOptions, V as Verdict, l as assertReleaseConfidence, m as bhAdjust, n as bootstrapCi, o as evaluateReleaseConfidence, p as judgeReplayGate, q as pairedBootstrap, r as pairedWilcoxon, s as releaseTraceEvidenceFromMultiShotTrials, t as renderReleaseReport } from './release-report-PWhGlpfO.js';
+import { a as FailureCluster } from './failure-cluster-D1NZKqYu.js';
+export { D as DEFAULT_FAILURE_RULES, b as FailureClassification, c as FailureContext, d as FailureRule, e as classifyFailure } from './failure-cluster-D1NZKqYu.js';
+import { C as ContinuousAgreementOptions, a as ContinuousAgreement } from './index-Cgt3DKXr.js';
+export { b as CalibrationResult, c as CandidateScore, d as ContinuousCalibrationResult, D as DEFAULT_RED_TEAM_CORPUS, E as EuRiskClass, G as GoldenItem, e as GovernanceContext, f as GovernanceFinding, g as GovernanceReport, P as PositionalBiasResult, R as RedTeamCase, h as RedTeamCategory, i as RedTeamFinding, j as RedTeamPayload, k as RedTeamReport, S as SelfPreferenceResult, U as UseCaseSignals, V as VerbosityBiasResult, l as calibrateJudge, m as calibrateJudgeContinuous, n as classifyEuAiRisk, o as continuousAgreement, p as euAiActReport, q as nistAiRmfReport, r as positionalBias, s as redTeamDataset, t as redTeamReport, u as renderMarkdown, v as scoreRedTeamOutput, w as selfPreference, x as soc2Report, y as summarize, z as toolNamesForRun, A as verbosityBias } from './index-Cgt3DKXr.js';
+import { S as SandboxDriver, H as HarnessConfig, a as SandboxHarnessResult } from './test-graded-scenario-BJ54PDan.js';
+export { D as DockerSandboxDriver, c as SandboxHarness, d as SandboxResult, e as SubprocessSandboxDriver, f as SubprocessSandboxDriverOptions, g as TestGradedRunOptions, b as TestGradedRunResult, T as TestGradedScenario, h as TestOutputParser, i as composeParsers, j as jestTestParser, p as pytestTestParser, r as runTestGradedScenario, v as vitestTestParser } from './test-graded-scenario-BJ54PDan.js';
+import { T as TraceEmitter } from './emitter-BqjeOvJh.js';
+export { R as RunCompleteHook, a as RunCompleteHookContext, S as SpanHandle, b as TraceEmitterOptions, l as llmSpanFromProvider } from './emitter-BqjeOvJh.js';
+export { F as FileSystemRawProviderSink, c as FileSystemRawProviderSinkOptions, I as InMemoryRawProviderSink, d as InMemoryRawProviderSinkOptions, N as NoopRawProviderSink, P as ProviderRedactor, e as RawProviderDirection, f as RawProviderEvent, R as RawProviderSink, g as RawProviderSinkFilter, h as RunIntegrityError, a as RunIntegrityExpectations, i as RunIntegrityIssue, j as RunIntegrityIssueCode, b as RunIntegrityReport, k as assertRunCaptured, l as defaultProviderRedactor, p as providerFromBaseUrl, t as throwIfRunIncomplete } from './integrity-BAxLGJ9I.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-BFDT0kX_.js';
+import { a as BaselineReport } from './baseline-BwdCXUS8.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-BwdCXUS8.js';
+import { T as Trajectory, a as TrajectoryStep } from './trajectory-BFmveYZt.js';
+export { b as buildTrajectory } from './trajectory-BFmveYZt.js';
 import { a as DatasetScenario, c as Dataset } from './dataset-CiK_3LDr.js';
 export { d as DatasetDifficulty, b as DatasetManifest, e as DatasetProvenance, D as DatasetSplit, H as HoldoutLockedError, S as SliceOptions, h as hashScenarios } from './dataset-CiK_3LDr.js';
-export { C as CalibrationResult, a as CandidateScore, b as ContinuousAgreement, c as ContinuousAgreementOptions, d as ContinuousCalibrationResult, D as DEFAULT_RED_TEAM_CORPUS, E as EuRiskClass, G as GoldenItem, e as GovernanceContext, f as GovernanceFinding, g as GovernanceReport, P as PositionalBiasResult, R as RedTeamCase, h as RedTeamCategory, i as RedTeamFinding, j as RedTeamPayload, k as RedTeamReport, S as SelfPreferenceResult, U as UseCaseSignals, V as VerbosityBiasResult, l as calibrateJudge, m as calibrateJudgeContinuous, n as classifyEuAiRisk, o as continuousAgreement, p as euAiActReport, q as nistAiRmfReport, r as positionalBias, s as redTeamDataset, t as redTeamReport, u as renderMarkdown, v as scoreRedTeamOutput, w as selfPreference, x as soc2Report, y as summarize, z as toolNamesForRun, A as verbosityBias } from './index-D3iBCjdF.js';
-import { a as PrmGrader } from './rubric-D5tjHNJQ.js';
-import { L as Layer, S as Severity, a as LayerResult, b as VerifyContext } from './multi-layer-verifier-LkP3LVKj.js';
-export { F as Finding, c as LayerStatus, M as MultiLayerVerifier, V as VerificationReport, d as VerifyOptions, g as gradeSemanticStatus } from './multi-layer-verifier-LkP3LVKj.js';
-import { L as LlmClientOptions } from './researcher-bGkI7vCl.js';
-export { C as CallbackResearcher, a as CallbackResearcherOptions, b as CampaignFactoryParams, c as CampaignIntegrityPolicy, d as CampaignRunContext, e as CampaignRunOutcome, f as CampaignRunner, g as CampaignScenario, h as CampaignVariant, E as EvalCampaignOptions, i as EvalCampaignResult, j as ExperimentPlan, k as ExperimentResult, F as FailedRun, l as FailureMode, m as LlmCallError, n as LlmCallRequest, o as LlmCallResult, p as LlmClient, q as LlmMessage, s as LlmRouteAssertionError, t as LlmRouteRequirements, u as LlmUsage, N as NoopResearcher, R as Researcher, S as SteeringChange, v as assertLlmRoute, w as callLlm, x as callLlmJson, y as probeLlm, r as runEvalCampaign, z as stripFencedJson } from './researcher-bGkI7vCl.js';
+import { a as PrmGrader } from './rubric-DgSqjqqj.js';
 export { B as BENCHMARK_SPLIT_SEED, a as BenchmarkAdapter, b as BenchmarkDatasetItem, c as BenchmarkEvaluation, d as benchmarkDeterministicSplit, i as benchmarks } from './index--fVrWDiR.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-Dgz1n51-.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 './outcome-store-D6KWmYvj.js';
 
+interface RunScore {
+    success: number;
+    goalProgress: number;
+    repoGroundedness: number;
+    driftPenalty: number;
+    toolUseQuality: number;
+    patchQuality: number;
+    testReality: number;
+    finalGate: number;
+    reviewerBlockers: number;
+    costUsd: number;
+    wallSeconds: number;
+    notes?: string[];
+}
+interface RunScoreWeights {
+    success: number;
+    goalProgress: number;
+    repoGroundedness: number;
+    driftPenalty: number;
+    toolUseQuality: number;
+    patchQuality: number;
+    testReality: number;
+    finalGate: number;
+    reviewerBlockers: number;
+    costUsd: number;
+    wallSeconds: number;
+}
+declare const DEFAULT_RUN_SCORE_WEIGHTS: RunScoreWeights;
+declare function aggregateRunScore(score: RunScore, weights?: Partial<RunScoreWeights>): number;
+declare function clamp01(value: number): number;
+
+interface RunTrace {
+    run: Run$1;
+    spans: Span[];
+    events: TraceEvent[];
+    artifacts: Artifact$1[];
+    budget: BudgetLedgerEntry[];
+}
+interface RunCriticOptions {
+    weights?: Partial<RunScoreWeights>;
+    driftPatterns?: RegExp[];
+}
+declare class RunCritic {
+    private readonly weights?;
+    private readonly driftPatterns;
+    constructor(options?: RunCriticOptions);
+    score(store: TraceStore, runId: string): Promise<RunScore>;
+    scoreTrace(trace: RunTrace): RunScore;
+    rank(score: RunScore): number;
+    private isDrift;
+}
+
 /**
- * Automated pull request opener for the production loop.
+ * Semantic concept judge — "does the built artifact actually implement
+ * the features the user asked for?"
  *
- * `runProductionLoop` produces a `promotedPrompt` string and a release
- * scorecard. To close the eval → prod → eval cycle the framework needs
- * to land that prompt as a reviewable code change. This module does
- * exactly that:
+ * Distinct from the domain/code/coherence judges in `judges.ts`:
+ *   - those judges score free-form conversational agent outputs along
+ *     quality dimensions (accuracy, depth, etc.)
+ *   - this judge scores a *built artifact* (served HTML + source files)
+ *     against an explicit list of expected concepts, returning per-concept
+ *     {present, score 0-10, evidence, severity}.
  *
- *   1. Stage a branch off `baseBranch`.
- *   2. Write each `fileChange` into the worktree.
- *   3. Commit + push.
- *   4. Open a PR via the GitHub API.
+ * The judge is strict about distinguishing (a) a working implementation
+ * from (b) a keyword-present stub. "// TODO: mint button" is NOT present.
+ * Only real, functional, wired-up code counts.
  *
- * Two transports ship in core:
+ * Use via {@link createSemanticConceptJudge} or directly via
+ * {@link runSemanticConceptJudge}. Soft-fails (available=false) on LLM
+ * or JSON-parse errors so the caller can treat that as "layer skipped"
+ * rather than "layer failed" in a multi-layer pipeline.
+ */
+
+/**
+ * Implementation complexity class for weighted scoring.
  *
- *   - `ghCliClient(opts)` — shells out to the `gh` CLI. No extra deps,
- *     re-uses the developer machine's `gh auth` state, works with both
- *     github.com and GitHub Enterprise. This is the recommended default.
- *   - `httpGithubClient(opts)` — direct `fetch` against `api.github.com`
- *     with a bearer token. Useful in CI where `gh` may not be installed.
+ * - `render` (default): the concept is a UI surface that displays static
+ *   data — render a list, show a counter, lay out a button. Single-file
+ *   work, no external integration.
+ * - `integrate`: the concept requires wiring a real external system —
+ *   wallet connect (wagmi + RainbowKit + chain config), payment provider
+ *   (Stripe Elements + intent + webhook), an API client with auth.
+ *   Multi-file, library-knowledge, runtime correctness matters.
+ * - `compute`: the concept requires algorithmic work — solver, simulator,
+ *   constraint propagation, ML inference. Correctness > UI polish.
  *
- * Both implement the small `AutoPrClient` interface, so tests substitute
- * a fake without spinning a process or network.
+ * Default weights (when applied via `weightConcepts: 'complexity'`):
+ *   render=1.0, integrate=2.0, compute=2.5
  *
- * @experimental — added in 0.25.0. Surface may evolve as consumers wire
- * it into CI workflows.
+ * Cross-vertical scoring without complexity weighting silently inflates
+ * the rate of UI-heavy verticals (healthcare, fintech dashboards) vs
+ * integration-heavy verticals (DeFi, wallets) — all concepts treated
+ * equally even though the agent does 2-3x the work for `integrate`.
  */
-interface FileChange {
-    /** Repo-relative path. Forward slashes; no `..`. */
-    path: string;
-    /** New file contents. UTF-8. */
-    contents: string;
-    /** Optional explanatory comment shown in the commit body. */
-    rationale?: string;
-}
-interface RepoRef {
-    owner: string;
+type ConceptComplexity = 'render' | 'integrate' | 'compute';
+interface ConceptSpec {
     name: string;
+    /** Short hints that help the judge; not used for matching. */
+    keywords?: string[];
+    /** Optional explicit weight; default 1.0. Overrides complexity-derived weight. */
+    weight?: number;
+    /** Implementation complexity class. Default `render`. */
+    complexity?: ConceptComplexity;
 }
-interface ProposeAutomatedPullRequestInput {
-    repo: RepoRef;
-    /** Branch to base the PR on. Default `'main'`. */
-    baseBranch?: string;
-    /** New branch name. Use a prefix + a short stable id; no spaces. */
-    branchName: string;
-    fileChanges: FileChange[];
-    title: string;
-    body: string;
-    /** Optional GitHub usernames to request review from. */
-    reviewers?: string[];
-    /** Optional labels to apply. */
-    labels?: string[];
-    /** Commit author name. Default: derived from the GitHub client. */
-    authorName?: string;
-    /** Commit author email. Default: derived from the GitHub client. */
-    authorEmail?: string;
-    /** Dry-run — do not push or open a PR; just return the would-be plan. */
-    dryRun?: boolean;
+interface ConceptFinding {
+    concept: string;
+    present: boolean;
+    /** 0..10. 10 = production-ready; 7 = functional thin; 4 = partial; 0 = absent. */
+    score: number;
+    evidence: string;
+    severity: Severity;
 }
-interface ProposeAutomatedPullRequestResult {
-    prUrl: string;
-    branchName: string;
-    headSha: string;
-    dryRun: boolean;
+interface SemanticConceptJudgeInput {
+    /** Full natural-language prompt the agent was handed. */
+    userRequest: string;
+    /** Rendered HTML the preview returns (UI artifacts). Optional. */
+    servedHtml?: string;
+    /** Top-level source files from the agent's workdir. */
+    sourceFiles: Array<{
+        path: string;
+        content: string;
+    }>;
+    /** The expected concept list. */
+    expectedConcepts: ConceptSpec[];
+    /** Free-form metadata (id, difficulty) to inject into the prompt. */
+    artifactLabel?: string;
+    artifactDescription?: string;
 }
-/** Pluggable transport for the auto-PR pipeline. */
-interface AutoPrClient {
+interface SemanticConceptJudgeResult {
+    kind: 'semantic-concept';
+    version: string;
+    /** Normalized 0..1 score — mean of per-concept scores / 10. */
+    score: number;
+    presentCount: number;
+    totalCount: number;
+    findings: ConceptFinding[];
+    summary: string;
+    durationMs: number;
+    costUsd: number | null;
+    /** False on LLM/JSON error — treat as "skipped / unable to judge" in pipelines. */
+    available: boolean;
+    error?: string;
+}
+/**
+ * Score-aggregation strategy. `mean` averages 0-10 scores uniformly.
+ * `complexity` applies the default weight table (render=1, integrate=2,
+ * compute=2.5) unless a concept has an explicit `weight`. `explicit`
+ * honors only `weight` (defaulting to 1 for unspecified).
+ */
+type ConceptWeightStrategy = 'mean' | 'complexity' | 'explicit';
+declare const DEFAULT_COMPLEXITY_WEIGHTS: Record<ConceptComplexity, number>;
+interface SemanticConceptJudgeOptions {
+    /** Model id to call. Default 'claude-sonnet-4-6' via agent-eval defaults. */
+    model?: string;
+    /** Per-call timeout. Default 180s. */
+    timeoutMs?: number;
+    /** Pipeline budget for the prompt (source blob truncation). Default 45000. */
+    maxSourceChars?: number;
+    /** Per-file cap before inclusion. Default 20000. */
+    maxPerFileChars?: number;
+    /** HTML cap. Default 30000. */
+    maxHtmlChars?: number;
+    /** LlmClient config (baseUrl, apiKey, authHeader, …). */
+    llm?: LlmClientOptions;
     /**
-     * Create a branch from `baseBranch`, write file changes, commit, push,
-     * and open a PR. Returns the PR's HTML url and head SHA.
-     *
-     * Implementations must be idempotent on `branchName`: if the branch
-     * already exists with the same head SHA as the would-be commit, return
-     * the existing PR rather than failing. This makes the production loop
-     * safe to retry on transient errors.
+     * Score aggregation strategy. Default `mean` — uniform average across
+     * concepts. Cross-vertical comparisons should use `complexity` to
+     * neutralize the integrate-vs-render asymmetry.
      */
-    proposeChange(input: ProposeAutomatedPullRequestInput): Promise<ProposeAutomatedPullRequestResult>;
-}
-declare function proposeAutomatedPullRequest(client: AutoPrClient, input: ProposeAutomatedPullRequestInput): Promise<ProposeAutomatedPullRequestResult>;
-interface HttpGithubClientOptions {
-    /** Personal access token, GitHub App token, or `GITHUB_TOKEN` from Actions. */
-    token: string;
-    /** Override for GitHub Enterprise. Default `'https://api.github.com'`. */
-    apiBase?: string;
-    /** Test seam — defaults to global `fetch`. */
-    fetchImpl?: typeof fetch;
-    /** Test seam — clock for commit timestamps. */
-    now?: () => Date;
+    weightConcepts?: ConceptWeightStrategy;
+    /** Override the default complexity → weight table. */
+    complexityWeights?: Partial<Record<ConceptComplexity, number>>;
 }
+declare const SEMANTIC_CONCEPT_JUDGE_VERSION = "semantic-concept-judge-v1-2026-04-24";
 /**
- * Direct REST-API GitHub client. No external deps.
- *
- * Idempotency strategy: before creating refs/commits/PRs, check whether
- * the branch already exists at the desired tree. If so, return the
- * existing PR (or open one if missing). Errors from concurrent runs
- * (`Reference already exists`) are caught and treated as success.
+ * Run the semantic concept judge. Soft-fails to available=false on
+ * LLM/JSON errors — callers in a MultiLayerVerifier pipeline can treat
+ * that as "skip" rather than "fail."
  */
-declare function httpGithubClient(opts: HttpGithubClientOptions): AutoPrClient;
-interface GhCliClientOptions {
-    /** Override the CLI binary (`gh`). For testing. */
-    bin?: string;
-    /** Working directory containing a clone of `repo`. Default: process cwd. */
-    cwd?: string;
-    /** Test seam: process spawner. Default: node:child_process spawn. */
-    exec?: (bin: string, args: string[], opts: {
-        cwd: string;
-        stdin?: string;
-    }) => Promise<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-    }>;
-}
+declare function runSemanticConceptJudge(input: SemanticConceptJudgeInput, options?: SemanticConceptJudgeOptions): Promise<SemanticConceptJudgeResult>;
 /**
- * `gh` CLI transport. Requires:
- *   - `gh` installed and authenticated (`gh auth status`).
- *   - A local clone of the repo with a clean working tree.
- *   - `git` on PATH.
- *
- * Uses `gh api` for repo metadata and `gh pr create` for the PR. The
- * actual commit lands via `git`, which keeps `gh`'s footprint minimal.
+ * Factory: pin LLM options once, return a closure that accepts inputs.
+ * Convenient for pipelines that want to share a single LlmClient config.
  */
-declare function ghCliClient(opts?: GhCliClientOptions): AutoPrClient;
+declare function createSemanticConceptJudge(options?: SemanticConceptJudgeOptions): (input: SemanticConceptJudgeInput) => Promise<SemanticConceptJudgeResult>;
 
 interface Scenario {
     id: string;
@@ -410,13 +476,954 @@ interface CheckResult {
     expected: string;
     actual: string;
 }
-interface EvalResult {
-    scenario: string;
-    status: 'pass' | 'fail' | 'skip';
-    duration: number;
-    detail?: string;
-    artifact?: string;
+interface EvalResult {
+    scenario: string;
+    status: 'pass' | 'fail' | 'skip';
+    duration: number;
+    detail?: string;
+    artifact?: string;
+}
+
+/**
+ * ChatClient — the single LLM abstraction analysts call.
+ *
+ * agent-eval already ships an `LlmClient` (OpenAI-compatible, retry,
+ * graceful JSON-schema degrade) and judges that talk to `TCloud`. Two
+ * mixed patterns force every analyst author to pick a transport, which
+ * couples analyst code to runtime concerns (cli-bridge vs router vs
+ * sandbox-sdk) it shouldn't know about.
+ *
+ * `ChatClient` is one interface every analyst takes via `AnalystContext.chat`.
+ * The operator decides at the registry boundary which transport binds
+ * to it. Analyst code stays transport-agnostic; swapping production
+ * (sandbox-sdk) for local dev (cli-bridge) or tests (mock) is a one-
+ * line factory call.
+ *
+ * Designed to coexist: existing `LlmClient` callers and existing
+ * `TCloud`-based judges keep working untouched. New analyst code uses
+ * `ChatClient`. When old call sites migrate, they pick up budgeting,
+ * cancellation, and unified telemetry for free.
+ */
+
+/**
+ * Unified chat interface. Mirrors LlmCallRequest/Result so the OpenAI-
+ * compatible mental model stays. Two methods: a one-shot `chat()` and
+ * an `streamChat()` for future agentic loops (not yet exposed).
+ */
+interface ChatClient {
+    /** Display name of the bound transport — included in telemetry. */
+    readonly transport: ChatTransport;
+    /** Default model when caller omits — operators bind this per environment. */
+    readonly defaultModel?: string;
+    chat(req: ChatRequest, opts?: ChatCallOpts): Promise<ChatResponse>;
+}
+type ChatTransport = 'router' | 'sandbox-sdk' | 'cli-bridge' | 'direct-provider' | 'mock';
+interface ChatRequest extends Omit<LlmCallRequest, 'model'> {
+    /** Optional — falls back to ChatClient.defaultModel. */
+    model?: string;
+}
+type ChatResponse = LlmCallResult;
+interface ChatCallOpts {
+    /** Cancel the in-flight request. */
+    signal?: AbortSignal;
+    /** Hard USD ceiling for this single call (informational; the underlying transport may not enforce). */
+    maxCostUsd?: number;
+    /** Correlation tag carried into request headers when the transport allows. */
+    correlationId?: string;
+}
+type CreateChatClientOpts = RouterTransportOpts | CliBridgeTransportOpts | DirectProviderTransportOpts | SandboxSdkTransportOpts | MockTransportOpts;
+interface BaseTransportOpts {
+    defaultModel?: string;
+}
+interface RouterTransportOpts extends BaseTransportOpts {
+    transport: 'router';
+    baseUrl?: string;
+    apiKey: string;
+}
+interface CliBridgeTransportOpts extends BaseTransportOpts {
+    transport: 'cli-bridge';
+    baseUrl?: string;
+    bearer?: string;
+}
+interface DirectProviderTransportOpts extends BaseTransportOpts {
+    transport: 'direct-provider';
+    baseUrl: string;
+    apiKey: string;
+}
+/**
+ * Sandbox-SDK transport. Provided as a thin pass-through: the caller
+ * supplies a callable that mimics LlmClient.chat() against an already-
+ * configured Sandbox handle. We don't import the SDK here to keep
+ * agent-eval dep-free of @tangle-network/sandbox.
+ */
+interface SandboxSdkTransportOpts extends BaseTransportOpts {
+    transport: 'sandbox-sdk';
+    chat: (req: ChatRequest, opts?: ChatCallOpts) => Promise<ChatResponse>;
+}
+/**
+ * Mock transport for tests. The handler receives the request and returns
+ * whatever the test wants. No retries, no JSON-schema degrade.
+ */
+interface MockTransportOpts extends BaseTransportOpts {
+    transport: 'mock';
+    handler: (req: ChatRequest, opts?: ChatCallOpts) => Promise<ChatResponse>;
+}
+/**
+ * Build a ChatClient bound to a specific transport. The returned client
+ * is safe to share across analysts in a single registry run.
+ */
+declare function createChatClient(opts: CreateChatClientOpts): ChatClient;
+
+/**
+ * Analyst contract — the missing orchestration layer over agent-eval's
+ * existing analyzers (analyzeTraces, MultiLayerVerifier, RunCritic,
+ * SemanticConceptJudge, JudgeFn, ...).
+ *
+ * Each existing primitive returns its own output shape. The Analyst
+ * contract is the single envelope every primitive lifts into, so a
+ * registry can run N analysts against a run and a single renderer can
+ * compose findings without knowing which analyzer produced them.
+ *
+ * The contract is intentionally domain-agnostic: nothing here knows
+ * about code, voice, RAG, or any particular agent stack. Analysts
+ * declare what INPUT KIND they need (a trace store, an artifact dir,
+ * a RunRecord, a JudgeInput, or `custom`), and the registry routes
+ * the matching input from `AnalystRunInputs`.
+ */
+
+/**
+ * Unified envelope every analyst emits. Schema-versioned so renderers
+ * and time-series diffs survive future field additions.
+ */
+interface AnalystFinding {
+    schema_version: '1.0.0';
+    /**
+     * Stable hash over identity-defining fields (analyst_id + canonical
+     * claim + area + optional subject). Two findings from two runs that
+     * "are the same finding" share this id — that's what `diffFindings`
+     * uses to compute appeared/disappeared sets across runs.
+     */
+    finding_id: string;
+    analyst_id: string;
+    produced_at: string;
+    severity: AnalystSeverity;
+    /**
+     * Coarse classification. Renderers group by this. Free-form so
+     * domain-specific analysts can introduce categories without a
+     * schema change ('agent-reasoning', 'verification', 'cost',
+     * 'tool-use', 'safety', 'latency', 'data-quality', ...).
+     */
+    area: string;
+    claim: string;
+    rationale?: string;
+    evidence_refs: EvidenceRef[];
+    recommended_action?: string;
+    validation_plan?: string;
+    /** 0..1 — the analyst's own confidence. Not calibrated across analysts. */
+    confidence: number;
+    /**
+     * Optional subject the finding is about — leaf id, agent id, request
+     * id. Included in finding_id when present so per-subject findings
+     * diff cleanly across runs.
+     */
+    subject?: string;
+    /** Analyst-private extras; renderers ignore unless they know the analyst. */
+    metadata?: Record<string, unknown>;
+}
+type AnalystSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+interface EvidenceRef {
+    /**
+     * Where the evidence lives. `span` and `event` refer to OTLP trace
+     * elements; `artifact` to a file inside the run's artifact tree;
+     * `finding` to another AnalystFinding (cross-analyst chaining);
+     * `metric` to a named scalar reading the renderer knows how to read.
+     */
+    kind: 'span' | 'event' | 'artifact' | 'finding' | 'metric';
+    uri: string;
+    excerpt?: string;
+}
+/**
+ * The discriminator the registry uses to pass the right input.
+ * `custom` is the escape hatch — analysts that need something else
+ * (e.g. an embedding cache, a partner SDK handle) read it from
+ * `AnalystRunInputs.custom[<analyst id>]`.
+ */
+type AnalystInputKind = 'trace-store' | 'artifact-dir' | 'run-record' | 'judge-input' | 'custom';
+interface AnalystCost {
+    /** `deterministic` analysts MUST NOT call the LLM. */
+    kind: 'deterministic' | 'llm';
+    /** Optional declared upper bound; the registry can enforce a budget. */
+    est_usd_per_run?: number;
+    /** Models the analyst expects to use (informational). */
+    models?: string[];
+}
+interface AnalystRequirements {
+    /** Min number of shots / samples the analyst needs to produce signal. */
+    min_shots?: number;
+    /** Capabilities the runtime must supply (e.g. ['network', 'gpu']). */
+    capabilities?: string[];
+}
+/**
+ * What's passed to every analyst call. The registry resolves which
+ * field the analyst's `inputKind` selects and asserts it's present.
+ */
+interface AnalystRunInputs {
+    traceStore?: TraceAnalysisStore;
+    artifactDir?: string;
+    runRecord?: RunRecord;
+    judgeInput?: JudgeInput;
+    /** Keyed by analyst id; populated by callers that registered custom analysts. */
+    custom?: Record<string, unknown>;
+}
+interface AnalystContext {
+    runId: string;
+    /** Stable correlation id so logs from a single registry.run() share a tag. */
+    correlationId: string;
+    /** Wall-clock deadline (epoch ms). Analysts SHOULD honor for graceful cancel. */
+    deadlineMs?: number;
+    /** Per-analyst USD budget. Analysts MAY check before issuing LLM calls. */
+    budgetUsd?: number;
+    /**
+     * Shared chat client. Analysts that call an LLM go through this so
+     * the operator picks transport (sandbox-sdk | router | cli-bridge |
+     * direct-provider | mock) at the registry boundary without touching
+     * analyst code.
+     */
+    chat?: ChatClient;
+    /** Free-form runtime tags (env, host, op). Findings can echo these into metadata. */
+    tags?: Record<string, string>;
+    /** Logger callback — analysts SHOULD prefer this over console.* for testability. */
+    log?: (msg: string, fields?: Record<string, unknown>) => void;
+    /** Optional abort signal. Analysts SHOULD pass it through to LLM calls. */
+    signal?: AbortSignal;
+}
+/**
+ * The minimal contract. Concrete analysts can refine `TInput` so
+ * implementations stay type-safe (e.g. a trace analyst's `TInput` is
+ * `TraceAnalysisStore`); the registry passes the right field from
+ * `AnalystRunInputs` based on `inputKind`.
+ */
+interface Analyst<TInput = unknown> {
+    /** Stable identifier — appears in finding_id, telemetry, and registry exclusion lists. */
+    readonly id: string;
+    /** Human-readable. One sentence. */
+    readonly description: string;
+    readonly inputKind: AnalystInputKind;
+    readonly cost: AnalystCost;
+    readonly requires?: AnalystRequirements;
+    /** Bump on breaking changes to claim wording or area so old finding_ids don't collide. */
+    readonly version: string;
+    analyze(input: TInput, ctx: AnalystContext): Promise<AnalystFinding[]>;
+}
+/**
+ * Compute the stable finding_id from the identity-defining fields.
+ * Default implementation hashes {analyst_id, area, subject, normalized claim}.
+ * Analysts that emit findings whose claim text varies per run (timestamps,
+ * counts) SHOULD either: (a) pass an explicit `id_basis` to fix the hash,
+ * or (b) move the variable part into `rationale`/`metadata` and keep the
+ * `claim` static.
+ */
+declare function computeFindingId(input: {
+    analyst_id: string;
+    area: string;
+    subject?: string;
+    claim: string;
+    /** Override the claim for hashing — use when the displayed claim has run-specific bits. */
+    id_basis?: string;
+}): string;
+/**
+ * Convenience factory: produce a fully-formed AnalystFinding with the
+ * id computed automatically. Analyst code stays terse.
+ */
+declare function makeFinding(init: Omit<AnalystFinding, 'schema_version' | 'finding_id' | 'produced_at'> & {
+    id_basis?: string;
+    produced_at?: string;
+}): AnalystFinding;
+interface AnalystRunSummary {
+    analyst_id: string;
+    status: 'ok' | 'skipped' | 'failed';
+    /** Why skipped — missing input, budget exceeded, capability unmet. */
+    reason?: string;
+    findings_count: number;
+    latency_ms: number;
+    cost_usd: number;
+    /** When `status='failed'`: the error class + message, never the full stack. */
+    error?: {
+        class: string;
+        message: string;
+    };
+}
+interface AnalystRunResult {
+    run_id: string;
+    correlation_id: string;
+    started_at: string;
+    ended_at: string;
+    findings: AnalystFinding[];
+    per_analyst: AnalystRunSummary[];
+    /** Total LLM cost in USD across all analysts in this registry.run(). */
+    total_cost_usd: number;
+}
+
+/**
+ * Adapter factories — lift each existing agent-eval primitive into the
+ * Analyst contract without re-implementing it.
+ *
+ * Five primitives, five factories. Each one:
+ *   - Builds an Analyst with a stable id (caller chooses; defaults
+ *     given), a sensible default `inputKind`, a version derived from
+ *     the wrapped primitive's version + an adapter revision, and an
+ *     `analyze()` that calls the primitive and lifts its output to
+ *     AnalystFinding[] using `makeFinding()`.
+ *   - Maps severities: the existing `Severity` ('critical' | 'major' |
+ *     'minor' | 'info') projects onto AnalystSeverity ('critical' |
+ *     'high' | 'medium' | 'low' | 'info'); 'major' → 'high', 'minor' →
+ *     'medium'. Domain analysts that want finer-grained mapping override.
+ *
+ * Adapters never own state. Calling the same factory twice with the
+ * same primitive instance is safe.
+ */
+
+declare function liftSeverity(s: Severity): AnalystSeverity;
+interface TraceAnalystAdapterOpts {
+    id?: string;
+    area?: string;
+    /** The natural-language question(s) put to the analyst. One finding per question. */
+    questions: string[];
+    /** Caller-provided AxAI service — same one trace-analyst.ts expects. */
+    ai: AxAIService;
+    model?: string;
+    /** Forwarded to analyzeTraces. */
+    extra?: Omit<AnalyzeTracesOptions, 'source' | 'ai' | 'model'>;
+}
+/**
+ * @deprecated Prefer `createTraceAnalystKind` + one of the failure /
+ * improvement kinds from `./kinds`. This adapter wraps the legacy
+ * `analyzeTraces` flow whose output is `findings:string[]` — every
+ * bullet gets flat-defaulted severity `medium` / confidence `0.6`,
+ * which loses the per-finding grading kinds provide via Ax structured
+ * output + Zod validation. Kept for one minor while consumers migrate.
+ */
+declare function createTraceAnalystAdapter(opts: TraceAnalystAdapterOpts): Analyst<TraceAnalysisStore>;
+interface VerifierAdapterOpts<Env> {
+    id?: string;
+    area?: string;
+    verifier: MultiLayerVerifier<Env>;
+    /**
+     * The verifier expects an `env` per run. Adapters take it from
+     * `AnalystRunInputs.custom[<id>]` via the registry's 'custom' routing.
+     */
+    options?: Omit<VerifyOptions<Env>, 'env'>;
+}
+declare function createVerifierAdapter<Env>(opts: VerifierAdapterOpts<Env>): Analyst<Env>;
+interface RunCriticAdapterOpts {
+    id?: string;
+    area?: string;
+    critic?: RunCritic;
+    /** Optional threshold below which a dimension is reported as a finding. Default 0.5. */
+    threshold?: number;
+}
+declare function createRunCriticAdapter(opts?: RunCriticAdapterOpts): Analyst<RunTrace>;
+interface JudgeAdapterOpts {
+    id?: string;
+    area?: string;
+    judge: JudgeFn;
+    /** TCloud handle the JudgeFn calls. */
+    tcloud: TCloud;
+    /** Optional cost classification — most judges call an LLM. */
+    cost?: Analyst['cost'];
+    /** Optional threshold below which a JudgeScore becomes a finding. Default 6 (on 0-10 scale). */
+    threshold?: number;
+}
+declare function createJudgeAdapter(opts: JudgeAdapterOpts): Analyst<JudgeInput>;
+interface SemanticConceptJudgeAdapterOpts {
+    id?: string;
+    area?: string;
+    options?: SemanticConceptJudgeOptions;
+}
+declare function createSemanticConceptJudgeAdapter(opts?: SemanticConceptJudgeAdapterOpts): Analyst<SemanticConceptJudgeInput>;
+
+/**
+ * FindingsStore — durable persistence for AnalystFinding rows + a diff
+ * helper so we can answer "what changed since the last run?" without
+ * recomputing analysts.
+ *
+ * On-disk shape is JSONL: one finding per line, append-only, locked via
+ * LockedJsonlAppender. Operators get crash-safety (no partial JSON),
+ * cheap reads (sequential parse), and trivial backup (rsync the file).
+ *
+ * Reads are non-locking: a reader sees a consistent snapshot of all
+ * fully-written lines and skips an incomplete trailing line if the
+ * writer is mid-append. Cross-process locking is intentionally out of
+ * scope (see locked-jsonl-appender.ts).
+ *
+ * The store is run-scoped: callers pass `runId` on append and on load,
+ * which keeps multi-run files cleanly partitioned. The `diffFindings`
+ * helper compares two run-id sets using stable `finding_id` semantics —
+ * the diff is the cross-run signal the regression dashboard renders.
+ */
+
+/**
+ * One persisted row. We attach `run_id` on disk so a single file can
+ * hold multiple runs and the diff helper can query without re-walking
+ * separate files.
+ */
+interface PersistedFinding extends AnalystFinding {
+    run_id: string;
+}
+declare class FindingsStore {
+    readonly path: string;
+    private readonly appender;
+    constructor(path: string);
+    append(runId: string, findings: AnalystFinding[]): Promise<void>;
+    /** Load every persisted finding. Discards malformed trailing lines silently. */
+    loadAll(): PersistedFinding[];
+    /** Filter to a single run. */
+    loadRun(runId: string): PersistedFinding[];
+}
+interface FindingsDiff {
+    /** New finding ids in `current` that weren't in `previous`. */
+    appeared: PersistedFinding[];
+    /** Finding ids in `previous` that aren't in `current`. */
+    disappeared: PersistedFinding[];
+    /** Same finding id present in both runs and unchanged per the materiality test. */
+    persisted: PersistedFinding[];
+    /**
+     * Same finding id in both runs but at least one non-identity field
+     * shifted per `DiffPolicy.isMaterial`. Reported as [previous, current].
+     */
+    changed: Array<{
+        previous: PersistedFinding;
+        current: PersistedFinding;
+    }>;
+}
+interface DiffPolicy {
+    /**
+     * Predicate that decides whether two findings (same finding_id) count
+     * as a material change. Defaults to {@link defaultIsMaterial}: severity
+     * shift, confidence Δ > 0.05, or evidence count change. Compliance /
+     * perf consumers MAY supply a stricter predicate (e.g. rationale text
+     * diff, metric Δ thresholds).
+     */
+    isMaterial?: (previous: AnalystFinding, current: AnalystFinding) => boolean;
+}
+/**
+ * Default materiality test. Deliberately narrow so LLM-reword churn
+ * doesn't flood the diff. Stricter tests are opt-in via DiffPolicy.
+ */
+declare function defaultIsMaterial(a: AnalystFinding, b: AnalystFinding): boolean;
+/**
+ * Diff two findings sets by stable finding_id. Callers typically load
+ * the two run-id slices from the same store and pass them in.
+ */
+declare function diffFindings(previous: PersistedFinding[], current: PersistedFinding[], policy?: DiffPolicy): FindingsDiff;
+
+/**
+ * Typed Ax output for analyst findings.
+ *
+ * Replaces the legacy `findings:string[]` pattern (where every bullet
+ * became a flat-severity `AnalystFinding`) with a structured object
+ * array. Ax binds the field as `findings:json[]` so the provider emits
+ * native structured output; at the kind-factory boundary we Zod-validate
+ * each emitted finding so malformed rows fail loud instead of being
+ * silently lifted with default severity.
+ *
+ * Why not `f.object().array()` directly in the signature? The Ax
+ * signature string `question:string -> findings:json[]` already lets
+ * the provider emit JSON arrays. A Zod boundary is required either
+ * way (the provider can return any JSON), and Zod gives us a single
+ * validation surface independent of which Ax version is installed.
+ */
+
+declare const ANALYST_SEVERITIES: readonly ["critical", "high", "medium", "low", "info"];
+declare const RawAnalystFindingSchema: z.ZodObject<{
+    severity: z.ZodEnum<{
+        info: "info";
+        critical: "critical";
+        medium: "medium";
+        low: "low";
+        high: "high";
+    }>;
+    claim: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    evidence_uri: z.ZodString;
+    evidence_excerpt: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodNumber;
+    rationale: z.ZodOptional<z.ZodString>;
+    recommended_action: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type RawAnalystFinding = z.infer<typeof RawAnalystFindingSchema>;
+/**
+ * Description embedded into the actor prompt so the LLM knows what
+ * shape to emit. Kept here so kinds share one source of truth rather
+ * than restating the schema in every prompt.
+ */
+declare const RAW_FINDING_SCHEMA_PROMPT = "Each finding MUST be a JSON object with these fields:\n  - severity: one of \"critical\" | \"high\" | \"medium\" | \"low\" | \"info\"\n  - claim: one-sentence statement (max 2000 chars)\n  - subject?: the leaf id, agent id, span id, tool name, or noun phrase the finding is about\n  - evidence_uri: \"span://<trace_id>/<span_id>\" for trace evidence, \"artifact://<relative-path>\" for files, \"metric://<name>\" for named scalars \u2014 ALWAYS cite a real id surfaced by the tools\n  - evidence_excerpt?: short quote (<=2000 chars) from the cited span/artifact\n  - confidence: number 0..1 \u2014 0.9+ when backed by exact quotes, 0.6-0.8 for inferred patterns, <0.5 for speculative\n  - rationale?: one or two sentences explaining the reasoning\n  - recommended_action?: concrete change phrased as an imperative (\"Add ...\", \"Replace ...\", \"Stop ...\") \u2014 omit when the finding is purely descriptive\n\nEmit an empty array when the question has no findings to report. Do not fabricate evidence.";
+/**
+ * Validate one row emitted by the LLM. Returns the typed finding on
+ * success; returns `null` and logs the reason on failure so the kind
+ * factory can skip-and-count rather than abort the whole analyst run.
+ */
+declare function parseRawFinding(row: unknown, log?: (msg: string, fields?: Record<string, unknown>) => void): RawAnalystFinding | null;
+
+/**
+ * Analyst-kind factory — the typed, focused replacement for the
+ * legacy `createTraceAnalystAdapter`.
+ *
+ * A "kind" is a specialized analyst whose actor prompt, tool subset,
+ * and Ax recursion config target one failure-mode lens (failure-mode
+ * classification, knowledge gap discovery, knowledge poisoning, recursive
+ * self-improvement, ...). Kinds emit findings in the typed `RawAnalystFinding`
+ * shape via a JSON-array Ax output; the factory validates each row with
+ * Zod and lifts it into `AnalystFinding[]` with no shape guessing.
+ *
+ * Composition rules:
+ *   - Each kind owns its actor description. No generic "answer this
+ *     question" prompt — the prompt names the failure lens.
+ *   - Each kind picks a narrow tool subset from `ANALYST_TOOL_GROUPS`.
+ *     A kind that never needs full-trace dumps can drop `viewTrace` /
+ *     `viewSpans` and stay cheap.
+ *   - Each kind declares its recursion + parallelism budget. Discovery-
+ *     heavy kinds (failure-mode) get higher `maxDepth`; lens kinds
+ *     (poisoning) usually stay at 0 since they have a tighter brief.
+ *
+ * Optimizer hook: kinds may declare `goldens` — labeled examples used
+ * by `AxMiPRO` / `AxBootstrapFewShot` / `AxGEPA` to fit the actor
+ * description programmatically. Stored on the kind, not the registry,
+ * because the right metric is kind-specific.
+ */
+
+/**
+ * Per-kind specification. The factory turns this into a regular
+ * `Analyst<TraceAnalysisStore>` ready for `AnalystRegistry.register()`.
+ */
+interface TraceAnalystKindSpec {
+    /** Stable id. Appears in finding_id, telemetry, and registry exclusions. */
+    id: string;
+    /** One-sentence description shown in `registry.list()`. */
+    description: string;
+    /** Coarse classification stamped on every emitted finding (`failure-mode`, `knowledge-gap`, ...). */
+    area: string;
+    /** Bump on any breaking change to the actor prompt or output schema. */
+    version: string;
+    /** Actor system prompt. Must instruct the LLM to emit `findings` per the schema. */
+    actorDescription: string;
+    /** Responder system prompt; falls back to a minimal "format the findings" instruction. */
+    responderDescription?: string;
+    /** Tool functions the actor may call. Pick narrow subsets via `ANALYST_TOOL_GROUPS`. */
+    buildTools: (store: TraceAnalysisStore) => AxFunction[];
+    /** Recursion budget. `maxDepth: 0` disables subagents. */
+    recursion?: {
+        maxDepth: number;
+        maxParallelSubagents?: number;
+    };
+    /** Actor turn cap. Default 12. */
+    maxTurns?: number;
+    /** Runtime char cap. Default 6000. */
+    maxRuntimeChars?: number;
+    /** Cost classification surfaced in `registry.list()` and budget enforcement. */
+    cost: AnalystCost;
+    /** Per-finding-row hook — kinds may reject / rewrite before lifting. */
+    postProcess?: (row: RawAnalystFinding, ctx: AnalystContext) => RawAnalystFinding | null;
+    /** Optional optimizer hook — populated when a kind wants to fit its prompt against labeled examples. */
+    goldens?: TraceAnalystGolden[];
+}
+/**
+ * One labeled example consumed by Ax optimizers (MIPRO / GEPA / Bootstrap).
+ * Each input is the same `{question}` an analyst would receive; `expected`
+ * is the ground-truth finding set a fitted prompt should produce on this
+ * input. Metric: kind-specific (default: F1 on `finding_id` overlap).
+ */
+interface TraceAnalystGolden {
+    question: string;
+    expected: ReadonlyArray<Omit<RawAnalystFinding, 'confidence'>>;
+}
+interface CreateTraceAnalystKindOpts {
+    /** AxAIService bound at registration time. */
+    ai: AxAIService;
+    /** Optional model override; falls back to the AI service's default. */
+    model?: string;
+    /** Override the spec's `version` (e.g. when an optimizer has fitted a new prompt). */
+    versionSuffix?: string;
+}
+/**
+ * Build an `Analyst<TraceAnalysisStore>` from a kind spec.
+ *
+ * Lifts the Ax pipeline once at registration time so the registry
+ * gets a stateless analyst. The Ax agent is freshly constructed per
+ * `analyze()` call (the agent carries chat-log + usage state we don't
+ * want shared across analyst runs).
+ */
+declare function createTraceAnalystKind(spec: TraceAnalystKindSpec, opts: CreateTraceAnalystKindOpts): Analyst<TraceAnalysisStore>;
+
+/**
+ * Failure-mode analyst — classifies what went wrong and why.
+ *
+ * Brief: read the trace dataset, identify the top failure modes across
+ * runs, classify each with severity + evidence, and surface them as
+ * findings. The actor's job is *taxonomy + evidence*, not fix-design —
+ * that's the improvement-analyst's job.
+ *
+ * Recursion is deep (`maxDepth: 3`) because real failure-mode
+ * discovery is genuinely tree-shaped: the actor splits the dataset
+ * into candidate clusters, each cluster spawns a focused investigator
+ * that drills into representative traces, and a deeply-recursed
+ * investigator may itself split a confounded mode into two sub-modes.
+ * Each level fans out 4-way, so the analyst can investigate up to
+ * ~16 leaf clusters before hitting the depth ceiling.
+ */
+
+declare const FAILURE_MODE_KIND_SPEC: TraceAnalystKindSpec;
+
+/**
+ * Knowledge-gap analyst — what did the agent NOT know that it needed?
+ *
+ * Brief: find moments in the trace where the agent had to guess, ask
+ * the user to fill in context, recover from a wrong assumption, or
+ * loop on a retrieval. Each finding names a *missing or outdated piece
+ * of knowledge* the agent's curated knowledge base should have held —
+ * or a downstream lookup (web, docs, tool description) that surfaced
+ * stale or outdated information.
+ *
+ * The primary expected store is `@tangle-network/agent-knowledge`: a
+ * Karpathy-style wiki the agent maintains with raw ↔ curated pages,
+ * source anchors, and claim/relation triples. A gap is anything the
+ * agent had to discover at run-time that should already have lived
+ * there. Secondary loci: web-search results that returned outdated
+ * pages, tool descriptions that omitted critical behavior, system-
+ * prompt sections that didn't cover the case.
+ *
+ * Distinct from failure-mode: failure-mode classifies *how* it broke;
+ * knowledge-gap names the *information* whose absence (or staleness)
+ * caused the break. One failure-mode often maps to several gaps.
+ *
+ * Recursion (`maxDepth: 2`) is enough to fan out one subagent per
+ * candidate gap-source layer; each subagent runs a focused detection.
+ */
+
+declare const KNOWLEDGE_GAP_KIND_SPEC: TraceAnalystKindSpec;
+
+/**
+ * Knowledge-poisoning analyst — what FALSE information misled the agent?
+ *
+ * Brief: find moments where the agent acted on information that was
+ * *wrong* — stale memory, RAG documents that contradicted ground truth,
+ * tool descriptions that lied about return shapes, system-prompt
+ * instructions that no longer matched reality, prior-run summaries that
+ * cached a wrong decision.
+ *
+ * Distinct from knowledge-gap: a gap is "the agent didn't know X"; a
+ * poisoning is "the agent confidently used X, but X was wrong." Gaps
+ * surface as questions / self-correction; poisonings surface as
+ * confident-but-wrong actions that downstream evidence contradicts.
+ *
+ * Recursion is moderate (`maxDepth: 2`) because each candidate
+ * poisoning typically needs two sub-investigations: one to confirm
+ * the agent acted on the false belief, one to confirm the belief
+ * itself is actually false in ground truth.
+ */
+
+declare const KNOWLEDGE_POISONING_KIND_SPEC: TraceAnalystKindSpec;
+
+/**
+ * Improvement analyst — actionable, recursive self-improvement findings.
+ *
+ * Brief: read findings from upstream analysts (failure-mode,
+ * knowledge-gap, knowledge-poisoning) AND the trace dataset itself,
+ * then propose **concrete edits** to the agent's runtime: prompt
+ * additions, RAG documents to ingest, tool descriptions to rewrite,
+ * scaffolding changes to make, memory entries to invalidate. Each
+ * finding is one proposed edit with the locus, the diff, and the
+ * expected effect.
+ *
+ * This is the recursive-self-improvement loop's last mile: the prior
+ * kinds describe *what's wrong*; this kind describes *what to change*.
+ *
+ * Recursion is deep (`maxDepth: 3`) because real improvement proposals
+ * are competitive: for each failure-mode there are usually 2-3 viable
+ * fix directions (tighten prompt vs add tool vs adjust scaffolding),
+ * and the actor should explore each with a focused subagent before
+ * picking the highest-leverage one to recommend.
+ */
+
+declare const IMPROVEMENT_KIND_SPEC: TraceAnalystKindSpec;
+
+/**
+ * Default analyst kinds focused on agent failure + recursive
+ * self-improvement.
+ *
+ * The four kinds chain: failure-mode classifies; knowledge-gap and
+ * knowledge-poisoning explain *why* in two orthogonal ways; improvement
+ * proposes concrete edits. Register all four against the same trace
+ * store and the registry runs them in dependency order if the operator
+ * pipes findings between them.
+ */
+
+/**
+ * The default kind suite. Order is the run order operators should
+ * use: failure-mode first (no upstream deps), gap + poisoning next
+ * (both depend on failures), improvement last (chains all three).
+ */
+declare const DEFAULT_TRACE_ANALYST_KINDS: readonly TraceAnalystKindSpec[];
+
+/**
+ * Pre-curated tool subsets for analyst kinds.
+ *
+ * The full trace-analyst tool set is seven functions. Most kinds only
+ * need three or four. Picking from named groups instead of importing
+ * the whole bundle keeps every kind's actor-context budget tight and
+ * makes "what can this analyst see?" obvious at registration time.
+ *
+ * Each function in the group keeps its full `name`/`description` from
+ * `buildTraceAnalystTools` — we filter, we don't re-implement.
+ */
+
+/** Named tool sets. Kinds pass `tools: TRACE_TOOL_GROUPS.failureForensics` etc. */
+type TraceToolGroupName = 
+/** All seven tools. Use for open-ended discovery kinds. */
+'all'
+/** Overview + paginated query + count. No deep reads. Cheap. */
+ | 'discovery'
+/** Discovery + viewTrace + viewSpans. Deep-read but no regex search. */
+ | 'discoveryAndRead'
+/** Discovery + search tools. For pattern-matching across many traces. */
+ | 'discoveryAndSearch'
+/** Discovery + viewSpans + searchSpan. Targeted-span work after another kind narrows down. */
+ | 'targeted';
+/**
+ * Build the tool set for a named group bound to a specific trace store.
+ *
+ * `all` returns every tool. Other groups filter `buildTraceAnalystTools`
+ * by name to the documented subset. An unrecognised group name throws —
+ * silently returning all tools would defeat the cost-control point.
+ */
+declare function buildTraceToolsForGroup(group: TraceToolGroupName, store: TraceAnalysisStore): AxFunction[];
+
+/**
+ * AnalystRegistry — orchestrate N analysts against one run.
+ *
+ * Owns three responsibilities and only three:
+ *   1. Registration — ids must be unique; bad registrations fail loudly
+ *      at register-time, not run-time.
+ *   2. Routing — each analyst declares its `inputKind`; the registry
+ *      picks the matching field from AnalystRunInputs and skips the
+ *      analyst with a logged reason if it's missing.
+ *   3. Isolation — one analyst's exception MUST NOT stop other analysts.
+ *      Failed analysts produce zero findings + a 'failed' summary row.
+ *
+ * Cross-cutting concerns (telemetry, error → finding conversion, cost
+ * ingestion, storage rotation) live in `AnalystHooks`. Budget shaping
+ * (equal split vs weighted vs custom) lives in `BudgetPolicy`. Both
+ * have sensible defaults; consumers override only what they need.
+ */
+
+interface AnalystHooks {
+    /** Before analyze() — last chance to mutate ctx (e.g. inject tags, override budget). */
+    onBeforeAnalyze?(args: {
+        analyst: Analyst;
+        ctx: AnalystContext;
+        runId: string;
+    }): void | Promise<void>;
+    /** After every analyst (ok | failed | skipped). Use for telemetry, ingestion, rotation. */
+    onAfterAnalyze?(args: {
+        analyst: Analyst;
+        summary: AnalystRunSummary;
+        findings: AnalystFinding[];
+        runId: string;
+    }): void | Promise<void>;
+    /**
+     * On analyst exception. Hook MAY return findings to convert the
+     * error into structured findings; the summary still reports 'failed'.
+     * Return void to keep the default empty-findings behavior.
+     */
+    onError?(args: {
+        analyst: Analyst;
+        error: Error;
+        runId: string;
+    }): AnalystFinding[] | void | Promise<AnalystFinding[] | void>;
+    /** Once after registry.run() completes. Use for final aggregation, persistence. */
+    onComplete?(args: {
+        result: AnalystRunResult;
+    }): void | Promise<void>;
+}
+interface BudgetPolicy {
+    /** Overall USD cap across the registry.run(). */
+    totalUsd?: number;
+    /** Per-analyst weight for the default allocator. Missing ids get weight 1. */
+    weights?: Record<string, number>;
+    /**
+     * Custom allocator — receives the analyst, remaining/total budget, and
+     * the count of analysts that will run. Returns the per-analyst budget
+     * (or undefined to leave it uncapped). Overrides weights when set.
+     */
+    allocate?: (args: {
+        analyst: Analyst;
+        totalUsd: number | undefined;
+        remainingUsd: number | undefined;
+        runningCount: number;
+    }) => number | undefined;
+}
+interface AnalystRegistryOptions {
+    /** Shared chat client passed to every LLM analyst via AnalystContext. */
+    chat?: ChatClient;
+    /** Logger callback. Defaults to a no-op. */
+    log?: (msg: string, fields?: Record<string, unknown>) => void;
+    /** Hooks invoked around analyze() — observability + customization seam. */
+    hooks?: AnalystHooks;
+    /** Default budget when run() doesn't override. */
+    defaultBudget?: BudgetPolicy;
+}
+interface RegistryRunOpts {
+    /** Restrict to a subset of registered analysts by id. */
+    only?: string[];
+    /** Skip these analysts even if registered. Useful for cheap iteration. */
+    skip?: string[];
+    /** Budget policy — totalUsd + optional weights/allocator. Falls back to options.defaultBudget. */
+    budget?: BudgetPolicy;
+    /** Wall-clock cap. Analysts SHOULD honor `ctx.deadlineMs`. */
+    timeoutMs?: number;
+    /** Abort signal — forwarded into every analyst's context. */
+    signal?: AbortSignal;
+    /** Tags echoed into AnalystContext.tags — useful for tracking environment/version in findings. */
+    tags?: Record<string, string>;
+}
+declare class AnalystRegistry {
+    private readonly analysts;
+    private readonly options;
+    constructor(options?: AnalystRegistryOptions);
+    register(analyst: Analyst): void;
+    list(): ReadonlyArray<{
+        id: string;
+        description: string;
+        version: string;
+        cost: Analyst['cost'];
+    }>;
+    run(runId: string, inputs: AnalystRunInputs, runOpts?: RegistryRunOpts): Promise<AnalystRunResult>;
+    private selectAnalysts;
+    private routeInput;
+}
+
+/**
+ * Automated pull request opener for the production loop.
+ *
+ * `runProductionLoop` produces a `promotedPrompt` string and a release
+ * scorecard. To close the eval → prod → eval cycle the framework needs
+ * to land that prompt as a reviewable code change. This module does
+ * exactly that:
+ *
+ *   1. Stage a branch off `baseBranch`.
+ *   2. Write each `fileChange` into the worktree.
+ *   3. Commit + push.
+ *   4. Open a PR via the GitHub API.
+ *
+ * Two transports ship in core:
+ *
+ *   - `ghCliClient(opts)` — shells out to the `gh` CLI. No extra deps,
+ *     re-uses the developer machine's `gh auth` state, works with both
+ *     github.com and GitHub Enterprise. This is the recommended default.
+ *   - `httpGithubClient(opts)` — direct `fetch` against `api.github.com`
+ *     with a bearer token. Useful in CI where `gh` may not be installed.
+ *
+ * Both implement the small `AutoPrClient` interface, so tests substitute
+ * a fake without spinning a process or network.
+ *
+ * @experimental — surface may evolve as consumers wire it into CI workflows.
+ */
+interface FileChange {
+    /** Repo-relative path. Forward slashes; no `..`. */
+    path: string;
+    /** New file contents. UTF-8. */
+    contents: string;
+    /** Optional explanatory comment shown in the commit body. */
+    rationale?: string;
+}
+interface RepoRef {
+    owner: string;
+    name: string;
+}
+interface ProposeAutomatedPullRequestInput {
+    repo: RepoRef;
+    /** Branch to base the PR on. Default `'main'`. */
+    baseBranch?: string;
+    /** New branch name. Use a prefix + a short stable id; no spaces. */
+    branchName: string;
+    fileChanges: FileChange[];
+    title: string;
+    body: string;
+    /** Optional GitHub usernames to request review from. */
+    reviewers?: string[];
+    /** Optional labels to apply. */
+    labels?: string[];
+    /** Commit author name. Default: derived from the GitHub client. */
+    authorName?: string;
+    /** Commit author email. Default: derived from the GitHub client. */
+    authorEmail?: string;
+    /** Dry-run — do not push or open a PR; just return the would-be plan. */
+    dryRun?: boolean;
+}
+interface ProposeAutomatedPullRequestResult {
+    prUrl: string;
+    branchName: string;
+    headSha: string;
+    dryRun: boolean;
+}
+/** Pluggable transport for the auto-PR pipeline. */
+interface AutoPrClient {
+    /**
+     * Create a branch from `baseBranch`, write file changes, commit, push,
+     * and open a PR. Returns the PR's HTML url and head SHA.
+     *
+     * Implementations must be idempotent on `branchName`: if the branch
+     * already exists with the same head SHA as the would-be commit, return
+     * the existing PR rather than failing. This makes the production loop
+     * safe to retry on transient errors.
+     */
+    proposeChange(input: ProposeAutomatedPullRequestInput): Promise<ProposeAutomatedPullRequestResult>;
+}
+declare function proposeAutomatedPullRequest(client: AutoPrClient, input: ProposeAutomatedPullRequestInput): Promise<ProposeAutomatedPullRequestResult>;
+interface HttpGithubClientOptions {
+    /** Personal access token, GitHub App token, or `GITHUB_TOKEN` from Actions. */
+    token: string;
+    /** Override for GitHub Enterprise. Default `'https://api.github.com'`. */
+    apiBase?: string;
+    /** Test seam — defaults to global `fetch`. */
+    fetchImpl?: typeof fetch;
+    /** Test seam — clock for commit timestamps. */
+    now?: () => Date;
+}
+/**
+ * Direct REST-API GitHub client. No external deps.
+ *
+ * Idempotency strategy: before creating refs/commits/PRs, check whether
+ * the branch already exists at the desired tree. If so, return the
+ * existing PR (or open one if missing). Errors from concurrent runs
+ * (`Reference already exists`) are caught and treated as success.
+ */
+declare function httpGithubClient(opts: HttpGithubClientOptions): AutoPrClient;
+interface GhCliClientOptions {
+    /** Override the CLI binary (`gh`). For testing. */
+    bin?: string;
+    /** Working directory containing a clone of `repo`. Default: process cwd. */
+    cwd?: string;
+    /** Test seam: process spawner. Default: node:child_process spawn. */
+    exec?: (bin: string, args: string[], opts: {
+        cwd: string;
+        stdin?: string;
+    }) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
 }
+/**
+ * `gh` CLI transport. Requires:
+ *   - `gh` installed and authenticated (`gh auth status`).
+ *   - A local clone of the repo with a clean working tree.
+ *   - `git` on PATH.
+ *
+ * Uses `gh api` for repo metadata and `gh pr create` for the PR. The
+ * actual commit lands via `git`, which keeps `gh`'s footprint minimal.
+ */
+declare function ghCliClient(opts?: GhCliClientOptions): AutoPrClient;
 
 /**
  * BenchmarkRunner — orchestrates scenarios, executor, judges, and scoring.
@@ -747,8 +1754,7 @@ declare class MetricsCollector {
  * primitive is idempotent + replayable: re-running with the same
  * `runId` will produce the same plan.
  *
- * @experimental — added in 0.25.0. Surface may evolve as the 5 product
- * agents wire it in.
+ * @experimental — surface may evolve as product agents wire it in.
  */
 
 interface FailureClusterConfig {
@@ -998,6 +2004,78 @@ declare function wilcoxonSignedRank(before: number[], after: number[]): {
  * Rule of thumb: |d| < 0.2 negligible, 0.2–0.5 small, 0.5–0.8 medium, > 0.8 large.
  */
 declare function cohensD(a: number[], b: number[]): number;
+interface CorpusScoreRecord {
+    /** Stable identifier for the rated item (scenario, span, turn, …). */
+    itemId: string;
+    /** Identifier for the judge that produced this score. */
+    judgeName: string;
+    /** Dimension name (matches `JudgeScore.dimension`). */
+    dimension: string;
+    /** Numeric score; must be finite. */
+    score: number;
+}
+interface CorpusAgreementPerDimension extends ContinuousAgreement {
+    dimension: string;
+    /** Item IDs that contributed to this dimension's matrix (every judge scored them). */
+    itemIds: string[];
+    /** Judge IDs that contributed to this dimension's matrix. */
+    judgeIds: string[];
+}
+interface CorpusAgreementReport {
+    /** Per-dimension ICC(2,1) + κ_w + Pearson + Spearman + bootstrap CIs. */
+    perDimension: CorpusAgreementPerDimension[];
+    /** Mean ICC across dimensions (NaN if no dimension yielded a finite ICC). */
+    overallIcc: number;
+    /** Mean weighted κ across dimensions (NaN if none finite). */
+    overallWeightedKappa: number;
+    /** Dimensions evaluated (sorted). */
+    dimensions: string[];
+    /** Judges seen across the corpus (sorted). */
+    judgeIds: string[];
+}
+interface CorpusAgreementOptions extends ContinuousAgreementOptions {
+    /**
+     * Restrict the audit to these dimensions. Default = every dimension
+     * that appears in the input. A dimension named here but absent from
+     * the input throws — silent omission would corrupt the overall metric.
+     */
+    dimensions?: string[];
+    /**
+     * Restrict the audit to these judges. Default = every judge that
+     * appears in the input. A judge named here but absent from a
+     * dimension throws (see "fail loud" below).
+     */
+    judges?: string[];
+}
+/**
+ * Corpus-wide inter-rater agreement across N items × M judges × D dimensions.
+ *
+ * For each dimension, builds the [n_items][n_judges] matrix of scores
+ * (keeping only items every judge rated on that dimension), then runs
+ * `continuousAgreement` to get ICC(2,1), κ_w, Pearson, Spearman, and
+ * bootstrap CIs. Reports a pooled mean across dimensions as a single
+ * "is this judge panel reliable on this corpus?" number.
+ *
+ * Fail-loud contract:
+ *   - Empty input throws.
+ *   - Fewer than 2 judges or fewer than 2 items per dimension throws.
+ *   - A judge present in some dimensions but with zero scored items on
+ *     another dimension throws (would silently shrink the matrix).
+ *   - Duplicate (itemId, judgeName, dimension) records throw.
+ */
+declare function corpusInterRaterAgreement(records: CorpusScoreRecord[], opts?: CorpusAgreementOptions): CorpusAgreementReport;
+/**
+ * Convenience adapter for `JudgeScore[]` data keyed externally by item.
+ *
+ * Use when you have per-item arrays of `JudgeScore[]` (e.g. one
+ * `ScenarioResult.judgeScores` per scenario) and want corpus-wide
+ * agreement without manually flattening. `itemId` must be unique per
+ * row of `itemsScores`.
+ */
+declare function corpusInterRaterAgreementFromJudgeScores(itemsScores: Array<{
+    itemId: string;
+    scores: JudgeScore[];
+}>, opts?: CorpusAgreementOptions): CorpusAgreementReport;
 
 /**
  * Anti-slop quality judge.
@@ -1241,58 +2319,6 @@ declare class DualAgentBench {
     run(config: DualAgentBenchConfig): Promise<DualAgentReport>;
 }
 
-interface RunScore {
-    success: number;
-    goalProgress: number;
-    repoGroundedness: number;
-    driftPenalty: number;
-    toolUseQuality: number;
-    patchQuality: number;
-    testReality: number;
-    finalGate: number;
-    reviewerBlockers: number;
-    costUsd: number;
-    wallSeconds: number;
-    notes?: string[];
-}
-interface RunScoreWeights {
-    success: number;
-    goalProgress: number;
-    repoGroundedness: number;
-    driftPenalty: number;
-    toolUseQuality: number;
-    patchQuality: number;
-    testReality: number;
-    finalGate: number;
-    reviewerBlockers: number;
-    costUsd: number;
-    wallSeconds: number;
-}
-declare const DEFAULT_RUN_SCORE_WEIGHTS: RunScoreWeights;
-declare function aggregateRunScore(score: RunScore, weights?: Partial<RunScoreWeights>): number;
-declare function clamp01(value: number): number;
-
-interface RunTrace {
-    run: Run$1;
-    spans: Span[];
-    events: TraceEvent[];
-    artifacts: Artifact$1[];
-    budget: BudgetLedgerEntry[];
-}
-interface RunCriticOptions {
-    weights?: Partial<RunScoreWeights>;
-    driftPatterns?: RegExp[];
-}
-declare class RunCritic {
-    private readonly weights?;
-    private readonly driftPatterns;
-    constructor(options?: RunCriticOptions);
-    score(store: TraceStore, runId: string): Promise<RunScore>;
-    scoreTrace(trace: RunTrace): RunScore;
-    rank(score: RunScore): number;
-    private isDrift;
-}
-
 interface HostedJudgeDimension {
     name: string;
     weight: number;
@@ -2623,9 +3649,9 @@ declare function paraphraseRobustnessScenarios(args: ParaphraseRobustnessScenari
  *      `bonferroni(pValues, alpha)` correct for multiple pairwise tests
  *      so pairwise variant comparisons stay statistically honest.
  *
- * Fixes the correctness bug in 0.2's pairwise optimizer which applied
- * alpha directly across n*(n-1)/2 pairwise tests without correction —
- * dramatically inflating false-positive rate when variants ≥ 3.
+ * Applying alpha directly across n*(n-1)/2 pairwise tests without
+ * correction inflates the false-positive rate when variants ≥ 3 — the
+ * BH and Bonferroni helpers prevent that.
  */
 /**
  * Required N per arm for a two-sample comparison at target effect size,
@@ -2940,12 +3966,9 @@ interface HypothesisManifest {
  * Identifier for the hashing scheme used to produce `contentHash`.
  *
  * `'sha256-content'` — sha256 hex over the canonicalized manifest with
- * the `contentHash` and `algo` fields stripped. This is what
- * `signManifest` produces today.
- *
- * Held as a string union so future schemes can be added without
- * breaking parsers; legacy SignedManifest values written before this
- * field existed will deserialize cleanly because the field is optional.
+ * 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 {
@@ -2954,10 +3977,10 @@ interface SignedManifest extends HypothesisManifest {
     /**
      * Algorithm string describing how `contentHash` was produced.
      *
-     * Optional on the type so legacy serialized manifests (pre-`algo`)
-     * 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.
+     * 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;
 }
@@ -2996,10 +4019,9 @@ declare function canonicalize(v: unknown): unknown;
  *   - encoder choice (UTF-8 via TextEncoder, fixed)
  *   - runtime (uses the Web Crypto subtle digest, present in Node ≥18 and browsers)
  *
- * Naming note: `hashJson` rather than `hashContent` because `hashContent` is
- * already taken in `prompt-registry.ts` for the truncated 12-char prompt-id
- * helper, which has different semantics (string input, short return). Both
- * coexist; `hashJson` is the right name when you mean "canonicalize then hash."
+ * 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' })
@@ -3012,17 +4034,15 @@ declare function hashJson<T>(obj: T): Promise<string>;
  * 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; legacy serialized
- * manifests without `algo` still verify because it is stripped before
- * hashing on both sides.
+ * 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 legacy manifests
- * (written before `algo` was emitted) verify identically to current
- * ones.
+ * 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>;
 /**
@@ -3334,9 +4354,8 @@ declare const localCommandRunner: CommandRunner;
  *   - artifact dir contains an entry point (index.html for static SPAs,
  *     equivalent per framework family)
  *
- * Shipped in 0.11 with the canonical `vite` runner. Future generations
- * add wrangler-deploy --dry-run, next-build, etc — each as another
- * runner factory.
+ * Ships with a canonical `vite` runner. Additional runners
+ * (wrangler-deploy --dry-run, next-build, etc.) plug in as factories.
  */
 
 type DeployFamily = 'frontend-static' | 'nextjs' | 'remix' | 'fullstack-ts';
@@ -3508,10 +4527,8 @@ declare function extractErrorCount(text: string, opts?: ExtractOptions): Extract
  *   - test: in-memory mock that returns canned step outcomes
  *   - future: Playwright, Puppeteer, custom scrapers
  *
- * Shipped in 0.11 alongside {@link runIntentMatchJudge} — together they
- * close the "the agent shipped the wrong app and we didn't catch it"
- * blind spot. Intent-match catches "wrong app entirely"; flow catches
- * "right app but the buttons don't work."
+ * Paired with {@link runIntentMatchJudge}: intent-match catches "wrong
+ * app entirely"; flow-layer catches "right app but the buttons don't work."
  */
 
 type FlowAction = 'navigate' | 'click' | 'fill' | 'expect-text' | 'expect-element' | 'expect-url' | 'wait';
@@ -3607,10 +4624,6 @@ declare function flowLayer<Env extends FlowLayerEnv = FlowLayerEnv>(input: FlowL
  *
  * Soft-fails on LLM/JSON error (`available: false`) so callers can
  * treat failure as "judge skipped."
- *
- * Added in 0.11 to replace the lying `completenessScore: 1` field that
- * VerticalBench shipped pre-Gen-48 — that field was keyword-driven and
- * fired true on builds with zero spec concepts implemented.
  */
 
 declare const INTENT_MATCH_JUDGE_VERSION = "intent-match-judge-v1-2026-04-24";
@@ -4120,141 +5133,6 @@ declare function buildReviewerPrompt(input: ReviewerPromptInput): {
  */
 declare function createDefaultReviewer(options: CreateDefaultReviewerOptions): (input: ReviewerPromptInput) => Promise<ReviewerOutput>;
 
-/**
- * Semantic concept judge — "does the built artifact actually implement
- * the features the user asked for?"
- *
- * Distinct from the domain/code/coherence judges in `judges.ts`:
- *   - those judges score free-form conversational agent outputs along
- *     quality dimensions (accuracy, depth, etc.)
- *   - this judge scores a *built artifact* (served HTML + source files)
- *     against an explicit list of expected concepts, returning per-concept
- *     {present, score 0-10, evidence, severity}.
- *
- * The judge is strict about distinguishing (a) a working implementation
- * from (b) a keyword-present stub. "// TODO: mint button" is NOT present.
- * Only real, functional, wired-up code counts.
- *
- * Use via {@link createSemanticConceptJudge} or directly via
- * {@link runSemanticConceptJudge}. Soft-fails (available=false) on LLM
- * or JSON-parse errors so the caller can treat that as "layer skipped"
- * rather than "layer failed" in a multi-layer pipeline.
- */
-
-/**
- * Implementation complexity class for weighted scoring (added 0.11).
- *
- * - `render` (default): the concept is a UI surface that displays static
- *   data — render a list, show a counter, lay out a button. Single-file
- *   work, no external integration.
- * - `integrate`: the concept requires wiring a real external system —
- *   wallet connect (wagmi + RainbowKit + chain config), payment provider
- *   (Stripe Elements + intent + webhook), an API client with auth.
- *   Multi-file, library-knowledge, runtime correctness matters.
- * - `compute`: the concept requires algorithmic work — solver, simulator,
- *   constraint propagation, ML inference. Correctness > UI polish.
- *
- * Default weights (when applied via `weightConcepts: 'complexity'`):
- *   render=1.0, integrate=2.0, compute=2.5
- *
- * Cross-vertical scoring without complexity weighting silently inflates
- * the rate of UI-heavy verticals (healthcare, fintech dashboards) vs
- * integration-heavy verticals (DeFi, wallets) — all concepts treated
- * equally even though the agent does 2-3x the work for `integrate`.
- */
-type ConceptComplexity = 'render' | 'integrate' | 'compute';
-interface ConceptSpec {
-    name: string;
-    /** Short hints that help the judge; not used for matching. */
-    keywords?: string[];
-    /** Optional explicit weight; default 1.0. Overrides complexity-derived weight. */
-    weight?: number;
-    /** Implementation complexity class. Default `render`. */
-    complexity?: ConceptComplexity;
-}
-interface ConceptFinding {
-    concept: string;
-    present: boolean;
-    /** 0..10. 10 = production-ready; 7 = functional thin; 4 = partial; 0 = absent. */
-    score: number;
-    evidence: string;
-    severity: Severity;
-}
-interface SemanticConceptJudgeInput {
-    /** Full natural-language prompt the agent was handed. */
-    userRequest: string;
-    /** Rendered HTML the preview returns (UI artifacts). Optional. */
-    servedHtml?: string;
-    /** Top-level source files from the agent's workdir. */
-    sourceFiles: Array<{
-        path: string;
-        content: string;
-    }>;
-    /** The expected concept list. */
-    expectedConcepts: ConceptSpec[];
-    /** Free-form metadata (id, difficulty) to inject into the prompt. */
-    artifactLabel?: string;
-    artifactDescription?: string;
-}
-interface SemanticConceptJudgeResult {
-    kind: 'semantic-concept';
-    version: string;
-    /** Normalized 0..1 score — mean of per-concept scores / 10. */
-    score: number;
-    presentCount: number;
-    totalCount: number;
-    findings: ConceptFinding[];
-    summary: string;
-    durationMs: number;
-    costUsd: number | null;
-    /** False on LLM/JSON error — treat as "skipped / unable to judge" in pipelines. */
-    available: boolean;
-    error?: string;
-}
-/**
- * Score-aggregation strategy. Default `mean` (legacy behavior — 0.10
- * and earlier always averaged 0-10 scores). `complexity` applies the
- * default weight table (render=1, integrate=2, compute=2.5) unless a
- * concept has an explicit `weight`. `explicit` honors only `weight`
- * (defaulting to 1 for unspecified).
- */
-type ConceptWeightStrategy = 'mean' | 'complexity' | 'explicit';
-declare const DEFAULT_COMPLEXITY_WEIGHTS: Record<ConceptComplexity, number>;
-interface SemanticConceptJudgeOptions {
-    /** Model id to call. Default 'claude-sonnet-4-6' via agent-eval defaults. */
-    model?: string;
-    /** Per-call timeout. Default 180s. */
-    timeoutMs?: number;
-    /** Pipeline budget for the prompt (source blob truncation). Default 45000. */
-    maxSourceChars?: number;
-    /** Per-file cap before inclusion. Default 20000. */
-    maxPerFileChars?: number;
-    /** HTML cap. Default 30000. */
-    maxHtmlChars?: number;
-    /** LlmClient config (baseUrl, apiKey, authHeader, …). */
-    llm?: LlmClientOptions;
-    /**
-     * Score aggregation strategy. Default `mean` for backward compatibility
-     * with 0.10 and earlier callers. Cross-vertical comparisons should use
-     * `complexity` to neutralize the integrate-vs-render asymmetry.
-     */
-    weightConcepts?: ConceptWeightStrategy;
-    /** Override the default complexity → weight table. */
-    complexityWeights?: Partial<Record<ConceptComplexity, number>>;
-}
-declare const SEMANTIC_CONCEPT_JUDGE_VERSION = "semantic-concept-judge-v1-2026-04-24";
-/**
- * Run the semantic concept judge. Soft-fails to available=false on
- * LLM/JSON errors — callers in a MultiLayerVerifier pipeline can treat
- * that as "skip" rather than "fail."
- */
-declare function runSemanticConceptJudge(input: SemanticConceptJudgeInput, options?: SemanticConceptJudgeOptions): Promise<SemanticConceptJudgeResult>;
-/**
- * Factory: pin LLM options once, return a closure that accepts inputs.
- * Convenient for pipelines that want to share a single LlmClient config.
- */
-declare function createSemanticConceptJudge(options?: SemanticConceptJudgeOptions): (input: SemanticConceptJudgeInput) => Promise<SemanticConceptJudgeResult>;
-
 /**
  * Liveness canaries — cheap statistical checks that catch the failure
  * modes a green test suite never sees.
@@ -4458,9 +5336,8 @@ interface LineageNode {
 }
 /**
  * `kindOf` decides whether a variant is a seed (no parent), code mutation,
- * or prompt mutation. Default looks at `variant.payload.codeMutation` —
- * that field is part of the audit-bench convention but cheap enough to
- * accept any payload that mirrors it. Override by passing your own.
+ * or prompt mutation. Default looks at `variant.payload.codeMutation` and
+ * accepts any payload that exposes that field; override by passing your own.
  */
 type LineageKindResolver<P> = (variant: EvolvableVariant<P>) => LineageKind;
 /**
@@ -4707,9 +5584,8 @@ declare function createSandboxCodeMutator<T, P>(opts: CreateSandboxCodeMutatorOp
  *                  Δ improvement (auto-detect when prompt evolution has
  *                  hit a structural ceiling).
  *
- * Naming is generic: the original audit-bench version called the channels
- * "prompt" and "code" — those are the canonical use cases, but the
- * primitive doesn't care what each mutator actually does.
+ * Naming is generic — the canonical use cases are "prompt" and "code"
+ * channels, but the primitive doesn't care what each mutator actually does.
  */
 
 type CompositePolicy = 'primary-only' | 'secondary-only' | 'alternate' | 'plateau';
@@ -4754,25 +5630,15 @@ declare class Mutex {
 }
 
 /**
- * Persona discovery — replaces every consumer's hardcoded TRAINING_PERSONA_FILES.
- *
- * Today's failure mode: each product agent (legal/gtm/tax/creative) defines
- * a TRAINING_PERSONA_FILES const with 5 hardcoded filenames. When the 2yr
- * rewrite added 10+ new personas, those personas existed on disk but the
- * evolve runner never loaded them — the new rubric dims (audit_defendability,
- * intake_discipline, etc) got no training signal. The personas were
- * cosmetic, the rewrites partially uninformed.
- *
- * `discoverPersonas` walks a personas directory and returns every persona
- * file matching the convention. Consumers can filter by include/exclude
- * patterns. Default behavior — discover everything — eliminates the
- * "forgot to add the new persona to the list" failure mode.
+ * Walk a personas directory and return every file matching the convention
+ * `NN-slug.{yaml,yml,json,md}`. Sorted by filename so the numeric prefix
+ * gives stable persona ordering for reproducibility. Consumers filter
+ * through `include` / `exclude`.
  */
 interface DiscoverPersonasOptions {
     /**
      * Regex applied to filenames. Files that don't match are skipped.
-     * Default: `^[0-9]{2}-.+\.(yaml|yml|json|md)$` (the prevailing convention
-     * across legal/gtm/tax/creative: `NN-slug.yaml`).
+     * Default: `^[0-9]{2}-.+\.(yaml|yml|json|md)$`.
      */
     pattern?: RegExp;
     /**
@@ -4782,14 +5648,10 @@ interface DiscoverPersonasOptions {
     exclude?: readonly string[];
     /**
      * If set, return only personas whose basename contains one of these
-     * substrings (post-pattern filter). Used by the CLI's `--personas a,b,c`
-     * flag — consumers pass through.
+     * substrings (post-pattern filter).
      */
     include?: readonly string[];
-    /**
-     * Recurse into subdirectories. Default false (legal/gtm/tax/creative all
-     * store personas flat).
-     */
+    /** Recurse into subdirectories. Default false. */
     recursive?: boolean;
 }
 interface DiscoveredPersona {
@@ -4800,14 +5662,6 @@ interface DiscoveredPersona {
     /** Filename without extension — the conventional persona id. */
     id: string;
 }
-/**
- * Walk `dir` and return every persona file matching the convention. Async
- * because the consumer almost always wants this to be I/O-driven (so a new
- * persona added on disk is picked up without a code change).
- *
- * Sorted by filename (which gives stable persona id order via the `NN-`
- * numeric prefix convention) for reproducibility.
- */
 declare function discoverPersonas(dir: string, opts?: DiscoverPersonasOptions): Promise<DiscoveredPersona[]>;
 
 /**
@@ -4914,43 +5768,17 @@ declare class JsonlTrialCache implements TrialCache {
 }
 
 /**
- * Judge-retry wrapper.
- *
- * Today's failure mode: a judge LLM call aborts mid-stream (connection
- * dropped, model timed out, schema rejected) → consumer's try/catch swallows
- * the error and returns `score: 0`. The eval composite then weights that
- * zero into the mean, silently corrupting the score. Today's tax/gtm evals
- * had `judge=0` across every trial — the prompt rewrites couldn't be
- * evaluated honestly because the measurement instrument was broken.
- *
- * `withJudgeRetry` is the substrate fix. It wraps a single judge invocation
- * with:
- *
- *   1. N retry attempts on transient failures (abort, timeout, network).
- *   2. Optional fallback-model rotation — try the next model in the list
- *      if the primary keeps aborting (a verbose new prompt may stream-abort
- *      on claude-code/sonnet but succeed on kimi-code/k2p6).
- *   3. Exponential backoff between attempts.
- *   4. A typed outcome `{ succeeded, attempts, value, error }` that callers
- *      MUST decide what to do with. No silent zero.
- *
- * The reporting contract: callers ship `TrialResult.judgeSucceeded = succeeded`
- * and `TrialResult.judgeAttempts = attempts`. `aggregateTrials({mode: 'exclude-failed'})`
- * then skips failed-judge trials when computing composites.
- *
- * The library does NOT decide what score to record on failure — that's the
- * caller's product choice. Today's product agents (legal/gtm/tax/creative)
- * should set `score: NaN` + `judgeSucceeded: false` + `error: ...` so the
- * aggregator's exclude-failed mode drops the trial. Defaulting to 0 is what
- * caused today's data corruption.
- */
-/**
- * Retry policy for judge LLM calls.
+ * 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.
  *
- * Defaults are tuned for the verbose post-2yr-rewrite prompts that exceed
- * the 60s `callLlm` default and abort on streaming. Pick a different timeout
- * for cheap-and-quick judges (e.g., 30s) or longer for thinking models.
+ * 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;
@@ -5003,8 +5831,8 @@ interface JudgeRetryOutcome<T> {
  * 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 that
- * is exactly what caused today's eval data corruption.
+ * `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>>;
 
@@ -5070,42 +5898,30 @@ declare function referenceReplayRunsToSteeringRows<Input = unknown>(runs: Refere
 declare function referenceReplayScenarioToRunScore(scenarioScore: ReferenceReplayScenarioScore, durationMs?: number): RunScore;
 
 /**
- * Trial-aggregator modes.
- *
- * The prompt-evolution loop's internal `aggregateTrials` defaulted to
- * including every non-`error` trial in the mean — which corrupted the mean
- * when a trial had `score: 0` because the judge silently aborted (the
- * caller's try/catch swallowed the abort and returned zero). Today's
- * tax/gtm evals show this: every trial scored judge=0 because the judge
- * aborted, and the composite then reflected `structural * 0.3 + slop * 0.1`
- * instead of the intended `judge * 0.6 + structural * 0.3 + slop * 0.1`.
+ * Aggregate trials with explicit handling of judge failure. Three modes:
  *
- * `aggregateTrialsByMode` is the substrate fix. Consumers can choose:
+ *   - `strict-fail` — any `judgeSucceeded === false` trial fails the whole
+ *     aggregate. Use for production gates: one corrupt trial halts the gate.
  *
- *   - `strict-fail` — any trial with `judgeSucceeded === false` fails the
- *     whole aggregate. Right for production-gate runs where one corrupted
- *     trial means "we don't know if the prompt is good, halt the gate."
+ *   - `exclude-failed` — drop `judgeSucceeded === false` trials from the
+ *     mean; report `excludedFailedTrials` separately. Default for new code.
  *
- *   - `exclude-failed` — drop trials with `judgeSucceeded === false` from
- *     the mean; report `failedTrials` separately. Right for research /
- *     comparison runs where you want to use the signal that DID land.
- *     Default for new code.
+ *   - `zero-fill` — failed trials count as `score: 0` in the mean. Available
+ *     only for adapters that don't yet set `judgeSucceeded`.
  *
- *   - `zero-fill` — legacy behavior: failed trials count as score=0 in
- *     the mean. Default ONLY for backwards-compat with adapters that
- *     don't yet set `judgeSucceeded`. Migrate off this — it's the source
- *     of today's data corruption.
+ * Hard-errored trials (`t.error` set) are always excluded — those are
+ * infrastructure failures, not eval signal.
  */
 
 type AggregatorMode = 'strict-fail' | 'exclude-failed' | 'zero-fill';
 interface TrialAggregate {
     /** Mean score over the trials counted by the chosen mode. */
     meanScore: number;
-    /** Mean cost (legacy, kept for compatibility). */
+    /** Mean cost across counted trials. */
     meanCost: number;
-    /** Mean wall time (legacy). */
+    /** Mean wall time across counted trials. */
     meanDurationMs: number;
-    /** ok-rate (legacy). */
+    /** Fraction of counted trials with `ok === true`. */
     okRate: number;
     /** Trials counted in the mean (mode-dependent). */
     countedTrials: number;
@@ -5125,13 +5941,8 @@ interface TrialAggregate {
         firstError?: string;
     };
 }
-/**
- * Aggregate trials with explicit failed-judge handling. Returns counts for
- * counted + excluded so callers can surface "the score is based on 7 of 10
- * trials; 3 judges failed" instead of silently weighting zero.
- */
 declare function aggregateTrialsByMode(trials: TrialResult[], opts: {
     mode: AggregatorMode;
 }): TrialAggregate;
 
-export { ActionableSideInfo, type ActiveLearningOptions, type AdapterRun, AgentDriver, type AgentDriverConfig, AgentEvalError, type AggregatorMode, type AlignmentOp, type AntiSlopConfig, type AntiSlopIssue, type AntiSlopReport, Artifact$1 as Artifact, type ArtifactCheck, type Artifact as ArtifactCheckArtifact, type ArtifactResult, type ArtifactValidator, type AutoPrClient, AxGepaSteeringOptimizer, type AxSteeringOptimizerConfig, BaselineReport, BehaviorAssertion, type BenchmarkReport, BenchmarkRunner, type BenchmarkRunnerConfig, type BisectOptions, type BisectResult, type BisectStep, BudgetBreachError, BudgetGuard, BudgetLedgerEntry, BudgetSpec, CallExpectation, type CanaryAlert, type CanaryKind, type CanaryLeak, type CanaryOptions, type CanaryReport, type CanarySeverity, type CandidateScenario, type CausalAttributionReport, type CheckResult, type CodeMutationOutcome, type CodeMutationRunner, type CollectedArtifacts, type CommandRunner, type CompletionCriterion, type CompositePolicy, type ConceptComplexity, type ConceptFinding, type ConceptSpec, type ConceptWeightStrategy, type ContinuityCheck, type ContinuityCheckResult, type ContinuityReport, type ContinuitySnapshotPair, type ContractMetric, type ContractReport, ControlEvalResult, ConvergenceTracker, type CostEntry, CostLedger, type CostLedgerGeneration, type CostLedgerSnapshot, type CostSummary, CostTracker, type CounterfactualContext, type CounterfactualMutation, type CounterfactualResult, type CounterfactualRunner, type CreateCompositeMutatorOpts, type CreateDefaultReviewerOptions, type CreateSandboxCodeMutatorOpts, type CreateSandboxPoolOpts, type CrossTraceDiff, type CrossTraceDiffOptions, D1ExperimentStore, type D1ExperimentStoreOptions, type D1Like, type D1PreparedStatementLike, DEFAULT_AGENT_SLOS, DEFAULT_COMPLEXITY_WEIGHTS, DEFAULT_FINDERS, DEFAULT_HARNESS_OBJECTIVES, DEFAULT_MUTATORS, DEFAULT_RUN_SCORE_WEIGHTS, DEFAULT_SEVERITY_WEIGHTS, Dataset, DatasetScenario, type DeployFamily, type DeployGateLayerInput, type DeployRunResult, type DeployRunner, type DirEntry, type DiscoverPersonasOptions, type DiscoveredPersona, type DriverResult, type DriverState, DualAgentBench, type DualAgentBenchConfig, type DualAgentReport, type DualAgentRound, type DualAgentScenario, type DualAgentScenarioResult, ERROR_COUNT_PATTERNS, type ErrorCountPattern, type EvalResult, type EvolutionRound, EvolvableVariant, type ExecutorConfig, type Expectation, type Experiment, type Run as ExperimentRun, type ExperimentStore, ExperimentTracker, type ExportedRewardModel, type ExtractOptions, type ExtractResult, type FactorContribution, type FactorialCell, type FailureClusterConfig, FeedbackLabel, type FeedbackPattern, FeedbackTrajectory, FeedbackTrajectoryStore, type FileChange, FileSystemExperimentStore, type FileSystemExperimentStoreOptions, type FlowAction, type FlowLayerEnv, type FlowLayerFactoryInput, type FlowRunner, type FlowRunnerStepResult, type FlowSpec, type FlowStep, GateDecision, type GhCliClientOptions, type GoldenSeverity, type GoldenSpec, type HarnessAdapter, HarnessConfig, type HarnessExperimentConfig, type HarnessExperimentResult, type HarnessIntervention, type HarnessRunRequest, type HarnessRunResult, type HarnessScenario, type HarnessSelection, type HarnessVariant, type HarnessVariantReport, HeldOutGateConfig, HoldoutAuditor, type HostedJudgeConfig, type HostedJudgeDimension, type HostedJudgeRequest, type HostedJudgeResponse, type HostedRunCriticConfig, type HostedRunScoreRequest, type HostedRunScoreResponse, type HttpGithubClientOptions, type HypothesisManifest, type HypothesisResult, INTENT_MATCH_JUDGE_VERSION, type ImageData, InMemoryExperimentStore, InMemoryWorkspaceInspector, type InferenceScorer, type InspectorContext, type IntegrationGateSurface, type IntegrationInvokeFailureInput, type IntegrationManifestGateInput, type IntentMatchInput, type IntentMatchOptions, type IntentMatchResult, type InteractionContribution, JsonlTrialCache, type JudgeConfig, type JudgeFleetOptions, type JudgeFn, type JudgeInput, type JudgeReplayResult, type JudgeRetryOutcome, type JudgeRetryPolicy, type JudgeRubric, JudgeRunner, type JudgeScore, type KeywordConceptSpec, type KeywordCoverageFinding, type KeywordCoverageOptions, type KeywordCoverageResult, type LangfuseEnvelope, type LangfuseGeneration, type LangfuseScore, Layer, LayerResult, type LineageKind, type LineageKindResolver, type LineageNode, LineageRecorder, type LiveProofArtifact, type LiveProofConfig, type LiveProofContext, type LiveProofResult, LlmClientOptions, LlmSpan, LockedJsonlAppender, MODEL_PRICING, type MatchResult, type MatcherResult, type MeasurementPolicy, type MergeOptions, MetricsCollector, type MuffledFinder, type MuffledFinding, MultiShotMutateAdapter, MultiShotOptimizationResult, MultiShotRunner, MultiShotScorer, MultiShotTrialResult, type MultiToolchainLayerConfig, MutateAdapter, type MutationAttempt, type MutationChannel, MutationTelemetry, type Mutator, Mutex, Objective, type Oracle, type OracleObservation, type OracleReport, type OracleResult, type OrthogonalityInput, type OrthogonalityResult, PairwiseSteeringOptimizer, type ParaphraseRobustnessScenarioInput, type ParaphraseRobustnessScenarioResult, ParetoResult, type PersonaConfig, type Playbook, type PlaybookEntry, type PoolSlot, ProductClient, type ProductClientConfig, type ProductionEvolveConfig, type ProductionLoopCronConfig, type ProductionLoopDecision, type ProductionLoopRenderContext, type ProductionLoopResult, type ProductionShipConfig, type PromptHandle, PromptRegistry, TrialResult as PromptTrialResult, type ProposeAutomatedPullRequestInput, type ProposeAutomatedPullRequestResult, 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, ReleaseConfidenceScorecard, ReleaseConfidenceThresholds, type RepoRef, type ReviewerMemoryEntry, type ReviewerOutput, type ReviewerPromptInput, type ReviewerSoftFailDefaults, type ReviewerVerificationSummary, type RobustnessResult, type RouteMap, type RubricDimension, Run$1 as Run, type RunCommandInput, type RunCommandResult, type RunConfig, RunCritic, type RunCriticOptions, type RunDiff, RunFilter, type RunProductionLoopOptions, RunRecord, type RunScore, type RunScoreWeights, RunSplitTag, type RunTrace, SEMANTIC_CONCEPT_JUDGE_VERSION, SandboxDriver, SandboxHarnessResult, type SandboxJudgeKind, type SandboxJudgeResult, type SandboxJudgeSpec, type SandboxPool, type ScanOptions, type Scenario, type ScenarioCost, type ScenarioFile, ScenarioRegistry, type ScenarioResult, type ScoredTarget, type SelfPlayOptions, type SelfPlayProposer, type SelfPlayScorer, type SemanticConceptJudgeInput, type SemanticConceptJudgeOptions, type SemanticConceptJudgeResult, type SeriesConvergenceOptions, type SeriesConvergenceResult, Severity, type SignedManifest, type SignedManifestAlgo, type Slo, type SloCheckResult, type SloComparator, type SloReport, type SloSeverity, type SlopCategory, type SlotFactory, Span, type SteeringBundle, type SteeringDelta, type SteeringOptimizationResult, type SteeringOptimizationRow, type SteeringOptimizationSelector, type SteeringOptimizerBackend, type SteeringOptimizerConfig, type SteeringRolePrompt, type StepAttribution, type SynthesisReason, type SynthesisTarget, type TestResult, type ThresholdContract, TokenCounter, type TokenSpec, TraceEmitter, TraceEvent, TraceStore, Trajectory, TrajectoryStep, type TrialAggregate, type TrialAttempt, TrialCache, TrialTelemetry, type Turn, type TurnMetrics, type TurnResult, UNIVERSAL_FINDERS, type ValidationContext, type ValidationIssue, type ValidationResult, VariantAggregate, VerifyContext, type VisualDiffOptions, type VisualDiffResult, type ViteDeployRunnerInput, type WorkflowTopology, type WorkspaceAssertion, type WorkspaceAssertionResult, type WorkspaceInspector, type WorkspaceSnapshot, type WranglerDeployRunnerInput, adversarialJudge, aggregateRunScore, aggregateTrialsByMode, analyzeAntiSlop, analyzeSeries, attributeCounterfactuals, benjaminiHochberg, bisect, bonferroni, buildReviewerPrompt, byteLengthRange, canaryLeakView, canonicalize, causalAttribution, checkBehavioralCanary, checkCanaries, checkSlos, clamp01, codeExecutionJudge, cohensD, coherenceJudge, collectionPreserved, commitBisect, compareReferenceReplay, compilerJudge, composeValidators, confidenceInterval, containsAll, createAntiSlopJudge, createCompositeMutator, createCustomJudge, createDefaultReviewer, createDomainExpertJudge, createIntentMatchJudge, createSandboxCodeMutator, createSandboxPool, createSemanticConceptJudge, crossTraceDiff, decideReferenceReplayPromotion, decideReferenceReplayRunPromotion, defaultJudges, defaultReferenceReplayMatcher, deployGateLayer, discoverPersonas, distillPlaybook, estimateCost, estimateTokens, evaluateContract, evaluateHypothesis, evaluateOracles, executeScenario, expectAgent, exportRewardModel, extractAssetUrls, extractErrorCount, fileContains, fileExists, findAutoMatchNoExpectation, findConstructorCwdDropped, findFallbackToPass, findLiteralTruePass, findSkipCountsAsPass, flowLayer, formatBenchmarkReport, formatDriverReport, formatFindings, ghCliClient, precision as goldenPrecision, hashContent, hashJson, htmlContainsElement, httpGithubClient, inMemoryReferenceReplayStore, integrationAsi, integrationGateEvals, integrationInvokeFailedPayload, integrationManifestResolvedPayload, integrationManifestValidatedPayload, interRaterReliability, jsonHasKeys, jsonShape, jsonlReferenceReplayStore, keyPreserved, linterJudge, loadScorerFromGrader, localCommandRunner, lowercaseMutator, mannWhitneyU, matchGoldens, mergeLayerResults, mergeSteeringBundle, multiToolchainLayer, normalizeScores, notBlocked, pairedTTest, paraphraseRobustness, paraphraseRobustnessScenarios, partialCredit, passOrthogonality, pixelDeltaRatio, politenessPrefixMutator, printDriverSummary, promptBisect, proposeAutomatedPullRequest, proposeSynthesisTargets, referenceReplayRunsToSteeringRows, referenceReplayScenarioToRunScore, regexMatch, regexMatches, renderMarkdownReport, renderPlaybookMarkdown, renderSteeringText, replayScorerOverCorpus, replayTraceThroughJudge, requiredSampleSize, resetLockedAppendersForTesting, rowCount, rowWhere, runAssertions, runBehavioralCanaries, runCanaries, runCounterfactual, runE2EWorkflow, runExpectations, runHarnessExperiment, runIntentMatchJudge, runJudgeFleet, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runLiveProof, runProductionLoop, runReferenceReplay, runSelfPlay, runSemanticConceptJudge, scanForMuffledGates, scoreContinuity, scoreReferenceReplay, securityJudge, selectHarnessVariant, sentenceReorderMutator, signManifest, statusAdvanced, summarizeHarnessResults, testJudge, textInSnapshot, toLangfuseEnvelope, toPrometheusText, typoMutator, urlContains, verifyManifest, visualDiff, viteDeployRunner, weightedMean, weightedRecall, whitespaceCollapseMutator, wilcoxonSignedRank, withJudgeRetry, wranglerDeployRunner };
+export { ANALYST_SEVERITIES, ActionableSideInfo, type ActiveLearningOptions, type AdapterRun, AgentDriver, type AgentDriverConfig, AgentEvalError, type AggregatorMode, type AlignmentOp, type Analyst, type AnalystContext, type AnalystCost, type AnalystFinding, type AnalystHooks, type AnalystInputKind, AnalystRegistry, type AnalystRegistryOptions, type AnalystRequirements, type AnalystRunInputs, type AnalystRunResult, type AnalystRunSummary, type AnalystSeverity, type AntiSlopConfig, type AntiSlopIssue, type AntiSlopReport, Artifact$1 as Artifact, type ArtifactCheck, type Artifact as ArtifactCheckArtifact, type ArtifactResult, type ArtifactValidator, type AutoPrClient, AxGepaSteeringOptimizer, type AxSteeringOptimizerConfig, BaselineReport, BehaviorAssertion, type BenchmarkReport, BenchmarkRunner, type BenchmarkRunnerConfig, type BisectOptions, type BisectResult, type BisectStep, BudgetBreachError, BudgetGuard, BudgetLedgerEntry, type BudgetPolicy, BudgetSpec, CallExpectation, type CanaryAlert, type CanaryKind, type CanaryLeak, type CanaryOptions, type CanaryReport, type CanarySeverity, type CandidateScenario, type CausalAttributionReport, type ChatCallOpts, type ChatClient, type ChatRequest, type ChatResponse, type ChatTransport, type CheckResult, type CliBridgeTransportOpts, type CodeMutationOutcome, type CodeMutationRunner, type CollectedArtifacts, type CommandRunner, type CompletionCriterion, type CompositePolicy, type ConceptComplexity, type ConceptFinding, type ConceptSpec, type ConceptWeightStrategy, type ContinuityCheck, type ContinuityCheckResult, type ContinuityReport, type ContinuitySnapshotPair, ContinuousAgreement, ContinuousAgreementOptions, type ContractMetric, type ContractReport, ControlEvalResult, ConvergenceTracker, type CorpusAgreementOptions, type CorpusAgreementPerDimension, type CorpusAgreementReport, type CorpusScoreRecord, type CostEntry, CostLedger, type CostLedgerGeneration, type CostLedgerSnapshot, type CostSummary, CostTracker, type CounterfactualContext, type CounterfactualMutation, type CounterfactualResult, type CounterfactualRunner, type CreateChatClientOpts, type CreateCompositeMutatorOpts, type CreateDefaultReviewerOptions, type CreateSandboxCodeMutatorOpts, type CreateSandboxPoolOpts, type CreateTraceAnalystKindOpts, type CrossTraceDiff, type CrossTraceDiffOptions, D1ExperimentStore, type D1ExperimentStoreOptions, type D1Like, type D1PreparedStatementLike, DEFAULT_AGENT_SLOS, DEFAULT_COMPLEXITY_WEIGHTS, DEFAULT_FINDERS, DEFAULT_HARNESS_OBJECTIVES, DEFAULT_MUTATORS, DEFAULT_RUN_SCORE_WEIGHTS, DEFAULT_SEVERITY_WEIGHTS, DEFAULT_TRACE_ANALYST_KINDS, Dataset, DatasetScenario, type DeployFamily, type DeployGateLayerInput, type DeployRunResult, type DeployRunner, type DiffPolicy, type DirEntry, type DirectProviderTransportOpts, type DiscoverPersonasOptions, type DiscoveredPersona, type DriverResult, type DriverState, DualAgentBench, type DualAgentBenchConfig, type DualAgentReport, type DualAgentRound, type DualAgentScenario, type DualAgentScenarioResult, ERROR_COUNT_PATTERNS, type ErrorCountPattern, type EvalResult, type EvidenceRef, type EvolutionRound, EvolvableVariant, type ExecutorConfig, type Expectation, type Experiment, type Run as ExperimentRun, type ExperimentStore, ExperimentTracker, type ExportedRewardModel, type ExtractOptions, type ExtractResult, FAILURE_MODE_KIND_SPEC, type FactorContribution, type FactorialCell, type FailureClusterConfig, FeedbackLabel, type FeedbackPattern, FeedbackTrajectory, FeedbackTrajectoryStore, type FileChange, FileSystemExperimentStore, type FileSystemExperimentStoreOptions, type FindingsDiff, FindingsStore, type FlowAction, type FlowLayerEnv, type FlowLayerFactoryInput, type FlowRunner, type FlowRunnerStepResult, type FlowSpec, type FlowStep, GateDecision, type GhCliClientOptions, type GoldenSeverity, type GoldenSpec, type HarnessAdapter, HarnessConfig, type HarnessExperimentConfig, type HarnessExperimentResult, type HarnessIntervention, type HarnessRunRequest, type HarnessRunResult, type HarnessScenario, type HarnessSelection, type HarnessVariant, type HarnessVariantReport, HeldOutGateConfig, HoldoutAuditor, type HostedJudgeConfig, type HostedJudgeDimension, type HostedJudgeRequest, type HostedJudgeResponse, type HostedRunCriticConfig, type HostedRunScoreRequest, type HostedRunScoreResponse, type HttpGithubClientOptions, type HypothesisManifest, type HypothesisResult, IMPROVEMENT_KIND_SPEC, INTENT_MATCH_JUDGE_VERSION, type ImageData, InMemoryExperimentStore, InMemoryWorkspaceInspector, type InferenceScorer, type InspectorContext, type IntegrationGateSurface, type IntegrationInvokeFailureInput, type IntegrationManifestGateInput, type IntentMatchInput, type IntentMatchOptions, type IntentMatchResult, type InteractionContribution, JsonlTrialCache, type JudgeAdapterOpts, type JudgeConfig, type JudgeFleetOptions, type JudgeFn, type JudgeInput, type JudgeReplayResult, type JudgeRetryOutcome, type JudgeRetryPolicy, type JudgeRubric, JudgeRunner, type JudgeScore, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type KeywordConceptSpec, type KeywordCoverageFinding, type KeywordCoverageOptions, type KeywordCoverageResult, type LangfuseEnvelope, type LangfuseGeneration, type LangfuseScore, Layer, LayerResult, type LineageKind, type LineageKindResolver, type LineageNode, LineageRecorder, type LiveProofArtifact, type LiveProofConfig, type LiveProofContext, type LiveProofResult, LlmCallRequest, LlmCallResult, LlmClientOptions, LlmSpan, LockedJsonlAppender, MODEL_PRICING, type MatchResult, type MatcherResult, type MeasurementPolicy, type MergeOptions, MetricsCollector, type MockTransportOpts, type MuffledFinder, type MuffledFinding, MultiLayerVerifier, MultiShotMutateAdapter, MultiShotOptimizationResult, MultiShotRunner, MultiShotScorer, MultiShotTrialResult, type MultiToolchainLayerConfig, MutateAdapter, type MutationAttempt, type MutationChannel, MutationTelemetry, type Mutator, Mutex, Objective, type Oracle, type OracleObservation, type OracleReport, type OracleResult, type OrthogonalityInput, type OrthogonalityResult, PairwiseSteeringOptimizer, type ParaphraseRobustnessScenarioInput, type ParaphraseRobustnessScenarioResult, ParetoResult, type PersistedFinding, type PersonaConfig, type Playbook, type PlaybookEntry, type PoolSlot, ProductClient, type ProductClientConfig, type ProductionEvolveConfig, type ProductionLoopCronConfig, type ProductionLoopDecision, type ProductionLoopRenderContext, type ProductionLoopResult, type ProductionShipConfig, type PromptHandle, PromptRegistry, TrialResult as PromptTrialResult, type ProposeAutomatedPullRequestInput, type ProposeAutomatedPullRequestResult, RAW_FINDING_SCHEMA_PROMPT, type RawAnalystFinding, RawAnalystFindingSchema, 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 RegistryRunOpts, ReleaseConfidenceScorecard, ReleaseConfidenceThresholds, type RepoRef, type ReviewerMemoryEntry, type ReviewerOutput, type ReviewerPromptInput, type ReviewerSoftFailDefaults, type ReviewerVerificationSummary, type RobustnessResult, type RouteMap, type RouterTransportOpts, type RubricDimension, Run$1 as Run, type RunCommandInput, type RunCommandResult, type RunConfig, RunCritic, type RunCriticAdapterOpts, type RunCriticOptions, type RunDiff, RunFilter, type RunProductionLoopOptions, RunRecord, type RunScore, type RunScoreWeights, RunSplitTag, type RunTrace, SEMANTIC_CONCEPT_JUDGE_VERSION, SandboxDriver, SandboxHarnessResult, type SandboxJudgeKind, type SandboxJudgeResult, type SandboxJudgeSpec, type SandboxPool, type SandboxSdkTransportOpts, type ScanOptions, type Scenario, type ScenarioCost, type ScenarioFile, ScenarioRegistry, type ScenarioResult, type ScoredTarget, type SelfPlayOptions, type SelfPlayProposer, type SelfPlayScorer, type SemanticConceptJudgeAdapterOpts, type SemanticConceptJudgeInput, type SemanticConceptJudgeOptions, type SemanticConceptJudgeResult, type SeriesConvergenceOptions, type SeriesConvergenceResult, Severity, type SignedManifest, type SignedManifestAlgo, type Slo, type SloCheckResult, type SloComparator, type SloReport, type SloSeverity, type SlopCategory, type SlotFactory, Span, type SteeringBundle, type SteeringDelta, type SteeringOptimizationResult, type SteeringOptimizationRow, type SteeringOptimizationSelector, type SteeringOptimizerBackend, type SteeringOptimizerConfig, type SteeringRolePrompt, type StepAttribution, type SynthesisReason, type SynthesisTarget, type TestResult, type ThresholdContract, TokenCounter, type TokenSpec, type TraceAnalystAdapterOpts, type TraceAnalystGolden, type TraceAnalystKindSpec, TraceEmitter, TraceEvent, TraceStore, type TraceToolGroupName, Trajectory, TrajectoryStep, type TrialAggregate, type TrialAttempt, TrialCache, TrialTelemetry, type Turn, type TurnMetrics, type TurnResult, UNIVERSAL_FINDERS, type ValidationContext, type ValidationIssue, type ValidationResult, VariantAggregate, type VerifierAdapterOpts, VerifyContext, VerifyOptions, type VisualDiffOptions, type VisualDiffResult, type ViteDeployRunnerInput, type WorkflowTopology, type WorkspaceAssertion, type WorkspaceAssertionResult, type WorkspaceInspector, type WorkspaceSnapshot, type WranglerDeployRunnerInput, adversarialJudge, aggregateRunScore, aggregateTrialsByMode, analyzeAntiSlop, analyzeSeries, attributeCounterfactuals, benjaminiHochberg, bisect, bonferroni, buildReviewerPrompt, buildTraceToolsForGroup, byteLengthRange, canaryLeakView, canonicalize, causalAttribution, checkBehavioralCanary, checkCanaries, checkSlos, clamp01, codeExecutionJudge, cohensD, coherenceJudge, collectionPreserved, commitBisect, compareReferenceReplay, compilerJudge, composeValidators, computeFindingId, confidenceInterval, containsAll, corpusInterRaterAgreement, corpusInterRaterAgreementFromJudgeScores, createAntiSlopJudge, createChatClient, createCompositeMutator, createCustomJudge, createDefaultReviewer, createDomainExpertJudge, createIntentMatchJudge, createJudgeAdapter, createRunCriticAdapter, createSandboxCodeMutator, createSandboxPool, createSemanticConceptJudge, createSemanticConceptJudgeAdapter, createTraceAnalystAdapter, createTraceAnalystKind, createVerifierAdapter, crossTraceDiff, decideReferenceReplayPromotion, decideReferenceReplayRunPromotion, defaultIsMaterial, defaultJudges, defaultReferenceReplayMatcher, deployGateLayer, diffFindings, discoverPersonas, distillPlaybook, estimateCost, estimateTokens, evaluateContract, evaluateHypothesis, evaluateOracles, executeScenario, expectAgent, exportRewardModel, extractAssetUrls, extractErrorCount, fileContains, fileExists, findAutoMatchNoExpectation, findConstructorCwdDropped, findFallbackToPass, findLiteralTruePass, findSkipCountsAsPass, flowLayer, formatBenchmarkReport, formatDriverReport, formatFindings, ghCliClient, precision as goldenPrecision, hashContent, hashJson, htmlContainsElement, httpGithubClient, inMemoryReferenceReplayStore, integrationAsi, integrationGateEvals, integrationInvokeFailedPayload, integrationManifestResolvedPayload, integrationManifestValidatedPayload, interRaterReliability, jsonHasKeys, jsonShape, jsonlReferenceReplayStore, keyPreserved, liftSeverity, linterJudge, loadScorerFromGrader, localCommandRunner, lowercaseMutator, makeFinding, mannWhitneyU, matchGoldens, mergeLayerResults, mergeSteeringBundle, multiToolchainLayer, normalizeScores, notBlocked, pairedTTest, paraphraseRobustness, paraphraseRobustnessScenarios, parseRawFinding, partialCredit, passOrthogonality, pixelDeltaRatio, politenessPrefixMutator, printDriverSummary, promptBisect, proposeAutomatedPullRequest, proposeSynthesisTargets, referenceReplayRunsToSteeringRows, referenceReplayScenarioToRunScore, regexMatch, regexMatches, renderMarkdownReport, renderPlaybookMarkdown, renderSteeringText, replayScorerOverCorpus, replayTraceThroughJudge, requiredSampleSize, resetLockedAppendersForTesting, rowCount, rowWhere, runAssertions, runBehavioralCanaries, runCanaries, runCounterfactual, runE2EWorkflow, runExpectations, runHarnessExperiment, runIntentMatchJudge, runJudgeFleet, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runLiveProof, runProductionLoop, runReferenceReplay, runSelfPlay, runSemanticConceptJudge, scanForMuffledGates, scoreContinuity, scoreReferenceReplay, securityJudge, selectHarnessVariant, sentenceReorderMutator, signManifest, statusAdvanced, summarizeHarnessResults, testJudge, textInSnapshot, toLangfuseEnvelope, toPrometheusText, typoMutator, urlContains, verifyManifest, visualDiff, viteDeployRunner, weightedMean, weightedRecall, whitespaceCollapseMutator, wilcoxonSignedRank, withJudgeRetry, wranglerDeployRunner };