@tangle-network/agent-eval 0.95.0 → 0.96.0

package/dist/{counterfactual.d.ts → counterfactual-DlOz8PBx.d.ts}

@@ -1,3 +1,7 @@
+import { T as TraceEmitter } from './emitter-C2rqGH_l.js';
+import { T as TraceStore } from './store-BcFXE6LG.js';
+import { T as Trajectory, a as TrajectoryStep } from './trajectory-2TkpSEVh.js';
+
 /**
  * Counterfactual replay — "what would have happened if we'd changed
  * exactly one thing at turn N?"
@@ -11,11 +15,8 @@
  * `parentRunId = originalRunId`, so downstream diff + correlation
  * pipelines see them natively.
  */
-import { TraceEmitter } from './trace/emitter';
-import type { Span } from './trace/schema';
-import type { TraceStore } from './trace/store';
-import { type Trajectory, type TrajectoryStep } from './trajectory';
-export type CounterfactualMutation = {
+
+type CounterfactualMutation = {
     kind: 'swap-model';
     at: number;
     newModel: string;
@@ -36,7 +37,7 @@ export type CounterfactualMutation = {
     describe: string;
     apply: (step: TrajectoryStep) => TrajectoryStep;
 };
-export interface CounterfactualContext {
+interface CounterfactualContext {
     originalRunId: string;
     originalTrajectory: Trajectory;
     /** Steps up to (but not including) the mutation point — the prefix the
@@ -48,7 +49,7 @@ export interface CounterfactualContext {
      *  re-emit it or continue from there). */
     mutatedStep: TrajectoryStep;
 }
-export interface CounterfactualResult {
+interface CounterfactualResult {
     counterfactualRunId: string;
     originalRunId: string;
     mutation: CounterfactualMutation;
@@ -59,7 +60,7 @@ export interface CounterfactualResult {
         deltaScore: number | null;
     };
 }
-export interface CounterfactualRunner {
+interface CounterfactualRunner {
     /**
      * Execute the agent from `ctx.prefix` with the mutation applied.
      * MUST emit spans into the provided emitter so they become part of
@@ -67,18 +68,18 @@ export interface CounterfactualRunner {
      */
     executeFrom: (ctx: CounterfactualContext, emitter: TraceEmitter) => Promise<void>;
 }
-export declare function runCounterfactual(store: TraceStore, originalRunId: string, mutation: CounterfactualMutation, runner: CounterfactualRunner): Promise<CounterfactualResult>;
+declare function runCounterfactual(store: TraceStore, originalRunId: string, mutation: CounterfactualMutation, runner: CounterfactualRunner): Promise<CounterfactualResult>;
 /**
  * Aggregate a batch of counterfactuals into a simple attribution table:
  * which mutation kinds move outcomes most? (Useful when you run a grid
  * over the same trajectory — swap-model at every llm span, swap-tool
  * at every tool span — and want a ranked summary.)
  */
-export declare function attributeCounterfactuals(results: CounterfactualResult[]): Array<{
+declare function attributeCounterfactuals(results: CounterfactualResult[]): Array<{
     mutationKind: CounterfactualMutation['kind'];
     n: number;
     meanAbsDelta: number;
     meanSignedDelta: number;
 }>;
-export type { Span };
-//# sourceMappingURL=counterfactual.d.ts.map
+
+export { type CounterfactualMutation as C, attributeCounterfactuals as a, type CounterfactualRunner as b, type CounterfactualContext as c, type CounterfactualResult as d, runCounterfactual as r };

package/dist/{dataset.d.ts → dataset-BbGkaN2I.d.ts}

@@ -1,3 +1,5 @@
+import { V as ValidationError } from './errors-CzMUYo7b.js';
+
 /**
  * Dataset — versioned, sliceable, content-hashed scenario collection.
  *
@@ -14,9 +16,9 @@
  * can read them but `mutate` throws, which prevents "oh I'll just
  * tweak that one scenario" contamination drift.
  */
-export type DatasetSplit = 'train' | 'dev' | 'test' | 'holdout';
-export type DatasetDifficulty = 'easy' | 'medium' | 'hard' | 'extreme';
-export interface DatasetScenario {
+type DatasetSplit = 'train' | 'dev' | 'test' | 'holdout';
+type DatasetDifficulty = 'easy' | 'medium' | 'hard' | 'extreme';
+interface DatasetScenario {
     id: string;
     /** Arbitrary payload; the framework doesn't interpret it. */
     payload: unknown;
@@ -36,7 +38,7 @@ export interface DatasetScenario {
     forbiddenPattern?: string;
     tags?: Record<string, string>;
 }
-export interface DatasetProvenance {
+interface DatasetProvenance {
     contributor?: string;
     createdAt: string;
     sourceUrl?: string;
@@ -45,7 +47,7 @@ export interface DatasetProvenance {
     /** Monotonic human-readable version (e.g. "2026.04.20"). */
     version: string;
 }
-export interface DatasetManifest {
+interface DatasetManifest {
     name: string;
     provenance: DatasetProvenance;
     /** sha256 hex over canonicalized scenarios. */
@@ -53,7 +55,7 @@ export interface DatasetManifest {
     scenarioCount: number;
     splitCounts: Record<DatasetSplit, number>;
 }
-export interface SliceOptions {
+interface SliceOptions {
     split?: DatasetSplit;
     difficulty?: DatasetDifficulty;
     /** Number of scenarios (random sample, seeded). Omit to take all that match. */
@@ -64,12 +66,12 @@ export interface SliceOptions {
     /** If true, include scenarios marked as holdout. Default false. */
     includeHoldout?: boolean;
 }
-import { ValidationError } from './errors';
+
 /** Locked holdouts — throws on mutate. Callers that need a mutable dataset fork it. */
-export declare class HoldoutLockedError extends ValidationError {
+declare class HoldoutLockedError extends ValidationError {
     constructor(datasetName: string);
 }
-export declare class Dataset {
+declare class Dataset {
     readonly name: string;
     readonly provenance: DatasetProvenance;
     private scenarios;
@@ -108,5 +110,6 @@ export declare class Dataset {
     toJsonl(): string;
     static fromJsonl(jsonl: string, manifest: Omit<DatasetManifest, 'contentHash' | 'scenarioCount' | 'splitCounts'>): Dataset;
 }
-export declare function hashScenarios(scenarios: DatasetScenario[]): Promise<string>;
-//# sourceMappingURL=dataset.d.ts.map
+declare function hashScenarios(scenarios: DatasetScenario[]): Promise<string>;
+
+export { type DatasetSplit as D, HoldoutLockedError as H, type SliceOptions as S, type DatasetScenario as a, Dataset as b, type DatasetManifest as c, type DatasetDifficulty as d, type DatasetProvenance as e, hashScenarios as h };

package/dist/{analyst/registry.d.ts → default-registry-GyE8X5SP.d.ts}

@@ -1,3 +1,7 @@
+import { AxAIService } from '@ax-llm/ax';
+import { T as TraceAnalystKindSpec } from './kind-factory-X3eDYbKn.js';
+import { A as Analyst, a as AnalystContext, b as AnalystRunSummary, c as AnalystFinding, d as AnalystRunResult, C as ChatClient, e as AnalystRunInputs, f as AnalystRunEvent } from './types-B5x54y6n.js';
+
 /**
  * AnalystRegistry — orchestrate N analysts against one run.
  *
@@ -15,9 +19,8 @@
  * (equal split vs weighted vs custom) lives in `BudgetPolicy`. Both
  * have sensible defaults; consumers override only what they need.
  */
-import type { ChatClient } from './chat-client';
-import type { Analyst, AnalystContext, AnalystFinding, AnalystRunEvent, AnalystRunInputs, AnalystRunResult, AnalystRunSummary } from './types';
-export interface AnalystHooks {
+
+interface AnalystHooks {
     /** Before analyze() — last chance to mutate ctx (e.g. inject tags, override budget). */
     onBeforeAnalyze?(args: {
         analyst: Analyst;
@@ -46,7 +49,7 @@ export interface AnalystHooks {
         result: AnalystRunResult;
     }): void | Promise<void>;
 }
-export interface BudgetPolicy {
+interface BudgetPolicy {
     /** Overall USD cap across the registry.run(). */
     totalUsd?: number;
     /** Per-analyst weight for the default allocator. Missing ids get weight 1. */
@@ -63,7 +66,7 @@ export interface BudgetPolicy {
         runningCount: number;
     }) => number | undefined;
 }
-export interface AnalystRegistryOptions {
+interface AnalystRegistryOptions {
     /** Shared chat client passed to every LLM analyst via AnalystContext. */
     chat?: ChatClient;
     /** Logger callback. Defaults to a no-op. */
@@ -73,7 +76,7 @@ export interface AnalystRegistryOptions {
     /** Default budget when run() doesn't override. */
     defaultBudget?: BudgetPolicy;
 }
-export interface RegistryRunOpts {
+interface RegistryRunOpts {
     /** Restrict to a subset of registered analysts by id. */
     only?: string[];
     /** Skip these analysts even if registered. Useful for cheap iteration. */
@@ -96,7 +99,7 @@ export interface RegistryRunOpts {
      */
     priorFindings?: ReadonlyArray<AnalystFinding> | Record<string, ReadonlyArray<AnalystFinding>>;
 }
-export declare class AnalystRegistry {
+declare class AnalystRegistry {
     private readonly analysts;
     private readonly options;
     constructor(options?: AnalystRegistryOptions);
@@ -123,4 +126,30 @@ export declare class AnalystRegistry {
     private selectAnalysts;
     private routeInput;
 }
-//# sourceMappingURL=registry.d.ts.map
+
+/**
+ * `buildDefaultAnalystRegistry` — the canonical analyst suite, so consumers
+ * stop hand-wiring `new AnalystRegistry()` + per-kind `createTraceAnalystKind`.
+ *
+ * The deterministic `behavioralAnalyst` is ALWAYS registered (it needs no
+ * model and is model-agnostic by construction). The agentic RLM kinds are
+ * registered only when an `ai` service is supplied — so a caller with no LLM
+ * still gets the full behavioral/efficiency diagnosis, and the substrate's
+ * "any model (including no model)" guarantee holds at the suite level.
+ */
+
+interface DefaultAnalystRegistryOptions {
+    /** Ax service for the agentic RLM kinds. Omit → only the deterministic analyst. */
+    ai?: AxAIService;
+    /** Model for the agentic kinds (falls back to the ai service default). */
+    model?: string;
+    /** Which agentic kinds to register when `ai` is present. Default = the shipped suite. */
+    kinds?: readonly TraceAnalystKindSpec[];
+    /** Set false to omit the deterministic behavioral analyst (default: include). */
+    includeBehavioral?: boolean;
+    /** Forwarded to the AnalystRegistry constructor (signal, tags, priorFindings). */
+    registry?: AnalystRegistryOptions;
+}
+declare function buildDefaultAnalystRegistry(opts?: DefaultAnalystRegistryOptions): AnalystRegistry;
+
+export { AnalystRegistry as A, type BudgetPolicy as B, type DefaultAnalystRegistryOptions as D, type RegistryRunOpts as R, type AnalystHooks as a, type AnalystRegistryOptions as b, buildDefaultAnalystRegistry as c };

package/dist/diagnose.d.ts

@@ -1 +1,252 @@
-export * from './diagnose/index'
+import { C as CounterfactualMutation, a as attributeCounterfactuals, b as CounterfactualRunner } from './counterfactual-DlOz8PBx.js';
+export { c as CounterfactualContext, d as CounterfactualResult } from './counterfactual-DlOz8PBx.js';
+import { S as Span } from './schema-m0gsnbt3.js';
+import { T as TraceStore } from './store-BcFXE6LG.js';
+import { a as TrajectoryStep, T as Trajectory } from './trajectory-2TkpSEVh.js';
+import { h as AnalystSeverity, c as AnalystFinding } from './types-B5x54y6n.js';
+import { C as CorpusRecord } from './corpus-D4YW9UoJ.js';
+import { R as RunRecord } from './run-record-CP2ObebC.js';
+import './emitter-C2rqGH_l.js';
+import './store-C1YxJDEK.js';
+import './types-C7DGg5ex.js';
+import '@tangle-network/tcloud';
+import './llm-client-Bj7g0rqu.js';
+import './errors-CzMUYo7b.js';
+import './raw-provider-sink-C46HDghv.js';
+import '@tangle-network/agent-interface';
+
+/**
+ * Causal sweep — WHY did this run fail?
+ *
+ * Orchestrates the dormant counterfactual primitives into a responsibility
+ * report: for each candidate step, run `reps` counterfactual replays per
+ * mutation (via `runCounterfactual` — the consumer's `CounterfactualRunner`
+ * is the execution seam) and reduce the per-rep score deltas into a mean
+ * effect + bootstrap confidence interval (via `confidenceInterval`).
+ *
+ * Why `reps` is REQUIRED: a single intervention delta is one stochastic
+ * draw — LLM re-execution from a prefix is sampled, so one replay cannot
+ * distinguish "this step caused the failure" from sampling noise. The
+ * signal is the distribution of deltas across reps; the CI over that
+ * distribution is what lets a caller say "this step's effect excludes
+ * zero" instead of eyeballing a point estimate.
+ *
+ * Budget discipline: the sweep never silently drops cells. When the
+ * remaining budget cannot fund a full `reps`-sized cell, the sweep halts
+ * and every step not fully probed is named in `uncovered`.
+ */
+
+/** Stable reference to a trajectory step — carried through reports,
+ *  findings, and corpus records so evidence stays addressable. */
+interface StepRef {
+    index: number;
+    spanId: string;
+    kind: Span['kind'];
+    name: string;
+}
+declare function stepRefOf(step: TrajectoryStep): StepRef;
+interface CausalSweepOptions {
+    store: TraceStore;
+    /** The failed run to diagnose. Its `outcome.score` is the baseline every
+     *  counterfactual delta is measured against. */
+    runId: string;
+    /** Execution seam — identical contract to `runCounterfactual`: re-runs the
+     *  agent from the mutation point and MUST `endRun` with a numeric score. */
+    runner: CounterfactualRunner;
+    /** Trajectory indices to probe. Default: every llm + tool span — the kinds
+     *  the existing `CounterfactualMutation` set targets. */
+    candidateSteps?: number[];
+    /**
+     * Mutations to probe a given step with. Returned mutations MUST target
+     * `step.index`. Default probes are the payload-free existing kinds:
+     *   - tool span → `swap-tool-result` with `newResult: null` (knockout:
+     *     how much did the run depend on this tool's information?)
+     *   - llm span → `truncate-after` (re-roll: how much did the realized
+     *     turn deviate from the policy's typical continuation?)
+     * `swap-model` / `inject-system-message` need consumer payloads, so they
+     * are opt-in via this callback.
+     */
+    mutationsPerStep?: (step: TrajectoryStep) => CounterfactualMutation[];
+    /** Replays per (step, mutation) cell. Minimum 2 — see module doc. */
+    reps: number;
+    /** Hard cap on total counterfactual replays across the whole sweep. */
+    budget: number;
+    /** Seed for the bootstrap CI resampler. Deterministic default so two
+     *  sweeps over the same deltas report identical intervals. */
+    ciSeed?: number;
+    /** Bootstrap CI confidence level. Default 0.95. */
+    ciConfidence?: number;
+}
+interface StepResponsibility {
+    stepRef: StepRef;
+    mutationKind: CounterfactualMutation['kind'];
+    /** Mean of per-rep score deltas (counterfactual − original). */
+    meanEffect: number;
+    /** Bootstrap CI over the per-rep deltas. */
+    ci: {
+        mean: number;
+        lower: number;
+        upper: number;
+    };
+    /** `ci.lower > 0 || ci.upper < 0` — the effect is distinguishable from noise. */
+    ciExcludesZero: boolean;
+    reps: number;
+    /** Raw per-rep deltas — downstream evidence, never re-derived. */
+    deltas: number[];
+    /** Replay run ids (layer='meta', parentRunId=original) for audit. */
+    counterfactualRunIds: string[];
+}
+interface CausalResponsibilityReport {
+    runId: string;
+    originalScore: number;
+    /** Ranked by |meanEffect| descending — the blame ordering. */
+    steps: StepResponsibility[];
+    /** Kind-level aggregate from the existing `attributeCounterfactuals`. */
+    byMutationKind: ReturnType<typeof attributeCounterfactuals>;
+    replaysUsed: number;
+    budget: number;
+    /** Steps planned but not fully probed before the budget ran out.
+     *  Named, never silent: an absent step is "no effect found"; an
+     *  uncovered step is "not measured". */
+    uncovered: StepRef[];
+}
+declare function causalSweep(opts: CausalSweepOptions): Promise<CausalResponsibilityReport>;
+
+/**
+ * Replay-validated repair — WHAT SHOULD HAVE HAPPENED?
+ *
+ * Takes the blamed steps from a `CausalResponsibilityReport`, asks a
+ * consumer-supplied `proposeFix` (LLM-backed in live use) for candidate
+ * mutations, and machine-verifies each candidate by replaying the run
+ * WITH the mutation applied (through the same `runCounterfactual` seam
+ * the sweep uses).
+ *
+ * A repair is "what should have happened" ONLY when every validation
+ * replay crosses `flipThreshold` — a prescription is never speculated,
+ * it is demonstrated. Candidates that don't flip, or whose replay
+ * errors, land in `rejected` with a typed reason; nothing is dropped
+ * silently.
+ */
+
+/** Context handed to `proposeFix` so an LLM-backed proposer can see the
+ *  full trajectory plus the responsibility evidence for the blamed step. */
+interface RepairContext {
+    runId: string;
+    trajectory: Trajectory;
+    originalScore: number;
+    responsibility: StepResponsibility;
+}
+interface PrescribeRepairOptions {
+    store: TraceStore;
+    /** The failed run the sweep diagnosed. */
+    runId: string;
+    /** Execution seam — same `CounterfactualRunner` contract as the sweep. */
+    runner: CounterfactualRunner;
+    /** Blamed steps from `causalSweep` — typically `report.steps.slice(0, k)`. */
+    blamed: StepResponsibility[];
+    /** Candidate-fix generator. Consumer-supplied; LLM-backed in live use.
+     *  Returned mutations MUST target the blamed step's index. */
+    proposeFix: (step: TrajectoryStep, context: RepairContext) => Promise<CounterfactualMutation[]>;
+    /** Score every validation replay must reach for the repair to count. Default 0.5. */
+    flipThreshold?: number;
+    /** Validation replays per candidate mutation. Default 3. */
+    repsToValidate?: number;
+    /** Max candidate mutations tried per step. Default: all proposed. */
+    maxAttemptsPerStep?: number;
+}
+interface ValidatedRepair {
+    stepRef: StepRef;
+    mutation: CounterfactualMutation;
+    /** Always true — presence in `repairs` IS the machine-verified claim. */
+    validated: true;
+    /** Mean counterfactual score across the validation reps. */
+    meanScore: number;
+    /** meanScore − originalScore. */
+    deltaScore: number;
+    reps: number;
+    /** Replay run ids backing the validation — audit trail. */
+    counterfactualRunIds: string[];
+}
+interface RejectedRepair {
+    stepRef: StepRef;
+    mutation: CounterfactualMutation;
+    reason: 'did-not-flip' | 'error';
+    /** Present for 'did-not-flip': mean delta over the reps that ran. */
+    deltaScore?: number;
+    /** Present for 'error': the message, preserved for diagnosis. */
+    error?: string;
+}
+interface RepairReport {
+    runId: string;
+    originalScore: number;
+    flipThreshold: number;
+    repairs: ValidatedRepair[];
+    rejected: RejectedRepair[];
+    replaysUsed: number;
+}
+declare function prescribeRepair(opts: PrescribeRepairOptions): Promise<RepairReport>;
+
+/**
+ * Remediation adapters — HOW DO WE MAKE IT HAPPEN?
+ *
+ * The diagnose chain ends by feeding existing improvement machinery,
+ * not by building new machinery:
+ *
+ *   - `toAnalystFindings` → the analyst contract (`makeFinding`), so
+ *     responsibility evidence flows into the same registry / steering /
+ *     diff pipeline every other analyst feeds.
+ *   - `toCorpusRecord` → the RL corpus (`CorpusRecord`), pinning the
+ *     diagnosed failure + validated repair as a permanent scenario.
+ *   - `suggestInvariant` → a plain-data hint in the shape the
+ *     trace-contracts machinery consumes (`never` / `without` clauses).
+ */
+
+declare const DIAGNOSE_ANALYST_ID = "diagnose-causal-sweep";
+/** Severity from causal effect size. Effects whose CI includes zero are
+ *  'info' regardless of magnitude — an indistinguishable-from-noise effect
+ *  must not steer remediation priority. */
+declare function severityFromEffect(responsibility: StepResponsibility): AnalystSeverity;
+/** Deterministic human-readable rendering of a mutation — used in
+ *  recommended actions, corpus completions, and invariant hints. */
+declare function describeMutation(mutation: CounterfactualMutation): string;
+/**
+ * Lift a responsibility report (and optionally its validated repairs) into
+ * `AnalystFinding`s via the real `makeFinding` factory. One finding per
+ * probed step; a validated repair for that step upgrades the finding with
+ * a `recommended_action` + the replay-validation evidence.
+ *
+ * Findings are OBSERVED causal probes (replay deltas), not judge verdicts,
+ * so `derived_from_judge` stays unset and they may steer.
+ */
+declare function toAnalystFindings(report: CausalResponsibilityReport, repairs?: RepairReport): AnalystFinding[];
+/**
+ * Pin the diagnosed failure as a permanent corpus scenario. Takes the
+ * original run's `RunRecord` projection plus a validated repair and emits
+ * a fresh `CorpusRecord` (new runId, so corpus dedup keeps both the raw
+ * failure and the diagnosed entry).
+ *
+ * `completion` defaults to the validated mutation's rendering — "what
+ * should have happened" in machine-derived form. Supply `prompt` (and
+ * optionally a richer `completion`) when the trajectory text is available
+ * so the record is harvestable by `buildDatasetFromCorpus`.
+ */
+declare function toCorpusRecord(run: RunRecord, repair: ValidatedRepair, opts?: {
+    prompt?: string;
+    completion?: string;
+}): CorpusRecord;
+/** Plain-data invariant hint. The trace-contracts machinery consumes this
+ *  shape: `never` is a pattern that must not appear in a passing trace;
+ *  `without` is a guard whose absence makes the failure reachable. */
+interface InvariantHint {
+    description: string;
+    never?: string;
+    without?: string;
+}
+/**
+ * Derive an invariant hint from a validated repair. Deterministic per
+ * mutation kind — the hint names the contract a trace must satisfy so
+ * the diagnosed failure cannot silently recur.
+ */
+declare function suggestInvariant(repair: ValidatedRepair): InvariantHint;
+
+export { type CausalResponsibilityReport, type CausalSweepOptions, CounterfactualMutation, CounterfactualRunner, DIAGNOSE_ANALYST_ID, type InvariantHint, type PrescribeRepairOptions, type RejectedRepair, type RepairContext, type RepairReport, type StepRef, type StepResponsibility, type ValidatedRepair, causalSweep, describeMutation, prescribeRepair, severityFromEffect, stepRefOf, suggestInvariant, toAnalystFindings, toCorpusRecord };

package/dist/{trace/emitter.d.ts → emitter-C2rqGH_l.d.ts}

@@ -1,3 +1,6 @@
+import { b as RunOutcome, R as Run, S as Span, c as SpanKind, L as LlmSpan, T as ToolSpan, d as RetrievalSpan, J as JudgeSpan, e as SandboxSpan, E as EventKind, a as TraceEvent, B as BudgetLedgerEntry, A as Artifact, M as Message } from './schema-m0gsnbt3.js';
+import { T as TraceStore } from './store-BcFXE6LG.js';
+
 /**
  * TraceEmitter — hierarchical span builder that auto-parents using an
  * internal stack. One emitter per Run; emitters do NOT share state.
@@ -8,14 +11,13 @@
  * the stack (e.g. fan-out parallel calls), pass `parentSpanId`
  * explicitly.
  */
-import type { Artifact, BudgetLedgerEntry, EventKind, JudgeSpan, LlmSpan, Message, RetrievalSpan, Run, RunOutcome, SandboxSpan, Span, SpanKind, ToolSpan, TraceEvent } from './schema';
-import type { TraceStore } from './store';
-export interface SpanHandle<S extends Span = Span> {
+
+interface SpanHandle<S extends Span = Span> {
     span: S;
     end(patch?: Partial<S>): Promise<void>;
     fail(error: string | Error, patch?: Partial<S>): Promise<void>;
 }
-export interface RunCompleteHookContext {
+interface RunCompleteHookContext {
     runId: string;
     emitter: TraceEmitter;
     store: TraceStore;
@@ -24,8 +26,8 @@ export interface RunCompleteHookContext {
     /** Final run status. */
     status: 'completed' | 'failed' | 'aborted';
 }
-export type RunCompleteHook = (ctx: RunCompleteHookContext) => Promise<void> | void;
-export interface TraceEmitterOptions {
+type RunCompleteHook = (ctx: RunCompleteHookContext) => Promise<void> | void;
+interface TraceEmitterOptions {
     runId?: string;
     /** Inject a clock for deterministic tests. */
     now?: () => number;
@@ -44,7 +46,7 @@ export interface TraceEmitterOptions {
     /** `'swallow'` (default) | `'throw'`. */
     hookErrors?: 'swallow' | 'throw';
 }
-export declare class TraceEmitter {
+declare class TraceEmitter {
     private store;
     private stack;
     private _runId;
@@ -102,7 +104,7 @@ export declare class TraceEmitter {
     within<T>(init: Parameters<TraceEmitter['span']>[0], fn: (handle: SpanHandle) => Promise<T>): Promise<T>;
 }
 /** Helper to build an LLM span handle args object from a provider-shaped response. */
-export declare function llmSpanFromProvider(args: {
+declare function llmSpanFromProvider(args: {
     name?: string;
     model: string;
     messages: Message[];
@@ -116,4 +118,5 @@ export declare function llmSpanFromProvider(args: {
     costUsd?: number;
     finishReason?: string;
 }): Omit<LlmSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>;
-//# sourceMappingURL=emitter.d.ts.map
+
+export { type RunCompleteHook as R, type SpanHandle as S, TraceEmitter as T, type RunCompleteHookContext as a, type TraceEmitterOptions as b, llmSpanFromProvider as l };

package/dist/{errors.d.ts → errors-CzMUYo7b.d.ts}

@@ -12,8 +12,8 @@
  * remain plain `Error`s on purpose — they're programmer-mistake assertions,
  * not consumer-catchable contract failures.
  */
-export type AgentEvalErrorCode = 'validation' | 'not_found' | 'config' | 'capture_integrity' | 'judge' | 'verification' | 'replay' | 'backend_integrity' | 'profile_matrix';
-export declare class AgentEvalError extends Error {
+type AgentEvalErrorCode = 'validation' | 'not_found' | 'config' | 'capture_integrity' | 'judge' | 'verification' | 'replay' | 'backend_integrity' | 'profile_matrix';
+declare class AgentEvalError extends Error {
     /** Stable string code. Survives minification; safe to switch on. */
     readonly code: AgentEvalErrorCode;
     constructor(code: AgentEvalErrorCode, message: string, options?: {
@@ -21,19 +21,19 @@ export declare class AgentEvalError extends Error {
     });
 }
 /** Caller passed invalid arguments (out of range, mutually-exclusive options, bad shape). */
-export declare class ValidationError extends AgentEvalError {
+declare class ValidationError extends AgentEvalError {
     constructor(message: string, options?: {
         cause?: unknown;
     });
 }
 /** A named resource (run, span, rubric, scenario, dataset row, route) does not exist. */
-export declare class NotFoundError extends AgentEvalError {
+declare class NotFoundError extends AgentEvalError {
     constructor(message: string, options?: {
         cause?: unknown;
     });
 }
 /** Configuration missing or malformed (`HOME` unset, required image not supplied, env var absent). */
-export declare class ConfigError extends AgentEvalError {
+declare class ConfigError extends AgentEvalError {
     constructor(message: string, options?: {
         cause?: unknown;
     });
@@ -43,27 +43,28 @@ export declare class ConfigError extends AgentEvalError {
  * raw HTTP capture absent, no LLM spans, route assertion failed, run-end
  * assertion tripped. Block ship on this; do not catch and move on.
  */
-export declare class CaptureIntegrityError extends AgentEvalError {
+declare class CaptureIntegrityError extends AgentEvalError {
     constructor(message: string, options?: {
         cause?: unknown;
     });
 }
 /** A judge call failed in a way that's not retryable: schema parse failure, bad rubric, conflicting dimensions. */
-export declare class JudgeError extends AgentEvalError {
+declare class JudgeError extends AgentEvalError {
     constructor(message: string, options?: {
         cause?: unknown;
     });
 }
 /** A verifier signalled a hard failure (compile, test, schema) — distinct from a low judge score. */
-export declare class VerificationError extends AgentEvalError {
+declare class VerificationError extends AgentEvalError {
     constructor(message: string, options?: {
         cause?: unknown;
     });
 }
 /** Replay cache cannot satisfy a request: miss with no fallback, sink lacks list(), unsupported URL. */
-export declare class ReplayError extends AgentEvalError {
+declare class ReplayError extends AgentEvalError {
     constructor(message: string, options?: {
         cause?: unknown;
     });
 }
-//# sourceMappingURL=errors.d.ts.map
+
+export { AgentEvalError as A, CaptureIntegrityError as C, JudgeError as J, NotFoundError as N, ReplayError as R, ValidationError as V, ConfigError as a, type AgentEvalErrorCode as b, VerificationError as c };