@tangle-network/agent-eval 0.95.0 → 0.96.0

package/dist/{prm/rubric.d.ts → rubric-Cc6UHvUb.d.ts}

@@ -1,3 +1,7 @@
+import { S as Span, J as JudgeSpan } from './schema-m0gsnbt3.js';
+import { T as TraceStore } from './store-BcFXE6LG.js';
+import { T as Trajectory, a as TrajectoryStep } from './trajectory-2TkpSEVh.js';
+
 /**
  * Process Reward Modeling — per-step rubric grading.
  *
@@ -11,10 +15,8 @@
  * densify the signal so optimizers and RL fine-tuning can assign
  * credit per turn.
  */
-import type { JudgeSpan, Span } from '../trace/schema';
-import type { TraceStore } from '../trace/store';
-import { type Trajectory, type TrajectoryStep } from '../trajectory';
-export interface StepContext {
+
+interface StepContext {
     trajectory: Trajectory;
     step: TrajectoryStep;
     /** Steps preceding `step` in trajectory order. */
@@ -22,7 +24,7 @@ export interface StepContext {
     /** Steps following `step`. */
     next: TrajectoryStep[];
 }
-export interface StepRubric {
+interface StepRubric {
     id: string;
     /** Only grade spans of these kinds (default: all). */
     kinds?: Array<Span['kind']>;
@@ -36,7 +38,7 @@ export interface StepRubric {
         evidence?: string;
     } | null>;
 }
-export interface GradedStep {
+interface GradedStep {
     spanId: string;
     rubricId: string;
     score: number;
@@ -44,7 +46,7 @@ export interface GradedStep {
     rationale?: string;
     evidence?: string;
 }
-export interface PrmGradedTrace {
+interface PrmGradedTrace {
     runId: string;
     steps: GradedStep[];
     /** Weighted mean of all graded steps; 0..1. */
@@ -54,7 +56,7 @@ export interface PrmGradedTrace {
     /** Number of spans in the trajectory that no rubric matched. */
     ungradedCount: number;
 }
-export declare class PrmGrader {
+declare class PrmGrader {
     private rubrics;
     constructor(rubrics: StepRubric[]);
     /**
@@ -66,5 +68,6 @@ export declare class PrmGrader {
 }
 /** Helper: reads JudgeVerdict spans that PRM emitted so downstream pipelines
  *  can distinguish PRM verdicts from human or top-level LLM judges. */
-export declare function isPrmVerdict(verdict: JudgeSpan): boolean;
-//# sourceMappingURL=rubric.d.ts.map
+declare function isPrmVerdict(verdict: JudgeSpan): boolean;
+
+export { type GradedStep as G, type PrmGradedTrace as P, type StepRubric as S, PrmGrader as a, type StepContext as b, isPrmVerdict as i };

package/dist/{meta-eval/rubric-predictive-validity.d.ts → rubric-predictive-validity-C2hDKM8Z.d.ts}

@@ -1,3 +1,6 @@
+import { R as RunRecord } from './run-record-CP2ObebC.js';
+import { b as OutcomeStore } from './outcome-store-rnXLEqSn.js';
+
 /**
  * Rubric predictive validity — does our eval rubric predict deployment
  * outcomes?
@@ -29,9 +32,8 @@
  * decorative rubrics, re-weight composite scores, or trigger a
  * recalibration sweep when predictive validity drops below a threshold.
  */
-import type { RunRecord } from '../run-record';
-import type { OutcomeStore } from './outcome-store';
-export interface RubricPredictiveValidityInput {
+
+interface RubricPredictiveValidityInput {
     /**
      * Canonical campaign output. Each record's `outcome.raw[<rubricId>]`
      * provides the eval score; missing keys are silently skipped per pair.
@@ -62,7 +64,7 @@ export interface RubricPredictiveValidityInput {
      */
     reduction?: 'latest' | 'mean' | 'max';
 }
-export interface RubricOutcomePair {
+interface RubricOutcomePair {
     rubric: string;
     outcome: string;
     n: number;
@@ -80,7 +82,7 @@ export interface RubricOutcomePair {
      */
     verdict: 'load_bearing' | 'informative' | 'decorative';
 }
-export interface RubricRanking {
+interface RubricRanking {
     rubric: string;
     /** Outcome metric this rubric correlated best with. */
     bestOutcome: string;
@@ -89,7 +91,7 @@ export interface RubricRanking {
     n: number;
     verdict: RubricOutcomePair['verdict'];
 }
-export interface RubricPredictiveValidityReport {
+interface RubricPredictiveValidityReport {
     pairs: RubricOutcomePair[];
     /** Per-rubric best pair, sorted descending by |spearman|. */
     ranked: RubricRanking[];
@@ -98,5 +100,6 @@ export interface RubricPredictiveValidityReport {
     /** Rubrics that were declared but never produced a usable score. */
     rubricsWithoutData: string[];
 }
-export declare function rubricPredictiveValidity(input: RubricPredictiveValidityInput): Promise<RubricPredictiveValidityReport>;
-//# sourceMappingURL=rubric-predictive-validity.d.ts.map
+declare function rubricPredictiveValidity(input: RubricPredictiveValidityInput): Promise<RubricPredictiveValidityReport>;
+
+export { type RubricOutcomePair as R, type RubricPredictiveValidityInput as a, type RubricPredictiveValidityReport as b, type RubricRanking as c, rubricPredictiveValidity as r };

package/dist/run-critic-CmMf05uV.d.ts

@@ -0,0 +1,56 @@
+import { R as Run, S as Span, a as TraceEvent, A as Artifact, B as BudgetLedgerEntry } from './schema-m0gsnbt3.js';
+import { T as TraceStore } from './store-BcFXE6LG.js';
+
+interface RunScore {
+    success: number;
+    goalProgress: number;
+    repoGroundedness: number;
+    driftPenalty: number;
+    toolUseQuality: number;
+    patchQuality: number;
+    testReality: number;
+    finalGate: number;
+    reviewerBlockers: number;
+    costUsd: number;
+    wallSeconds: number;
+    notes?: string[];
+}
+interface RunScoreWeights {
+    success: number;
+    goalProgress: number;
+    repoGroundedness: number;
+    driftPenalty: number;
+    toolUseQuality: number;
+    patchQuality: number;
+    testReality: number;
+    finalGate: number;
+    reviewerBlockers: number;
+    costUsd: number;
+    wallSeconds: number;
+}
+declare const DEFAULT_RUN_SCORE_WEIGHTS: RunScoreWeights;
+declare function aggregateRunScore(score: RunScore, weights?: Partial<RunScoreWeights>): number;
+declare function clamp01(value: number): number;
+
+interface RunTrace {
+    run: Run;
+    spans: Span[];
+    events: TraceEvent[];
+    artifacts: Artifact[];
+    budget: BudgetLedgerEntry[];
+}
+interface RunCriticOptions {
+    weights?: Partial<RunScoreWeights>;
+    driftPatterns?: RegExp[];
+}
+declare class RunCritic {
+    private readonly weights?;
+    private readonly driftPatterns;
+    constructor(options?: RunCriticOptions);
+    score(store: TraceStore, runId: string): Promise<RunScore>;
+    scoreTrace(trace: RunTrace): RunScore;
+    rank(score: RunScore): number;
+    private isDrift;
+}
+
+export { DEFAULT_RUN_SCORE_WEIGHTS as D, type RunScore as R, type RunTrace as a, type RunScoreWeights as b, RunCritic as c, type RunCriticOptions as d, aggregateRunScore as e, clamp01 as f };

package/dist/{run-record.d.ts → run-record-CP2ObebC.d.ts}

@@ -1,3 +1,106 @@
+import { AgentProfile } from '@tangle-network/agent-interface';
+import { V as ValidationError } from './errors-CzMUYo7b.js';
+import { F as FailureClass } from './schema-m0gsnbt3.js';
+
+type AgentProfileCellSchemaVersion = 'agent-profile-cell/v1';
+type AgentProfileJson = string | number | boolean | null | AgentProfileJson[] | {
+    [key: string]: AgentProfileJson;
+};
+type AgentProfileDimensionValue = string | number | boolean | null;
+interface AgentProfileSource {
+    /** Runtime/profile contract being fingerprinted, e.g. `agent-interface-profile`. */
+    kind: string;
+    /** sha256 over the canonical source profile object. */
+    hash: string;
+}
+interface AgentProfileSourceInput {
+    kind: string;
+    /** Precomputed sha256 for callers that already sign their profile artifact. */
+    hash?: string;
+    /** Full canonical runtime profile; hashed and then discarded from the cell. */
+    profile?: AgentProfileJson;
+}
+interface AgentProfileHarness {
+    id: string;
+    version?: string;
+    hash?: string;
+}
+interface AgentProfileCellInput {
+    profileId: string;
+    sourceProfile: AgentProfileSourceInput;
+    harness?: AgentProfileHarness;
+    model?: string;
+    promptHash?: string;
+    dimensions?: Record<string, AgentProfileDimensionValue>;
+}
+interface AgentProfileCell {
+    schemaVersion: AgentProfileCellSchemaVersion;
+    cellId: string;
+    profileId: string;
+    sourceProfile: AgentProfileSource;
+    harness?: AgentProfileHarness;
+    model?: string;
+    promptHash?: string;
+    dimensions?: Record<string, AgentProfileDimensionValue>;
+}
+declare class AgentProfileCellValidationError extends ValidationError {
+    readonly path: string;
+    constructor(message: string, path?: string);
+}
+declare function buildAgentProfileCell(input: AgentProfileCellInput): Promise<AgentProfileCell>;
+declare function agentProfileCellHashMaterial(cell: AgentProfileCell): Omit<AgentProfileCell, 'cellId'>;
+declare function verifyAgentProfileCell(cell: AgentProfileCell): Promise<boolean>;
+declare function validateAgentProfileCell(input: unknown): AgentProfileCell;
+declare function requireAgentProfileCell(record: {
+    runId: string;
+    agentProfile?: AgentProfileCell;
+}): AgentProfileCell;
+declare function agentProfileCellKey(record: {
+    runId: string;
+    agentProfile?: AgentProfileCell;
+}): string;
+declare function assertRunAgentProfileCell(record: {
+    runId: string;
+    model: string;
+    promptHash: string;
+    agentProfile?: AgentProfileCell;
+}): Promise<AgentProfileCell>;
+declare function groupRunsByAgentProfileCell<T extends {
+    runId: string;
+    agentProfile?: AgentProfileCell;
+}>(records: readonly T[]): Map<string, T[]>;
+/** Canonical `sourceProfile.kind` values. Two products fingerprinting the
+ *  same canonical profile MUST use the same kind for their cells to share
+ *  `sourceProfile.hash`. Extend rather than create new strings — adding a
+ *  new kind is a deliberate cross-product schema change. */
+declare const AGENT_PROFILE_KINDS: {
+    /** A profile declared via `defineAgentProfile(...)` from
+     *  `@tangle-network/agent-interface`. The default kind for router-backed
+     *  and sandbox-backed products. */
+    readonly AGENT_INTERFACE_PROFILE: "agent-interface-profile";
+};
+type AgentProfileKind = (typeof AGENT_PROFILE_KINDS)[keyof typeof AGENT_PROFILE_KINDS];
+/** Canonicalize an arbitrary value into `AgentProfileJson` by JSON
+ *  round-trip. Throws when the value contains anything not representable
+ *  as JSON (functions, BigInt, cycles) — non-portable profiles fail loud
+ *  rather than silently dropping fields. */
+declare function toAgentProfileJson(value: unknown): AgentProfileJson;
+/** Canonical AgentProfile shape required when deriving a stable cell id. */
+type AgentInterfaceProfileLike = AgentProfile & {
+    name: string;
+    version: string;
+};
+/** Higher-level helper that hard-codes the canonical
+ *  `agent-interface-profile` kind plus the JSON canonicalization. Equivalent
+ *  to calling `buildAgentProfileCell` with `profileId = \`${name}@${version}\``
+ *  and `sourceProfile = { kind: AGENT_INTERFACE_PROFILE, profile: <round-tripped> }`.
+ *
+ *  Use this from any product consuming an agent-interface `AgentProfile`; the
+ *  manual `buildAgentProfileCell` call is reserved for advanced cases
+ *  (custom kinds, pre-computed source hashes, alternate profileId
+ *  conventions). */
+declare function buildAgentInterfaceProfileCell(profile: AgentInterfaceProfileLike, input: Omit<AgentProfileCellInput, 'profileId' | 'sourceProfile'>): Promise<AgentProfileCell>;
+
 /**
  * Paper-grade RunRecord schema + runtime validator.
  *
@@ -22,18 +125,16 @@
  * The validator runs in pure TS — zod is intentionally NOT a
  * dependency. Round-trip tested in `tests/run-record.test.ts`.
  */
-import type { AgentProfileCell } from './agent-profile-cell';
-import { ValidationError } from './errors';
-import type { FailureClass } from './trace/schema';
+
 /** Search/dev/holdout split tag. 'search' is the paper-grade alias for the
  *  combined train+test pool that the optimizer is allowed to read. */
-export type RunSplitTag = 'search' | 'dev' | 'holdout';
-export interface RunTokenUsage {
+type RunSplitTag = 'search' | 'dev' | 'holdout';
+interface RunTokenUsage {
     input: number;
     output: number;
     cached?: number;
 }
-export interface RunJudgeMetadata {
+interface RunJudgeMetadata {
     model: string;
     promptVersion: string;
     /** [0,1] confidence the judge declared. Constant judge confidence
@@ -62,7 +163,7 @@ export interface RunJudgeMetadata {
  * by id. A missing key in `perJudge` is ambiguous (silent zero vs not
  * run); the explicit list makes a partial-failure recorded as such.
  */
-export interface JudgeScoresRecord {
+interface JudgeScoresRecord {
     /** Per-judge per-dimension scores. `{ "kimi-k2.6": { helpfulness: 0.8, clarity: 0.7 }, ... }`. */
     perJudge: Record<string, Record<string, number>>;
     /** Per-dim mean across judges. Convenience — derivable from `perJudge`. */
@@ -78,7 +179,7 @@ export interface JudgeScoresRecord {
      *  first-judge only — consumer's choice). */
     notes?: string;
 }
-export interface RunOutcome {
+interface RunOutcome {
     /** Score on the search/optimization split. Optional because a
      *  holdout-only evaluation only fills `holdoutScore`. */
     searchScore?: number;
@@ -123,7 +224,7 @@ export interface RunOutcome {
  *     `claude-sonnet-4` or `gpt-4o` are banned — they remap silently.
  *     Use `claude-sonnet-4-6@2025-04-15` or `gpt-4o-2024-11-20`.
  */
-export interface RunRecord {
+interface RunRecord {
     /** UUID for the run. */
     runId: string;
     /** Logical experiment grouping (a treatment vs a baseline within
@@ -187,7 +288,7 @@ export interface RunRecord {
      */
     agentProfile?: AgentProfileCell;
 }
-export declare class RunRecordValidationError extends ValidationError {
+declare class RunRecordValidationError extends ValidationError {
     readonly path: string;
     constructor(message: string, path?: string);
 }
@@ -196,11 +297,11 @@ export declare class RunRecordValidationError extends ValidationError {
  * missing or wrongly-typed field. Returns the input cast to
  * `RunRecord` on success — the validator does not coerce.
  */
-export declare function validateRunRecord(input: unknown): RunRecord;
+declare function validateRunRecord(input: unknown): RunRecord;
 /** Boolean validator — convenience for filtering arrays. */
-export declare function isRunRecord(input: unknown): input is RunRecord;
+declare function isRunRecord(input: unknown): input is RunRecord;
 /** Non-throwing validator — returns a discriminated union. */
-export declare function parseRunRecordSafe(input: unknown): {
+declare function parseRunRecordSafe(input: unknown): {
     ok: true;
     value: RunRecord;
 } | {
@@ -208,5 +309,6 @@ export declare function parseRunRecordSafe(input: unknown): {
     error: RunRecordValidationError;
 };
 /** Round-trip helper — `JSON.parse(JSON.stringify(record))` then validate. */
-export declare function roundTripRunRecord(record: RunRecord): RunRecord;
-//# sourceMappingURL=run-record.d.ts.map
+declare function roundTripRunRecord(record: RunRecord): RunRecord;
+
+export { type AgentProfileCell as A, toAgentProfileJson as B, validateAgentProfileCell as C, validateRunRecord as D, verifyAgentProfileCell as E, type JudgeScoresRecord as J, type RunRecord as R, type RunSplitTag as a, type RunTokenUsage as b, type RunJudgeMetadata as c, type AgentProfileCellInput as d, AGENT_PROFILE_KINDS as e, type AgentInterfaceProfileLike as f, type AgentProfileCellSchemaVersion as g, AgentProfileCellValidationError as h, type AgentProfileDimensionValue as i, type AgentProfileHarness as j, type AgentProfileJson as k, type AgentProfileKind as l, type AgentProfileSource as m, type AgentProfileSourceInput as n, type RunOutcome as o, RunRecordValidationError as p, agentProfileCellHashMaterial as q, agentProfileCellKey as r, assertRunAgentProfileCell as s, buildAgentInterfaceProfileCell as t, buildAgentProfileCell as u, groupRunsByAgentProfileCell as v, isRunRecord as w, parseRunRecordSafe as x, requireAgentProfileCell as y, roundTripRunRecord as z };

package/dist/runtime-trajectory-BOUUjI0y.d.ts

@@ -0,0 +1,49 @@
+import { a as RunSplitTag } from './run-record-CP2ObebC.js';
+
+interface RuntimeTrajectoryHookEvent {
+    id: string;
+    runId: string;
+    scenarioId?: string;
+    target: string;
+    phase: string;
+    timestamp: number;
+    stepIndex?: number;
+    parentId?: string;
+    payload?: unknown;
+    metadata?: Record<string, unknown>;
+}
+interface RuntimeTrajectoryRecord {
+    id?: string;
+    scenarioId?: string;
+    splitTag?: RunSplitTag;
+    runtimeEvents?: unknown;
+    [key: string]: unknown;
+}
+interface RuntimeTrajectoryRunRecord {
+    runId: string;
+    scenarioId?: string;
+    splitTag: RunSplitTag;
+}
+interface RuntimeTrajectoryEvidenceSummary {
+    recordCount: number;
+    recordWithRuntimeEventsCount: number;
+    runtimeRunCount: number;
+    lifecycleEventCount: number;
+    defaultedSplitCount: number;
+}
+interface RuntimeTrajectoryEvidenceProjection {
+    runs: RuntimeTrajectoryRunRecord[];
+    events: RuntimeTrajectoryHookEvent[];
+    summary: RuntimeTrajectoryEvidenceSummary;
+    diagnostics: string[];
+}
+interface ProjectRuntimeTrajectoryEvidenceOptions<TRecord extends RuntimeTrajectoryRecord = RuntimeTrajectoryRecord> {
+    records: TRecord[];
+    defaultSplitTag?: RunSplitTag;
+    recordIdOf?: (record: TRecord, index: number) => string | undefined;
+    scenarioIdOf?: (record: TRecord, index: number) => string | undefined;
+}
+declare function projectRuntimeTrajectoryEvidence<TRecord extends RuntimeTrajectoryRecord>(options: ProjectRuntimeTrajectoryEvidenceOptions<TRecord>): RuntimeTrajectoryEvidenceProjection;
+declare function parseRuntimeTrajectoryHookEvent(input: unknown): RuntimeTrajectoryHookEvent | null;
+
+export { type ProjectRuntimeTrajectoryEvidenceOptions as P, type RuntimeTrajectoryRecord as R, type RuntimeTrajectoryEvidenceProjection as a, type RuntimeTrajectoryEvidenceSummary as b, type RuntimeTrajectoryHookEvent as c, type RuntimeTrajectoryRunRecord as d, projectRuntimeTrajectoryEvidence as e, parseRuntimeTrajectoryHookEvent as p };

package/dist/{trace/schema.d.ts → schema-m0gsnbt3.d.ts}

@@ -9,15 +9,15 @@
  * judge, sandbox) and first-class BudgetLedger / Artifact / JudgeVerdict
  * entities that OTEL leaves as free-form attributes.
  */
-export declare const TRACE_SCHEMA_VERSION = "1.0.0";
-export type RunStatus = 'running' | 'completed' | 'failed' | 'aborted';
-export interface BudgetSpec {
+declare const TRACE_SCHEMA_VERSION = "1.0.0";
+type RunStatus = 'running' | 'completed' | 'failed' | 'aborted';
+interface BudgetSpec {
     tokens?: number;
     wallMs?: number;
     calls?: number;
     usd?: number;
 }
-export interface RunOutcome {
+interface RunOutcome {
     score?: number;
     pass?: boolean;
     failureClass?: FailureClass;
@@ -30,8 +30,8 @@ export interface RunOutcome {
  * `app-runtime`: a run of the generated agent against a domain scenario.
  * `meta`: any meta-eval (judge replay, correlation analysis).
  */
-export type RunLayer = 'builder' | 'app-build' | 'app-runtime' | 'meta' | 'custom';
-export interface Run {
+type RunLayer = 'builder' | 'app-build' | 'app-runtime' | 'meta' | 'custom';
+interface Run {
     runId: string;
     /**
      * Stable identifier of the scenario being executed.
@@ -74,9 +74,9 @@ export interface Run {
     /** Free-form labels for downstream grouping. */
     tags?: Record<string, string>;
 }
-export type SpanKind = 'agent' | 'llm' | 'tool' | 'retrieval' | 'judge' | 'sandbox' | 'custom';
-export type SpanStatus = 'ok' | 'error';
-export interface SpanBase {
+type SpanKind = 'agent' | 'llm' | 'tool' | 'retrieval' | 'judge' | 'sandbox' | 'custom';
+type SpanStatus = 'ok' | 'error';
+interface SpanBase {
     spanId: string;
     parentSpanId?: string;
     runId: string;
@@ -89,7 +89,7 @@ export interface SpanBase {
     /** Anything not covered by typed fields. Kept deliberately free-form. */
     attributes?: Record<string, unknown>;
 }
-export interface Message {
+interface Message {
     role: 'system' | 'user' | 'assistant' | 'tool';
     content: string;
     tokens?: number;
@@ -100,7 +100,7 @@ export interface Message {
         mime?: string;
     }>;
 }
-export interface LlmSpan extends SpanBase {
+interface LlmSpan extends SpanBase {
     kind: 'llm';
     model: string;
     messages: Message[];
@@ -112,14 +112,14 @@ export interface LlmSpan extends SpanBase {
     costUsd?: number;
     finishReason?: string;
 }
-export interface ToolSpan extends SpanBase {
+interface ToolSpan extends SpanBase {
     kind: 'tool';
     toolName: string;
     args: unknown;
     result?: unknown;
     latencyMs?: number;
 }
-export interface RetrievalSpan extends SpanBase {
+interface RetrievalSpan extends SpanBase {
     kind: 'retrieval';
     query: string;
     hits: Array<{
@@ -128,7 +128,7 @@ export interface RetrievalSpan extends SpanBase {
         content?: string;
     }>;
 }
-export interface JudgeSpan extends SpanBase {
+interface JudgeSpan extends SpanBase {
     kind: 'judge';
     judgeId: string;
     /** Span this judgment applies to. */
@@ -139,7 +139,7 @@ export interface JudgeSpan extends SpanBase {
     rationale?: string;
     evidence?: string;
 }
-export interface SandboxSpan extends SpanBase {
+interface SandboxSpan extends SpanBase {
     kind: 'sandbox';
     image?: string;
     command?: string;
@@ -151,12 +151,12 @@ export interface SandboxSpan extends SpanBase {
     /** Duration in ms; the harness fills this explicitly (endedAt - startedAt may miss setup). */
     wallMs?: number;
 }
-export interface GenericSpan extends SpanBase {
+interface GenericSpan extends SpanBase {
     kind: 'agent' | 'custom';
 }
-export type Span = LlmSpan | ToolSpan | RetrievalSpan | JudgeSpan | SandboxSpan | GenericSpan;
-export type EventKind = 'log' | 'error' | 'budget_decrement' | 'budget_breach' | 'state_mutation' | 'policy_violation' | 'redaction_applied' | 'custom';
-export interface TraceEvent {
+type Span = LlmSpan | ToolSpan | RetrievalSpan | JudgeSpan | SandboxSpan | GenericSpan;
+type EventKind = 'log' | 'error' | 'budget_decrement' | 'budget_breach' | 'state_mutation' | 'policy_violation' | 'redaction_applied' | 'custom';
+interface TraceEvent {
     eventId: string;
     runId: string;
     spanId?: string;
@@ -164,7 +164,7 @@ export interface TraceEvent {
     timestamp: number;
     payload: Record<string, unknown>;
 }
-export interface BudgetLedgerEntry {
+interface BudgetLedgerEntry {
     runId: string;
     dimension: keyof BudgetSpec;
     limit: number;
@@ -175,7 +175,7 @@ export interface BudgetLedgerEntry {
     /** Span that triggered this entry, if any. */
     spanId?: string;
 }
-export interface Artifact {
+interface Artifact {
     artifactId: string;
     runId: string;
     spanId?: string;
@@ -188,11 +188,12 @@ export interface Artifact {
     /** Inline content for small blobs — keep under ~64KB. */
     inlineContent?: string;
 }
-export type FailureClass = 'success' | 'reasoning_error' | 'tool_selection_error' | 'tool_argument_error' | 'tool_recovery_failure' | 'hallucination' | 'instruction_following' | 'safety_refusal_miss' | 'policy_violation' | 'budget_exceeded' | 'format_drift' | 'permission_escalation' | 'pii_leak' | 'cost_overrun' | 'timeout' | 'sandbox_failure' | 'missing_user_data' | 'missing_domain_data' | 'missing_codebase_context' | 'missing_runtime_context' | 'missing_credentials' | 'missing_integration_connection' | 'missing_integration_scope' | 'integration_approval_required' | 'integration_auth_expired' | 'integration_provider_failure' | 'bad_integration_manifest' | 'unsafe_integration_write_denied' | 'stale_external_data' | 'bad_retrieval' | 'insufficient_evidence' | 'contradictory_evidence' | 'ambiguous_user_intent' | 'knowledge_readiness_blocked' | 'unknown';
-export declare const FAILURE_CLASSES: readonly FailureClass[];
-export declare function isLlmSpan(s: Span): s is LlmSpan;
-export declare function isToolSpan(s: Span): s is ToolSpan;
-export declare function isRetrievalSpan(s: Span): s is RetrievalSpan;
-export declare function isJudgeSpan(s: Span): s is JudgeSpan;
-export declare function isSandboxSpan(s: Span): s is SandboxSpan;
-//# sourceMappingURL=schema.d.ts.map
+type FailureClass = 'success' | 'reasoning_error' | 'tool_selection_error' | 'tool_argument_error' | 'tool_recovery_failure' | 'hallucination' | 'instruction_following' | 'safety_refusal_miss' | 'policy_violation' | 'budget_exceeded' | 'format_drift' | 'permission_escalation' | 'pii_leak' | 'cost_overrun' | 'timeout' | 'sandbox_failure' | 'missing_user_data' | 'missing_domain_data' | 'missing_codebase_context' | 'missing_runtime_context' | 'missing_credentials' | 'missing_integration_connection' | 'missing_integration_scope' | 'integration_approval_required' | 'integration_auth_expired' | 'integration_provider_failure' | 'bad_integration_manifest' | 'unsafe_integration_write_denied' | 'stale_external_data' | 'bad_retrieval' | 'insufficient_evidence' | 'contradictory_evidence' | 'ambiguous_user_intent' | 'knowledge_readiness_blocked' | 'unknown';
+declare const FAILURE_CLASSES: readonly FailureClass[];
+declare function isLlmSpan(s: Span): s is LlmSpan;
+declare function isToolSpan(s: Span): s is ToolSpan;
+declare function isRetrievalSpan(s: Span): s is RetrievalSpan;
+declare function isJudgeSpan(s: Span): s is JudgeSpan;
+declare function isSandboxSpan(s: Span): s is SandboxSpan;
+
+export { type Artifact as A, type BudgetLedgerEntry as B, type EventKind as E, type FailureClass as F, type GenericSpan as G, type JudgeSpan as J, type LlmSpan as L, type Message as M, type Run as R, type Span as S, type ToolSpan as T, type TraceEvent as a, type RunOutcome as b, type SpanKind as c, type RetrievalSpan as d, type SandboxSpan as e, type RunStatus as f, type RunLayer as g, type BudgetSpec as h, FAILURE_CLASSES as i, type SpanBase as j, type SpanStatus as k, TRACE_SCHEMA_VERSION as l, isJudgeSpan as m, isLlmSpan as n, isRetrievalSpan as o, isSandboxSpan as p, isToolSpan as q };