@tangle-network/agent-eval 0.136.0 → 0.138.0

package/dist/analyst/index.d.ts

@@ -1,11 +1,12 @@
 import { a as MultiLayerVerifier, l as VerifyOptions, o as Severity } from "../multi-layer-verifier-BHY1gWAc.js";
-import { C as FindingSubjectKind, D as parseFindingSubject, E as findingSubjectGrammarPromptFor, F as createAnalystAi, H as SemanticConceptJudgeInput, O as renderFindingSubject, P as CreateAnalystAiConfig, S as FindingSubject, T as KIND_EXPECTED_SUBJECTS, U as SemanticConceptJudgeOptions, Y as RunTrace, _ as defaultIsMaterial, a as SkillUsageScanConfig, b as FINDING_SUBJECT_KINDS, c as DEFAULT_TRACE_ANALYST_KINDS, d as IMPROVEMENT_KIND_SPEC, f as FAILURE_MODE_KIND_SPEC, g as PersistedFinding, h as FindingsStore, i as SkillUsageReport, k as BehavioralMetrics, l as KNOWLEDGE_POISONING_KIND_SPEC, m as FindingsDiff, n as SkillUsageAnalyst, o as buildSkillUsageReport, p as DiffPolicy, q as RunCritic, r as SkillUsageRecord, s as emitSkillUsageFindings, t as SKILL_USAGE_ANALYST, u as KNOWLEDGE_GAP_KIND_SPEC, v as diffFindings, w as FindingSubjectStringSchema, x as FINDING_SUBJECT_SYNTAX, y as FINDING_SUBJECT_GRAMMAR_PROMPT } from "../skill-usage-BDQVPIG1.js";
-import { c as CostLedgerHandle } from "../cost-ledger-fGS_u_O1.js";
-import { o as LlmClientOptions } from "../llm-client-BiK4HW0u.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-Cc3qbqzj.js";
-import { t as TraceAnalysisStore } from "../store-CxJry_cs.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-DVjczBM9.js";
-import { _ as RawAnalystEvidenceSchema, a as AnalystRegistryOptions, b as evidenceRefsFromRawFinding, c as CreateTraceAnalystKindOpts, d as createTraceAnalystKind, f as renderPriorFindings, g as RawAnalystEvidence, h as RAW_FINDING_SCHEMA_PROMPT, i as AnalystRegistry, l as TraceAnalystGolden, m as ANALYST_SEVERITIES, n as buildDefaultAnalystRegistry, o as BudgetPolicy, p as renderUpstreamFindings, r as AnalystHooks, s as RegistryRunOpts, t as DefaultAnalystRegistryOptions, u as TraceAnalystKindSpec, v as RawAnalystFinding, x as parseRawFinding, y as RawAnalystFindingSchema } from "../default-registry-Brxr728w.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-Bv3G4VkA.js";
+import { c as CostLedgerHandle } from "../cost-ledger-B1D3COAc.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-5q2T25iW.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-BtJhn8v6.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-PUhIVRWz.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-Dpw2LeHA.js";
+import { a as ExactAnalystBudgetPolicy, c as RegistryRunOpts, i as BudgetPolicy, l as assertExactRegistryRunOpts, n as AnalystRegistry, o as ExactAnalystRunExecutionError, r as AnalystRegistryOptions, s as ExactRegistryRunOpts, t as AnalystHooks } from "../registry-C4yJTza7.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-DlQgU_XI.js";
 import { AxFunction } from "@ax-llm/ax";
 //#region src/analyst/adapters.d.ts
 declare function liftSeverity(s: Severity): AnalystSeverity;
@@ -50,17 +51,570 @@ interface SemanticConceptJudgeAdapterOpts {
 }
 declare function createSemanticConceptJudgeAdapter(opts?: SemanticConceptJudgeAdapterOpts): Analyst<SemanticConceptJudgeInput>;
 //#endregion
-//#region src/analyst/behavioral-analyst.d.ts
-/**
- * Map computed signals → structured AnalystFindings. Pure: no LLM, no clock
- * dependence beyond `produced_at` (overridable for deterministic tests).
- */
-declare function deriveEfficiencyFindings(metrics: BehavioralMetrics, opts?: {
+//#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 AgentRxCalibrationSummary {
+  protocol: 'official-agentrx-root-cause';
+  upstreamRevision: string;
+  rationale: string;
+  runners: AgentRxCalibrationRunnerSummary[];
+}
+declare function summarizeAgentRxCalibration(result: AnalystBenchmarkResult, upstreamRevision: string): AgentRxCalibrationSummary;
+declare function renderAgentRxCalibrationMarkdown(summary: AgentRxCalibrationSummary): string;
+//#endregion
+//#region src/analyst/benchmark-dataset-types.d.ts
+type ExternalId = string | number;
+interface AgentRxFailure {
+  failure_id: ExternalId;
+  step_number: number;
+  step_reason: string;
+  failure_category: string;
+  category_reason?: string;
+  failed_agent?: string;
+}
+interface AgentRxRow {
+  trajectory_id: ExternalId;
+  failures: readonly AgentRxFailure[];
+  root_cause?: {
+    failure_id: ExternalId;
+    reason_for_root_cause?: string;
+  };
+  root_cause_failure_id?: ExternalId;
+  root_cause_reason?: string;
+  failure_summary?: string;
+  num_failures?: number;
+}
+interface AgentRxPrediction {
+  task_id?: ExternalId;
+  failure_case: number | string;
+  step_number: number;
+  description?: string;
+  checklist_reasoning?: string | null;
+}
+interface AgentRxPredictionReport {
+  task_id?: ExternalId;
+  failures: readonly AgentRxPrediction[];
+  num_judges?: number;
+  trajectory_length?: number;
+  most_common_failure?: number | string;
+  modes?: readonly (number | string)[];
+  step_mean?: number;
+}
+interface CodeTraceStageAnnotation {
+  stage_id: number;
+  incorrect_step_ids?: readonly number[];
+  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[];
+  solved?: boolean | null;
+  step_count: number;
+  incorrect_stages: string | readonly CodeTraceStageAnnotation[];
+}
+interface StepLabelAdapterOptions {
+  evidenceKind?: EvidenceRef['kind'];
+  stepUri?: (trajectoryId: string, step: number) => string;
+}
+type CodeTraceBenchLabelSet = 'incorrect-only' | 'incorrect-and-unuseful';
+interface CodeTraceBenchLabelOptions {
+  /**
+   * CodeTraceBench's published metric scores incorrect steps only.
+   * Include unuseful steps only for an explicitly combined experiment.
+   */
+  labelSet?: CodeTraceBenchLabelSet;
+}
+interface CodeTraceBenchCaseOptions extends StepLabelAdapterOptions, CodeTraceBenchLabelOptions {}
+interface AgentRxBenchmarkCaseOptions extends StepLabelAdapterOptions {
+  stepCount?: number;
+  /** AgentRx's published task is root-cause localization. */
+  target?: 'root-cause' | 'all-failures';
+}
+interface UpstreamPredictionAdapterOptions extends StepLabelAdapterOptions {
   analystId?: string;
   producedAt?: string;
-}): AnalystFinding[];
-/** The deterministic behavioral/efficiency analyst (no LLM, any-model). */
-declare function behavioralAnalyst(): Analyst<TraceAnalysisStore>;
+  confidence?: number;
+  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>;
+/** 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: CodeTracerPredictions, options?: CodeTracerPredictionAdapterOptions): AnalystFinding[];
+//#endregion
+//#region src/analyst/benchmark-dataset-utils.d.ts
+declare function normalizeBenchmarkLabel(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;
+  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
+declare function createPublicBenchmarkModelRunner(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-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', 'model'];
+  };
+  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 {
+  createModelRunner?: (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 a real-model 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  --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 = "d06e3e3f171cc6bd5cf36b14325f507f34b1c6a9d5129ce8a85bf3c1681f8223";
+/** The published benchmark evidence was produced at this package version.
+ * A release changes package.json's version field, which is part of the lock
+ * manifest but cannot change benchmark behavior, so the evidence stays bound
+ * to the digest at its creation. A test proves the current lock differs from
+ * the evidence lock by the version stamp alone; any real dependency change
+ * still forces a new benchmark run or explicit retirement of the evidence. */
+declare const ANALYST_BENCHMARK_EVIDENCE_PACKAGE_VERSION = "0.137.0";
+declare const ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256 = "1e03f2daed356d60316aabefb407ec1e437ac94d408d61eea4ae096e9c6fbb5b";
+declare const ANALYST_BENCHMARK_IMPLEMENTATION_FILES: readonly string[];
+declare const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "4dba263b6256a30d56c7fdb2d992d3a953c0035d731f359b704db806f68f75ac";
+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'];
+}
+interface DefineExactTraceAnalystOptions extends DefineTraceAnalystOptions {
+  /** Canonical JSON for behavior knobs not already bound by `version`. */
+  executionConfig: Readonly<Record<string, unknown>>;
+}
+/** Define a custom trace analyst without repeating fixed registry fields. */
+declare function defineTraceAnalyst(options: DefineExactTraceAnalystOptions): ExactCapableAnalyst<TraceAnalysisStore>;
+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
 /**
@@ -142,7 +696,9 @@ type TraceToolGroupName =
 /** Discovery + search tools. For pattern-matching across many traces. */
 'discoveryAndSearch' |
 /** Discovery + viewSpans + searchSpan. Targeted-span work after another kind narrows down. */
-'targeted';
+'targeted' |
+/** One known-small trace: overview, bounded reads, and in-trace search. */
+'singleTrace';
 /**
  * Build the tool set for a named group bound to a specific trace store.
  *
@@ -152,5 +708,5 @@ type TraceToolGroupName =
  */
 declare function buildTraceToolsForGroup(group: TraceToolGroupName, store: TraceAnalysisStore): AxFunction[];
 //#endregion
-export { ANALYST_SEVERITIES, type Analyst, type AnalystContext, type AnalystCost, type AnalystFinding, type AnalystHooks, type AnalystInputKind, AnalystRegistry, type AnalystRegistryOptions, type AnalystRequirements, type AnalystRunEvent, type AnalystRunInputs, type AnalystRunResult, type AnalystRunSummary, type AnalystSeverity, type AnalystUsageReceipt, type BudgetPolicy, type ChatCallOpts, type ChatClient, type ChatRequest, type ChatResponse, type ChatTransport, type CliBridgeTransportOpts, type CreateAnalystAiConfig, type CreateChatClientOpts, type CreateTraceAnalystKindOpts, type CustomTransportOpts, DEFAULT_TRACE_ANALYST_KINDS, type DefaultAnalystRegistryOptions, 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 RunCriticAdapterOpts, SKILL_USAGE_ANALYST, type SandboxSdkTransportOpts, type SemanticConceptJudgeAdapterOpts, SkillUsageAnalyst, type SkillUsageRecord, type SkillUsageReport, type SkillUsageScanConfig, type StructureFindingsOptions, type StructureFindingsResult, type TraceAnalystGolden, type TraceAnalystKindSpec, type TraceToolGroupName, type VerifierAdapterOpts, assertProposalFindings, behavioralAnalyst, buildDefaultAnalystRegistry, buildSkillUsageReport, buildTraceToolsForGroup, coerceJson, coerceToFindingRows, computeFindingId, createAnalystAi, createChatClient, createJudgeAdapter, createRunCriticAdapter, createSemanticConceptJudgeAdapter, createTraceAnalystKind, createVerifierAdapter, defaultIsMaterial, deriveEfficiencyFindings, diffFindings, emitSkillUsageFindings, evidenceRefsFromRawFinding, findingSubjectGrammarPromptFor, isProposalFinding, liftSeverity, makeFinding, makeProposalFinding, parseFindingSubject, parseRawFinding, renderFindingSubject, renderPriorFindings, renderUpstreamFindings, stripCodeFences, structureFindings };
+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_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 CreateAnalystAiConfig, type CreateChatClientOpts, type CreateTraceAnalystKindOpts, type CustomTransportOpts, DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES, DEFAULT_TRACE_ANALYST_KINDS, type DefaultAnalystRegistryOptions, type DefineExactTraceAnalystOptions, type DefineTraceAnalystOptions, type DiffPolicy, type DirectProviderTransportOpts, 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 StructureFindingsOptions, type StructureFindingsResult, type TraceAnalystAnalyze, type TraceAnalystKindSpec, 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, createAnalystAi, createChatClient, createJudgeAdapter, createPublicBenchmarkModelRunner, createRunCriticAdapter, createSemanticConceptJudgeAdapter, createTraceAnalystKind, createVerifierAdapter, defaultIsMaterial, 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, roundAgentRxStep, runAnalystBenchmark, runAnalystBenchmarkCommand, scoreAnalystFindings, selectPublicBenchmarkRows, stripCodeFences, structureFindings, summarizeAgentRxCalibration, summarizeCodeTraceCalibration, traceStoreEvidenceResolver };
 //# sourceMappingURL=index.d.ts.map

package/dist/analyst/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/analyst/adapters.ts","../../src/analyst/behavioral-analyst.ts","../../src/analyst/parse-tolerant.ts","../../src/analyst/proposal-findings.ts","../../src/analyst/structure-findings.ts","../../src/analyst/tool-groups.ts"],"mappings":";;;;;;;;;;iBA4CgB,aAAa,GAAG,WAAgB;UAe/B,oBAAoB;EACnC;EACA;EACA,UAAU,mBAAmB;;;;;EAK7B,UAAU,KAAK,cAAc;;iBAGf,sBAAsB,KAAK,MAAM,oBAAoB,OAAO,QAAQ;UAwEnE;EACf;EACA;EACA,SAAS;;EAET;;iBAGc,uBAAuB,OAAM,uBAA4B,QAAQ;UAiEhE;EACf;EACA;EACA,OAAO;;EAEP,MAAM;;EAEN,OAAO;;EAEP;;iBAGc,mBAAmB,MAAM,mBAAmB,QAAQ;UAiDnD;EACf;EACA;;EAEA,UAAU,KAAK;;EAEf;;iBAGc,kCACd,OAAM,kCACL,QAAQ;;;;;;;iBC5OK,yBACd,SAAS,mBACT;EAAQ;EAAoB;IAC3B;;iBAkCa,qBAAqB,QAAQ;;;;;;;;;;;;;;;iBC3E7B,gBAAgB;;;;;iBAgBhB,WAAW;;;;;;;iBAeX,oBAAoB;;;;iBCXpB,kBAAkB,mBAAmB,WAAW;;;;;;iBAShD,uBACd,mBACA,mBACC,cAAc;;;UCXA;;EAEf;EACA;;EAEA;EACA;EACA;EACA;;EAEA,aAAa;EACb;EACA,WAAW;EACX;EACA,SAAS;;EAET;;EAEA,cAAc,KAAK,sBAAsB;;EAEzC,kBAAkB;;EAElB,YAAY;;UAGG;EACf,UAAU;EACV;;iBAuCoB,kBACpB,MAAM,2BACL,QAAQ;;;;KCrFC;;;;;;;;;;;;;;;;;;iBAuCI,wBACd,OAAO,oBACP,OAAO,qBACN"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/analyst/adapters.ts","../../src/analyst/benchmark-agentrx-calibration.ts","../../src/analyst/benchmark-dataset-types.ts","../../src/analyst/benchmark-dataset-agentrx.ts","../../src/analyst/benchmark-dataset-codetrace.ts","../../src/analyst/benchmark-dataset-utils.ts","../../src/analyst/benchmark-verification-outcome.ts","../../src/analyst/benchmark-verification-artifacts.ts","../../src/analyst/benchmark-public-types.ts","../../src/analyst/benchmark-public-adapters.ts","../../src/analyst/benchmark-public-data.ts","../../src/analyst/benchmark-public-model.ts","../../src/analyst/benchmark-comparison.ts","../../src/analyst/benchmark-public-calibration.ts","../../src/analyst/benchmark-command-artifact.ts","../../src/analyst/benchmark-command-result.ts","../../src/analyst/benchmark-command.ts","../../src/analyst/benchmark-implementation.ts","../../src/analyst/benchmark-report.ts","../../src/analyst/define.ts","../../src/analyst/parse-tolerant.ts","../../src/analyst/proposal-findings.ts","../../src/analyst/structure-findings.ts","../../src/analyst/tool-groups.ts"],"mappings":"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A;EACA;IACE,QAAQ;;;iBC9HI,iCACd,SAAS,+BACT,QAAQ,oCACP,uBAAuB;iBAofV,8BAA8B,SAAS;cAoE1C;;;KC1mBD;UAoBK;EACf,QAAQ;EACR;;EAEA;;EAEA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA,SAAS;;iBASK,sBACd,QAAQ,wBACR;EACE;EACA;EACA;EACA;EACA;IAED;;;UCnEc;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA,SAAS;;iBAGK,8BACd,QAAQ,yBACP;iBAca,mCAAmC,SAAS;;;UCrC3C;EACf;EACA;EACA;IACE,SAAS;IACT;IACA;IACA;IACA;IACA,YAAY;MAAQ;MAAiB;MAAsB;;IAC3D,uBAAuB;IACvB,0BAA0B;IAC1B;MACE;MACA;MACA;MACA,QAAQ;;IAEV;MACE;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;;;EAGJ,QAAQ;EACR,aAAa;EACb,uBAAuB;EACvB,qBAAqB;;UAGN;EACf;EACA;EACA;EACA;IACE;IACA;IACA;;;UAIa;EACf;IACE,SAAS;IACT;IACA;IACA;MACE;MACA;MACA;;IAEF;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA,YAAY;MAAQ;MAAiB;MAAsB;;IAC3D;IACA;;;UAIa;EACf;EACA;EACA;EACA;EACA,UAAU;;UAGK;EACf;EACA;EACA;EACA;IACE;IACA;IACA;IACA;IACA;IACA;;EAEF;EACA;IACE;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;IACA;IACA;;;UAIa;EACf;EACA;EACA;EACA,aAAa;EACb;;cAGW;cACA;cACA;cACA;;;iBCxHS,6BACpB,eACC,QAAQ;;;UCyDM;EACf,qBACE,SAAS,+BACT,QAAQ,sCACL,uBAAuB;;UAGb;EACf,SAAS;EACT;EACA;EACA;EACA;EACA;EACA;EACA,OAAO;EACP;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;iBAKoB,2BACpB,yBACA,MAAK,OAAO,YACZ,eAAc,sCACb;cA8QU;;;cC7XA;cAEA;cAEA;cAKA;;;;;;;cASA;cAEA;cAGA;cAgEA;iBAGG;iBAIA;;;iBC3FA,+BACd,QAAQ,wBACR,uBAAsB;;;UCDP;EACf;EACA;EACA;EACA,MAAM;EACN,SAAS,QAAQ;;UAGF,uCAAuC;;EAEtD,iBAAiB,SAAS;;;iBAIZ,mBACd,SAAS,iCACR,oBAAoB;iBACP,mBAAmB,SAAS,4BAA4B,QAAQ;KA8BpE,uBACV,OAAO,oBACP,SAAS,WAAW,QAAQ,uCACzB,QAAQ;;;;;;;;;;;;;;;iBCzCG,gBAAgB;;;;;iBAgBhB,WAAW;;;;;;;iBAeX,oBAAoB;;;;iBCXpB,kBAAkB,mBAAmB,WAAW;;;;;;iBAShD,uBACd,mBACA,mBACC,cAAc;;;UCXA;;EAEf;EACA;;EAEA;EACA;EACA;EACA;;EAEA,aAAa;EACb;EACA,WAAW;EACX;EACA,SAAS;;EAET;;EAEA,cAAc,KAAK,sBAAsB;;EAEzC,kBAAkB;;EAElB,YAAY;;UAGG;EACf,UAAU;EACV;;iBAuCoB,kBACpB,MAAM,2BACL,QAAQ;;;;KCrFC;;;;;;;;;;;;;;;;;;;;iBAgDI,wBACd,OAAO,oBACP,OAAO,qBACN"}