@tangle-network/agent-eval 0.137.0 → 0.139.0

package/dist/analyst/index.d.ts

@@ -1,12 +1,14 @@
 import { a as MultiLayerVerifier, l as VerifyOptions, o as Severity } from "../multi-layer-verifier-BHY1gWAc.js";
-import { A as parseFindingSubject, B as SemanticConceptJudgeInput, C as FINDING_SUBJECT_KINDS, D as FindingSubjectStringSchema, E as FindingSubjectKind, G as RunCritic, M as CreateAnalystAiConfig, N as createAnalystAi, O as KIND_EXPECTED_SUBJECTS, S as FINDING_SUBJECT_GRAMMAR_PROMPT, T as FindingSubject, V as SemanticConceptJudgeOptions, _ as FindingsDiff, a as SkillUsageScanConfig, b as defaultIsMaterial, c as DEFAULT_TRACE_ANALYST_KINDS, d as IMPROVEMENT_KIND_SPEC, f as FAILURE_MODE_KIND_SPEC, g as DiffPolicy, h as emitControlIntegrityFindings, i as SkillUsageReport, j as renderFindingSubject, k as findingSubjectGrammarPromptFor, l as KNOWLEDGE_POISONING_KIND_SPEC, m as ControlIntegrityAnalyst, n as SkillUsageAnalyst, o as buildSkillUsageReport, p as CONTROL_INTEGRITY_ANALYST, q as RunTrace, r as SkillUsageRecord, s as emitSkillUsageFindings, t as SKILL_USAGE_ANALYST, u as KNOWLEDGE_GAP_KIND_SPEC, v as FindingsStore, w as FINDING_SUBJECT_SYNTAX, x as diffFindings, y as PersistedFinding } from "../skill-usage-CFDLLlhF.js";
-import { c as CostLedgerHandle } from "../cost-ledger-D2o6JOrL.js";
-import { A as ChatClient, B as SandboxSdkTransportOpts, F as CreateChatClientOpts, I as CustomTransportOpts, L as DirectProviderTransportOpts, M as ChatResponse, N as ChatTransport, P as CliBridgeTransportOpts, R as MockTransportOpts, V as createChatClient, j as ChatRequest, k as ChatCallOpts, m as JudgeInput, p as JudgeFn, q as LlmClientOptions, z as RouterTransportOpts } from "../types-CTvKfr5F.js";
-import { _ as makeFinding, a as AnalystInputKind, c as AnalystRunInputs, d as AnalystSeverity, f as AnalystUsageReceipt, g as computeFindingId, h as ProposalFindingOrigin, i as AnalystFinding, l as AnalystRunResult, m as ProposalFinding, n as AnalystContext, o as AnalystRequirements, p as EvidenceRef, r as AnalystCost, s as AnalystRunEvent, t as Analyst, u as AnalystRunSummary, v as makeProposalFinding, x as TraceAnalysisStore } from "../types-CKswbJGO.js";
-import { _ as behavioralAnalyst, a as createTraceAnalystKind, c as ANALYST_SEVERITIES, d as RawAnalystEvidenceSchema, f as RawAnalystFinding, g as BehavioralAnalystOptions, h as parseRawFinding, i as TraceAnalystKindSpec, l as RAW_FINDING_SCHEMA_PROMPT, m as evidenceRefsFromRawFinding, n as buildDefaultAnalystRegistry, o as renderPriorFindings, p as RawAnalystFindingSchema, r as CreateTraceAnalystKindOpts, s as renderUpstreamFindings, t as DefaultAnalystRegistryOptions, u as RawAnalystEvidence, v as deriveEfficiencyFindings } from "../default-registry-Dc5D_Loc.js";
-import { a as RegistryRunOpts, i as BudgetPolicy, n as AnalystRegistry, r as AnalystRegistryOptions, t as AnalystHooks } from "../registry-BdM7SuTr.js";
-import { _ as RunAnalystBenchmarkOptions, a as AnalystBenchmarkOutput, b as scoreAnalystFindings, c as AnalystBenchmarkRunner, d as AnalystEvidenceResolution, f as AnalystEvidenceResolutionError, g as AnalystLatencyDistribution, h as AnalystIssueExpectation, i as AnalystBenchmarkObservation, l as AnalystBenchmarkSummary, m as AnalystFindingScore, n as AnalystBenchmarkDatasetRef, o as AnalystBenchmarkProvenance, p as AnalystEvidenceResolver, r as AnalystBenchmarkDescriptor, s as AnalystBenchmarkResult, t as AnalystBenchmarkCase, u as AnalystEvidenceExpectation, v as registryBenchmarkRunner, x as traceStoreEvidenceResolver, y as runAnalystBenchmark } from "../benchmark-CHX4orG7.js";
-import { AxFunction } from "@ax-llm/ax";
+import { A as parseFindingSubject, C as FINDING_SUBJECT_KINDS, D as FindingSubjectStringSchema, E as FindingSubjectKind, F as DefineExactCustomAnalystOptions, G as SemanticConceptJudgeOptions, I as defineCustomAnalyst, L as defineTraceAnalyst, M as DspyRlmTraceEngineOptions, N as createDspyRlmTraceEngine, O as KIND_EXPECTED_SUBJECTS, P as DefineCustomAnalystOptions, S as FINDING_SUBJECT_GRAMMAR_PROMPT, T as FindingSubject, W as SemanticConceptJudgeInput, Y as RunCritic, Z as RunTrace, _ as FindingsDiff, a as SkillUsageScanConfig, b as defaultIsMaterial, c as DEFAULT_TRACE_ANALYST_KINDS, d as IMPROVEMENT_KIND_SPEC, f as FAILURE_MODE_KIND_SPEC, g as DiffPolicy, h as emitControlIntegrityFindings, i as SkillUsageReport, j as renderFindingSubject, k as findingSubjectGrammarPromptFor, l as KNOWLEDGE_POISONING_KIND_SPEC, m as ControlIntegrityAnalyst, n as SkillUsageAnalyst, o as buildSkillUsageReport, p as CONTROL_INTEGRITY_ANALYST, r as SkillUsageRecord, s as emitSkillUsageFindings, t as SKILL_USAGE_ANALYST, u as KNOWLEDGE_GAP_KIND_SPEC, v as FindingsStore, w as FINDING_SUBJECT_SYNTAX, x as diffFindings, y as PersistedFinding } from "../skill-usage-B-BFS8M2.js";
+import { b as CustomTokenPricing, c as CostLedgerHandle } from "../cost-ledger-DKgyIWRj.js";
+import { A as ChatClient, B as SandboxSdkTransportOpts, F as CreateChatClientOpts, I as CustomTransportOpts, L as DirectProviderTransportOpts, M as ChatResponse, N as ChatTransport, P as CliBridgeTransportOpts, R as MockTransportOpts, V as createChatClient, j as ChatRequest, k as ChatCallOpts, m as JudgeInput, p as JudgeFn, z as RouterTransportOpts } from "../types-uPrS6mD-.js";
+import { _ as makeFinding, a as AnalystInputKind, c as AnalystRunInputs, d as AnalystSeverity, f as AnalystUsageReceipt, g as computeFindingId, h as ProposalFindingOrigin, i as AnalystFinding, l as AnalystRunResult, m as ProposalFinding, n as AnalystContext, o as AnalystRequirements, p as EvidenceRef, r as AnalystCost, s as AnalystRunEvent, t as Analyst, u as AnalystRunSummary, v as makeProposalFinding } from "../types-DoEYskCd.js";
+import { a as createTraceAnalyst, c as runTraceAnalyst, d as deriveEfficiencyFindings, i as TraceAnalystDefinition, l as BehavioralAnalystOptions, n as buildDefaultAnalystRegistry, o as renderPriorFindings, r as CreateTraceAnalystOptions, s as renderUpstreamFindings, t as DefaultAnalystRegistryOptions, u as behavioralAnalyst } from "../default-registry-B8vf7Rmf.js";
+import { a as ExactAnalystRunPolicySnapshot, c as ExactAnalystSnapshot, d as ExactExecutionComponentSnapshot, i as ExactAnalystRunEvent, l as ExactCapableAnalyst, n as ExactAnalystExecutionPlanSnapshot, o as ExactAnalystRunResult, r as ExactAnalystRunCompletion, s as ExactAnalystRunSummary, t as ExactAnalystBudgetSnapshot, u as ExactExecutionComponentIdentity } from "../exact-types-MaaFcllV.js";
+import { A as ExactAnalystRunExecutionError, D as AnalystRegistryOptions, E as AnalystRegistry, M as RegistryRunOpts, N as assertExactRegistryRunOpts, O as BudgetPolicy, T as AnalystHooks, j as ExactRegistryRunOpts, k as ExactAnalystBudgetPolicy } from "../completion-verifier-IPoP4fQO.js";
+import { C as scoreAnalystFindings, S as traceStoreEvidenceResolver, _ as AnalystIssueExpectation, a as AnalystBenchmarkLabelState, b as registryBenchmarkRunner, c as AnalystBenchmarkProvenance, d as AnalystBenchmarkSummary, f as AnalystEvidenceExpectation, g as AnalystFindingScore, h as AnalystEvidenceResolver, i as AnalystBenchmarkError, l as AnalystBenchmarkResult, m as AnalystEvidenceResolutionError, n as AnalystBenchmarkDatasetRef, o as AnalystBenchmarkObservation, p as AnalystEvidenceResolution, r as AnalystBenchmarkDescriptor, s as AnalystBenchmarkOutput, t as AnalystBenchmarkCase, u as AnalystBenchmarkRunner, v as AnalystLatencyDistribution, x as runAnalystBenchmark, y as RunAnalystBenchmarkOptions } from "../benchmark-DDVdWcwA.js";
+import { r as ExternalOptimizerRunnerCommand } from "../external-optimizer-contracts-BrxY2Sli.js";
+import { a as TraceAnalysisEngineRequest, c as resolveTraceAnalystLimits, d as RawAnalystEvidence, f as RawAnalystEvidenceSchema, g as parseRawFinding, h as evidenceRefsFromRawFinding, i as TraceAnalysisEngine, l as ANALYST_SEVERITIES, m as RawAnalystFindingSchema, n as buildTraceToolsForGroup, o as TraceAnalysisEngineResult, p as RawAnalystFinding, r as DEFAULT_TRACE_ANALYST_LIMITS, s as TraceAnalystLimits, t as TraceToolGroupName, u as RAW_FINDING_SCHEMA_PROMPT } from "../tool-groups-CdYq22lX.js";
 //#region src/analyst/adapters.d.ts
 declare function liftSeverity(s: Severity): AnalystSeverity;
 interface VerifierAdapterOpts<Env> {
@@ -50,36 +52,40 @@ interface SemanticConceptJudgeAdapterOpts {
 }
 declare function createSemanticConceptJudgeAdapter(opts?: SemanticConceptJudgeAdapterOpts): Analyst<SemanticConceptJudgeInput>;
 //#endregion
-//#region src/analyst/benchmark-comparison.d.ts
-type AnalystComparisonMetric = 'completion' | 'issueRecall' | 'findingPrecision' | 'f1' | 'criticalStepAccuracy' | 'citationCoverage' | 'citationLabelAgreement' | 'citationResolution' | 'cleanAccuracy' | 'latencyMs' | 'calls' | 'inputTokens' | 'outputTokens' | 'reasoningTokens' | 'cachedTokens' | 'cacheWriteTokens' | 'costUsd';
-interface AnalystMetricComparison {
-  metric: AnalystComparisonMetric;
-  direction: 'higher' | 'lower';
-  pairedCases: number;
-  pairedObservations: number;
-  baselineMean: number;
-  candidateMean: number;
-  meanDelta: number;
-  intervalLow: number;
-  intervalHigh: number;
-  confidence: number;
-  resamples: number;
-  enoughCasesForInference: boolean;
+//#region src/analyst/benchmark-agentrx-calibration.d.ts
+declare const AGENT_RX_UPSTREAM_REVISION = "f228165bfec60a801fd5fedd9d8ffe0f9de0c69d";
+interface AgentRxCalibrationRunnerSummary {
+  runnerId: string;
+  selectedRuns: number;
+  completedRuns: number;
+  failedRuns: number;
+  predictedRuns: number;
+  missingPredictionRuns: number;
+  exactStepAccuracy: number | null;
+  stepAccuracyWithin1: number | null;
+  stepAccuracyWithin2: number | null;
+  stepAccuracyWithin3: number | null;
+  stepAccuracyWithin4: number | null;
+  stepAccuracyWithin5: number | null;
+  meanStepDistance: number | null;
+  normalizedMeanStepDistance: number | null;
+  normalizedDistanceRuns: number;
+  normalizedDistanceUnknownRuns: number;
+  rootCauseCategoryAccuracy: number | null;
+  anyFailureCategoryAccuracy: number | null;
+  earliestFailureCategoryAccuracy: number | null;
+  terminalFailureCategoryAccuracy: number | null;
 }
-interface AnalystRunnerComparison {
-  baselineRunnerId: string;
-  candidateRunnerId: string;
-  metrics: AnalystMetricComparison[];
+interface AgentRxCalibrationSummary {
+  protocol: 'official-agentrx-root-cause';
+  upstreamRevision: string;
+  rationale: string;
+  runners: AgentRxCalibrationRunnerSummary[];
 }
-declare function compareAnalystRunners(result: AnalystBenchmarkResult, options: {
-  baselineRunnerId: string;
-  candidateRunnerId: string;
-  confidence?: number;
-  resamples?: number;
-  seed?: number;
-}): AnalystRunnerComparison;
+declare function summarizeAgentRxCalibration(result: AnalystBenchmarkResult, upstreamRevision: string): AgentRxCalibrationSummary;
+declare function renderAgentRxCalibrationMarkdown(summary: AgentRxCalibrationSummary): string;
 //#endregion
-//#region src/analyst/benchmark-datasets.d.ts
+//#region src/analyst/benchmark-dataset-types.d.ts
 type ExternalId = string | number;
 interface AgentRxFailure {
   failure_id: ExternalId;
@@ -123,11 +129,31 @@ interface CodeTraceStageAnnotation {
   unuseful_step_ids?: readonly number[];
   reasoning?: string;
 }
+interface CodeTracerStepLabel {
+  step_id: number;
+  stage?: string | number;
+  stage_name?: string | number;
+  stage_id?: string | number;
+  label: 'incorrect' | 'unuseful';
+  rationale?: string;
+  reason?: string;
+  note?: string;
+  comment?: string;
+}
+interface CodeTracerLabelGroup {
+  stage?: string | number;
+  stage_name?: string | number;
+  stage_id?: string | number;
+  labels: readonly CodeTracerStepLabel[];
+}
+type CodeTracerPredictions = string | readonly CodeTraceStageAnnotation[] | readonly CodeTracerStepLabel[] | readonly CodeTracerLabelGroup[];
 interface CodeTraceBenchRow {
   traj_id: string;
   agent: string;
   model: string;
   task_name: string;
+  /** Native artifact extraction path in the public CodeTraceBench manifest. */
+  source_relpath?: string;
   difficulty?: string;
   category?: string;
   tags?: string | readonly string[];
@@ -160,30 +186,438 @@ interface UpstreamPredictionAdapterOptions extends StepLabelAdapterOptions {
   stepCount?: number;
 }
 interface CodeTracerPredictionAdapterOptions extends UpstreamPredictionAdapterOptions, CodeTraceBenchLabelOptions {}
+//#endregion
+//#region src/analyst/benchmark-dataset-agentrx.d.ts
 declare function agentRxBenchmarkCase<TInput>(row: AgentRxRow, input: TInput, options?: AgentRxBenchmarkCaseOptions): AnalystBenchmarkCase<TInput>;
-declare function codeTraceBenchCase<TInput>(row: CodeTraceBenchRow, input: TInput, options?: CodeTraceBenchCaseOptions): AnalystBenchmarkCase<TInput>;
 /** Translate AgentRx `Report.to_dict()` output or its `failures` array into findings. */
 declare function agentRxPredictionsToFindings(trajectoryIdValue: ExternalId, output: unknown, options?: UpstreamPredictionAdapterOptions): AnalystFinding[];
+declare function normalizeAgentRxCategory(value: string): string;
+/** Match Python's round() behavior used by AgentRx for consensus steps. */
+declare function roundAgentRxStep(value: number): number;
+//#endregion
+//#region src/analyst/benchmark-dataset-codetrace.d.ts
+declare function codeTraceBenchCase<TInput>(row: CodeTraceBenchRow, input: TInput, options?: CodeTraceBenchCaseOptions): AnalystBenchmarkCase<TInput>;
 /** Translate CodeTracer's `codetracer_labels.json` into shared findings. */
-declare function codeTracerPredictionsToFindings(trajectoryIdValue: string, predictions: string | readonly CodeTraceStageAnnotation[], options?: CodeTracerPredictionAdapterOptions): AnalystFinding[];
+declare function codeTracerPredictionsToFindings(trajectoryIdValue: string, predictions: CodeTracerPredictions, options?: CodeTracerPredictionAdapterOptions): AnalystFinding[];
+//#endregion
+//#region src/analyst/benchmark-dataset-utils.d.ts
 declare function normalizeBenchmarkLabel(value: string): string;
-declare function normalizeAgentRxCategory(value: string): string;
+//#endregion
+//#region src/analyst/benchmark-verification-outcome.d.ts
+type VerificationOutcomeStatus = 'passed' | 'failed' | 'unavailable';
+interface VerificationOutcomeSource {
+  path: string;
+  format: 'terminal-bench' | 'swe-bench' | 'swe-multi';
+  status: VerificationOutcomeStatus;
+}
+interface VerificationOutcome {
+  status: VerificationOutcomeStatus;
+  reason?: 'missing-result' | 'result-output-unavailable' | 'result-parse-error' | 'result-label-disagreement';
+  parseError?: {
+    class: string;
+    message: string;
+  };
+  sources: VerificationOutcomeSource[];
+  passedCheckCount: number;
+  failedCheckCount: number;
+  passedChecks: string[];
+  failedChecks: string[];
+}
+interface VerificationResultFile {
+  relativePath: string;
+  content: string;
+}
+declare function parseVerificationOutcome(files: readonly VerificationResultFile[]): VerificationOutcome;
+//#endregion
+//#region src/analyst/benchmark-verification-artifacts.d.ts
+declare const DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES: number;
+type VerificationArtifactRole = 'final-test-output' | 'final-result' | 'final-metrics';
+interface VerificationArtifactFile {
+  role: VerificationArtifactRole;
+  path: string;
+  relativePath: string;
+  sha256: string;
+  bytes: number;
+  spanId: string;
+}
+interface VerificationArtifactManifest {
+  traceId: string;
+  status: 'present' | 'missing';
+  outcome: VerificationOutcome;
+  outcomeSpanId: string;
+  caseDirectory: string;
+  caseDirectoriesSearched: string[];
+  totalBytes: number;
+  maxBytes: number;
+  files: VerificationArtifactFile[];
+  missingRoles: VerificationArtifactRole[];
+  searched: Record<VerificationArtifactRole, string[]>;
+}
+interface LoadedVerificationArtifacts {
+  manifest: VerificationArtifactManifest;
+  outcome: VerificationOutcome;
+  files: Array<VerificationArtifactFile & {
+    content: string;
+  }>;
+}
+declare function loadCodeTraceVerificationArtifacts(options: {
+  artifactDir: string;
+  row: CodeTraceBenchRow;
+  maxBytes?: number;
+}): Promise<LoadedVerificationArtifacts>;
+declare function appendVerificationArtifactsToOtlp(otlpText: string, traceId: string, artifacts: LoadedVerificationArtifacts, afterTimestamp: string): string;
+//#endregion
+//#region src/analyst/benchmark-public-types.d.ts
+type PublicAnalystBenchmarkDataset = 'agentrx' | 'codetracebench';
+interface PublicAnalystBenchmarkModelConfig {
+  baseUrl: string;
+  apiKey: string;
+  model: string;
+  maxOutputTokens: number;
+  timeoutMs: number;
+  /** Required when the model is absent from agent-eval's pricing table. */
+  pricing?: CustomTokenPricing;
+  /** Independent per-case recursive-engine spend limit. Default: 1 USD. */
+  maxCostUsdPerAnalysis?: number;
+  dspyRlm?: {
+    runner?: ExternalOptimizerRunnerCommand;
+    maxIterations?: number;
+    maxLlmCalls?: number;
+    maxToolCalls?: number;
+    maxOutputChars?: number;
+  };
+  costLedger?: CostLedgerHandle;
+  durability?: {
+    runIdentitySha256: string;
+    responseCacheDir: string;
+  };
+  /** Test-only transport injection. */
+  fetchImpl?: typeof fetch;
+}
+interface PreparedPublicAnalystBenchmark {
+  cases: AnalystBenchmarkCase<AnalystRunInputs>[];
+  sourceRowCount: number;
+  selectedCaseIds: string[];
+  labelsSha256: string;
+  traceFiles: Array<{
+    traceId: string;
+    relativePath: string;
+    sha256: string;
+  }>;
+  verificationArtifacts: VerificationArtifactManifest[];
+  selection: PublicBenchmarkSelectionReport;
+}
+interface PublicBenchmarkValueDistribution {
+  total: number;
+  missing: number;
+  counts: Record<string, number>;
+}
+interface PublicBenchmarkDistributions {
+  class: PublicBenchmarkValueDistribution;
+  agent: PublicBenchmarkValueDistribution;
+  model: PublicBenchmarkValueDistribution;
+  difficulty: PublicBenchmarkValueDistribution;
+  solved: PublicBenchmarkValueDistribution;
+}
+interface PublicBenchmarkSelectionReport {
+  method: 'census' | 'deterministic-hash';
+  seed: number;
+  sourceCount: number;
+  selectedCount: number;
+  stratified: false;
+  representativeOfInput: boolean;
+  source: PublicBenchmarkDistributions;
+  selected: PublicBenchmarkDistributions;
+}
+//#endregion
+//#region src/analyst/benchmark-public-adapters.d.ts
+declare function emptyPublicBenchmarkRunner(): AnalystBenchmarkRunner<AnalystRunInputs>;
+declare function adaptPublicBenchmarkFindings(dataset: PublicAnalystBenchmarkDataset, trajectoryId: string, findings: readonly AnalystFinding[], analystId: string): AnalystFinding[];
+//#endregion
+//#region src/analyst/benchmark-public-data.d.ts
+declare function loadPublicBenchmarkRows(path: string): Promise<Array<Record<string, unknown>>>;
+declare function selectPublicBenchmarkRows(dataset: PublicAnalystBenchmarkDataset, rows: readonly Record<string, unknown>[], options: {
+  limit: number;
+  seed: number;
+}): Array<Record<string, unknown>>;
+declare function publicBenchmarkDistributions(dataset: PublicAnalystBenchmarkDataset, rows: readonly Record<string, unknown>[]): PublicBenchmarkDistributions;
+declare function publicBenchmarkSelectionReport(dataset: PublicAnalystBenchmarkDataset, source: readonly Record<string, unknown>[], selected: readonly Record<string, unknown>[], seed: number): PublicBenchmarkSelectionReport;
+declare function preparePublicAnalystBenchmark(options: {
+  dataset: PublicAnalystBenchmarkDataset;
+  labelsPath: string;
+  traceDir: string;
+  artifactDir?: string;
+  maxArtifactBytes?: number;
+  limit: number;
+  seed: number;
+}): Promise<PreparedPublicAnalystBenchmark>;
+//#endregion
+//#region src/analyst/benchmark-public-model.d.ts
+/** One-shot JSON baseline. This is not a recursive trace analyst. */
+declare function createPublicBenchmarkDirectRunner(dataset: PublicAnalystBenchmarkDataset, config: PublicAnalystBenchmarkModelConfig): AnalystBenchmarkRunner<AnalystRunInputs>;
+declare function publicBenchmarkProtocolSha256(dataset: PublicAnalystBenchmarkDataset): string;
+declare const CODE_TRACE_BENCH_ANALYST_PROMPT = "Analyze exactly one coding-agent trajectory and its attached final verification.\nYour task is the CodeTraceBench incorrect-step task: identify every wrong state-changing action, bad hypothesis that drives an action, and regression.\nAn incorrect step remains incorrect when the agent later recovers or the final verification passes.\nInspect the complete supplied trace data.\nUse the final-verification outcome as evidence about the final state, not as a rule for whether earlier steps were incorrect.\nFor each candidate, inspect the assistant action and its following observation.\nLabel a failed command when the assistant caused it through a wrong action or unsupported hypothesis.\nLabel the later corrective action only when that action is itself wrong.\nDo not label a diagnostic probe merely because it exposes an earlier defect.\nDo not label a redundant but correct read or search; CodeTraceBench scores unuseful steps separately, and this run scores incorrect steps only.\nDo not label a step solely because final verification failed.\nWhen final verification is unavailable, use only directly observed trajectory evidence.\nEmit one finding per incorrect assistant step.\nEach finding's step MUST be the positive integer n from an existing assistant LLM span named step-<n>.\nNever select an EVALUATOR, TOOL, CHAIN, final-verification, benchmark-verification, or message-<n> span.\nBefore emitting a finding, inspect its candidate span's attributes.content and describe only the action shown there.\nWhen the trajectory has no incorrect steps, return an empty findings array.";
+//#endregion
+//#region src/analyst/benchmark-public-rlm.d.ts
+/** Public benchmark candidate that runs the actual recursive trace analyst. */
+declare function createPublicBenchmarkRlmRunner(dataset: PublicAnalystBenchmarkDataset, config: PublicAnalystBenchmarkModelConfig): AnalystBenchmarkRunner<AnalystRunInputs>;
+//#endregion
+//#region src/analyst/benchmark-comparison.d.ts
+type AnalystComparisonMetric = 'completion' | 'issueRecall' | 'findingPrecision' | 'f1' | 'criticalStepAccuracy' | 'citationCoverage' | 'citationExcerptCoverage' | 'citationLabelAgreement' | 'citationResolution' | 'trustedNegativeAccuracy' | 'latencyMs' | 'calls' | 'inputTokens' | 'outputTokens' | 'reasoningTokens' | 'cachedTokens' | 'cacheWriteTokens' | 'costUsd';
+interface AnalystMetricComparison {
+  metric: AnalystComparisonMetric;
+  direction: 'higher' | 'lower';
+  /** Trajectories with at least one complete pair for this metric. */
+  pairedCases: number;
+  /** Independent task or incident groups resampled by the interval. */
+  pairedClusters: number;
+  /** Same-run pairs where this metric applies before missing values are removed. */
+  eligibleObservations: number;
+  pairedObservations: number;
+  baselineMissingObservations: number;
+  candidateMissingObservations: number;
+  asymmetricMissingObservations: number;
+  survivorOnly: boolean;
+  baselineMean: number | null;
+  candidateMean: number | null;
+  meanDelta: number | null;
+  intervalLow: number | null;
+  intervalHigh: number | null;
+  confidence: number;
+  resamples: number;
+  minimumSampleMet: boolean;
+  populationInferenceEligible: boolean;
+  inferenceLimitations: string[];
+}
+interface AnalystRunnerComparison {
+  baselineRunnerId: string;
+  candidateRunnerId: string;
+  metrics: AnalystMetricComparison[];
+}
+declare function compareAnalystRunners(result: AnalystBenchmarkResult, options: {
+  baselineRunnerId: string;
+  candidateRunnerId: string;
+  confidence?: number;
+  resamples?: number;
+  seed?: number;
+}): AnalystRunnerComparison;
+//#endregion
+//#region src/analyst/benchmark-public-calibration.d.ts
+interface CodeTraceCalibrationRunnerSummary {
+  runnerId: string;
+  selectedRuns: number;
+  positiveRuns: number;
+  trustedNegativeRuns: number;
+  unlabeledRuns: number;
+  failedLabelEmptyRuns: number;
+  unknownLabelEmptyRuns: number;
+  completedRuns: number;
+  failedRuns: number;
+  expectedIncorrectSteps: number;
+  predictedIncorrectSteps: number;
+  matchedIncorrectSteps: number;
+  /** CodeTraceBench's published mean per-row incorrect-step F1 over every row. */
+  officialAllRowF1: number | null;
+  officialAllRowRuns: number;
+  precision: number | null;
+  recall: number | null;
+  f1: number | null;
+  trustedNegativeFalsePositiveRate: number | null;
+  trustedNegativeFailureRate: number | null;
+  unlabeledPredictionRate: number | null;
+  unlabeledFailureRate: number | null;
+}
+interface CodeTraceCalibrationSummary {
+  protocol: 'labeled-positive-and-solved-negative';
+  rationale: string;
+  runners: CodeTraceCalibrationRunnerSummary[];
+}
+declare function summarizeCodeTraceCalibration(result: AnalystBenchmarkResult): CodeTraceCalibrationSummary;
+declare function renderCodeTraceCalibrationMarkdown(summary: CodeTraceCalibrationSummary): string;
+//#endregion
+//#region src/analyst/benchmark-command-artifact.d.ts
+interface AnalystBenchmarkArtifact {
+  kind: 'agent-eval/analyst-benchmark-result';
+  runIdentitySha256: string;
+  inputs: {
+    dataset: PublicAnalystBenchmarkDataset;
+    datasetRevision: string;
+    datasetSplit: string;
+    labelsSha256: string;
+    sourceRowCount: number;
+    traceFiles: Array<{
+      traceId: string;
+      relativePath: string;
+      sha256: string;
+    }>;
+    verificationArtifacts: VerificationArtifactManifest[];
+    verificationAvailability: VerificationAvailabilitySummary;
+    selection: {
+      limit: number;
+      seed: number;
+      selectedCaseIds: string[];
+      report: PublicBenchmarkSelectionReport;
+    };
+    execution: {
+      repetitions: number;
+      concurrency: number;
+      model: string;
+      maxOutputTokens: number;
+      timeoutMs: number;
+      maxCostUsd: number;
+      maxArtifactBytes: number;
+      analystProtocolSha256: string;
+      implementationSha256: string;
+      dependencyLockSha256: string;
+    };
+  };
+  result: AnalystBenchmarkResult;
+  comparisons: AnalystRunnerComparison[];
+  codeTraceCalibration?: CodeTraceCalibrationSummary;
+  agentRxCalibration?: AgentRxCalibrationSummary;
+}
+interface VerificationAvailabilitySummary {
+  cases: number;
+  resultFilesPresent: number;
+  resultFilesMissing: number;
+  outcomes: {
+    passed: number;
+    failed: number;
+    unavailable: number;
+  };
+}
+interface AnalystBenchmarkRunIdentity {
+  config: {
+    dataset: PublicAnalystBenchmarkDataset;
+    datasetRevision: string;
+    datasetSplit: string;
+    model: {
+      id: string;
+      maxOutputTokens: number;
+      timeoutMs: number;
+    };
+    limit: number;
+    seed: number;
+    concurrency: number;
+    repetitions: number;
+    maxCostUsd: number;
+    maxArtifactBytes: number;
+    analystProtocolSha256: string;
+    implementationSha256: string;
+    dependencyLockSha256: string;
+    runnerIds: readonly ['empty', 'dspy-rlm'];
+  };
+  inputs: {
+    labelsSha256: string;
+    sourceRowCount: number;
+    selectedCaseIds: string[];
+    traceFiles: Array<{
+      traceId: string;
+      relativePath: string;
+      sha256: string;
+    }>;
+    verificationArtifactsSha256: string;
+    caseDefinitionsSha256: string;
+  };
+}
+interface AnalystBenchmarkRunManifest {
+  kind: 'agent-eval/analyst-benchmark-run';
+  createdAt: string;
+  identitySha256: string;
+  localIdentitySha256: string;
+  identity: AnalystBenchmarkRunIdentity;
+}
+interface AnalystBenchmarkLocalRunReceipt {
+  kind: 'agent-eval/analyst-benchmark-local-run';
+  runIdentitySha256: string;
+  localIdentitySha256: string;
+  local: {
+    labelsPath: string;
+    traceDir: string;
+    artifactDir?: string;
+    outputDir: string;
+    baseUrl: string;
+    apiKeyEnvironment: string;
+  };
+  command: string;
+  environment: {
+    node: string;
+    platform: string;
+    arch: string;
+  };
+  files: {
+    manifest: string;
+    observations: string;
+    costLedger: string;
+    modelResponses: string;
+    result: string;
+    report: string;
+  };
+}
+interface AnalystBenchmarkProgressRow {
+  sequence: number;
+  runIdentitySha256: string;
+  previousRowSha256: string | null;
+  observation: AnalystBenchmarkObservation;
+  rowSha256: string;
+}
+declare const ANALYST_BENCHMARK_MANIFEST_FILE = "manifest.json";
+declare const ANALYST_BENCHMARK_OBSERVATIONS_FILE = "observations.jsonl";
+declare const ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE = "run.local.json";
+declare const ANALYST_BENCHMARK_COST_LEDGER_FILE = "cost-ledger.jsonl";
+//#endregion
+//#region src/analyst/benchmark-command-result.d.ts
+declare function readAnalystBenchmarkArtifact(path: string): Promise<AnalystBenchmarkArtifact>;
+//#endregion
+//#region src/analyst/benchmark-command.d.ts
+interface AnalystBenchmarkCommandDependencies {
+  createAnalystRunner?: (dataset: PublicAnalystBenchmarkDataset, config: PublicAnalystBenchmarkModelConfig) => AnalystBenchmarkRunner<AnalystRunInputs>;
+}
+interface AnalystBenchmarkCommandConfig {
+  dataset: PublicAnalystBenchmarkDataset;
+  labelsPath: string;
+  traceDir: string;
+  artifactDir?: string;
+  outDir: string;
+  revision: string;
+  split: string;
+  model: PublicAnalystBenchmarkModelConfig;
+  limit: number;
+  seed: number;
+  concurrency: number;
+  repetitions: number;
+  maxCostUsd: number;
+  maxArtifactBytes: number;
+  apiKeyEnv: string;
+  command: string;
+  resume: boolean;
+}
+declare function runAnalystBenchmarkCommand(argv: readonly string[], env?: NodeJS.ProcessEnv, dependencies?: AnalystBenchmarkCommandDependencies): Promise<number>;
+declare const ANALYST_BENCHMARK_HELP = "agent-eval analyst-benchmark\n\nRun the recursive DSPy trace analyst against public AgentRx or CodeTraceBench labels.\n\nRequired:\n  --dataset agentrx|codetracebench\n  --labels <dataset.json|dataset.jsonl>\n  --trace-dir <one-trace-per-file OTLP JSONL directory>\n  --artifact-dir <extracted artifact root>  Required for CodeTraceBench\n  --out <new output directory>\n  --revision <full 40- or 64-character hex digest>\n  --split <dataset split>\n  --base-url <OpenAI-compatible /v1 URL>\n  --api-key-env <environment variable containing the bearer>\n  --model <provider model id>\n  --limit <positive case count>\n\nControls:\n  --resume                         Continue an interrupted run in --out\n  --seed <integer>                 Case-selection and comparison seed. Default: 0\n  --concurrency <positive integer> Parallel benchmark jobs. Default: 1\n  --repetitions <positive integer> Runs per case and runner. Default: 1\n  --max-output-tokens <positive>   Model output limit per call. Default: 4096\n  --python <executable>             Python with agent-eval-rpc[dspy]. Default: python\n  --timeout-ms <positive>          Model analyst deadline per case. Default: 300000\n  --max-cost-usd <positive>        Run-wide spend limit. Default: 5\n  --max-artifact-bytes <positive>  Final evidence bytes per case. Default: 8388608\n\nWrites result.json with every observation, metric, usage field, error, comparison,\ninput digest, artifact digest, case distribution, selected case id, and explicit\nunknown cost. Limited deterministic-hash subsets are marked non-representative.\nCompleted observations are fsynced to observations.jsonl. Shareable output is in\nresult.json and report.md. Machine-local paths, endpoint, and command are isolated\nin run.local.json.\nThe key is read from the named environment variable and is never written.";
+//#endregion
+//#region src/analyst/benchmark-implementation.d.ts
+declare const ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM = "sha256-canonical-source-manifest";
+declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM = "sha256-canonical-file-manifest";
+declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES: readonly string[];
+declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "6f3dc59755ff2a26fba4c2c1ad670f436cdd183faf252a5b9c2d50e6b190b460";
+/** The published benchmark evidence was produced at this package version, by
+ * the retired one-shot direct runner, before trace analysts moved to the
+ * recursive DSPy RLM engine. Both evidence digests below are historical facts
+ * about that artifact: the current implementation and dependency manifest have
+ * since changed, so they cannot describe the current engine. A fresh certified
+ * run must replace the published evidence before any accuracy number is
+ * attributed to the engine that ships today. */
+declare const ANALYST_BENCHMARK_EVIDENCE_PACKAGE_VERSION = "0.137.0";
+declare const ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256 = "1e03f2daed356d60316aabefb407ec1e437ac94d408d61eea4ae096e9c6fbb5b";
+declare const ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256 = "4dba263b6256a30d56c7fdb2d992d3a953c0035d731f359b704db806f68f75ac";
+declare const ANALYST_BENCHMARK_IMPLEMENTATION_FILES: readonly string[];
+declare const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "5e47fc9d9f49c468d3ef06c5d552925e6a026f9e22a75056a9c8c5a2879744c0";
+declare function analystBenchmarkImplementationDigest(): string;
+declare function analystBenchmarkDependencyLockDigest(): string;
 //#endregion
 //#region src/analyst/benchmark-report.d.ts
 declare function renderAnalystBenchmarkMarkdown(result: AnalystBenchmarkResult, comparisons?: readonly AnalystRunnerComparison[]): string;
 //#endregion
-//#region src/analyst/define.d.ts
-interface DefineTraceAnalystOptions {
-  id: string;
-  description: string;
-  version?: string;
-  cost: AnalystCost;
-  analyze: Analyst<TraceAnalysisStore>['analyze'];
-}
-/** Define a custom trace analyst without repeating fixed registry fields. */
-declare function defineTraceAnalyst(options: DefineTraceAnalystOptions): Analyst<TraceAnalysisStore>;
-type TraceAnalystAnalyze = (store: TraceAnalysisStore, context: Parameters<Analyst<TraceAnalysisStore>['analyze']>[1]) => Promise<AnalystFinding[]>;
-//#endregion
 //#region src/analyst/parse-tolerant.d.ts
 /**
  * Forgiving pre-parse for analyst findings. Weak models routinely emit
@@ -221,58 +655,5 @@ declare function isProposalFinding(finding: unknown): finding is ProposalFinding
  */
 declare function assertProposalFindings(findings: unknown, context?: string): ReadonlyArray<ProposalFinding>;
 //#endregion
-//#region src/analyst/structure-findings.d.ts
-interface StructureFindingsOptions {
-  /** The actor's free-form diagnosis prose. */
-  report: string;
-  analystId: string;
-  /** Coarse classification stamped on every extracted finding. */
-  area: string;
-  model: string;
-  baseUrl: string;
-  apiKey?: string;
-  /** Optional ledger for direct use. */
-  costLedger?: CostLedgerHandle;
-  costPhase?: string;
-  costTags?: Record<string, string>;
-  maxTokens?: number;
-  signal?: AbortSignal;
-  /** Max reask attempts after a zero/invalid extraction. Default 1. */
-  maxReasks?: number;
-  /** Apply the caller's normal finding rules before a recovered row is lifted. */
-  processRow?: (row: RawAnalystFinding) => RawAnalystFinding | null;
-  /** Provenance copied onto every recovered finding. */
-  findingMetadata?: Record<string, unknown>;
-  /** Test seam: inject a fetch (no network in unit tests). */
-  fetchImpl?: LlmClientOptions['fetch'];
-}
-interface StructureFindingsResult {
-  findings: AnalystFinding[];
-  outcome: 'ok' | 'extraction_failed';
-}
-declare function structureFindings(opts: StructureFindingsOptions): Promise<StructureFindingsResult>;
-//#endregion
-//#region src/analyst/tool-groups.d.ts
-/** 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[];
-//#endregion
-export { ANALYST_SEVERITIES, type AgentRxBenchmarkCaseOptions, type AgentRxFailure, type AgentRxPrediction, type AgentRxPredictionReport, type AgentRxRow, type Analyst, type AnalystBenchmarkCase, type AnalystBenchmarkDatasetRef, type AnalystBenchmarkDescriptor, type AnalystBenchmarkObservation, type AnalystBenchmarkOutput, type AnalystBenchmarkProvenance, type AnalystBenchmarkResult, type AnalystBenchmarkRunner, type AnalystBenchmarkSummary, type AnalystComparisonMetric, type AnalystContext, type AnalystCost, type AnalystEvidenceExpectation, type AnalystEvidenceResolution, type AnalystEvidenceResolutionError, type AnalystEvidenceResolver, type AnalystFinding, type AnalystFindingScore, type AnalystHooks, type AnalystInputKind, type AnalystIssueExpectation, type AnalystLatencyDistribution, type AnalystMetricComparison, AnalystRegistry, type AnalystRegistryOptions, type AnalystRequirements, type AnalystRunEvent, type AnalystRunInputs, type AnalystRunResult, type AnalystRunSummary, type AnalystRunnerComparison, type AnalystSeverity, type AnalystUsageReceipt, type BehavioralAnalystOptions, type BudgetPolicy, CONTROL_INTEGRITY_ANALYST, type ChatCallOpts, type ChatClient, type ChatRequest, type ChatResponse, type ChatTransport, type CliBridgeTransportOpts, type CodeTraceBenchCaseOptions, type CodeTraceBenchLabelOptions, type CodeTraceBenchLabelSet, type CodeTraceBenchRow, type CodeTraceStageAnnotation, type CodeTracerPredictionAdapterOptions, ControlIntegrityAnalyst, type CreateAnalystAiConfig, type CreateChatClientOpts, type CreateTraceAnalystKindOpts, type CustomTransportOpts, DEFAULT_TRACE_ANALYST_KINDS, type DefaultAnalystRegistryOptions, type DefineTraceAnalystOptions, type DiffPolicy, type DirectProviderTransportOpts, type EvidenceRef, FAILURE_MODE_KIND_SPEC, FINDING_SUBJECT_GRAMMAR_PROMPT, FINDING_SUBJECT_KINDS, FINDING_SUBJECT_SYNTAX, type FindingSubject, type FindingSubjectKind, FindingSubjectStringSchema, type FindingsDiff, FindingsStore, IMPROVEMENT_KIND_SPEC, type JudgeAdapterOpts, KIND_EXPECTED_SUBJECTS, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type MockTransportOpts, type PersistedFinding, type ProposalFinding, type ProposalFindingOrigin, RAW_FINDING_SCHEMA_PROMPT, type RawAnalystEvidence, RawAnalystEvidenceSchema, type RawAnalystFinding, RawAnalystFindingSchema, type RegistryRunOpts, type RouterTransportOpts, type RunAnalystBenchmarkOptions, type RunCriticAdapterOpts, SKILL_USAGE_ANALYST, type SandboxSdkTransportOpts, type SemanticConceptJudgeAdapterOpts, SkillUsageAnalyst, type SkillUsageRecord, type SkillUsageReport, type SkillUsageScanConfig, type StepLabelAdapterOptions, type StructureFindingsOptions, type StructureFindingsResult, type TraceAnalystAnalyze, type TraceAnalystKindSpec, type TraceToolGroupName, type UpstreamPredictionAdapterOptions, type VerifierAdapterOpts, agentRxBenchmarkCase, agentRxPredictionsToFindings, assertProposalFindings, behavioralAnalyst, buildDefaultAnalystRegistry, buildSkillUsageReport, buildTraceToolsForGroup, codeTraceBenchCase, codeTracerPredictionsToFindings, coerceJson, coerceToFindingRows, compareAnalystRunners, computeFindingId, createAnalystAi, createChatClient, createJudgeAdapter, createRunCriticAdapter, createSemanticConceptJudgeAdapter, createTraceAnalystKind, createVerifierAdapter, defaultIsMaterial, defineTraceAnalyst, deriveEfficiencyFindings, diffFindings, emitControlIntegrityFindings, emitSkillUsageFindings, evidenceRefsFromRawFinding, findingSubjectGrammarPromptFor, isProposalFinding, liftSeverity, makeFinding, makeProposalFinding, normalizeAgentRxCategory, normalizeBenchmarkLabel, parseFindingSubject, parseRawFinding, registryBenchmarkRunner, renderAnalystBenchmarkMarkdown, renderFindingSubject, renderPriorFindings, renderUpstreamFindings, runAnalystBenchmark, scoreAnalystFindings, stripCodeFences, structureFindings, traceStoreEvidenceResolver };
+export { AGENT_RX_UPSTREAM_REVISION, ANALYST_BENCHMARK_COST_LEDGER_FILE, ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM, ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES, ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_EVIDENCE_PACKAGE_VERSION, ANALYST_BENCHMARK_HELP, ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM, ANALYST_BENCHMARK_IMPLEMENTATION_FILES, ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, ANALYST_BENCHMARK_MANIFEST_FILE, ANALYST_BENCHMARK_OBSERVATIONS_FILE, ANALYST_SEVERITIES, type AgentRxBenchmarkCaseOptions, type AgentRxCalibrationRunnerSummary, type AgentRxCalibrationSummary, type AgentRxFailure, type AgentRxPrediction, type AgentRxPredictionReport, type AgentRxRow, type Analyst, type AnalystBenchmarkArtifact, type AnalystBenchmarkCase, type AnalystBenchmarkCommandConfig, type AnalystBenchmarkCommandDependencies, type AnalystBenchmarkDatasetRef, type AnalystBenchmarkDescriptor, type AnalystBenchmarkError, type AnalystBenchmarkLabelState, type AnalystBenchmarkLocalRunReceipt, type AnalystBenchmarkObservation, type AnalystBenchmarkOutput, type AnalystBenchmarkProgressRow, type AnalystBenchmarkProvenance, type AnalystBenchmarkResult, type AnalystBenchmarkRunIdentity, type AnalystBenchmarkRunManifest, type AnalystBenchmarkRunner, type AnalystBenchmarkSummary, type AnalystComparisonMetric, type AnalystContext, type AnalystCost, type AnalystEvidenceExpectation, type AnalystEvidenceResolution, type AnalystEvidenceResolutionError, type AnalystEvidenceResolver, type AnalystFinding, type AnalystFindingScore, type AnalystHooks, type AnalystInputKind, type AnalystIssueExpectation, type AnalystLatencyDistribution, type AnalystMetricComparison, AnalystRegistry, type AnalystRegistryOptions, type AnalystRequirements, type AnalystRunEvent, type AnalystRunInputs, type AnalystRunResult, type AnalystRunSummary, type AnalystRunnerComparison, type AnalystSeverity, type AnalystUsageReceipt, type BehavioralAnalystOptions, type BudgetPolicy, CODE_TRACE_BENCH_ANALYST_PROMPT, CONTROL_INTEGRITY_ANALYST, type ChatCallOpts, type ChatClient, type ChatRequest, type ChatResponse, type ChatTransport, type CliBridgeTransportOpts, type CodeTraceBenchCaseOptions, type CodeTraceBenchLabelOptions, type CodeTraceBenchLabelSet, type CodeTraceBenchRow, type CodeTraceCalibrationRunnerSummary, type CodeTraceCalibrationSummary, type CodeTraceStageAnnotation, type CodeTracerLabelGroup, type CodeTracerPredictionAdapterOptions, type CodeTracerPredictions, type CodeTracerStepLabel, ControlIntegrityAnalyst, type CreateChatClientOpts, type CreateTraceAnalystOptions, type CustomTransportOpts, DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES, DEFAULT_TRACE_ANALYST_KINDS, DEFAULT_TRACE_ANALYST_LIMITS, type DefaultAnalystRegistryOptions, type DefineCustomAnalystOptions, type DefineExactCustomAnalystOptions, type DiffPolicy, type DirectProviderTransportOpts, type DspyRlmTraceEngineOptions, type EvidenceRef, type ExactAnalystBudgetPolicy, type ExactAnalystBudgetSnapshot, type ExactAnalystExecutionPlanSnapshot, type ExactAnalystRunCompletion, type ExactAnalystRunEvent, ExactAnalystRunExecutionError, type ExactAnalystRunPolicySnapshot, type ExactAnalystRunResult, type ExactAnalystRunSummary, type ExactAnalystSnapshot, type ExactCapableAnalyst, type ExactExecutionComponentIdentity, type ExactExecutionComponentSnapshot, type ExactRegistryRunOpts, FAILURE_MODE_KIND_SPEC, FINDING_SUBJECT_GRAMMAR_PROMPT, FINDING_SUBJECT_KINDS, FINDING_SUBJECT_SYNTAX, type FindingSubject, type FindingSubjectKind, FindingSubjectStringSchema, type FindingsDiff, FindingsStore, IMPROVEMENT_KIND_SPEC, type JudgeAdapterOpts, KIND_EXPECTED_SUBJECTS, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type LoadedVerificationArtifacts, type MockTransportOpts, type PersistedFinding, type PreparedPublicAnalystBenchmark, type ProposalFinding, type ProposalFindingOrigin, type PublicAnalystBenchmarkDataset, type PublicAnalystBenchmarkModelConfig, type PublicBenchmarkDistributions, type PublicBenchmarkSelectionReport, type PublicBenchmarkValueDistribution, RAW_FINDING_SCHEMA_PROMPT, type RawAnalystEvidence, RawAnalystEvidenceSchema, type RawAnalystFinding, RawAnalystFindingSchema, type RegistryRunOpts, type RouterTransportOpts, type RunAnalystBenchmarkOptions, type RunCriticAdapterOpts, SKILL_USAGE_ANALYST, type SandboxSdkTransportOpts, type SemanticConceptJudgeAdapterOpts, SkillUsageAnalyst, type SkillUsageRecord, type SkillUsageReport, type SkillUsageScanConfig, type StepLabelAdapterOptions, type TraceAnalysisEngine, type TraceAnalysisEngineRequest, type TraceAnalysisEngineResult, type TraceAnalystDefinition, type TraceAnalystLimits, type TraceToolGroupName, type UpstreamPredictionAdapterOptions, type VerificationArtifactFile, type VerificationArtifactManifest, type VerificationArtifactRole, type VerificationAvailabilitySummary, type VerificationOutcome, type VerificationOutcomeSource, type VerificationOutcomeStatus, type VerificationResultFile, type VerifierAdapterOpts, adaptPublicBenchmarkFindings, agentRxBenchmarkCase, agentRxPredictionsToFindings, analystBenchmarkDependencyLockDigest, analystBenchmarkImplementationDigest, appendVerificationArtifactsToOtlp, assertExactRegistryRunOpts, assertProposalFindings, behavioralAnalyst, buildDefaultAnalystRegistry, buildSkillUsageReport, buildTraceToolsForGroup, codeTraceBenchCase, codeTracerPredictionsToFindings, coerceJson, coerceToFindingRows, compareAnalystRunners, computeFindingId, createChatClient, createDspyRlmTraceEngine, createJudgeAdapter, createPublicBenchmarkDirectRunner, createPublicBenchmarkRlmRunner, createRunCriticAdapter, createSemanticConceptJudgeAdapter, createTraceAnalyst, createVerifierAdapter, defaultIsMaterial, defineCustomAnalyst, defineTraceAnalyst, deriveEfficiencyFindings, diffFindings, emitControlIntegrityFindings, emitSkillUsageFindings, emptyPublicBenchmarkRunner, evidenceRefsFromRawFinding, findingSubjectGrammarPromptFor, isProposalFinding, liftSeverity, loadCodeTraceVerificationArtifacts, loadPublicBenchmarkRows, makeFinding, makeProposalFinding, normalizeAgentRxCategory, normalizeBenchmarkLabel, parseFindingSubject, parseRawFinding, parseVerificationOutcome, preparePublicAnalystBenchmark, publicBenchmarkDistributions, publicBenchmarkProtocolSha256, publicBenchmarkSelectionReport, readAnalystBenchmarkArtifact, registryBenchmarkRunner, renderAgentRxCalibrationMarkdown, renderAnalystBenchmarkMarkdown, renderCodeTraceCalibrationMarkdown, renderFindingSubject, renderPriorFindings, renderUpstreamFindings, resolveTraceAnalystLimits, roundAgentRxStep, runAnalystBenchmark, runAnalystBenchmarkCommand, runTraceAnalyst, scoreAnalystFindings, selectPublicBenchmarkRows, stripCodeFences, summarizeAgentRxCalibration, summarizeCodeTraceCalibration, traceStoreEvidenceResolver };
 //# sourceMappingURL=index.d.ts.map