@tangle-network/agent-eval 0.200.1 → 0.202.0

package/dist/analyst/index.d.ts

@@ -21,10 +21,10 @@ interface SemanticConceptJudgeAdapterOpts {
   /** Maximum post-cancellation wait for a provider receipt. Default 5 seconds. */
   settlementTimeoutMs?: number;
 }
-declare function createSemanticConceptJudgeAdapter(opts: SemanticConceptJudgeAdapterOpts): Analyst<SemanticConceptJudgeInput>;
+export declare function createSemanticConceptJudgeAdapter(opts: SemanticConceptJudgeAdapterOpts): Analyst<SemanticConceptJudgeInput>;
 //#endregion
 //#region src/analyst/benchmark-agentrx-calibration.d.ts
-declare const AGENT_RX_UPSTREAM_REVISION = "f228165bfec60a801fd5fedd9d8ffe0f9de0c69d";
+export declare const AGENT_RX_UPSTREAM_REVISION = "f228165bfec60a801fd5fedd9d8ffe0f9de0c69d";
 interface AgentRxCalibrationRunnerSummary {
   runnerId: string;
   selectedRuns: number;
@@ -53,8 +53,8 @@ interface AgentRxCalibrationSummary {
   rationale: string;
   runners: AgentRxCalibrationRunnerSummary[];
 }
-declare function summarizeAgentRxCalibration(result: AnalystBenchmarkResult, upstreamRevision: string): AgentRxCalibrationSummary;
-declare function renderAgentRxCalibrationMarkdown(summary: AgentRxCalibrationSummary): string;
+export declare function summarizeAgentRxCalibration(result: AnalystBenchmarkResult, upstreamRevision: string): AgentRxCalibrationSummary;
+export declare function renderAgentRxCalibrationMarkdown(summary: AgentRxCalibrationSummary): string;
 //#endregion
 //#region src/analyst/benchmark-dataset-types.d.ts
 type ExternalId = string | number;
@@ -159,20 +159,20 @@ interface UpstreamPredictionAdapterOptions extends StepLabelAdapterOptions {
 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>;
+export 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;
+export declare function agentRxPredictionsToFindings(trajectoryIdValue: ExternalId, output: unknown, options?: UpstreamPredictionAdapterOptions): AnalystFinding[];
+export declare function normalizeAgentRxCategory(value: string): string;
 /** Match Python's round() behavior used by AgentRx for consensus steps. */
-declare function roundAgentRxStep(value: number): number;
+export 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>;
+export 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[];
+export 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;
+export declare function normalizeBenchmarkLabel(value: string): string;
 //#endregion
 //#region src/analyst/benchmark-verification-outcome.d.ts
 type VerificationOutcomeStatus = 'passed' | 'failed' | 'unavailable';
@@ -198,10 +198,10 @@ interface VerificationResultFile {
   relativePath: string;
   content: string;
 }
-declare function parseVerificationOutcome(files: readonly VerificationResultFile[]): VerificationOutcome;
+export declare function parseVerificationOutcome(files: readonly VerificationResultFile[]): VerificationOutcome;
 //#endregion
 //#region src/analyst/benchmark-verification-artifacts.d.ts
-declare const DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES: number;
+export declare const DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES: number;
 type VerificationArtifactRole = 'final-test-output' | 'final-result' | 'final-metrics';
 interface VerificationArtifactFile {
   role: VerificationArtifactRole;
@@ -231,12 +231,12 @@ interface LoadedVerificationArtifacts {
     content: string;
   }>;
 }
-declare function loadCodeTraceVerificationArtifacts(options: {
+export declare function loadCodeTraceVerificationArtifacts(options: {
   artifactDir: string;
   row: CodeTraceBenchRow;
   maxBytes?: number;
 }): Promise<LoadedVerificationArtifacts>;
-declare function appendVerificationArtifactsToOtlp(otlpText: string, traceId: string, artifacts: LoadedVerificationArtifacts, afterTimestamp: string): string;
+export 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';
@@ -404,8 +404,8 @@ interface CodeTraceStepAssignment {
   step: number;
   block: CodeTraceFailureBlock;
 }
-declare function emptyPublicBenchmarkRunner(): AnalystBenchmarkRunner<AnalystRunInputs>;
-declare function adaptPublicBenchmarkFindings(options: {
+export declare function emptyPublicBenchmarkRunner(): AnalystBenchmarkRunner<AnalystRunInputs>;
+export declare function adaptPublicBenchmarkFindings(options: {
   dataset: PublicAnalystBenchmarkDataset;
   trajectoryId: string;
   findings: readonly AnalystFinding[];
@@ -425,7 +425,7 @@ declare function adaptPublicBenchmarkFindings(options: {
  * blocks never reach it: every runner reports blocks, and this function turns
  * them into the per-step findings the benchmark defines.
  */
-declare function expandCodeTraceFailureBlocks(options: {
+export declare function expandCodeTraceFailureBlocks(options: {
   trajectoryId: string;
   blocks: readonly CodeTraceFailureBlock[];
   store: TraceAnalysisStore;
@@ -439,14 +439,14 @@ declare function expandCodeTraceFailureBlocks(options: {
 }>;
 //#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: {
+export declare function loadPublicBenchmarkRows(path: string): Promise<Array<Record<string, unknown>>>;
+export 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: {
+export declare function publicBenchmarkDistributions(dataset: PublicAnalystBenchmarkDataset, rows: readonly Record<string, unknown>[]): PublicBenchmarkDistributions;
+export declare function publicBenchmarkSelectionReport(dataset: PublicAnalystBenchmarkDataset, source: readonly Record<string, unknown>[], selected: readonly Record<string, unknown>[], seed: number): PublicBenchmarkSelectionReport;
+export declare function preparePublicAnalystBenchmark(options: {
   dataset: PublicAnalystBenchmarkDataset;
   labelsPath: string;
   traceDir: string;
@@ -646,14 +646,14 @@ interface AnalystDefinition<TRow = unknown, TAssignment = unknown, TBlock = unkn
  * message names the construct so an expressiveness gap is a loud, attributable
  * failure instead of a silently narrowed protocol.
  */
-declare class AnalystExpressivenessError extends Error {}
+export declare class AnalystExpressivenessError extends Error {}
 /**
  * Digest of everything a definition can send to its model. An inline
  * definition hashes under the historical prime-protocol domain, so its digest
  * equals the digest its bespoke arm always recorded; other projections hash
  * under the definition domain.
  */
-declare function analystDefinitionProtocolSha256<TRow, TAssignment, TBlock>(definition: AnalystDefinition<TRow, TAssignment, TBlock>): string;
+export declare function analystDefinitionProtocolSha256<TRow, TAssignment, TBlock>(definition: AnalystDefinition<TRow, TAssignment, TBlock>): string;
 /** One definition's declared difference from the compared set. */
 interface AnalystDefinitionAsymmetry {
   readonly id: string;
@@ -682,27 +682,27 @@ interface AnalystDefinitionAsymmetryReport {
  * arm, because a retry is a second sample. Projection, reasoning effort, and
  * budget differences are declared and reported, never hidden.
  */
-declare function analystDefinitionAsymmetries(definitions: ReadonlyArray<AnalystDefinition<unknown, unknown, unknown>>): AnalystDefinitionAsymmetryReport;
+export declare function analystDefinitionAsymmetries(definitions: ReadonlyArray<AnalystDefinition<unknown, unknown, unknown>>): AnalystDefinitionAsymmetryReport;
 //#endregion
 //#region src/analyst/benchmark-public-prompt.d.ts
 /** Widest contiguous failure block a model may report. The published corpus's
  * widest labeled block is 8 steps and its widest stage span is 9, so this bound
  * never binds honest enumeration; it caps how far one over-wide block can push
  * unlabeled steps into the precision denominator. */
-declare const MAX_INCORRECT_BLOCK_STEPS = 12;
+export declare const MAX_INCORRECT_BLOCK_STEPS = 12;
 /** Most blocks a model may report for one trajectory. The published corpus's
  * densest case carries 4 disjoint labeled blocks. Together with the per-block
  * cap this bounds one case at 192 predicted steps without a second ceiling. */
-declare const MAX_INCORRECT_BLOCKS = 16;
-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 incorrect step, defined as a wrong state-changing intervention given the evidence — a mislocalized edit, a wrong hypothesis that drives an action, a regression, an irrelevant change, or an incorrect dependency or configuration choice.\nIf the final verification failed, the trajectory MUST contain at least one incorrect step. Never return an empty findings array on a failing trajectory; trace backward until you find the root cause.\nWork backward, the way this benchmark was annotated, never by scanning forward for suspicious steps: start from the final verification outcome or the latest observed failure evidence, identify the immediately preceding step whose action or output produced that observed error, then recursively ask which earlier decision led to each intermediate failure, until the preceding steps contain no error or the cause is unrelated to the trajectory's own decisions.\nEach backward chain terminates at an error-critical step — the earliest decision that triggered the downstream cascade — and that step is the block's first_step: the step that committed the mistake, not the step that planned it and not a later step that repeats it.\nA block is a maximal contiguous sequence of strictly incorrect steps. A step belongs in the block ONLY if it introduces, propagates, or compounds the error. \nDo NOT include steps that merely \"act on\", diagnose, or react to the error. A diagnostic command, a test run exposing the bug, or a correct exploratory read is a CORRECT step. \nIf an incorrect step is followed by a correct diagnostic step and then another incorrect step, you MUST emit two separate blocks. NEVER bridge correct steps by grouping them into a single block with incorrect steps. Over-blocking drastically hurts your precision.\nAfter identifying first_step, extend last_step forward ONLY through consecutive steps that independently introduce, propagate, or compound the mistake. A cascade of repeated failed attempts at the same wrong approach is one maximal block, provided EVERY step is independently incorrect.\nDo not end a block merely because the agent tried a variation of the same wrong approach; a variation that still carries the error stays inside the block.\nA partially correct or ambiguous fix still counts as incorrect; the block ends only at the first step free of the error — a clean diagnostic read, the corrective action that closes the issue and needs no further rework, or a genuine abandonment of the wrong approach.\nBlock extent follows the traced chain and this forward extension, nothing else.\nReport each failure block as exactly one finding whose first_step is the block's first incorrect step and whose last_step is its last, covering every consecutive step between them.\nEvery step inside a block is scored on its own: naming a correct step costs exactly as much as missing an incorrect one, and naming only the first step of a longer block forfeits every unnamed step. Because of this, carefully verify every step between first_step and last_step. Only include steps that introduce, propagate, or compound the error.\nReport blocks separated by at least one correct step as separate findings, and never let two blocks overlap. If there are multiple separate failure cascades, emit a separate finding for each one.\nPrefer anchored blocks: a block whose chain traces back from observed failure evidence — a failing command or verification, an error observation, a regression, or, on a solved trajectory, a later step that reverts or supersedes it — outranks one without.\nWhen an action is clearly wrong on its own evidence but you cannot trace such an anchor, report the block anyway with proportionally lower confidence.\nA solved trajectory still carries every mistake made along the way: inspect its final patching and verification stages for a state-changing action that a later step reverted, superseded, or corrected — a wrong edit just before the final fix is incorrect even when every test ends green.\nBefore emitting a candidate block, check its boundaries.\nNeighbor check: ask whether the accusation fits one step earlier (the decision rather than its consequence) or one step later (the next step still acts on or reworks the same error) better than where you placed it, and move the boundary when it does; a boundary off by one step scores zero at that step.\nCompleteness check: a block must cover the maximal contiguous sequence of incorrect steps. If an agent fails at step 10, tries to fix it at 11, fails, and tries again at 12 and 13, all four steps are incorrect and must be included in the block. Never truncate a cascade. If you miss the later steps of a cascade, your recall drops to zero for them.\nCounterfactual check: ask which step's correct execution would have made the downstream failure or rework disappear, and move first_step onto that step; use this check only to move a boundary, never to delete a block.\nWidth check: inspect the step immediately before first_step and the step immediately after last_step; when either neighbor commits to, compounds, or propagates the same mistake, it belongs inside the block — move that boundary outward and repeat until both neighbors are free of the error.\nFor each block you keep, name as consequence_step the step number whose action or observation shows the damage — a failing command, a wrong file state, a repeated failure, or rework the agent had to do because of this block; that step is the block's own last step when its observation already shows the damage, and a later step otherwise.\nWhen you cannot name that step number from the trace you were given, drop the block; a plausible story about why a step looks wrong is not evidence that it was.\nA passing final verification is not evidence that a block caused nothing, and a failing final verification is not evidence that any particular block caused it.\nFor every block, decide whether the agent escaped the failure.\nMark escape_status \"escaped\" only when you can name the single later step that fully reversed the block, the agent needed no other step to recover, and nothing after that step revisits the same file, command, or hypothesis; write that step number in the rationale. If the agent required multiple steps to fix the issue, or if you are unsure, it is not escaped.\nMark escape_status \"unescaped\" in every other case, including whenever you are unsure.\nA passing final verification never makes a block escaped.\nDo not label a diagnostic probe or test run merely because its output 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. Never include a correct step in a block just to bridge two incorrect steps; instead, emit two separate blocks.\nDo not label a step solely because final verification failed.\nWhen final verification is unavailable, trace backward from the latest failure evidence inside the trajectory itself.\nEvery step in a reported block 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 every covered span's attributes.content and describe only the actions shown there.\nReport at most 16 blocks and at most 12 steps in one block; when more candidates than that exist, report the ones whose chains carry the clearest downstream evidence.\nWhen the trajectory has no incorrect steps — its final verification passed and the final-stage sweep found no reverted, superseded, or corrected action — return an empty findings array.";
+export declare const MAX_INCORRECT_BLOCKS = 16;
+export 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 incorrect step, defined as a wrong state-changing intervention given the evidence — a mislocalized edit, a wrong hypothesis that drives an action, a regression, an irrelevant change, or an incorrect dependency or configuration choice.\nIf the final verification failed, the trajectory MUST contain at least one incorrect step. Never return an empty findings array on a failing trajectory; trace backward until you find the root cause.\nWork backward, the way this benchmark was annotated, never by scanning forward for suspicious steps: start from the final verification outcome or the latest observed failure evidence, identify the immediately preceding step whose action or output produced that observed error, then recursively ask which earlier decision led to each intermediate failure, until the preceding steps contain no error or the cause is unrelated to the trajectory's own decisions.\nEach backward chain terminates at an error-critical step — the earliest decision that triggered the downstream cascade — and that step is the block's first_step: the step that committed the mistake, not the step that planned it and not a later step that repeats it.\nA block is a maximal contiguous sequence of strictly incorrect steps. A step belongs in the block ONLY if it introduces, propagates, or compounds the error. \nDo NOT include steps that merely \"act on\", diagnose, or react to the error. A diagnostic command, a test run exposing the bug, or a correct exploratory read is a CORRECT step. \nIf an incorrect step is followed by a correct diagnostic step and then another incorrect step, you MUST emit two separate blocks. NEVER bridge correct steps by grouping them into a single block with incorrect steps. Over-blocking drastically hurts your precision.\nAfter identifying first_step, extend last_step forward ONLY through consecutive steps that independently introduce, propagate, or compound the mistake. A cascade of repeated failed attempts at the same wrong approach is one maximal block, provided EVERY step is independently incorrect.\nDo not end a block merely because the agent tried a variation of the same wrong approach; a variation that still carries the error stays inside the block.\nA partially correct or ambiguous fix still counts as incorrect; the block ends only at the first step free of the error — a clean diagnostic read, the corrective action that closes the issue and needs no further rework, or a genuine abandonment of the wrong approach.\nBlock extent follows the traced chain and this forward extension, nothing else.\nReport each failure block as exactly one finding whose first_step is the block's first incorrect step and whose last_step is its last, covering every consecutive step between them.\nEvery step inside a block is scored on its own: naming a correct step costs exactly as much as missing an incorrect one, and naming only the first step of a longer block forfeits every unnamed step. Because of this, carefully verify every step between first_step and last_step. Only include steps that introduce, propagate, or compound the error.\nReport blocks separated by at least one correct step as separate findings, and never let two blocks overlap. If there are multiple separate failure cascades, emit a separate finding for each one.\nPrefer anchored blocks: a block whose chain traces back from observed failure evidence — a failing command or verification, an error observation, a regression, or, on a solved trajectory, a later step that reverts or supersedes it — outranks one without.\nWhen an action is clearly wrong on its own evidence but you cannot trace such an anchor, report the block anyway with proportionally lower confidence.\nA solved trajectory still carries every mistake made along the way: inspect its final patching and verification stages for a state-changing action that a later step reverted, superseded, or corrected — a wrong edit just before the final fix is incorrect even when every test ends green.\nBefore emitting a candidate block, check its boundaries.\nNeighbor check: ask whether the accusation fits one step earlier (the decision rather than its consequence) or one step later (the next step still acts on or reworks the same error) better than where you placed it, and move the boundary when it does; a boundary off by one step scores zero at that step.\nCompleteness check: a block must cover the maximal contiguous sequence of incorrect steps. If an agent fails at step 10, tries to fix it at 11, fails, and tries again at 12 and 13, all four steps are incorrect and must be included in the block. Never truncate a cascade. If you miss the later steps of a cascade, your recall drops to zero for them.\nCounterfactual check: ask which step's correct execution would have made the downstream failure or rework disappear, and move first_step onto that step; use this check only to move a boundary, never to delete a block.\nWidth check: inspect the step immediately before first_step and the step immediately after last_step; when either neighbor commits to, compounds, or propagates the same mistake, it belongs inside the block — move that boundary outward and repeat until both neighbors are free of the error.\nFor each block you keep, name as consequence_step the step number whose action or observation shows the damage — a failing command, a wrong file state, a repeated failure, or rework the agent had to do because of this block; that step is the block's own last step when its observation already shows the damage, and a later step otherwise.\nWhen you cannot name that step number from the trace you were given, drop the block; a plausible story about why a step looks wrong is not evidence that it was.\nA passing final verification is not evidence that a block caused nothing, and a failing final verification is not evidence that any particular block caused it.\nFor every block, decide whether the agent escaped the failure.\nMark escape_status \"escaped\" only when you can name the single later step that fully reversed the block, the agent needed no other step to recover, and nothing after that step revisits the same file, command, or hypothesis; write that step number in the rationale. If the agent required multiple steps to fix the issue, or if you are unsure, it is not escaped.\nMark escape_status \"unescaped\" in every other case, including whenever you are unsure.\nA passing final verification never makes a block escaped.\nDo not label a diagnostic probe or test run merely because its output 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. Never include a correct step in a block just to bridge two incorrect steps; instead, emit two separate blocks.\nDo not label a step solely because final verification failed.\nWhen final verification is unavailable, trace backward from the latest failure evidence inside the trajectory itself.\nEvery step in a reported block 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 every covered span's attributes.content and describe only the actions shown there.\nReport at most 16 blocks and at most 12 steps in one block; when more candidates than that exist, report the ones whose chains carry the clearest downstream evidence.\nWhen the trajectory has no incorrect steps — its final verification passed and the final-stage sweep found no reverted, superseded, or corrected action — return an empty findings array.";
 /** One-shot JSON transport prompt for the direct runner. */
-declare function publicBenchmarkSystemPrompt(dataset: PublicAnalystBenchmarkDataset): string;
+export declare function publicBenchmarkSystemPrompt(dataset: PublicAnalystBenchmarkDataset): string;
 /** Tool-loop prompt for the recursive runner. Same task, subject-encoded block. */
-declare function publicBenchmarkRlmInstructions(dataset: PublicAnalystBenchmarkDataset): string;
+export declare function publicBenchmarkRlmInstructions(dataset: PublicAnalystBenchmarkDataset): string;
 /** Digest of every prompt a runner can send plus the shared transport limits.
  * Both runner contracts are hashed so an edit to either one changes the digest
  * a run records, whichever runner executed. */
-declare function publicBenchmarkProtocolSha256(dataset: PublicAnalystBenchmarkDataset): string;
+export declare function publicBenchmarkProtocolSha256(dataset: PublicAnalystBenchmarkDataset): string;
 //#endregion
 //#region src/analyst/benchmark-public-model.d.ts
 /**
@@ -724,9 +724,9 @@ interface PublicDirectDefinitionArgs {
   maxCostUsd: number;
 }
 /** The direct arm as a declarative unit for one public dataset. */
-declare function publicDirectAnalystDefinition(dataset: PublicAnalystBenchmarkDataset, args: PublicDirectDefinitionArgs): AnalystDefinition<PublicBenchmarkModelPrediction>;
+export declare function publicDirectAnalystDefinition(dataset: PublicAnalystBenchmarkDataset, args: PublicDirectDefinitionArgs): AnalystDefinition<PublicBenchmarkModelPrediction>;
 /** Thin shell: validate config, declare the definition, run the chunked strategy. */
-declare function createPublicBenchmarkDirectRunner(dataset: PublicAnalystBenchmarkDataset, config: PublicAnalystBenchmarkModelConfig): AnalystBenchmarkRunner<AnalystRunInputs>;
+export declare function createPublicBenchmarkDirectRunner(dataset: PublicAnalystBenchmarkDataset, config: PublicAnalystBenchmarkModelConfig): AnalystBenchmarkRunner<AnalystRunInputs>;
 declare const AgentRxPredictionSchema: z.ZodObject<{
   step: z.ZodNumber;
   severity: z.ZodEnum<{
@@ -805,11 +805,11 @@ interface PublicRlmDefinitionArgs {
   engineLimits: TraceAnalystLimits;
 }
 /** The dspy-rlm arm as a declarative unit for one public dataset. */
-declare function publicRlmAnalystDefinition(dataset: PublicAnalystBenchmarkDataset, args: PublicRlmDefinitionArgs): AnalystDefinition<RawAnalystFinding, CodeTraceStepAssignment>;
+export declare function publicRlmAnalystDefinition(dataset: PublicAnalystBenchmarkDataset, args: PublicRlmDefinitionArgs): AnalystDefinition<RawAnalystFinding, CodeTraceStepAssignment>;
 /** Thin shell: validate config, declare the definition, run the repl-variable strategy. */
-declare function createPublicBenchmarkRlmRunner(dataset: PublicAnalystBenchmarkDataset, config: PublicAnalystBenchmarkModelConfig): AnalystBenchmarkRunner<AnalystRunInputs>;
+export declare function createPublicBenchmarkRlmRunner(dataset: PublicAnalystBenchmarkDataset, config: PublicAnalystBenchmarkModelConfig): AnalystBenchmarkRunner<AnalystRunInputs>;
 /** Engine iteration limits with this arm's defaults applied. */
-declare function rlmEngineLimits(config: PublicAnalystBenchmarkModelConfig): TraceAnalystLimits;
+export declare function rlmEngineLimits(config: PublicAnalystBenchmarkModelConfig): TraceAnalystLimits;
 //#endregion
 //#region src/analyst/benchmark-runner-prime.d.ts
 interface PrimeBenchmarkRunnerOptions {
@@ -830,7 +830,7 @@ interface PrimeBenchmarkRunnerOptions {
  * Digest of everything this arm can send to the bridge, recorded per
  * observation so a prime result names the exact contract that produced it.
  */
-declare function primeAnalystProtocolSha256(): string;
+export declare function primeAnalystProtocolSha256(): string;
 interface PrimeCodeTraceDefinitionArgs {
   /** Deadline for one bridge call. */
   timeoutMs: number;
@@ -841,9 +841,9 @@ interface PrimeCodeTraceDefinitionArgs {
  * The prime arm as a declarative unit. CodeTraceBench-only: the question,
  * task text, and block grammar speak its incorrect-step definition.
  */
-declare function primeCodeTraceAnalystDefinition(args: PrimeCodeTraceDefinitionArgs): AnalystDefinition<CodeTraceFailureBlock>;
+export declare function primeCodeTraceAnalystDefinition(args: PrimeCodeTraceDefinitionArgs): AnalystDefinition<CodeTraceFailureBlock>;
 /** Thin shell: validate options, declare the definition, run the inline strategy. */
-declare function createPrimeBenchmarkRunner(options: PrimeBenchmarkRunnerOptions): AnalystBenchmarkRunner<AnalystRunInputs>;
+export declare function createPrimeBenchmarkRunner(options: PrimeBenchmarkRunnerOptions): AnalystBenchmarkRunner<AnalystRunInputs>;
 //#endregion
 //#region src/analyst/benchmark-comparison.d.ts
 /**
@@ -904,7 +904,7 @@ interface AnalystRunnerComparison {
   candidateRunnerId: string;
   metrics: AnalystMetricComparison[];
 }
-declare function compareAnalystRunners(result: AnalystBenchmarkResult, options: {
+export declare function compareAnalystRunners(result: AnalystBenchmarkResult, options: {
   baselineRunnerId: string;
   candidateRunnerId: string;
   confidence?: number;
@@ -942,8 +942,8 @@ interface CodeTraceCalibrationSummary {
   rationale: string;
   runners: CodeTraceCalibrationRunnerSummary[];
 }
-declare function summarizeCodeTraceCalibration(result: AnalystBenchmarkResult): CodeTraceCalibrationSummary;
-declare function renderCodeTraceCalibrationMarkdown(summary: CodeTraceCalibrationSummary): string;
+export declare function summarizeCodeTraceCalibration(result: AnalystBenchmarkResult): CodeTraceCalibrationSummary;
+export declare function renderCodeTraceCalibrationMarkdown(summary: CodeTraceCalibrationSummary): string;
 //#endregion
 //#region src/analyst/benchmark-command-artifact.d.ts
 interface AnalystBenchmarkArtifact {
@@ -1122,13 +1122,13 @@ interface AnalystBenchmarkProgressRow {
   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";
+export declare const ANALYST_BENCHMARK_MANIFEST_FILE = "manifest.json";
+export declare const ANALYST_BENCHMARK_OBSERVATIONS_FILE = "observations.jsonl";
+export declare const ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE = "run.local.json";
+export 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>;
+export declare function readAnalystBenchmarkArtifact(path: string): Promise<AnalystBenchmarkArtifact>;
 //#endregion
 //#region src/analyst/benchmark-command.d.ts
 interface AnalystBenchmarkCommandDependencies {
@@ -1176,27 +1176,27 @@ interface AnalystBenchmarkCommandConfig {
   command: string;
   resume: boolean;
 }
-declare function runAnalystBenchmarkCommand(argv: readonly string[], env?: NodeJS.ProcessEnv, dependencies?: AnalystBenchmarkCommandDependencies): Promise<number>;
+export declare function runAnalystBenchmarkCommand(argv: readonly string[], env?: NodeJS.ProcessEnv, dependencies?: AnalystBenchmarkCommandDependencies): Promise<number>;
 //#endregion
 //#region src/analyst/benchmark-implementation.d.ts
-declare const ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM = "sha256-canonical-source-manifest";
+export declare const ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM = "sha256-canonical-source-manifest";
 /** The dependency files' manifest digest with the package's own version
  * fields blanked, so a release that only bumps the version keeps the pin. */
-declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM = "sha256-canonical-file-manifest-without-own-version";
-declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES: readonly string[];
-declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "007041f0de3b376aa3def1d3efe8221a724030a22ac0a7988921db12c4624c09";
-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 = "8bb4bdae57e4c5596ffe77d80c7a16e67eef7b2fc5087c2af369a417ed423a26";
-declare function analystBenchmarkImplementationDigest(): string;
-declare function analystBenchmarkDependencyLockDigest(): string;
+export declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM = "sha256-canonical-file-manifest-without-own-version";
+export declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES: readonly string[];
+export declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "e57c71c31ecb3ec79d6cf08dc6f1603aa8109bafee4208e63f0e3a1234619d5a";
+export declare const ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256 = "1e03f2daed356d60316aabefb407ec1e437ac94d408d61eea4ae096e9c6fbb5b";
+export declare const ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256 = "4dba263b6256a30d56c7fdb2d992d3a953c0035d731f359b704db806f68f75ac";
+export declare const ANALYST_BENCHMARK_IMPLEMENTATION_FILES: readonly string[];
+export declare const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "86541c7a96fc25a05247656739bced9fbfd89625ce67b56e484266f564447663";
+export declare function analystBenchmarkImplementationDigest(): string;
+export declare function analystBenchmarkDependencyLockDigest(): string;
 //#endregion
 //#region src/analyst/benchmark-instructions-override.d.ts
 /** Build an override from instruction text. Blank text is a caller error. */
-declare function analystInstructionsOverrideFromText(text: string): AnalystInstructionsOverride;
+export declare function analystInstructionsOverrideFromText(text: string): AnalystInstructionsOverride;
 /** Read override instructions from a file. Any read failure is fatal. */
-declare function readAnalystInstructionsOverride(path: string): AnalystInstructionsOverride;
+export declare function readAnalystInstructionsOverride(path: string): AnalystInstructionsOverride;
 /**
  * Protocol digest of the run as executed.
  *
@@ -1207,13 +1207,13 @@ declare function readAnalystInstructionsOverride(path: string): AnalystInstructi
  * prompt) to the exact override text, so the recorded digest always hashes the
  * instructions that actually ran.
  */
-declare function effectiveAnalystProtocolSha256(dataset: PublicAnalystBenchmarkDataset, override?: Pick<AnalystInstructionsOverride, 'sha256'>): string;
+export declare function effectiveAnalystProtocolSha256(dataset: PublicAnalystBenchmarkDataset, override?: Pick<AnalystInstructionsOverride, 'sha256'>): string;
 //#endregion
 //#region src/analyst/benchmark-report.d.ts
-declare function renderAnalystBenchmarkMarkdown(result: AnalystBenchmarkResult, comparisons?: readonly AnalystRunnerComparison[]): string;
+export declare function renderAnalystBenchmarkMarkdown(result: AnalystBenchmarkResult, comparisons?: readonly AnalystRunnerComparison[]): string;
 //#endregion
 //#region src/analyst/benchmark-summary.d.ts
-declare function summarizeAnalystBenchmarkRunner(runnerId: string, observations: readonly AnalystBenchmarkObservation[]): AnalystBenchmarkSummary;
+export declare function summarizeAnalystBenchmarkRunner(runnerId: string, observations: readonly AnalystBenchmarkObservation[]): AnalystBenchmarkSummary;
 //#endregion
 //#region src/analyst/bind.d.ts
 /** Execution half of a binding: who actually reaches the model. */
@@ -1233,7 +1233,7 @@ type AnalystTransportBinding = {
  * Compile a definition plus a transport binding into a runnable arm. Dispatch
  * is total over the expressible pairs; everything else is a loud refusal.
  */
-declare function bindAnalyst<TRow, TAssignment, TBlock>(definition: AnalystDefinition<TRow, TAssignment, TBlock>, transports: AnalystTransportBinding): AnalystBenchmarkRunner<AnalystRunInputs>;
+export declare function bindAnalyst<TRow, TAssignment, TBlock>(definition: AnalystDefinition<TRow, TAssignment, TBlock>, transports: AnalystTransportBinding): AnalystBenchmarkRunner<AnalystRunInputs>;
 //#endregion
 //#region src/analyst/define.d.ts
 /**
@@ -1243,7 +1243,7 @@ declare function bindAnalyst<TRow, TAssignment, TBlock>(definition: AnalystDefin
  * it to any TraceAnalysisEngine with `runTraceAnalyst` or
  * `createTraceAnalyst`.
  */
-declare function defineTraceAnalyst(definition: TraceAnalystDefinition): TraceAnalystDefinition;
+export declare function defineTraceAnalyst(definition: TraceAnalystDefinition): TraceAnalystDefinition;
 interface DefineCustomAnalystOptions {
   id: string;
   description: string;
@@ -1256,8 +1256,8 @@ interface DefineExactCustomAnalystOptions extends DefineCustomAnalystOptions {
   executionConfig: Readonly<Record<string, unknown>>;
 }
 /** Construct a registrable analyst from a hand-written analyze function. */
-declare function defineCustomAnalyst(options: DefineExactCustomAnalystOptions): ExactCapableAnalyst<TraceAnalysisStore>;
-declare function defineCustomAnalyst(options: DefineCustomAnalystOptions): Analyst<TraceAnalysisStore>;
+export declare function defineCustomAnalyst(options: DefineExactCustomAnalystOptions): ExactCapableAnalyst<TraceAnalysisStore>;
+export declare function defineCustomAnalyst(options: DefineCustomAnalystOptions): Analyst<TraceAnalysisStore>;
 //#endregion
 //#region src/analyst/kinds/skill-usage.d.ts
 type SkillKind = 'public' | 'private';
@@ -1307,9 +1307,9 @@ interface SkillUsageScanConfig {
   maxTranscriptsPerDir?: number;
 }
 /** Scan the corpus + skill roots into a {@link SkillUsageReport}. Deterministic. */
-declare function buildSkillUsageReport(config: SkillUsageScanConfig): SkillUsageReport;
+export declare function buildSkillUsageReport(config: SkillUsageScanConfig): SkillUsageReport;
 /** Pure rule pass over a report → findings. Exported for direct/unit use. */
-declare function emitSkillUsageFindings(report: SkillUsageReport, producedAt: string): AnalystFinding[];
+export declare function emitSkillUsageFindings(report: SkillUsageReport, producedAt: string): AnalystFinding[];
 declare class SkillUsageAnalyst implements ExactCapableAnalyst<SkillUsageReport> {
   readonly id = "skill-usage";
   readonly description = "Deterministic multi-signal skill-usage analysis: flags dead skills, measurement-invisible (orchestrated) usage, discovery gaps, public-repo leaks, bloat, missing evals, and missing run-logging.";
@@ -1326,7 +1326,7 @@ declare class SkillUsageAnalyst implements ExactCapableAnalyst<SkillUsageReport>
   };
   analyze(input: SkillUsageReport, ctx: AnalystContext): Promise<AnalystFinding[]>;
 }
-declare const SKILL_USAGE_ANALYST: SkillUsageAnalyst;
+export declare const SKILL_USAGE_ANALYST: SkillUsageAnalyst;
 //#endregion
 //#region src/analyst/parse-tolerant.d.ts
 /**
@@ -1341,22 +1341,22 @@ declare const SKILL_USAGE_ANALYST: SkillUsageAnalyst;
  * Pure + deterministic. No model, no network.
  */
 /** Strip a ```lang ... ``` (or bare ``` ... ```) code fence, if the string is one. */
-declare function stripCodeFences(text: string): string;
+export declare function stripCodeFences(text: string): string;
 /**
  * Best-effort parse of a string into JSON. De-fences, drops trailing commas,
  * then `JSON.parse`. Returns `undefined` (never throws) when unrecoverable.
  */
-declare function coerceJson(text: string): unknown;
+export declare function coerceJson(text: string): unknown;
 //#endregion
 //#region src/analyst/proposal-findings.d.ts
 /** True when a finding names a source candidate generation may learn from. */
-declare function isProposalFinding(finding: unknown): finding is ProposalFinding;
+export declare function isProposalFinding(finding: unknown): finding is ProposalFinding;
 /**
  * Reject findings whose source has not been explicitly admitted for candidate
  * generation. Search feedback and observed production behavior are allowed;
  * final evaluation data has no allowed origin.
  */
-declare function assertProposalFindings(findings: unknown, context?: string): ReadonlyArray<ProposalFinding>;
+export declare function assertProposalFindings(findings: unknown, context?: string): ReadonlyArray<ProposalFinding>;
 //#endregion
-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_IMPLEMENTATION_DIGEST_ALGORITHM, ANALYST_BENCHMARK_IMPLEMENTATION_FILES, ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, ANALYST_BENCHMARK_MANIFEST_FILE, ANALYST_BENCHMARK_OBSERVATIONS_FILE, 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 AnalystBudgetDeclaration, type AnalystComparisonMetric, type AnalystContext, type AnalystCost, type AnalystDefinition, type AnalystDefinitionAsymmetry, type AnalystDefinitionAsymmetryReport, type AnalystEvidenceBinding, type AnalystEvidenceExpectation, type AnalystEvidenceResolution, type AnalystEvidenceResolutionError, type AnalystEvidenceResolver, AnalystExpressivenessError, type AnalystFinding, type AnalystFindingScore, type AnalystHooks, type AnalystInputKind, type AnalystInstructionsOverride, type AnalystIssueExpectation, type AnalystLatencyDistribution, type AnalystMetricComparison, type AnalystProfileFragment, AnalystRegistry, type AnalystRegistryOptions, type AnalystRepairDeclaration, type AnalystRequirements, type AnalystRowExpansion, type AnalystRunEvent, type AnalystRunInputs, type AnalystRunResult, type AnalystRunSummary, type AnalystRunnerComparison, type AnalystSeverity, type AnalystTransportBinding, type AnalystUsageReceipt, type AskTraceQuestionsOptions, type BehavioralAnalystOptions, type BudgetPolicy, CODE_TRACE_BENCH_ANALYST_PROMPT, CONTROL_INTEGRITY_ANALYST, type ChatCallOpts, type ChatClient, type ChatRequest, type ChatResponse, type ChatTraceEngineOptions, type ChatTransport, type ChunkedEvidenceBinding, type CodeTraceBenchCaseOptions, type CodeTraceBenchLabelOptions, type CodeTraceBenchLabelSet, type CodeTraceBenchRow, type CodeTraceBlockDiagnostics, type CodeTraceCalibrationRunnerSummary, type CodeTraceCalibrationSummary, type CodeTraceFailureBlock, 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_OUTPUT_TOKENS, type DecodedReply, type DefaultAnalystRegistryOptions, type DefineCustomAnalystOptions, type DefineExactCustomAnalystOptions, type DiffPolicy, type DspyRlmTraceEngineOptions, type EvidenceProjection, 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, type ExecutionProbe, type ExecutionProbeOutcome, type ExecutionProbeRequest, type ExpandRowsArgs, FAILURE_MODE_KIND_SPEC, FINDING_SUBJECT_KINDS, FINDING_SUBJECT_SYNTAX, type FindingSubject, type FindingSubjectKind, type FindingsDiff, FindingsStore, IMPROVEMENT_KIND_SPEC, type InlineEvidenceBinding, KIND_EXPECTED_SUBJECTS, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type LoadedVerificationArtifacts, MAX_INCORRECT_BLOCKS, MAX_INCORRECT_BLOCK_STEPS, type MockTransportOpts, type OpenAiCompatibleTransportOpts, type PersistedFinding, type PreparedPublicAnalystBenchmark, type PrimeBenchmarkRunnerOptions, type PrimeBridgeTransport, type PrimeBridgeTransportRequest, type PrimeBridgeTransportResult, type PrimeCodeTraceDefinitionArgs, type PrimeExchangeOptions, type PrimeExchangeOutcome, type PrimeFailure, type PrimeProjectionDelivery, type PrimeProjectionOutcome, type PrimeProjectionSource, type PrimePromptSpec, type PrimeProtocolIdentity, type PrimeRawUsage, type PrimeRejectedRow, type PrimeRepairPromptSpec, type PrimeRepairState, type PrimeReplyContract, type PrimeRowDecoded, type PrimeTurnRecord, type ProposalFinding, type ProposalFindingOrigin, type PublicAnalystBenchmarkDataset, type PublicAnalystBenchmarkModelConfig, type PublicAnalystBenchmarkModelOwner, type PublicAnalystBenchmarkModelSettings, type PublicBenchmarkDistributions, type PublicBenchmarkModelPrediction, type PublicBenchmarkSelectionReport, type PublicBenchmarkValueDistribution, type PublicDirectDefinitionArgs, type PublicRlmDefinitionArgs, RAW_FINDING_SCHEMA_PROMPT, type RawAnalystEvidence, type RawAnalystFinding, RawAnalystFindingSchema, type RegistryRunOpts, type ReplVariableConsensusPort, type ReplVariableEvidenceBinding, type ReplyContract, type ReplyEnvelope, type ReplyRowDecoded, type ReplyRowRejection, type RunAnalystBenchmarkOptions, SKILL_USAGE_ANALYST, type SandboxSdkTransportOpts, type SemanticConceptJudgeAdapterOpts, type SkillUsageRecord, type SkillUsageReport, type SkillUsageScanConfig, type StepLabelAdapterOptions, type TraceAnalysisEngine, type TraceAnalysisEngineRequest, type TraceAnalysisEngineResult, type TraceAnalystDefinition, type TraceAnalystLimits, type TraceQuestionOutcome, type TraceQuestionSpec, type TraceToolGroupName, type UpstreamPredictionAdapterOptions, type VerificationArtifactFile, type VerificationArtifactManifest, type VerificationArtifactRole, type VerificationAvailabilitySummary, type VerificationOutcome, type VerificationOutcomeSource, type VerificationOutcomeStatus, type VerificationResultFile, type VerifiedTraceFinding, adaptPublicBenchmarkFindings, agentRxBenchmarkCase, agentRxPredictionsToFindings, analystBenchmarkDependencyLockDigest, analystBenchmarkImplementationDigest, analystDefinitionAsymmetries, analystDefinitionProtocolSha256, analystInstructionsOverrideFromText, analystUsageReceiptFromPrimeUsage, appendVerificationArtifactsToOtlp, askTraceQuestions, assertProposalFindings, behavioralAnalyst, bindAnalyst, buildDefaultAnalystRegistry, buildPrimePrompt, buildPrimeRepairPrompt, buildSkillUsageReport, buildTraceToolsForGroup, citedSpansOnly, codeTraceBenchCase, codeTracerPredictionsToFindings, coerceJson, compareAnalystRunners, computeFindingId, createChatClient, createChatTraceEngine, createDspyRlmTraceEngine, createPrimeBenchmarkRunner, createPublicBenchmarkDirectRunner, createPublicBenchmarkRlmRunner, createSemanticConceptJudgeAdapter, createTraceAnalyst, decodeReplyRows, defaultIsMaterial, defineCustomAnalyst, defineTraceAnalyst, deriveEfficiencyFindings, diffFindings, effectiveAnalystProtocolSha256, emitControlIntegrityFindings, emitSkillUsageFindings, emptyPrimeRawUsage, emptyPublicBenchmarkRunner, evidenceRefsFromRawFinding, expandCodeTraceFailureBlocks, extractPrimeJsonObject, findingSubjectGrammarPromptFor, isProposalFinding, loadCodeTraceVerificationArtifacts, loadPublicBenchmarkRows, makeFinding, makeProposalFinding, mergePrimeRawUsage, nodeHttpPrimeBridgeTransport, normalizeAgentRxCategory, normalizeBenchmarkLabel, normalizePrimeUsage, parseFindingSubject, parseRawFinding, parseVerificationOutcome, preparePublicAnalystBenchmark, primeAnalystProtocolSha256, primeCodeTraceAnalystDefinition, primeProtocolSha256, primeReplyDefect, projectPrimeTrajectory, publicBenchmarkDistributions, publicBenchmarkProtocolSha256, publicBenchmarkRlmInstructions, publicBenchmarkSelectionReport, publicBenchmarkSystemPrompt, publicDirectAnalystDefinition, publicRlmAnalystDefinition, readAnalystBenchmarkArtifact, readAnalystInstructionsOverride, registryBenchmarkRunner, renderAgentRxCalibrationMarkdown, renderAnalystBenchmarkMarkdown, renderCodeTraceCalibrationMarkdown, renderFindingSubject, renderPriorFindings, resolveTraceAnalystLimits, rlmEngineLimits, roundAgentRxStep, runAnalystBenchmark, runAnalystBenchmarkCommand, runPrimeExchange, runTraceAnalyst, scoreAnalystFindings, selectPublicBenchmarkRows, stripCodeFences, summarizeAgentRxCalibration, summarizeAnalystBenchmarkRunner, summarizeCodeTraceCalibration, traceStoreEvidenceResolver };
+export { 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 AnalystBudgetDeclaration, type AnalystComparisonMetric, type AnalystContext, type AnalystCost, type AnalystDefinition, type AnalystDefinitionAsymmetry, type AnalystDefinitionAsymmetryReport, type AnalystEvidenceBinding, type AnalystEvidenceExpectation, type AnalystEvidenceResolution, type AnalystEvidenceResolutionError, type AnalystEvidenceResolver, type AnalystFinding, type AnalystFindingScore, type AnalystHooks, type AnalystInputKind, type AnalystInstructionsOverride, type AnalystIssueExpectation, type AnalystLatencyDistribution, type AnalystMetricComparison, type AnalystProfileFragment, AnalystRegistry, type AnalystRegistryOptions, type AnalystRepairDeclaration, type AnalystRequirements, type AnalystRowExpansion, type AnalystRunEvent, type AnalystRunInputs, type AnalystRunResult, type AnalystRunSummary, type AnalystRunnerComparison, type AnalystSeverity, type AnalystTransportBinding, type AnalystUsageReceipt, type AskTraceQuestionsOptions, type BehavioralAnalystOptions, type BudgetPolicy, CONTROL_INTEGRITY_ANALYST, type ChatCallOpts, type ChatClient, type ChatRequest, type ChatResponse, type ChatTraceEngineOptions, type ChatTransport, type ChunkedEvidenceBinding, type CodeTraceBenchCaseOptions, type CodeTraceBenchLabelOptions, type CodeTraceBenchLabelSet, type CodeTraceBenchRow, type CodeTraceBlockDiagnostics, type CodeTraceCalibrationRunnerSummary, type CodeTraceCalibrationSummary, type CodeTraceFailureBlock, type CodeTraceStageAnnotation, type CodeTracerLabelGroup, type CodeTracerPredictionAdapterOptions, type CodeTracerPredictions, type CodeTracerStepLabel, ControlIntegrityAnalyst, type CreateChatClientOpts, type CreateTraceAnalystOptions, type CustomTransportOpts, DEFAULT_TRACE_ANALYST_KINDS, DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS, type DecodedReply, type DefaultAnalystRegistryOptions, type DefineCustomAnalystOptions, type DefineExactCustomAnalystOptions, type DiffPolicy, type DspyRlmTraceEngineOptions, type EvidenceProjection, 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, type ExecutionProbe, type ExecutionProbeOutcome, type ExecutionProbeRequest, type ExpandRowsArgs, FAILURE_MODE_KIND_SPEC, FINDING_SUBJECT_KINDS, FINDING_SUBJECT_SYNTAX, type FindingSubject, type FindingSubjectKind, type FindingsDiff, FindingsStore, IMPROVEMENT_KIND_SPEC, type InlineEvidenceBinding, KIND_EXPECTED_SUBJECTS, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type LoadedVerificationArtifacts, type MockTransportOpts, type OpenAiCompatibleTransportOpts, type PersistedFinding, type PreparedPublicAnalystBenchmark, type PrimeBenchmarkRunnerOptions, type PrimeBridgeTransport, type PrimeBridgeTransportRequest, type PrimeBridgeTransportResult, type PrimeCodeTraceDefinitionArgs, type PrimeExchangeOptions, type PrimeExchangeOutcome, type PrimeFailure, type PrimeProjectionDelivery, type PrimeProjectionOutcome, type PrimeProjectionSource, type PrimePromptSpec, type PrimeProtocolIdentity, type PrimeRawUsage, type PrimeRejectedRow, type PrimeRepairPromptSpec, type PrimeRepairState, type PrimeReplyContract, type PrimeRowDecoded, type PrimeTurnRecord, type ProposalFinding, type ProposalFindingOrigin, type PublicAnalystBenchmarkDataset, type PublicAnalystBenchmarkModelConfig, type PublicAnalystBenchmarkModelOwner, type PublicAnalystBenchmarkModelSettings, type PublicBenchmarkDistributions, type PublicBenchmarkModelPrediction, type PublicBenchmarkSelectionReport, type PublicBenchmarkValueDistribution, type PublicDirectDefinitionArgs, type PublicRlmDefinitionArgs, RAW_FINDING_SCHEMA_PROMPT, type RawAnalystEvidence, type RawAnalystFinding, RawAnalystFindingSchema, type RegistryRunOpts, type ReplVariableConsensusPort, type ReplVariableEvidenceBinding, type ReplyContract, type ReplyEnvelope, type ReplyRowDecoded, type ReplyRowRejection, type RunAnalystBenchmarkOptions, type SandboxSdkTransportOpts, type SemanticConceptJudgeAdapterOpts, type SkillUsageRecord, type SkillUsageReport, type SkillUsageScanConfig, type StepLabelAdapterOptions, type TraceAnalysisEngine, type TraceAnalysisEngineRequest, type TraceAnalysisEngineResult, type TraceAnalystDefinition, type TraceAnalystLimits, type TraceQuestionOutcome, type TraceQuestionSpec, type TraceToolGroupName, type UpstreamPredictionAdapterOptions, type VerificationArtifactFile, type VerificationArtifactManifest, type VerificationArtifactRole, type VerificationAvailabilitySummary, type VerificationOutcome, type VerificationOutcomeSource, type VerificationOutcomeStatus, type VerificationResultFile, type VerifiedTraceFinding, analystUsageReceiptFromPrimeUsage, askTraceQuestions, behavioralAnalyst, buildDefaultAnalystRegistry, buildPrimePrompt, buildPrimeRepairPrompt, buildTraceToolsForGroup, citedSpansOnly, computeFindingId, createChatClient, createChatTraceEngine, createDspyRlmTraceEngine, createTraceAnalyst, decodeReplyRows, defaultIsMaterial, deriveEfficiencyFindings, diffFindings, emitControlIntegrityFindings, emptyPrimeRawUsage, evidenceRefsFromRawFinding, extractPrimeJsonObject, findingSubjectGrammarPromptFor, makeFinding, makeProposalFinding, mergePrimeRawUsage, nodeHttpPrimeBridgeTransport, normalizePrimeUsage, parseFindingSubject, parseRawFinding, primeProtocolSha256, primeReplyDefect, projectPrimeTrajectory, registryBenchmarkRunner, renderFindingSubject, renderPriorFindings, resolveTraceAnalystLimits, runAnalystBenchmark, runPrimeExchange, runTraceAnalyst, scoreAnalystFindings, 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/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/definition.ts","../../src/analyst/benchmark-public-prompt.ts","../../src/analyst/benchmark-public-model.ts","../../src/analyst/benchmark-public-rlm.ts","../../src/analyst/benchmark-runner-prime.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-instructions-override.ts","../../src/analyst/benchmark-report.ts","../../src/analyst/benchmark-summary.ts","../../src/analyst/bind.ts","../../src/analyst/define.ts","../../src/analyst/kinds/skill-usage.ts","../../src/analyst/parse-tolerant.ts","../../src/analyst/proposal-findings.ts"],"mappings":";;;;;;;;;;;;;;;UA8CiB;EACf;EACA;;EAEA,SAAS,KAAK;;EAEd;;iBAGc,kCACd,MAAM,kCACL,QAAQ;;;cCtDE;UAEI;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA,SAAS;;iBAGK,4BACd,QAAQ,wBACR,2BACC;iBAkBa,iCAAiC,SAAS;;;KCtD9C;UAEK;EACf,YAAY;EACZ;EACA;EACA;EACA;EACA;;UAGe;EACf,eAAe;EACf,mBAAmB;EACnB;IAAe,YAAY;IAAY;;EACvC,wBAAwB;EACxB;EACA;EACA;;UAGe;EACf,UAAU;EACV;EACA;EACA;EACA;;UAGe;EACf,UAAU;EACV,mBAAmB;EACnB;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA,iBAAiB;;KAGP,0CAEC,sCACA,iCACA;UAEI;EACf;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA,oCAAoC;;UAGrB;EACf,eAAe;EACf,WAAW,sBAAsB;;KAGvB;UAEK;;;;;EAKf,WAAW;;UAGI,kCACP,yBACN;UAEa,oCAAoC;EACnD;;EAEA;;UAGe,yCAAyC;EACxD;EACA;EACA;EACA;;UAGe,2CACP,kCACN;;;iBCtGY,qBAAqB,QACnC,KAAK,YACL,OAAO,QACP,UAAS,8BACR,qBAAqB;;iBAsGR,6BACd,mBAAmB,YACnB,iBACA,UAAS,mCACR;iBA6Ea,yBAAyB;;iBAoNzB,iBAAiB;;;iBC/YjB,mBAAmB,QACjC,KAAK,mBACL,OAAO,QACP,UAAS,4BACR,qBAAqB;;iBAwFR,gCACd,2BACA,aAAa,uBACb,UAAS,qCACR;;;iBClHa,wBAAwB;;;KCA5B;UAEK;EACf;EACA;EACA,QAAQ;;UAGO;EACf,QAAQ;EACR;EAKA;IAAe;IAAe;;EAC9B,SAAS;EACT;EACA;EACA;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;;;;iBA8EE;UAIC;;EAEf;;EAEA;;;;;;iBAOc,gCACd,MAAM,+BACL,kBAAkB;;iBAyDL,2BACd,SAAS,8BACR,uBAAuB;;;;;;;;;;cC5OpB;WACQ;WACC;WACK;WACd;WACkB;WACJ;WACO;WACD;WACJ;WACK;WACd;WACJ;WACM;WACC;WACG;WACH;WACI;WACT;;KAGC,uCAAuC;UAgBlC;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;;;UC3Fc;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;;;UCpC3C;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;;MAEA;MACA;;MAEA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,UAAU;MACV;QACE;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;MAEF;QACE;QACA;QACA;;MAEF;MACA;MACA;;MAEA;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;MACA;MACA;MACA;MACA;MACA;MACA,SAAS;MACT;QACE;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;MAEF;QACE;QACA;QACA;;;IAGJ;IACA;IACA;IACA;;IAEA;IACA;IACA;IACA;;IAEA;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;;IAEA;;EAEF;EACA;IACE;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;IACA;IACA;;;UAIa;EACf;EACA;EACA;EACA,aAAa;EACb;;cAGW;cACA;cACA;cACA;;;iBC5KS,6BACpB,eACC,QAAQ;;;UCuEM;EACf,uBACE,SAAS,+BACT,QAAQ,wCACL,uBAAuB;EAC5B,2BACE,mBACA;IACE;IACA,aAAa,SAAS,OAAO;QAE5B,QAAQ;;;;;;;;;KAUH;;UAGK;EACf;EACA;;UAGe;EACf,SAAS;EACT,SAAS;EACT;EACA;EACA;EACA;EACA;EACA;EACA,OAAO;EACP;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA,QAAQ;EACR;EACA;;iBAKoB,2BACpB,yBACA,MAAK,OAAO,YACZ,eAAc,sCACb;;;cCzJU;;;cAIA;cAGA;cAOA;cAYA;cAGA;cAGA;cAiHA;iBAGG;iBAIA;;;;iBC/IA,oCAAoC,eAAe;;iBAQnD,gCAAgC,eAAe;;;;;;;;;;;iBAyB/C,+BACd,SAAS,+BACT,WAAW,KAAK;;;iBCzCF,+BACd,QAAQ,wBACR,uBAAsB;;;iBCIR,gCACd,kBACA,uBAAuB,gCACtB;;;;KCcS;;WAGG;WACA;WACA;WACA,YAAY;WACZ,UAAU;;;WAIV;WACA,QAAQ;;;;;;iBAOP,YAAY,MAAM,aAAa,QAC7C,YAAY,kBAAkB,MAAM,aAAa,SACjD,YAAY,0BACX,uBAAuB;;;;;;;;;;iBCpCV,mBAAmB,YAAY,yBAAyB;UAkBvD;EACf;EACA;EACA;EACA,MAAM;EACN,SAAS,QAAQ;;UAGF,wCAAwC;;EAEvD,iBAAiB,SAAS;;;iBAIZ,oBACd,SAAS,kCACR,oBAAoB;iBACP,oBACd,SAAS,6BACR,QAAQ;;;KCpBC;;UAGK;EACf;EACA,MAAM;;EAEN;EACA;;EAEA;;EAEA;;;EAGA;;EAEA;;EAEA;EACA;EACA;;EAEA;;EAEA;;UAGe;EACf;EACA,SAAS;;UAGM;;EAEf;;EAEA;IAAc;IAAc,MAAM;;;EAElC;;;EAGA,kBAAkB;;EAElB;;;iBA2Ec,sBAAsB,QAAQ,uBAAuB;;iBAiHrD,uBACd,QAAQ,kBACR,qBACC;cA2HG,6BAA6B,oBAAoB;WAC5C;WACA;WAEA;WACA;IAAS;IAAgC;;WACzC;WACA;aACP;aACA;aACA;;EAGI,QAAQ,OAAO,kBAAkB,KAAK,iBAAiB,QAAQ;;cAS1D,qBAAmB;;;;;;;;;;;;;;;iBC5YhB,gBAAgB;;;;;iBAgBhB,WAAW;;;;iBCIX,kBAAkB,mBAAmB,WAAW;;;;;;iBAShD,uBACd,mBACA,mBACC,cAAc"}
+{"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/definition.ts","../../src/analyst/benchmark-public-prompt.ts","../../src/analyst/benchmark-public-model.ts","../../src/analyst/benchmark-public-rlm.ts","../../src/analyst/benchmark-runner-prime.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-instructions-override.ts","../../src/analyst/benchmark-report.ts","../../src/analyst/benchmark-summary.ts","../../src/analyst/bind.ts","../../src/analyst/define.ts","../../src/analyst/kinds/skill-usage.ts","../../src/analyst/parse-tolerant.ts","../../src/analyst/proposal-findings.ts"],"mappings":";;;;;;;;;;;;;;;UA8CiB;EACf;EACA;;EAEA,SAAS,KAAK;;EAEd;;wBAGc,kCACd,MAAM,kCACL,QAAQ;;;qBCtDE;UAEI;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA,SAAS;;wBAGK,4BACd,QAAQ,wBACR,2BACC;wBAkBa,iCAAiC,SAAS;;;KCtD9C;UAEK;EACf,YAAY;EACZ;EACA;EACA;EACA;EACA;;UAGe;EACf,eAAe;EACf,mBAAmB;EACnB;IAAe,YAAY;IAAY;;EACvC,wBAAwB;EACxB;EACA;EACA;;UAGe;EACf,UAAU;EACV;EACA;EACA;EACA;;UAGe;EACf,UAAU;EACV,mBAAmB;EACnB;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA,iBAAiB;;KAGP,0CAEC,sCACA,iCACA;UAEI;EACf;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA,oCAAoC;;UAGrB;EACf,eAAe;EACf,WAAW,sBAAsB;;KAGvB;UAEK;;;;;EAKf,WAAW;;UAGI,kCACP,yBACN;UAEa,oCAAoC;EACnD;;EAEA;;UAGe,yCAAyC;EACxD;EACA;EACA;EACA;;UAGe,2CACP,kCACN;;;wBCtGY,qBAAqB,QACnC,KAAK,YACL,OAAO,QACP,UAAS,8BACR,qBAAqB;;wBAsGR,6BACd,mBAAmB,YACnB,iBACA,UAAS,mCACR;wBA6Ea,yBAAyB;;wBAoNzB,iBAAiB;;;wBC/YjB,mBAAmB,QACjC,KAAK,mBACL,OAAO,QACP,UAAS,4BACR,qBAAqB;;wBAwFR,gCACd,2BACA,aAAa,uBACb,UAAS,qCACR;;;wBClHa,wBAAwB;;;KCA5B;UAEK;EACf;EACA;EACA,QAAQ;;UAGO;EACf,QAAQ;EACR;EAKA;IAAe;IAAe;;EAC9B,SAAS;EACT;EACA;EACA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YAAY;;;;;;wBA8EE;UAIC;;EAEf;;EAEA;;;;;;wBAOc,gCACd,MAAM,+BACL,kBAAkB;;wBAyDL,2BACd,SAAS,8BACR,uBAAuB;;;;;;;;;;cC5OpB;WACQ;WACC;WACK;WACd;WACkB;WACJ;WACO;WACD;WACJ;WACK;WACd;WACJ;WACM;WACC;WACG;WACH;WACI;WACT;;KAGC,uCAAuC;UAgBlC;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;;wBASK,sBACd,QAAQ,wBACR;EACE;EACA;EACA;EACA;EACA;IAED;;;UC3Fc;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;;wBAGK,8BACd,QAAQ,yBACP;wBAca,mCAAmC,SAAS;;;UCpC3C;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;;MAEA;MACA;;MAEA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,UAAU;MACV;QACE;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;MAEF;QACE;QACA;QACA;;MAEF;MACA;MACA;;MAEA;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;MACA;MACA;MACA;MACA;MACA;MACA,SAAS;MACT;QACE;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;MAEF;QACE;QACA;QACA;;;IAGJ;IACA;IACA;IACA;;IAEA;IACA;IACA;IACA;;IAEA;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;;IAEA;;EAEF;EACA;IACE;IACA;IACA;;EAEF;IACE;IACA;IACA;IACA;IACA;IACA;;;UAIa;EACf;EACA;EACA;EACA,aAAa;EACb;;qBAGW;qBACA;qBACA;qBACA;;;wBC5KS,6BACpB,eACC,QAAQ;;;UCuEM;EACf,uBACE,SAAS,+BACT,QAAQ,wCACL,uBAAuB;EAC5B,2BACE,mBACA;IACE;IACA,aAAa,SAAS,OAAO;QAE5B,QAAQ;;;;;;;;;KAUH;;UAGK;EACf;EACA;;UAGe;EACf,SAAS;EACT,SAAS;EACT;EACA;EACA;EACA;EACA;EACA;EACA,OAAO;EACP;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA,QAAQ;EACR;EACA;;wBAKoB,2BACpB,yBACA,MAAK,OAAO,YACZ,eAAc,sCACb;;;qBCzJU;;;qBAIA;qBAGA;qBAOA;qBAYA;qBAGA;qBAGA;qBAiHA;wBAGG;wBAIA;;;;wBC/IA,oCAAoC,eAAe;;wBAQnD,gCAAgC,eAAe;;;;;;;;;;;wBAyB/C,+BACd,SAAS,+BACT,WAAW,KAAK;;;wBCzCF,+BACd,QAAQ,wBACR,uBAAsB;;;wBCIR,gCACd,kBACA,uBAAuB,gCACtB;;;;KCcS;;WAGG;WACA;WACA;WACA,YAAY;WACZ,UAAU;;;WAIV;WACA,QAAQ;;;;;;wBAOP,YAAY,MAAM,aAAa,QAC7C,YAAY,kBAAkB,MAAM,aAAa,SACjD,YAAY,0BACX,uBAAuB;;;;;;;;;;wBCpCV,mBAAmB,YAAY,yBAAyB;UAkBvD;EACf;EACA;EACA;EACA,MAAM;EACN,SAAS,QAAQ;;UAGF,wCAAwC;;EAEvD,iBAAiB,SAAS;;;wBAIZ,oBACd,SAAS,kCACR,oBAAoB;wBACP,oBACd,SAAS,6BACR,QAAQ;;;KCpBC;;UAGK;EACf;EACA,MAAM;;EAEN;EACA;;EAEA;;EAEA;;;EAGA;;EAEA;;EAEA;EACA;EACA;;EAEA;;EAEA;;UAGe;EACf;EACA,SAAS;;UAGM;;EAEf;;EAEA;IAAc;IAAc,MAAM;;;EAElC;;;EAGA,kBAAkB;;EAElB;;;wBA2Ec,sBAAsB,QAAQ,uBAAuB;;wBAiHrD,uBACd,QAAQ,kBACR,qBACC;cA2HG,6BAA6B,oBAAoB;WAC5C;WACA;WAEA;WACA;IAAS;IAAgC;;WACzC;WACA;aACP;aACA;aACA;;EAGI,QAAQ,OAAO,kBAAkB,KAAK,iBAAiB,QAAQ;;qBAS1D,qBAAmB;;;;;;;;;;;;;;;wBC5YhB,gBAAgB;;;;;wBAgBhB,WAAW;;;;wBCIX,kBAAkB,mBAAmB,WAAW;;;;;;wBAShD,uBACd,mBACA,mBACC,cAAc"}

package/dist/analyst/index.js

@@ -2,13 +2,13 @@ import { i as CostLedger } from "../cost-ledger-_IbkejCF.js";
 import { n as assertProposalFindings, r as isProposalFinding } from "../abort-signal-CtzAM_sJ.js";
 import { B as FINDING_SUBJECT_SYNTAX, F as parseRawFinding, G as DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS, H as findingSubjectGrammarPromptFor, I as parseTraceSpanEvidenceUri, K as resolveTraceAnalystLimits, L as coerceJson, M as RAW_FINDING_SCHEMA_PROMPT, N as RawAnalystFindingSchema, P as evidenceRefsFromRawFinding, R as stripCodeFences, U as parseFindingSubject, V as KIND_EXPECTED_SUBJECTS, W as renderFindingSubject, i as buildTraceToolsForGroup, n as renderPriorFindings, r as runTraceAnalyst, t as createTraceAnalyst, z as FINDING_SUBJECT_KINDS } from "../kind-factory-CdPPHtGZ.js";
 import { i as validateUsageSettlementTimeout, n as settleUsageReceiptFromCostLedger } from "../usage-receipt-Cx3xNeyB.js";
-import { a as KNOWLEDGE_POISONING_KIND_SPEC, c as FAILURE_MODE_KIND_SPEC, d as emitControlIntegrityFindings, f as behavioralAnalyst, i as DEFAULT_TRACE_ANALYST_KINDS, l as CONTROL_INTEGRITY_ANALYST, n as AnalystRegistry, o as KNOWLEDGE_GAP_KIND_SPEC, p as deriveEfficiencyFindings, r as ExactAnalystRunExecutionError, s as IMPROVEMENT_KIND_SPEC, t as buildDefaultAnalystRegistry, u as ControlIntegrityAnalyst } from "../default-registry-xMLX160E.js";
+import { a as KNOWLEDGE_POISONING_KIND_SPEC, c as FAILURE_MODE_KIND_SPEC, d as emitControlIntegrityFindings, f as behavioralAnalyst, i as DEFAULT_TRACE_ANALYST_KINDS, l as CONTROL_INTEGRITY_ANALYST, n as AnalystRegistry, o as KNOWLEDGE_GAP_KIND_SPEC, p as deriveEfficiencyFindings, r as ExactAnalystRunExecutionError, s as IMPROVEMENT_KIND_SPEC, t as buildDefaultAnalystRegistry, u as ControlIntegrityAnalyst } from "../default-registry-D4qXx2aG.js";
 import { i as makeProposalFinding, n as computeFindingId, r as makeFinding } from "../types-CW5b90JH.js";
-import { t as createDspyRlmTraceEngine } from "../dspy-rlm-engine-B5T43BkZ.js";
-import { a as diffFindings, i as defaultIsMaterial, n as runSemanticConceptJudge, o as createChatTraceEngine, r as FindingsStore, t as SEMANTIC_CONCEPT_JUDGE_VERSION } from "../semantic-concept-judge-2SE_kXGF.js";
-import { t as createChatClient } from "../chat-client-CJORSG_J.js";
-import { a as scoreAnalystFindings, i as summarizeAnalystBenchmarkRunner, n as runAnalystBenchmark, r as traceStoreEvidenceResolver, t as registryBenchmarkRunner } from "../benchmark-BeQJyrRC.js";
-import { $ as ANALYST_BENCHMARK_MANIFEST_FILE, A as readAnalystInstructionsOverride, B as parseVerificationOutcome, C as emptyPublicBenchmarkRunner, D as summarizeCodeTraceCalibration, E as renderCodeTraceCalibrationMarkdown, F as publicBenchmarkRlmInstructions, G as ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256, H as ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES, I as publicBenchmarkSystemPrompt, J as ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, K as ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM, L as DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES, M as MAX_INCORRECT_BLOCKS, N as MAX_INCORRECT_BLOCK_STEPS, O as analystInstructionsOverrideFromText, P as publicBenchmarkProtocolSha256, Q as ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, R as appendVerificationArtifactsToOtlp, S as adaptPublicBenchmarkFindings, T as readAnalystBenchmarkArtifact, U as ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256, V as ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM, W as ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256, X as analystBenchmarkImplementationDigest, Y as analystBenchmarkDependencyLockDigest, Z as ANALYST_BENCHMARK_COST_LEDGER_FILE, _ as publicDirectAnalystDefinition, a as primeCodeTraceAnalystDefinition, at as codeTraceBenchCase, b as analystDefinitionAsymmetries, c as preparePublicAnalystBenchmark, ct as agentRxPredictionsToFindings, d as selectPublicBenchmarkRows, dt as normalizeBenchmarkLabel, et as ANALYST_BENCHMARK_OBSERVATIONS_FILE, f as createPublicBenchmarkRlmRunner, g as createPublicBenchmarkDirectRunner, h as runReplVariableAnalystDefinition, i as primeAnalystProtocolSha256, it as summarizeAgentRxCalibration, j as CODE_TRACE_BENCH_ANALYST_PROMPT, k as effectiveAnalystProtocolSha256, l as publicBenchmarkDistributions, lt as normalizeAgentRxCategory, m as rlmEngineLimits, n as renderAnalystBenchmarkMarkdown, nt as AGENT_RX_UPSTREAM_REVISION, o as runInlineAnalystDefinition, ot as codeTracerPredictionsToFindings, p as publicRlmAnalystDefinition, q as ANALYST_BENCHMARK_IMPLEMENTATION_FILES, r as createPrimeBenchmarkRunner, rt as renderAgentRxCalibrationMarkdown, s as loadPublicBenchmarkRows, st as agentRxBenchmarkCase, t as runAnalystBenchmarkCommand, tt as compareAnalystRunners, u as publicBenchmarkSelectionReport, ut as roundAgentRxStep, v as runChunkedAnalystDefinition, w as expandCodeTraceFailureBlocks, x as analystDefinitionProtocolSha256, y as AnalystExpressivenessError, z as loadCodeTraceVerificationArtifacts } from "../benchmark-command-EBmuMUBo.js";
+import { t as createDspyRlmTraceEngine } from "../dspy-rlm-engine-US8YsYGq.js";
+import { a as diffFindings, i as defaultIsMaterial, n as runSemanticConceptJudge, o as createChatTraceEngine, r as FindingsStore, t as SEMANTIC_CONCEPT_JUDGE_VERSION } from "../semantic-concept-judge-BcjYg37z.js";
+import { t as createChatClient } from "../chat-client-DUhWNQQS.js";
+import { a as scoreAnalystFindings, i as summarizeAnalystBenchmarkRunner, n as runAnalystBenchmark, r as traceStoreEvidenceResolver, t as registryBenchmarkRunner } from "../benchmark-BywPeAUo.js";
+import { $ as ANALYST_BENCHMARK_MANIFEST_FILE, A as readAnalystInstructionsOverride, B as parseVerificationOutcome, C as emptyPublicBenchmarkRunner, D as summarizeCodeTraceCalibration, E as renderCodeTraceCalibrationMarkdown, F as publicBenchmarkRlmInstructions, G as ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256, H as ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES, I as publicBenchmarkSystemPrompt, J as ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, K as ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM, L as DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES, M as MAX_INCORRECT_BLOCKS, N as MAX_INCORRECT_BLOCK_STEPS, O as analystInstructionsOverrideFromText, P as publicBenchmarkProtocolSha256, Q as ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, R as appendVerificationArtifactsToOtlp, S as adaptPublicBenchmarkFindings, T as readAnalystBenchmarkArtifact, U as ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256, V as ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM, W as ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256, X as analystBenchmarkImplementationDigest, Y as analystBenchmarkDependencyLockDigest, Z as ANALYST_BENCHMARK_COST_LEDGER_FILE, _ as publicDirectAnalystDefinition, a as primeCodeTraceAnalystDefinition, at as codeTraceBenchCase, b as analystDefinitionAsymmetries, c as preparePublicAnalystBenchmark, ct as agentRxPredictionsToFindings, d as selectPublicBenchmarkRows, dt as normalizeBenchmarkLabel, et as ANALYST_BENCHMARK_OBSERVATIONS_FILE, f as createPublicBenchmarkRlmRunner, g as createPublicBenchmarkDirectRunner, h as runReplVariableAnalystDefinition, i as primeAnalystProtocolSha256, it as summarizeAgentRxCalibration, j as CODE_TRACE_BENCH_ANALYST_PROMPT, k as effectiveAnalystProtocolSha256, l as publicBenchmarkDistributions, lt as normalizeAgentRxCategory, m as rlmEngineLimits, n as renderAnalystBenchmarkMarkdown, nt as AGENT_RX_UPSTREAM_REVISION, o as runInlineAnalystDefinition, ot as codeTracerPredictionsToFindings, p as publicRlmAnalystDefinition, q as ANALYST_BENCHMARK_IMPLEMENTATION_FILES, r as createPrimeBenchmarkRunner, rt as renderAgentRxCalibrationMarkdown, s as loadPublicBenchmarkRows, st as agentRxBenchmarkCase, t as runAnalystBenchmarkCommand, tt as compareAnalystRunners, u as publicBenchmarkSelectionReport, ut as roundAgentRxStep, v as runChunkedAnalystDefinition, w as expandCodeTraceFailureBlocks, x as analystDefinitionProtocolSha256, y as AnalystExpressivenessError, z as loadCodeTraceVerificationArtifacts } from "../benchmark-command-DFs_i62N.js";
 import { a as extractPrimeJsonObject, c as primeProtocolSha256, d as runPrimeExchange, f as decodeReplyRows, i as emptyPrimeRawUsage, l as primeReplyDefect, n as buildPrimePrompt, o as mergePrimeRawUsage, r as buildPrimeRepairPrompt, s as normalizePrimeUsage, t as analystUsageReceiptFromPrimeUsage, u as projectPrimeTrajectory } from "../prime-protocol-DcAK9pC8.js";
 import { t as nodeHttpPrimeBridgeTransport } from "../prime-bridge-transport-Z3cpKGoV.js";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";