@tangle-network/agent-eval 0.144.5 → 0.144.7

package/dist/analyst/index.d.ts

@@ -1,14 +1,17 @@
-import { a as MultiLayerVerifier, l as VerifyOptions, o as Severity } from "../multi-layer-verifier-BHY1gWAc.js";
-import { A as parseFindingSubject, C as FINDING_SUBJECT_KINDS, D as FindingSubjectStringSchema, E as FindingSubjectKind, F as DefineExactCustomAnalystOptions, G as SemanticConceptJudgeOptions, I as defineCustomAnalyst, L as defineTraceAnalyst, M as DspyRlmTraceEngineOptions, N as createDspyRlmTraceEngine, O as KIND_EXPECTED_SUBJECTS, P as DefineCustomAnalystOptions, S as FINDING_SUBJECT_GRAMMAR_PROMPT, T as FindingSubject, W as SemanticConceptJudgeInput, Y as RunCritic, Z as RunTrace, _ as FindingsDiff, a as SkillUsageScanConfig, b as defaultIsMaterial, c as DEFAULT_TRACE_ANALYST_KINDS, d as IMPROVEMENT_KIND_SPEC, f as FAILURE_MODE_KIND_SPEC, g as DiffPolicy, h as emitControlIntegrityFindings, i as SkillUsageReport, j as renderFindingSubject, k as findingSubjectGrammarPromptFor, l as KNOWLEDGE_POISONING_KIND_SPEC, m as ControlIntegrityAnalyst, n as SkillUsageAnalyst, o as buildSkillUsageReport, p as CONTROL_INTEGRITY_ANALYST, r as SkillUsageRecord, s as emitSkillUsageFindings, t as SKILL_USAGE_ANALYST, u as KNOWLEDGE_GAP_KIND_SPEC, v as FindingsStore, w as FINDING_SUBJECT_SYNTAX, x as diffFindings, y as PersistedFinding } from "../skill-usage-DUvvudWR.js";
-import { b as CustomTokenPricing, c as CostLedgerHandle } from "../cost-ledger-FuQvHxPm.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-BjMFz88h.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-CZt1PBIk.js";
-import { a as createTraceAnalyst, c as runTraceAnalyst, d as deriveEfficiencyFindings, i as TraceAnalystDefinition, l as BehavioralAnalystOptions, n as buildDefaultAnalystRegistry, o as renderPriorFindings, r as CreateTraceAnalystOptions, s as renderUpstreamFindings, t as DefaultAnalystRegistryOptions, u as behavioralAnalyst } from "../default-registry-BwbZ9N9v.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-BQ7W90C4.js";
-import { A as ExactAnalystRunExecutionError, D as AnalystRegistryOptions, E as AnalystRegistry, M as RegistryRunOpts, N as assertExactRegistryRunOpts, O as BudgetPolicy, T as AnalystHooks, j as ExactRegistryRunOpts, k as ExactAnalystBudgetPolicy } from "../completion-verifier-VvpHRu78.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-Fmo42QVE.js";
-import { f as ExternalOptimizerModelExecutionObservation, h as ExternalOptimizerRunnerCommand, l as ExternalOptimizerModelCall } from "../external-optimizer-contracts-CdmX2K2S.js";
-import { a as TraceAnalysisEngineRequest, c as resolveTraceAnalystLimits, d as RawAnalystEvidence, f as RawAnalystEvidenceSchema, g as parseRawFinding, h as evidenceRefsFromRawFinding, i as TraceAnalysisEngine, l as ANALYST_SEVERITIES, m as RawAnalystFindingSchema, n as buildTraceToolsForGroup, o as TraceAnalysisEngineResult, p as RawAnalystFinding, r as DEFAULT_TRACE_ANALYST_LIMITS, s as TraceAnalystLimits, t as TraceToolGroupName, u as RAW_FINDING_SCHEMA_PROMPT } from "../tool-groups-ByZiqpVk.js";
+import { a as MultiLayerVerifier, l as VerifyOptions, o as Severity } from "../multi-layer-verifier-DnAqwl0h.js";
+import { A as parseFindingSubject, C as FINDING_SUBJECT_KINDS, D as FindingSubjectStringSchema, E as FindingSubjectKind, F as DefineExactCustomAnalystOptions, G as SemanticConceptJudgeOptions, I as defineCustomAnalyst, L as defineTraceAnalyst, M as DspyRlmTraceEngineOptions, N as createDspyRlmTraceEngine, O as KIND_EXPECTED_SUBJECTS, P as DefineCustomAnalystOptions, S as FINDING_SUBJECT_GRAMMAR_PROMPT, T as FindingSubject, W as SemanticConceptJudgeInput, Y as RunCritic, Z as RunTrace, _ as FindingsDiff, a as SkillUsageScanConfig, b as defaultIsMaterial, c as DEFAULT_TRACE_ANALYST_KINDS, d as IMPROVEMENT_KIND_SPEC, f as FAILURE_MODE_KIND_SPEC, g as DiffPolicy, h as emitControlIntegrityFindings, i as SkillUsageReport, j as renderFindingSubject, k as findingSubjectGrammarPromptFor, l as KNOWLEDGE_POISONING_KIND_SPEC, m as ControlIntegrityAnalyst, n as SkillUsageAnalyst, o as buildSkillUsageReport, p as CONTROL_INTEGRITY_ANALYST, r as SkillUsageRecord, s as emitSkillUsageFindings, t as SKILL_USAGE_ANALYST, u as KNOWLEDGE_GAP_KIND_SPEC, v as FindingsStore, w as FINDING_SUBJECT_SYNTAX, x as diffFindings, y as PersistedFinding } from "../skill-usage-CJlWEUFt.js";
+import { b as CustomTokenPricing, c as CostLedgerHandle } from "../cost-ledger-Bv_e8XHY.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-D216SgwM.js";
+import { I as TraceAnalystSpan, _ as ProposalFinding, a as AnalystInputKind, b as makeFinding, c as AnalystRunInputs, d as AnalystSeverity, f as AnalystUsageReceipt, g as ExecutionProbeRequest, h as ExecutionProbeOutcome, i as AnalystFinding, l as AnalystRunResult, m as ExecutionProbe, n as AnalystContext, o as AnalystRequirements, p as EvidenceRef, r as AnalystCost, s as AnalystRunEvent, t as Analyst, u as AnalystRunSummary, v as ProposalFindingOrigin, w as TraceAnalysisStore, x as makeProposalFinding, y as computeFindingId } from "../types-DF_Udrp-.js";
+import { a as createTraceAnalyst, c as runTraceAnalyst, d as deriveEfficiencyFindings, i as TraceAnalystDefinition, l as BehavioralAnalystOptions, n as buildDefaultAnalystRegistry, o as renderPriorFindings, r as CreateTraceAnalystOptions, s as renderUpstreamFindings, t as DefaultAnalystRegistryOptions, u as behavioralAnalyst } from "../default-registry-BZhStdjl.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-Djvzosly.js";
+import { A as ExactAnalystRunExecutionError, D as AnalystRegistryOptions, E as AnalystRegistry, M as RegistryRunOpts, N as assertExactRegistryRunOpts, O as BudgetPolicy, T as AnalystHooks, j as ExactRegistryRunOpts, k as ExactAnalystBudgetPolicy } from "../completion-verifier-foUCLif_.js";
+import { A as registryBenchmarkRunner, C as AnalystEvidenceResolution, D as AnalystIssueExpectation, E as AnalystFindingScore, M as traceStoreEvidenceResolver, N as scoreAnalystFindings, O as AnalystLatencyDistribution, S as AnalystEvidenceExpectation, T as AnalystEvidenceResolver, _ as AnalystBenchmarkOutput, b as AnalystBenchmarkRunner, d as AnalystBenchmarkCase, f as AnalystBenchmarkDatasetRef, g as AnalystBenchmarkObservation, h as AnalystBenchmarkLabelState, j as runAnalystBenchmark, k as RunAnalystBenchmarkOptions, m as AnalystBenchmarkError, p as AnalystBenchmarkDescriptor, t as AgentProfile, v as AnalystBenchmarkProvenance, w as AnalystEvidenceResolutionError, x as AnalystBenchmarkSummary, y as AnalystBenchmarkResult } from "../agent-profile-CgDTo40f.js";
+import { f as ExternalOptimizerModelExecutionObservation, h as ExternalOptimizerRunnerCommand, l as ExternalOptimizerModelCall } from "../external-optimizer-contracts-CZuJNcT5.js";
+import { a as TraceAnalystLimits, c as RAW_FINDING_SCHEMA_PROMPT, d as RawAnalystFinding, f as RawAnalystFindingSchema, i as TraceAnalysisEngineResult, l as RawAnalystEvidence, m as parseRawFinding, n as TraceAnalysisEngine, o as resolveTraceAnalystLimits, p as evidenceRefsFromRawFinding, r as TraceAnalysisEngineRequest, s as ANALYST_SEVERITIES, t as DEFAULT_TRACE_ANALYST_LIMITS, u as RawAnalystEvidenceSchema } from "../engine-nB64f48I.js";
+import { n as buildTraceToolsForGroup, t as TraceToolGroupName } from "../tool-groups-DIVBnJyl.js";
+import { i as nodeHttpPrimeBridgeTransport, n as PrimeBridgeTransportRequest, r as PrimeBridgeTransportResult, t as PrimeBridgeTransport } from "../prime-bridge-transport-6feEglLf.js";
+import { z } from "zod";
 //#region src/analyst/adapters.d.ts
 declare function liftSeverity(s: Severity): AnalystSeverity;
 interface VerifierAdapterOpts<Env> {
@@ -485,6 +488,320 @@ declare function preparePublicAnalystBenchmark(options: {
   seed: number;
 }): Promise<PreparedPublicAnalystBenchmark>;
 //#endregion
+//#region src/analyst/reply-contract.d.ts
+/**
+ * The reply grammar an analyst arm holds a model to, independent of transport.
+ *
+ * One contract serves every arm shape: the inline bridge protocol
+ * (`runPrimeExchange`) reads the base fields, and one-shot JSON arms
+ * additionally use the strict-envelope and all-rejected knobs. `PrimeReplyContract`
+ * in ./prime-protocol is a type alias of this contract, so a consumer written
+ * against the prime protocol names the same grammar object.
+ */
+/** Verdict of decoding one raw reply row. */
+type ReplyRowDecoded<TRow> = {
+  ok: true;
+  row: TRow;
+} | {
+  ok: false;
+  reason: string;
+};
+/** A strictly parsed reply envelope: the row array plus retained extras. */
+interface ReplyEnvelope {
+  rows: readonly unknown[];
+  /** Envelope fields beside the rows the arm retains (e.g. a `report` string). */
+  extras: Record<string, unknown>;
+}
+interface ReplyContract<TRow> {
+  /** Name of the reply's row array, e.g. `blocks` or `findings`. */
+  rowsField: string;
+  /** Row-grammar lines spliced into the first-turn prompt. */
+  contractLines: readonly string[];
+  /**
+   * The same grammar restated for the repair turn, which never carries the
+   * evidence. Empty when the arm declares zero repair turns.
+   */
+  repairContractLines: readonly string[];
+  /**
+   * Validate and convert one raw row in a single pass. One function rather than
+   * a separate validator and constructor, so the two can never disagree about
+   * what a valid row is.
+   */
+  decodeRow(row: unknown, index: number): ReplyRowDecoded<TRow>;
+  /**
+   * Cap on ACCEPTED rows. The cap is applied after decoding, so malformed rows
+   * never consume an accepted slot; the surplus is reported as `overflow`.
+   * Omit when the consumer's own expansion owns the cap and records the drop.
+   */
+  maxRows?: number;
+  /**
+   * Strict envelope parse for one-shot JSON arms. Throws on an envelope defect
+   * (missing report, unknown key, over-cap row count). When absent, rows are
+   * read from `rowsField` on the parsed reply object.
+   */
+  parseEnvelope?(value: unknown): ReplyEnvelope;
+  /**
+   * What a reply whose EVERY reported row was rejected means. `fail` throws a
+   * validation error carrying each rejection; `accept-empty` (the default)
+   * keeps the honest empty result beside the recorded rejections.
+   */
+  whenAllRowsRejected?: 'fail' | 'accept-empty';
+  /**
+   * Message prefix for the `fail` case, in the contract's own row vocabulary
+   * (e.g. "every reported failure block was malformed").
+   */
+  allRejectedMessage?: string;
+}
+/** One rejected row, indexed as the model reported it. */
+interface ReplyRowRejection {
+  index: number;
+  reason: string;
+}
+interface DecodedReply<TRow> {
+  rows: TRow[];
+  /** Envelope fields beside the rows (empty when the contract has no envelope). */
+  extras: Record<string, unknown>;
+  rejected: ReplyRowRejection[];
+  /** Rows the model reported, before decoding or the count cap. */
+  reportedRows: number;
+  /** Valid rows dropped by `maxRows`. */
+  overflow: number;
+}
+/**
+ * Decode a parsed reply value under a contract: strict envelope when declared,
+ * then per-row decoding, then the all-rejected policy. Shape before count: a
+ * malformed row never consumes an accepted slot.
+ */
+declare function decodeReplyRows<TRow>(contract: ReplyContract<TRow>, value: unknown): DecodedReply<TRow>;
+//#endregion
+//#region src/analyst/definition.d.ts
+/**
+ * The slice of the canonical `AgentProfile` an analyst definition carries:
+ * model hints (pinned model, reasoning effort) and prompt shaping. Transport
+ * bindings that own model selection leave `model.default` unset.
+ */
+type AnalystProfileFragment = Pick<AgentProfile, 'model' | 'prompt'>;
+/**
+ * How evidence reaches the model. This is the declared affordance axis of an
+ * arm: two arms answering the same question through different projections are
+ * comparable only with the difference rendered, never silently.
+ */
+type EvidenceProjection = {
+  readonly mode: 'inline';
+  /** Ceiling on serialized evidence characters embedded in one prompt. */
+  readonly maxInlineChars: number;
+  /**
+   * Per-attribute byte cap for the reduced refetch when the full
+   * projection is oversized. Still oversized after the refetch = refusal,
+   * never a silent truncation.
+   */
+  readonly cappedAttributeBytes: number;
+} | {
+  readonly mode: 'chunked';
+  /** Descending per-attribute byte caps tried until the store yields a projection. */
+  readonly attributeByteCaps: readonly number[];
+} | {
+  /** Evidence bound as an engine REPL variable, read through bounded trace tools. */
+  readonly mode: 'repl-variable';
+  readonly toolGroup: TraceToolGroupName;
+} | {
+  /** Evidence read through agent tool calls only; no REPL. */
+  readonly mode: 'agent-tools';
+  readonly toolGroup: TraceToolGroupName;
+};
+interface AnalystBudgetDeclaration {
+  /** Deadline for one model exchange. */
+  readonly timeoutMs: number;
+  /** Provider spend ceiling for one analysis, when the transport meters cost. */
+  readonly maxCostUsd?: number;
+  /** Completion-token cap per model call, when the transport enforces one. */
+  readonly maxOutputTokens?: number;
+  /** Recursive-engine iteration limits (repl-variable / agent-tools projections). */
+  readonly engineLimits?: TraceAnalystLimits;
+}
+interface AnalystRepairDeclaration {
+  /**
+   * Bounded retries a structurally malformed reply earns. Compared definitions
+   * must declare the same number: a retry is a second sample.
+   */
+  readonly turns: number;
+}
+interface AnalystRowExpansion {
+  findings: AnalystFinding[];
+  /** Arm-specific expansion diagnostics recorded in observation metadata. */
+  diagnostics?: unknown;
+}
+interface ExpandRowsArgs<TRow> {
+  /** Evidence subject the case names (e.g. a trajectory id). */
+  subject: string;
+  rows: readonly TRow[];
+  store: TraceAnalysisStore;
+  analystId: string;
+  producedAt?: string;
+  /** Model the provider reported serving, when the transport captures it. */
+  providerModel?: string;
+  signal?: AbortSignal;
+}
+/** Ports an inline-projection arm binds: prompt framing plus row expansion. */
+interface InlineEvidenceBinding<TRow> {
+  readonly kind: 'inline';
+  subjectFromCaseId(caseId: string): string;
+  /** Base observation metadata (analysis mode, engine label). */
+  readonly baseMetadata: Readonly<Record<string, unknown>>;
+  /**
+   * Line introducing the inlined evidence. Throws when the projected spans
+   * cannot ground the question (e.g. no assistant step spans).
+   */
+  header(subject: string, spans: readonly TraceAnalystSpan[]): string;
+  /** Material appended after the evidence. */
+  trailer(subject: string, spans: readonly TraceAnalystSpan[]): string;
+  expandRows(args: ExpandRowsArgs<TRow>): Promise<AnalystRowExpansion>;
+}
+/** Ports a chunked-projection one-shot arm binds. */
+interface ChunkedEvidenceBinding<TRow> {
+  readonly kind: 'chunked';
+  subjectFromCaseId(caseId: string): string;
+  readonly baseMetadata: Readonly<Record<string, unknown>>;
+  /** Actor name paid calls are attributed to in the cost ledger. */
+  readonly costActor: string;
+  /** Cost-ledger phase paid calls settle under. */
+  readonly costPhase: string;
+  /** Compose the user message around the rendered evidence. */
+  userMessage(rendered: string): string;
+  expandRows(args: ExpandRowsArgs<TRow>): Promise<AnalystRowExpansion>;
+  /** Ground accepted findings against the store; throws on unresolvable evidence. */
+  verifyFindings?(args: {
+    subject: string;
+    findings: readonly AnalystFinding[];
+    store: TraceAnalysisStore;
+    signal?: AbortSignal;
+  }): Promise<void>;
+}
+/** Majority-vote ports for a multi-sample repl-variable arm. */
+interface ReplVariableConsensusPort<TAssignment, TBlock> {
+  /** Vote across per-sample assignments; returns voted blocks plus the decision record. */
+  vote(samples: ReadonlyArray<readonly TAssignment[]>): {
+    blocks: readonly TBlock[];
+    decision: unknown;
+  };
+  /** Expand voted blocks into findings grounded in the store. */
+  expand(args: {
+    subject: string;
+    blocks: readonly TBlock[];
+    store: TraceAnalysisStore;
+    analystId: string;
+    producedAt: string;
+    signal?: AbortSignal;
+  }): Promise<AnalystRowExpansion>;
+  /** Per-sample observation record (accepted blocks, member steps). */
+  sampleRecord(assignments: readonly TAssignment[]): Record<string, unknown>;
+}
+/** Ports a repl-variable (recursive engine) arm binds. */
+interface ReplVariableEvidenceBinding<TAssignment = unknown, TBlock = unknown> {
+  readonly kind: 'repl-variable';
+  /** Identity of the trace-analyst definition the engine runs. */
+  readonly traceAnalystId: string;
+  subjectFromCaseId(caseId: string): string;
+  readonly baseMetadata: Readonly<Record<string, unknown>>;
+  /** Metadata stamped on every finding the arm emits. */
+  readonly findingBaseMetadata: Readonly<Record<string, unknown>>;
+  /** Cost-ledger phase paid calls settle under. */
+  readonly costPhase: string;
+  /** Row metadata derived from the finding's subject grammar. */
+  metadataFromSubject?(subject: string | undefined): Record<string, unknown> | undefined;
+  /** Map raw engine rows into scored findings grounded in the store. */
+  adapt(args: {
+    subject: string;
+    findings: readonly AnalystFinding[];
+    analystId: string;
+    store: TraceAnalysisStore;
+    signal?: AbortSignal;
+  }): Promise<{
+    findings: AnalystFinding[];
+    stepBlocks?: TAssignment[];
+    diagnostics?: unknown;
+  }>;
+  /** Multi-sample majority consensus; required when the arm runs samples > 1. */
+  consensus?: ReplVariableConsensusPort<TAssignment, TBlock>;
+  /** Second-opinion arm invoked when the engine submits no finding at all. */
+  abstentionFallback(config: PublicAnalystBenchmarkModelConfig): AnalystBenchmarkRunner<AnalystRunInputs>;
+}
+type AnalystEvidenceBinding<TRow, TAssignment = unknown, TBlock = unknown> = InlineEvidenceBinding<TRow> | ChunkedEvidenceBinding<TRow> | ReplVariableEvidenceBinding<TAssignment, TBlock>;
+interface AnalystDefinition<TRow = unknown, TAssignment = unknown, TBlock = unknown> {
+  /** Arm identity — appears as the runner id and in every finding. */
+  readonly id: string;
+  readonly description: string;
+  readonly version: string;
+  /** Finding area the arm's expansion stamps, when uniform per arm. */
+  readonly area?: string;
+  readonly profile: AnalystProfileFragment;
+  /** User-facing question. Empty when the task text is the whole ask. */
+  readonly question: string;
+  /** Task definition / instruction text sent beside the question. */
+  readonly taskDefinition?: string;
+  readonly projection: EvidenceProjection;
+  readonly replyContract: ReplyContract<TRow>;
+  /**
+   * Numeric limits the contract states (row caps, width caps). They enter the
+   * protocol digest; insertion order is digest-bearing because the digest
+   * serializes with `JSON.stringify`.
+   */
+  readonly contractLimits: Readonly<Record<string, number>>;
+  readonly budget: AnalystBudgetDeclaration;
+  readonly repair: AnalystRepairDeclaration;
+  /**
+   * Digest the bound arm stamps on observations. For an inline definition this
+   * equals `analystDefinitionProtocolSha256`; benchmark arms that record a
+   * shared dataset-level digest carry that digest here instead.
+   */
+  readonly protocolSha256: string;
+  readonly binding: AnalystEvidenceBinding<TRow, TAssignment, TBlock>;
+}
+/**
+ * Thrown at bind time when a definition asks for something no strategy can
+ * compile — an unknown projection × transport pair, a repair-turn count the
+ * exchange machinery cannot grant, a reasoning effort the arm cannot map. The
+ * message names the construct so an expressiveness gap is a loud, attributable
+ * failure instead of a silently narrowed protocol.
+ */
+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;
+/** One definition's declared difference from the compared set. */
+interface AnalystDefinitionAsymmetry {
+  readonly id: string;
+  readonly projectionMode: EvidenceProjection['mode'];
+  readonly reasoningEffort: NonNullable<AgentProfile['model']>['reasoningEffort'] | null;
+  readonly timeoutMs: number;
+  readonly maxCostUsd: number | null;
+  readonly maxOutputTokens: number | null;
+  /** The digest the arm records on observations. */
+  readonly protocolSha256: string;
+  /** The definition's own protocol identity. */
+  readonly definitionSha256: string;
+}
+interface AnalystDefinitionAsymmetryReport {
+  readonly ids: readonly string[];
+  /** Repair turns every compared definition declares. */
+  readonly repairTurns: number;
+  /** The one projection mode all definitions share, or null when they differ. */
+  readonly sharedProjectionMode: EvidenceProjection['mode'] | null;
+  readonly asymmetries: readonly AnalystDefinitionAsymmetry[];
+}
+/**
+ * Refuse a set of definitions that cannot be compared on equal terms, and
+ * render what still differs between the ones that can. The hard rule is the
+ * repair turn: a malformed reply must earn the same number of retries in every
+ * 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;
+//#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
@@ -506,59 +823,111 @@ declare function publicBenchmarkRlmInstructions(dataset: PublicAnalystBenchmarkD
 declare function publicBenchmarkProtocolSha256(dataset: PublicAnalystBenchmarkDataset): string;
 //#endregion
 //#region src/analyst/benchmark-public-model.d.ts
-/** One-shot JSON baseline. This is not a recursive trace analyst. */
+/**
+ * One-shot JSON baseline arm. Not a recursive trace analyst.
+ *
+ * The arm is expressed as an `AnalystDefinition`
+ * (`publicDirectAnalystDefinition`): the task text, field and envelope
+ * contracts, the descending projection ladder, and the zero-repair declaration
+ * are definition content, and `createPublicBenchmarkDirectRunner` is a thin
+ * shell that builds the definition and runs it through the chunked strategy
+ * below — the same strategy `bindAnalyst` (./bind) dispatches to.
+ */
+interface PublicDirectDefinitionArgs {
+  /** Whole-analysis deadline (`config.timeoutMs`). */
+  timeoutMs: number;
+  /** Completion-token cap per call (`config.maxOutputTokens`). */
+  maxOutputTokens: number;
+  /** Per-case provider spend ceiling (`config.maxCostUsdPerAnalysis`). */
+  maxCostUsd: number;
+}
+/** The direct arm as a declarative unit for one public dataset. */
+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>;
+declare const AgentRxPredictionSchema: z.ZodObject<{
+  step: z.ZodNumber;
+  severity: z.ZodEnum<{
+    critical: "critical";
+    high: "high";
+    info: "info";
+    low: "low";
+    medium: "medium";
+  }>;
+  claim: z.ZodString;
+  confidence: z.ZodNumber;
+  rationale: z.ZodOptional<z.ZodString>;
+  recommended_action: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const CodeTraceBlockPredictionSchema: z.ZodObject<{
+  first_step: z.ZodNumber;
+  last_step: z.ZodNumber;
+  consequence_step: z.ZodNumber;
+  escape_status: z.ZodEnum<{
+    escaped: "escaped";
+    unescaped: "unescaped";
+  }>;
+  severity: z.ZodEnum<{
+    critical: "critical";
+    high: "high";
+    info: "info";
+    low: "low";
+    medium: "medium";
+  }>;
+  claim: z.ZodString;
+  confidence: z.ZodNumber;
+  rationale: z.ZodOptional<z.ZodString>;
+  recommended_action: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const AgentRxCategorySchema: z.ZodEnum<{
+  "guardrails-triggered": "guardrails-triggered";
+  inconclusive: "inconclusive";
+  "instruction-plan-adherence-failure": "instruction-plan-adherence-failure";
+  "intent-not-supported": "intent-not-supported";
+  "intent-plan-misalignment": "intent-plan-misalignment";
+  "invalid-invocation": "invalid-invocation";
+  "invention-of-new-information": "invention-of-new-information";
+  "misinterpretation-of-tool-output-handoff-failure": "misinterpretation-of-tool-output-handoff-failure";
+  "system-failure": "system-failure";
+  "underspecified-user-intent": "underspecified-user-intent";
+}>;
+type AgentRxModelPrediction = z.infer<typeof AgentRxPredictionSchema> & {
+  category?: z.infer<typeof AgentRxCategorySchema>;
+};
+type CodeTraceModelPrediction = z.infer<typeof CodeTraceBlockPredictionSchema>;
+type PublicBenchmarkModelPrediction = AgentRxModelPrediction | CodeTraceModelPrediction;
 //#endregion
 //#region src/analyst/benchmark-public-rlm.d.ts
-/** Public benchmark candidate that runs the actual recursive trace analyst. */
-declare function createPublicBenchmarkRlmRunner(dataset: PublicAnalystBenchmarkDataset, config: PublicAnalystBenchmarkModelConfig): AnalystBenchmarkRunner<AnalystRunInputs>;
-//#endregion
-//#region src/analyst/prime-bridge-transport.d.ts
 /**
- * The bridge seam for the prime analyst protocol: one POST to an
- * OpenAI-compatible `/v1/chat/completions` endpoint, returning the raw status
- * and body text.
+ * Public benchmark candidate that runs the actual recursive trace analyst.
  *
- * Deliberately NOT `callLlm` from `../llm-client`, which serves a different
- * contract:
- *  - it retries transient failures, and a prime turn holds a single model seat
- *    for minutes — a silent second attempt doubles the seat time and the spend;
- *  - it normalizes usage, while the protocol's receipt depends on the bridge's
- *    non-standard `model_requests` and `estimated` fields;
- *  - it composes sampling and response-format options the bridge's CLI backends
- *    reject;
- *  - it collapses HTTP status, unparseable body, and empty content into two
- *    error classes, while the protocol classifies them as three distinct
- *    terminal reasons.
+ * The arm is expressed as an `AnalystDefinition` (`publicRlmAnalystDefinition`):
+ * the question, the recursive instructions (stock or override), the tool group,
+ * the engine iteration limits, and the budget are definition content, and
+ * `createPublicBenchmarkRlmRunner` is a thin shell that builds the definition
+ * and runs it through the repl-variable strategy below — the same strategy
+ * `bindAnalyst` (./bind) dispatches to.
  */
-interface PrimeBridgeTransportRequest {
-  url: string;
-  body: {
-    model: string;
-    messages: Array<{
-      role: 'user';
-      content: string;
-    }>;
-  };
-  /**
-   * The call's only deadline. The protocol aborts it on the per-call timeout
-   * and on the caller's cancellation, so a transport that imposes a second
-   * deadline of its own competes with this one.
-   */
-  signal: AbortSignal;
-}
-interface PrimeBridgeTransportResult {
-  status: number;
-  text: string;
+interface PublicRlmDefinitionArgs {
+  /** Effective recursive instructions: the override text or the stock prompt. */
+  instructions: string;
+  /** Digest the arm records: the stock digest, bound to any override. */
+  protocolSha256: string;
+  /** Whole-analysis deadline (`config.timeoutMs`). */
+  timeoutMs: number;
+  /** Controller completion-token cap (`config.maxOutputTokens`). */
+  maxOutputTokens: number;
+  /** Per-case engine spend ceiling (`config.maxCostUsdPerAnalysis`). */
+  maxCostUsd: number;
+  /** Resolved recursive-engine iteration limits. */
+  engineLimits: TraceAnalystLimits;
 }
-/** One POST to the bridge. Injectable so tests run against a fake bridge. */
-type PrimeBridgeTransport = (request: PrimeBridgeTransportRequest) => Promise<PrimeBridgeTransportResult>;
-/**
- * Default transport on node:http/node:https rather than fetch: undici's fixed
- * response-header timeout kills prime calls that legitimately run past five
- * minutes, so the request's AbortSignal is the only deadline.
- */
-declare function nodeHttpPrimeBridgeTransport(): PrimeBridgeTransport;
+/** The dspy-rlm arm as a declarative unit for one public dataset. */
+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>;
+/** Engine iteration limits with this arm's defaults applied. */
+declare function rlmEngineLimits(config: PublicAnalystBenchmarkModelConfig): TraceAnalystLimits;
 //#endregion
 //#region src/analyst/benchmark-runner-prime.d.ts
 interface PrimeBenchmarkRunnerOptions {
@@ -576,11 +945,22 @@ interface PrimeBenchmarkRunnerOptions {
   transport?: PrimeBridgeTransport;
 }
 /**
- * Digest of everything this runner can send to the bridge, recorded per
+ * 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;
-/** CodeTraceBench-only: the prompt and output contract speak its block grammar. */
+interface PrimeCodeTraceDefinitionArgs {
+  /** Deadline for one bridge call. */
+  timeoutMs: number;
+  /** 1 grants the bounded repair turn; 0 disables it. */
+  repairTurns: number;
+}
+/**
+ * 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>;
+/** Thin shell: validate options, declare the definition, run the inline strategy. */
 declare function createPrimeBenchmarkRunner(options: PrimeBenchmarkRunnerOptions): AnalystBenchmarkRunner<AnalystRunInputs>;
 //#endregion
 //#region src/analyst/benchmark-comparison.d.ts
@@ -894,7 +1274,7 @@ declare const ANALYST_BENCHMARK_HELP = "agent-eval analyst-benchmark\n\nRun the
 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 = "4785a1e0d785431f287362808dae777cf73125c551c18260117a711a5f2a6263";
+declare const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "96a42e1ad7cc0c9b00b2430ae09092c14bd5de385c696e849cb50507b9d77f02";
 /** The published benchmark evidence was produced at this package version, by
  * the retired one-shot direct runner, before trace analysts moved to the
  * recursive DSPy RLM engine. Both evidence digests below are historical facts
@@ -906,7 +1286,7 @@ declare const ANALYST_BENCHMARK_EVIDENCE_PACKAGE_VERSION = "0.137.0";
 declare const ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256 = "1e03f2daed356d60316aabefb407ec1e437ac94d408d61eea4ae096e9c6fbb5b";
 declare const ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256 = "4dba263b6256a30d56c7fdb2d992d3a953c0035d731f359b704db806f68f75ac";
 declare const ANALYST_BENCHMARK_IMPLEMENTATION_FILES: readonly string[];
-declare const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "46af7a98d6df73d845394827283390bac7a2fb9712f418b14b1093f19a21faea";
+declare const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "cc354effd79c8dfc8669c230706c67c63a06e3aff013f540806361263bae8860";
 declare function analystBenchmarkImplementationDigest(): string;
 declare function analystBenchmarkDependencyLockDigest(): string;
 //#endregion
@@ -933,6 +1313,26 @@ declare function renderAnalystBenchmarkMarkdown(result: AnalystBenchmarkResult,
 //#region src/analyst/benchmark-summary.d.ts
 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. */
+type AnalystTransportBinding = {
+  /** An OpenAI-compatible cli-bridge endpoint (inline projections). */
+  readonly kind: 'prime-bridge';
+  readonly baseUrl: string;
+  readonly model: string;
+  readonly transport?: PrimeBridgeTransport;
+  readonly pricing?: CustomTokenPricing;
+} | {
+  /** The caller-owned model path (chunked and repl-variable projections). */
+  readonly kind: 'model-owner';
+  readonly config: PublicAnalystBenchmarkModelConfig;
+};
+/**
+ * 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>;
+//#endregion
 //#region src/analyst/parse-tolerant.d.ts
 /**
  * Forgiving pre-parse for analyst findings. Weak models routinely emit
@@ -979,33 +1379,15 @@ declare function coerceToFindingRows(raw: unknown): unknown[];
  * nothing in this file may import a block type, a finding type, or a trace
  * store, and no consumer needs another copy of the protocol.
  */
-type PrimeRowDecoded<TRow> = {
-  ok: true;
-  row: TRow;
-} | {
-  ok: false;
-  reason: string;
-};
-interface PrimeReplyContract<TRow> {
-  /** Name of the reply's row array, e.g. `blocks` or `findings`. */
-  rowsField: string;
-  /** Row-grammar lines spliced into the first-turn prompt. */
-  contractLines: readonly string[];
-  /** The same grammar restated for the repair turn, which never carries the trajectory. */
-  repairContractLines: readonly string[];
-  /**
-   * Validate and convert one raw row in a single pass. One function rather than
-   * a separate validator and constructor, so the two can never disagree about
-   * what a valid row is.
-   */
-  decodeRow(row: unknown, index: number): PrimeRowDecoded<TRow>;
-  /**
-   * Cap on ACCEPTED rows. The cap is applied after decoding, so malformed rows
-   * never consume an accepted slot; the surplus is reported as `overflow`.
-   * Omit when the consumer's own expansion owns the cap and records the drop.
-   */
-  maxRows?: number;
-}
+/**
+ * The prime reply grammar is the general analyst reply contract: these aliases
+ * keep every prime-protocol consumer compiling against the shared type in
+ * ./reply-contract. The exchange below reads the base fields (`rowsField`,
+ * contract lines, `decodeRow`, `maxRows`); the strict-envelope knobs serve
+ * one-shot JSON arms and are inert here.
+ */
+type PrimeRowDecoded<TRow> = ReplyRowDecoded<TRow>;
+type PrimeReplyContract<TRow> = ReplyContract<TRow>;
 interface PrimePromptSpec {
   question: string;
   /** Task definition spliced under a `TASK DEFINITION:` heading. Omit when the question is the whole task. */
@@ -1229,5 +1611,5 @@ declare function isProposalFinding(finding: unknown): finding is ProposalFinding
  */
 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_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 AnalystInstructionsOverride, 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 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_LIMITS, type DefaultAnalystRegistryOptions, type DefineCustomAnalystOptions, type DefineExactCustomAnalystOptions, type DiffPolicy, type DirectProviderTransportOpts, type DspyRlmTraceEngineOptions, type EvidenceRef, type ExactAnalystBudgetPolicy, type ExactAnalystBudgetSnapshot, type ExactAnalystExecutionPlanSnapshot, type ExactAnalystRunCompletion, type ExactAnalystRunEvent, ExactAnalystRunExecutionError, type ExactAnalystRunPolicySnapshot, type ExactAnalystRunResult, type ExactAnalystRunSummary, type ExactAnalystSnapshot, type ExactCapableAnalyst, type ExactExecutionComponentIdentity, type ExactExecutionComponentSnapshot, type ExactRegistryRunOpts, FAILURE_MODE_KIND_SPEC, FINDING_SUBJECT_GRAMMAR_PROMPT, FINDING_SUBJECT_KINDS, FINDING_SUBJECT_SYNTAX, type FindingSubject, type FindingSubjectKind, FindingSubjectStringSchema, type FindingsDiff, FindingsStore, IMPROVEMENT_KIND_SPEC, type JudgeAdapterOpts, KIND_EXPECTED_SUBJECTS, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type LoadedVerificationArtifacts, MAX_INCORRECT_BLOCKS, MAX_INCORRECT_BLOCK_STEPS, type MockTransportOpts, type PersistedFinding, type PreparedPublicAnalystBenchmark, type PrimeBenchmarkRunnerOptions, type PrimeBridgeTransport, type PrimeBridgeTransportRequest, type PrimeBridgeTransportResult, 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 PublicBenchmarkSelectionReport, type PublicBenchmarkValueDistribution, RAW_FINDING_SCHEMA_PROMPT, type RawAnalystEvidence, RawAnalystEvidenceSchema, type RawAnalystFinding, RawAnalystFindingSchema, type RegistryRunOpts, type RouterTransportOpts, type RunAnalystBenchmarkOptions, type RunCriticAdapterOpts, SKILL_USAGE_ANALYST, type SandboxSdkTransportOpts, type SemanticConceptJudgeAdapterOpts, SkillUsageAnalyst, type SkillUsageRecord, type SkillUsageReport, type SkillUsageScanConfig, type StepLabelAdapterOptions, type TraceAnalysisEngine, type TraceAnalysisEngineRequest, type TraceAnalysisEngineResult, type TraceAnalystDefinition, type TraceAnalystLimits, type TraceToolGroupName, type UpstreamPredictionAdapterOptions, type VerificationArtifactFile, type VerificationArtifactManifest, type VerificationArtifactRole, type VerificationAvailabilitySummary, type VerificationOutcome, type VerificationOutcomeSource, type VerificationOutcomeStatus, type VerificationResultFile, type VerifierAdapterOpts, adaptPublicBenchmarkFindings, agentRxBenchmarkCase, agentRxPredictionsToFindings, analystBenchmarkDependencyLockDigest, analystBenchmarkImplementationDigest, analystInstructionsOverrideFromText, analystUsageReceiptFromPrimeUsage, appendVerificationArtifactsToOtlp, assertExactRegistryRunOpts, assertProposalFindings, behavioralAnalyst, buildDefaultAnalystRegistry, buildPrimePrompt, buildPrimeRepairPrompt, buildSkillUsageReport, buildTraceToolsForGroup, codeTraceBenchCase, codeTracerPredictionsToFindings, coerceJson, coerceToFindingRows, compareAnalystRunners, computeFindingId, createChatClient, createDspyRlmTraceEngine, createJudgeAdapter, createPrimeBenchmarkRunner, createPublicBenchmarkDirectRunner, createPublicBenchmarkRlmRunner, createRunCriticAdapter, createSemanticConceptJudgeAdapter, createTraceAnalyst, createVerifierAdapter, defaultIsMaterial, defineCustomAnalyst, defineTraceAnalyst, deriveEfficiencyFindings, diffFindings, effectiveAnalystProtocolSha256, emitControlIntegrityFindings, emitSkillUsageFindings, emptyPrimeRawUsage, emptyPublicBenchmarkRunner, evidenceRefsFromRawFinding, expandCodeTraceFailureBlocks, extractPrimeJsonObject, findingSubjectGrammarPromptFor, isProposalFinding, liftSeverity, loadCodeTraceVerificationArtifacts, loadPublicBenchmarkRows, makeFinding, makeProposalFinding, mergePrimeRawUsage, nodeHttpPrimeBridgeTransport, normalizeAgentRxCategory, normalizeBenchmarkLabel, normalizePrimeUsage, parseFindingSubject, parseRawFinding, parseVerificationOutcome, preparePublicAnalystBenchmark, primeAnalystProtocolSha256, primeProtocolSha256, primeReplyDefect, projectPrimeTrajectory, publicBenchmarkDistributions, publicBenchmarkProtocolSha256, publicBenchmarkRlmInstructions, publicBenchmarkSelectionReport, publicBenchmarkSystemPrompt, readAnalystBenchmarkArtifact, readAnalystInstructionsOverride, registryBenchmarkRunner, renderAgentRxCalibrationMarkdown, renderAnalystBenchmarkMarkdown, renderCodeTraceCalibrationMarkdown, renderFindingSubject, renderPriorFindings, renderUpstreamFindings, resolveTraceAnalystLimits, roundAgentRxStep, runAnalystBenchmark, runAnalystBenchmarkCommand, runPrimeExchange, runTraceAnalyst, scoreAnalystFindings, selectPublicBenchmarkRows, stripCodeFences, summarizeAgentRxCalibration, summarizeAnalystBenchmarkRunner, summarizeCodeTraceCalibration, traceStoreEvidenceResolver };
+export { AGENT_RX_UPSTREAM_REVISION, ANALYST_BENCHMARK_COST_LEDGER_FILE, ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM, ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES, ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_EVIDENCE_PACKAGE_VERSION, ANALYST_BENCHMARK_HELP, ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM, ANALYST_BENCHMARK_IMPLEMENTATION_FILES, ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, ANALYST_BENCHMARK_MANIFEST_FILE, ANALYST_BENCHMARK_OBSERVATIONS_FILE, ANALYST_SEVERITIES, type AgentRxBenchmarkCaseOptions, type AgentRxCalibrationRunnerSummary, type AgentRxCalibrationSummary, type AgentRxFailure, type AgentRxPrediction, type AgentRxPredictionReport, type AgentRxRow, type Analyst, type AnalystBenchmarkArtifact, type AnalystBenchmarkCase, type AnalystBenchmarkCommandConfig, type AnalystBenchmarkCommandDependencies, type AnalystBenchmarkDatasetRef, type AnalystBenchmarkDescriptor, type AnalystBenchmarkError, type AnalystBenchmarkLabelState, type AnalystBenchmarkLocalRunReceipt, type AnalystBenchmarkObservation, type AnalystBenchmarkOutput, type AnalystBenchmarkProgressRow, type AnalystBenchmarkProvenance, type AnalystBenchmarkResult, type AnalystBenchmarkRunIdentity, type AnalystBenchmarkRunManifest, type AnalystBenchmarkRunner, type AnalystBenchmarkSummary, type 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 BehavioralAnalystOptions, type BudgetPolicy, CODE_TRACE_BENCH_ANALYST_PROMPT, CONTROL_INTEGRITY_ANALYST, type ChatCallOpts, type ChatClient, type ChatRequest, type ChatResponse, type ChatTransport, type ChunkedEvidenceBinding, type CliBridgeTransportOpts, 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_LIMITS, type DecodedReply, type DefaultAnalystRegistryOptions, type DefineCustomAnalystOptions, type DefineExactCustomAnalystOptions, type DiffPolicy, type DirectProviderTransportOpts, 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_GRAMMAR_PROMPT, FINDING_SUBJECT_KINDS, FINDING_SUBJECT_SYNTAX, type FindingSubject, type FindingSubjectKind, FindingSubjectStringSchema, type FindingsDiff, FindingsStore, IMPROVEMENT_KIND_SPEC, type InlineEvidenceBinding, type JudgeAdapterOpts, KIND_EXPECTED_SUBJECTS, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type LoadedVerificationArtifacts, MAX_INCORRECT_BLOCKS, MAX_INCORRECT_BLOCK_STEPS, type MockTransportOpts, 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, RawAnalystEvidenceSchema, type RawAnalystFinding, RawAnalystFindingSchema, type RegistryRunOpts, type ReplVariableConsensusPort, type ReplVariableEvidenceBinding, type ReplyContract, type ReplyEnvelope, type ReplyRowDecoded, type ReplyRowRejection, type RouterTransportOpts, type RunAnalystBenchmarkOptions, type RunCriticAdapterOpts, SKILL_USAGE_ANALYST, type SandboxSdkTransportOpts, type SemanticConceptJudgeAdapterOpts, SkillUsageAnalyst, type SkillUsageRecord, type SkillUsageReport, type SkillUsageScanConfig, type StepLabelAdapterOptions, type TraceAnalysisEngine, type TraceAnalysisEngineRequest, type TraceAnalysisEngineResult, type TraceAnalystDefinition, type TraceAnalystLimits, type TraceToolGroupName, type UpstreamPredictionAdapterOptions, type VerificationArtifactFile, type VerificationArtifactManifest, type VerificationArtifactRole, type VerificationAvailabilitySummary, type VerificationOutcome, type VerificationOutcomeSource, type VerificationOutcomeStatus, type VerificationResultFile, type VerifierAdapterOpts, adaptPublicBenchmarkFindings, agentRxBenchmarkCase, agentRxPredictionsToFindings, analystBenchmarkDependencyLockDigest, analystBenchmarkImplementationDigest, analystDefinitionAsymmetries, analystDefinitionProtocolSha256, analystInstructionsOverrideFromText, analystUsageReceiptFromPrimeUsage, appendVerificationArtifactsToOtlp, assertExactRegistryRunOpts, assertProposalFindings, behavioralAnalyst, bindAnalyst, buildDefaultAnalystRegistry, buildPrimePrompt, buildPrimeRepairPrompt, buildSkillUsageReport, buildTraceToolsForGroup, codeTraceBenchCase, codeTracerPredictionsToFindings, coerceJson, coerceToFindingRows, compareAnalystRunners, computeFindingId, createChatClient, createDspyRlmTraceEngine, createJudgeAdapter, createPrimeBenchmarkRunner, createPublicBenchmarkDirectRunner, createPublicBenchmarkRlmRunner, createRunCriticAdapter, createSemanticConceptJudgeAdapter, createTraceAnalyst, createVerifierAdapter, decodeReplyRows, defaultIsMaterial, defineCustomAnalyst, defineTraceAnalyst, deriveEfficiencyFindings, diffFindings, effectiveAnalystProtocolSha256, emitControlIntegrityFindings, emitSkillUsageFindings, emptyPrimeRawUsage, emptyPublicBenchmarkRunner, evidenceRefsFromRawFinding, expandCodeTraceFailureBlocks, extractPrimeJsonObject, findingSubjectGrammarPromptFor, isProposalFinding, liftSeverity, 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, renderUpstreamFindings, resolveTraceAnalystLimits, rlmEngineLimits, roundAgentRxStep, runAnalystBenchmark, runAnalystBenchmarkCommand, runPrimeExchange, runTraceAnalyst, scoreAnalystFindings, selectPublicBenchmarkRows, stripCodeFences, summarizeAgentRxCalibration, summarizeAnalystBenchmarkRunner, summarizeCodeTraceCalibration, traceStoreEvidenceResolver };
 //# sourceMappingURL=index.d.ts.map