@tangle-network/agent-eval 0.95.0 → 0.96.0

package/dist/{trajectory.d.ts → trajectory-2TkpSEVh.d.ts}

@@ -1,3 +1,6 @@
+import { S as Span, a as TraceEvent } from './schema-m0gsnbt3.js';
+import { T as TraceStore } from './store-BcFXE6LG.js';
+
 /**
  * Trajectory — ordered, structured view over a run's spans.
  *
@@ -7,9 +10,8 @@
  * analyzers (stuck-loop detection, waste ratio) live in
  * `pipelines/` and consume the trajectory.
  */
-import type { Span, TraceEvent } from './trace/schema';
-import type { TraceStore } from './trace/store';
-export interface TrajectoryStep {
+
+interface TrajectoryStep {
     index: number;
     span: Span;
     /** Depth in the span tree from the root. 0 = top-level. */
@@ -17,7 +19,7 @@ export interface TrajectoryStep {
     /** Events attached to this span. */
     events: TraceEvent[];
 }
-export interface Trajectory {
+interface Trajectory {
     runId: string;
     steps: TrajectoryStep[];
     llmTurns: number;
@@ -26,7 +28,6 @@ export interface Trajectory {
     retrievals: number;
     totalDurationMs: number;
 }
-export declare function buildTrajectory(store: TraceStore, runId: string): Promise<Trajectory>;
-export type { Span, TraceEvent } from './trace/schema';
-export type { TraceStore } from './trace/store';
-//# sourceMappingURL=trajectory.d.ts.map
+declare function buildTrajectory(store: TraceStore, runId: string): Promise<Trajectory>;
+
+export { type Trajectory as T, type TrajectoryStep as a, buildTrajectory as b };

package/dist/{analyst/types.d.ts → types-B5x54y6n.d.ts}

@@ -1,3 +1,98 @@
+import { R as RunRecord } from './run-record-CP2ObebC.js';
+import { T as TraceAnalysisStore } from './store-C1YxJDEK.js';
+import { a as JudgeInput } from './types-C7DGg5ex.js';
+import { b as LlmCallRequest, c as LlmCallResult } from './llm-client-Bj7g0rqu.js';
+
+/**
+ * ChatClient — the single LLM abstraction analysts call.
+ *
+ * agent-eval already ships an `LlmClient` (OpenAI-compatible, retry,
+ * graceful JSON-schema degrade) and judges that talk to `TCloud`. Two
+ * mixed patterns force every analyst author to pick a transport, which
+ * couples analyst code to runtime concerns (cli-bridge vs router vs
+ * sandbox-sdk) it shouldn't know about.
+ *
+ * `ChatClient` is one interface every analyst takes via `AnalystContext.chat`.
+ * The operator decides at the registry boundary which transport binds
+ * to it. Analyst code stays transport-agnostic; swapping production
+ * (sandbox-sdk) for local dev (cli-bridge) or tests (mock) is a one-
+ * line factory call.
+ *
+ * Designed to coexist: existing `LlmClient` callers and existing
+ * `TCloud`-based judges keep working untouched. New analyst code uses
+ * `ChatClient`. When old call sites migrate, they pick up budgeting,
+ * cancellation, and unified telemetry for free.
+ */
+
+/**
+ * Unified chat interface. Mirrors LlmCallRequest/Result so the OpenAI-
+ * compatible mental model stays. Two methods: a one-shot `chat()` and
+ * an `streamChat()` for future agentic loops (not yet exposed).
+ */
+interface ChatClient {
+    /** Display name of the bound transport — included in telemetry. */
+    readonly transport: ChatTransport;
+    /** Default model when caller omits — operators bind this per environment. */
+    readonly defaultModel?: string;
+    chat(req: ChatRequest, opts?: ChatCallOpts): Promise<ChatResponse>;
+}
+type ChatTransport = 'router' | 'sandbox-sdk' | 'cli-bridge' | 'direct-provider' | 'mock';
+interface ChatRequest extends Omit<LlmCallRequest, 'model'> {
+    /** Optional — falls back to ChatClient.defaultModel. */
+    model?: string;
+}
+type ChatResponse = LlmCallResult;
+interface ChatCallOpts {
+    /** Cancel the in-flight request. */
+    signal?: AbortSignal;
+    /** Hard USD ceiling for this single call (informational; the underlying transport may not enforce). */
+    maxCostUsd?: number;
+    /** Correlation tag carried into request headers when the transport allows. */
+    correlationId?: string;
+}
+type CreateChatClientOpts = RouterTransportOpts | CliBridgeTransportOpts | DirectProviderTransportOpts | SandboxSdkTransportOpts | MockTransportOpts;
+interface BaseTransportOpts {
+    defaultModel?: string;
+}
+interface RouterTransportOpts extends BaseTransportOpts {
+    transport: 'router';
+    baseUrl?: string;
+    apiKey: string;
+}
+interface CliBridgeTransportOpts extends BaseTransportOpts {
+    transport: 'cli-bridge';
+    baseUrl?: string;
+    bearer?: string;
+}
+interface DirectProviderTransportOpts extends BaseTransportOpts {
+    transport: 'direct-provider';
+    baseUrl: string;
+    apiKey: string;
+}
+/**
+ * Sandbox-SDK transport. Provided as a thin pass-through: the caller
+ * supplies a callable that mimics LlmClient.chat() against an already-
+ * configured Sandbox handle. We don't import the SDK here to keep
+ * agent-eval dep-free of @tangle-network/sandbox.
+ */
+interface SandboxSdkTransportOpts extends BaseTransportOpts {
+    transport: 'sandbox-sdk';
+    chat: (req: ChatRequest, opts?: ChatCallOpts) => Promise<ChatResponse>;
+}
+/**
+ * Mock transport for tests. The handler receives the request and returns
+ * whatever the test wants. No retries, no JSON-schema degrade.
+ */
+interface MockTransportOpts extends BaseTransportOpts {
+    transport: 'mock';
+    handler: (req: ChatRequest, opts?: ChatCallOpts) => Promise<ChatResponse>;
+}
+/**
+ * Build a ChatClient bound to a specific transport. The returned client
+ * is safe to share across analysts in a single registry run.
+ */
+declare function createChatClient(opts: CreateChatClientOpts): ChatClient;
+
 /**
  * Analyst contract — the missing orchestration layer over agent-eval's
  * existing analyzers (analyzeTraces, MultiLayerVerifier, RunCritic,
@@ -14,15 +109,12 @@
  * a RunRecord, a JudgeInput, or `custom`), and the registry routes
  * the matching input from `AnalystRunInputs`.
  */
-import type { RunRecord } from '../run-record';
-import type { TraceAnalysisStore } from '../trace-analyst/store';
-import type { JudgeInput } from '../types';
-import type { ChatClient } from './chat-client';
+
 /**
  * Unified envelope every analyst emits. Schema-versioned so renderers
  * and time-series diffs survive future field additions.
  */
-export interface AnalystFinding {
+interface AnalystFinding {
     schema_version: '1.0.0';
     /**
      * Stable hash over identity-defining fields (analyst_id + canonical
@@ -66,8 +158,8 @@ export interface AnalystFinding {
     /** Analyst-private extras; renderers ignore unless they know the analyst. */
     metadata?: Record<string, unknown>;
 }
-export type AnalystSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
-export interface EvidenceRef {
+type AnalystSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+interface EvidenceRef {
     /**
      * Where the evidence lives. `span` and `event` refer to OTLP trace
      * elements; `artifact` to a file inside the run's artifact tree;
@@ -84,8 +176,8 @@ export interface EvidenceRef {
  * (e.g. an embedding cache, a partner SDK handle) read it from
  * `AnalystRunInputs.custom[<analyst id>]`.
  */
-export type AnalystInputKind = 'trace-store' | 'artifact-dir' | 'run-record' | 'judge-input' | 'custom';
-export interface AnalystCost {
+type AnalystInputKind = 'trace-store' | 'artifact-dir' | 'run-record' | 'judge-input' | 'custom';
+interface AnalystCost {
     /** `deterministic` analysts MUST NOT call the LLM. */
     kind: 'deterministic' | 'llm';
     /** Optional declared upper bound; the registry can enforce a budget. */
@@ -93,7 +185,7 @@ export interface AnalystCost {
     /** Models the analyst expects to use (informational). */
     models?: string[];
 }
-export interface AnalystRequirements {
+interface AnalystRequirements {
     /** Min number of shots / samples the analyst needs to produce signal. */
     min_shots?: number;
     /** Capabilities the runtime must supply (e.g. ['network', 'gpu']). */
@@ -103,7 +195,7 @@ export interface AnalystRequirements {
  * What's passed to every analyst call. The registry resolves which
  * field the analyst's `inputKind` selects and asserts it's present.
  */
-export interface AnalystRunInputs {
+interface AnalystRunInputs {
     traceStore?: TraceAnalysisStore;
     artifactDir?: string;
     runRecord?: RunRecord;
@@ -111,7 +203,7 @@ export interface AnalystRunInputs {
     /** Keyed by analyst id; populated by callers that registered custom analysts. */
     custom?: Record<string, unknown>;
 }
-export interface AnalystContext {
+interface AnalystContext {
     runId: string;
     /** Stable correlation id so logs from a single registry.run() share a tag. */
     correlationId: string;
@@ -149,7 +241,7 @@ export interface AnalystContext {
  * `TraceAnalysisStore`); the registry passes the right field from
  * `AnalystRunInputs` based on `inputKind`.
  */
-export interface Analyst<TInput = unknown> {
+interface Analyst<TInput = unknown> {
     /** Stable identifier — appears in finding_id, telemetry, and registry exclusion lists. */
     readonly id: string;
     /** Human-readable. One sentence. */
@@ -169,7 +261,7 @@ export interface Analyst<TInput = unknown> {
  * or (b) move the variable part into `rationale`/`metadata` and keep the
  * `claim` static.
  */
-export declare function computeFindingId(input: {
+declare function computeFindingId(input: {
     analyst_id: string;
     area: string;
     subject?: string;
@@ -181,11 +273,11 @@ export declare function computeFindingId(input: {
  * Convenience factory: produce a fully-formed AnalystFinding with the
  * id computed automatically. Analyst code stays terse.
  */
-export declare function makeFinding(init: Omit<AnalystFinding, 'schema_version' | 'finding_id' | 'produced_at'> & {
+declare function makeFinding(init: Omit<AnalystFinding, 'schema_version' | 'finding_id' | 'produced_at'> & {
     id_basis?: string;
     produced_at?: string;
 }): AnalystFinding;
-export interface AnalystRunSummary {
+interface AnalystRunSummary {
     analyst_id: string;
     status: 'ok' | 'skipped' | 'failed';
     /** Why skipped — missing input, budget exceeded, capability unmet. */
@@ -199,7 +291,7 @@ export interface AnalystRunSummary {
         message: string;
     };
 }
-export interface AnalystRunResult {
+interface AnalystRunResult {
     run_id: string;
     correlation_id: string;
     started_at: string;
@@ -222,7 +314,7 @@ export interface AnalystRunResult {
  * is the right granularity; subscribers wanting per-finding rendering
  * iterate `event.findings` themselves.
  */
-export type AnalystRunEvent = {
+type AnalystRunEvent = {
     type: 'run-started';
     run_id: string;
     correlation_id: string;
@@ -245,4 +337,5 @@ export type AnalystRunEvent = {
     type: 'run-completed';
     result: AnalystRunResult;
 };
-//# sourceMappingURL=types.d.ts.map
+
+export { type Analyst as A, type ChatClient as C, type DirectProviderTransportOpts as D, type EvidenceRef as E, type MockTransportOpts as M, type RouterTransportOpts as R, type SandboxSdkTransportOpts as S, type AnalystContext as a, type AnalystRunSummary as b, type AnalystFinding as c, type AnalystRunResult as d, type AnalystRunInputs as e, type AnalystRunEvent as f, type AnalystCost as g, type AnalystSeverity as h, type AnalystInputKind as i, type AnalystRequirements as j, type ChatCallOpts as k, type ChatRequest as l, type ChatResponse as m, type ChatTransport as n, type CliBridgeTransportOpts as o, type CreateChatClientOpts as p, computeFindingId as q, createChatClient as r, makeFinding as s };

package/dist/{campaign/types.d.ts → types-BMahhhio.d.ts}

@@ -1,3 +1,5 @@
+import { b as RunTokenUsage } from './run-record-CP2ObebC.js';
+
 /**
  * Pass A substrate types — `runCampaign` is the one primitive every
  * eval flow composes from. Three contracts in this file:
@@ -15,10 +17,10 @@
  * No new architecture vs 0.38 — Pass A formalizes the shapes so consumers
  * can build dashboards / CI gates / regression diffs against a stable schema.
  */
-import type { RunTokenUsage } from '../run-record';
+
 /** Stable identifier + kind tag for any scenario. Consumers
  *  extend with their per-domain payload (persona, task, requirement, ...). */
-export interface Scenario {
+interface Scenario {
     id: string;
     kind: string;
     tags?: string[];
@@ -26,7 +28,7 @@ export interface Scenario {
 /** Context handed to every dispatch invocation. Scoped — every
  *  trace/span carries the cellId, every artifact write lands under the cell's
  *  artifact root, the cost meter accumulates per cell. */
-export interface DispatchContext {
+interface DispatchContext {
     cellId: string;
     rep: number;
     generation?: number;
@@ -50,11 +52,11 @@ export interface DispatchContext {
 }
 /** One function: scenario + ctx → artifact. Dispatcher chooses
  *  whether to call `runMultishot`, `runLoop`, raw `streamPrompt`, anything. */
-export type DispatchFn<TScenario extends Scenario, TArtifact> = (scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
+type DispatchFn<TScenario extends Scenario, TArtifact> = (scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
 /** One session within a multi-session journey. Dispatch is
  *  invoked once per session in order; state from prior session's artifact
  *  is exposed via `ctx.priorSessionArtifact`. */
-export interface SessionScript<TScenario, TArtifact> {
+interface SessionScript<TScenario, TArtifact> {
     id: string;
     intent: string;
     maxTurns?: number;
@@ -64,7 +66,7 @@ export interface SessionScript<TScenario, TArtifact> {
      *  resolves. Returns the persona shape used by the NEXT session. */
     evolveAfterSession?: (artifact: TArtifact, sessionIndex: number, scenario: TScenario) => TScenario;
 }
-export interface JudgeDimension {
+interface JudgeDimension {
     /** JSON field name + score key. */
     key: string;
     /** Description shown in the judge's user prompt. */
@@ -77,7 +79,7 @@ export interface JudgeDimension {
  *  must not constrain that. The `llmJudge()` helper builds a `score` that does
  *  one LLM call for the common case. `appliesTo` lets a judge run only on
  *  scenarios that match (e.g. a legal-citation judge only on legal scenarios). */
-export interface JudgeConfig<TArtifact, TScenario extends Scenario = Scenario> {
+interface JudgeConfig<TArtifact, TScenario extends Scenario = Scenario> {
     name: string;
     dimensions: JudgeDimension[];
     /** Score one artifact. Throw on failure — a thrown judge is recorded as a
@@ -98,7 +100,7 @@ export interface JudgeConfig<TArtifact, TScenario extends Scenario = Scenario> {
  *  promotion-policy) — never renormalize a producer's values in place, as
  *  downstream thresholds (`composite >= 5` in multishot/matrix.ts, live-soak
  *  `>= 7` gates) key on the producer's native scale. */
-export interface JudgeScore {
+interface JudgeScore {
     dimensions: Record<string, number>;
     composite: number;
     notes: string;
@@ -119,7 +121,7 @@ export interface JudgeScore {
  *  trace findings → opens a worktree). Measured by checking out `worktreeRef`
  *  and running the worker against the changed code. See the improvement-tier
  *  table in `docs/design/loop-taxonomy.md`. */
-export interface CodeSurface {
+interface CodeSurface {
     kind: 'code';
     /** Worktree path or git ref holding the candidate code change. The
      *  consumer's `dispatchWithSurface` checks this out before running. */
@@ -136,14 +138,14 @@ export interface CodeSurface {
  *   - `CodeSurface` — tier 4: an implementation change behind a worktree ref.
  *  Tier 3 (knowledge) is owned by agent-knowledge and rides its own adapter,
  *  not this type. */
-export type MutableSurface = string | CodeSurface;
+type MutableSurface = string | CodeSurface;
 /** A proposer output carrying the surface AND the WHY behind
  *  it. Reflective proposers (`gepaProposer`) parse a `{label, rationale, payload}`
  *  from the model; without this wrapper the loop keeps only `payload` and the
  *  rationale that motivated the change is lost — the candidate becomes
  *  unattributable. `propose()` may return either bare `MutableSurface`s (cheap
  *  blind mutators) or these (reflective proposers); the loop normalizes both. */
-export interface ProposedCandidate {
+interface ProposedCandidate {
     surface: MutableSurface;
     /** Short human label for the change (≤ 40 chars typical). */
     label: string;
@@ -154,7 +156,7 @@ export interface ProposedCandidate {
 }
 /** Type guard: a proposal carrying its rationale vs a bare
  *  surface. The loop branches on this to populate `GenerationCandidate`. */
-export declare function isProposedCandidate(value: MutableSurface | ProposedCandidate): value is ProposedCandidate;
+declare function isProposedCandidate(value: MutableSurface | ProposedCandidate): value is ProposedCandidate;
 /** A non-dominated parent on the GEPA Pareto frontier — a
  *  surface that, across the per-scenario objective vectors, no other tried
  *  surface beats on every scenario. A candidate worse on the mean composite
@@ -163,7 +165,7 @@ export declare function isProposedCandidate(value: MutableSurface | ProposedCand
  *  computes the frontier across ALL generations and hands it to the proposer so
  *  a reflective proposer can combine complementary lessons (GEPA, Agrawal et
  *  al., arXiv:2507.19457). See `pareto.ts` (`paretoFrontier`). */
-export interface ParetoParent {
+interface ParetoParent {
     surface: MutableSurface;
     surfaceHash: string;
     /** The objective vector: per-scenario composite (higher is better). The
@@ -181,7 +183,7 @@ export interface ParetoParent {
  *  surface, return N candidate surfaces. Pure transform, no generation
  *  awareness. Reflective-mutation and `AxGEPA` mutators conform. Wrapped by
  *  `evolutionaryProposer` to become a `SurfaceProposer`. */
-export interface Mutator<TFindings = unknown> {
+interface Mutator<TFindings = unknown> {
     kind: string;
     mutate(args: {
         findings: TFindings[];
@@ -196,7 +198,7 @@ export interface Mutator<TFindings = unknown> {
  *  (`evolutionaryProposer`) can ignore them while a code-tier agentic generator
  *  consumes the report + dataset to drive a coding harness.
  *  See `docs/campaign-proposers.md`. */
-export interface ProposeContext<TFindings = unknown> {
+interface ProposeContext<TFindings = unknown> {
     currentSurface: MutableSurface;
     history: GenerationRecord[];
     findings: TFindings[];
@@ -240,7 +242,7 @@ export interface ProposeContext<TFindings = unknown> {
  *  SAME loop, not separate loops. The loop body (`runOptimization`) and the
  *  gated promotion shell (`runImprovementLoop`) are proposer-agnostic.
  */
-export interface SurfaceProposer<TFindings = unknown> {
+interface SurfaceProposer<TFindings = unknown> {
     kind: string;
     /** Plan: propose N candidate surfaces for the next generation. A proposer
      *  may return bare `MutableSurface`s or `ProposedCandidate`s that carry the
@@ -258,18 +260,18 @@ export interface SurfaceProposer<TFindings = unknown> {
 }
 /** Optional vocabulary alias. The loop is the optimizer; this object is the
  * proposer inside that loop. */
-export type OptimizationProposer<TFindings = unknown> = SurfaceProposer<TFindings>;
-export interface OptimizerConfigBase {
+type OptimizationProposer<TFindings = unknown> = SurfaceProposer<TFindings>;
+interface OptimizerConfigBase {
     populationSize: number;
     maxGenerations: number;
     surfaceExtractor: (profile: unknown) => MutableSurface;
 }
-export interface OptimizerConfig extends OptimizerConfigBase {
+interface OptimizerConfig extends OptimizerConfigBase {
     proposer: SurfaceProposer;
 }
 /** Five-valued verdict taxonomy (MOSS-paper alignment). */
-export type GateDecision = 'ship' | 'hold' | 'need_more_work' | 'model_ceiling' | 'arch_ceiling';
-export interface GateContext<TArtifact, TScenario extends Scenario> {
+type GateDecision = 'ship' | 'hold' | 'need_more_work' | 'model_ceiling' | 'arch_ceiling';
+interface GateContext<TArtifact, TScenario extends Scenario> {
     candidateArtifacts: Map<string, TArtifact>;
     baselineArtifacts?: Map<string, TArtifact>;
     /** Candidate (winner) judge scores, keyed by cellId. */
@@ -286,7 +288,7 @@ export interface GateContext<TArtifact, TScenario extends Scenario> {
     };
     signal: AbortSignal;
 }
-export interface GateResult {
+interface GateResult {
     decision: GateDecision;
     reasons: string[];
     contributingGates: Array<{
@@ -297,23 +299,23 @@ export interface GateResult {
     delta?: number;
 }
 /** Composable promotion gate. */
-export interface Gate<TArtifact = unknown, TScenario extends Scenario = Scenario> {
+interface Gate<TArtifact = unknown, TScenario extends Scenario = Scenario> {
     name: string;
     decide(ctx: GateContext<TArtifact, TScenario>): Promise<GateResult>;
 }
 /** Scoped trace writer handed to each dispatch — every span
  *  auto-tagged with the cellId so traces filter cleanly. */
-export interface CampaignTraceWriter {
+interface CampaignTraceWriter {
     span(name: string, attributes?: Record<string, unknown>): TraceSpan;
     flush(): Promise<void>;
 }
-export interface TraceSpan {
+interface TraceSpan {
     end(attributes?: Record<string, unknown>): void;
     setAttribute(key: string, value: unknown): void;
 }
 /** Scoped artifact writer — `write(path, content)` lands under
  *  `<runDir>/<cellId>/<path>`. */
-export interface CampaignArtifactWriter {
+interface CampaignArtifactWriter {
     write(path: string, content: string | Uint8Array): Promise<string>;
     writeJson(path: string, value: unknown): Promise<string>;
 }
@@ -321,7 +323,7 @@ export interface CampaignArtifactWriter {
  *  (run-record.ts, same package) so a cell maps onto a `RunRecord` for the
  *  backend-integrity guard with ONE source of truth — a field added to
  *  `RunTokenUsage` is a compile error here, not a silent drift. */
-export type CampaignTokenUsage = RunTokenUsage;
+type CampaignTokenUsage = RunTokenUsage;
 /** Cell-scoped cost meter. NOTHING is captured automatically —
  *  the substrate does not intercept the LLM call, so it cannot see cost or
  *  tokens unless the dispatch reports them. Every LLM cost MUST be reported via
@@ -329,7 +331,7 @@ export type CampaignTokenUsage = RunTokenUsage;
  *  neither yields a `{cost:0, tokens:0}` cell, which the backend-integrity
  *  guard (`assertRealBackend`) correctly reads as a stub. Also use `observe`
  *  for non-LLM spend (sandbox time, tool costs). */
-export interface CampaignCostMeter {
+interface CampaignCostMeter {
     observe(amountUsd: number, source: string): void;
     /** Record LLM token usage for this cell; accumulates across calls. A cell
      *  has `costUsd` but no token counts unless the dispatch reports them here —
@@ -344,8 +346,8 @@ export interface CampaignCostMeter {
 /** Source tag — required on every store write. Used by the
  *  default training-source filter (production-trace samples NOT used as
  *  training scenarios unless explicitly opted in). */
-export type LabeledScenarioSource = 'production-trace' | 'eval-run' | 'manual' | 'red-team' | 'synthetic';
-export type RedactionStatus = 'raw' | 'redacted-pii' | 'redacted-secrets' | 'fully-redacted';
+type LabeledScenarioSource = 'production-trace' | 'eval-run' | 'manual' | 'red-team' | 'synthetic';
+type RedactionStatus = 'raw' | 'redacted-pii' | 'redacted-secrets' | 'fully-redacted';
 /** How much a label can be trusted to evaluate against — the gold-admission
  *  gate. Strictly ordered: a record qualifies for a `minTrust` filter when its
  *  trust rank is >= the requested rank.
@@ -360,13 +362,13 @@ export type RedactionStatus = 'raw' | 'redacted-pii' | 'redacted-secrets' | 'ful
  *  Absent on a write ⇒ treated as `unverified` (fail-closed: a writer must
  *  explicitly assert trust to make a record gold-eligible — it never happens
  *  by accident). */
-export type LabelTrust = 'unverified' | 'verified-signal' | 'human-rated';
+type LabelTrust = 'unverified' | 'verified-signal' | 'human-rated';
 /** Ordinal rank for a label-trust tier; absent ⇒ `unverified` (rank 0). */
-export declare function labelTrustRank(trust: LabelTrust | undefined): number;
+declare function labelTrustRank(trust: LabelTrust | undefined): number;
 /** Required-provenance write. The store rejects writes that
  *  lack provenance — a default-on flywheel without provenance is the
  *  data-poisoning vector flagged in the alignment review. */
-export interface LabeledScenarioWrite<TScenario extends Scenario = Scenario, TArtifact = unknown> {
+interface LabeledScenarioWrite<TScenario extends Scenario = Scenario, TArtifact = unknown> {
     scenario: TScenario;
     artifact: TArtifact;
     judgeScores: Record<string, JudgeScore>;
@@ -382,14 +384,14 @@ export interface LabeledScenarioWrite<TScenario extends Scenario = Scenario, TAr
     /** Optional per-source rate-limit bucket key (e.g., the tenant id). */
     rateLimitBucket?: string;
 }
-export interface LabeledScenarioRecord<TScenario extends Scenario = Scenario, TArtifact = unknown> extends LabeledScenarioWrite<TScenario, TArtifact> {
+interface LabeledScenarioRecord<TScenario extends Scenario = Scenario, TArtifact = unknown> extends LabeledScenarioWrite<TScenario, TArtifact> {
     /** Stable hash of (scenario.id, source, capturedAt, sourceVersionHash). */
     recordHash: string;
     /** Substrate-assigned split — train if captured before the campaign's
      *  `temporalCutoff`, test if after. Explicit override allowed via filter. */
     split: 'train' | 'test';
 }
-export interface LabeledScenarioSampleArgs {
+interface LabeledScenarioSampleArgs {
     count: number;
     /** REQUIRED — substrate refuses to sample without an explicit split. */
     split: 'train' | 'test';
@@ -409,7 +411,7 @@ export interface LabeledScenarioSampleArgs {
         minTrust?: LabelTrust;
     };
 }
-export interface LabeledScenarioStore {
+interface LabeledScenarioStore {
     observe(write: LabeledScenarioWrite): Promise<void>;
     sample(args: LabeledScenarioSampleArgs): Promise<LabeledScenarioRecord[]>;
     size(): Promise<{
@@ -421,7 +423,7 @@ export interface LabeledScenarioStore {
         byTrust: Record<LabelTrust, number>;
     }>;
 }
-export interface CampaignCellResult<TArtifact> {
+interface CampaignCellResult<TArtifact> {
     cellId: string;
     scenarioId: string;
     rep: number;
@@ -438,18 +440,18 @@ export interface CampaignCellResult<TArtifact> {
     cached: boolean;
     error?: string;
 }
-export interface JudgeAggregate {
+interface JudgeAggregate {
     mean: number;
     stdev: number;
     ci95: [number, number];
     n: number;
 }
-export interface ScenarioAggregate {
+interface ScenarioAggregate {
     meanComposite: number;
     ci95: [number, number];
     n: number;
 }
-export interface GenerationRecord {
+interface GenerationRecord {
     generationIndex: number;
     candidates: GenerationCandidate[];
     promoted: string[];
@@ -458,7 +460,7 @@ export interface GenerationRecord {
  *  let a reflective proposer ground its next proposal on WHICH
  *  dimensions the candidate is weakest on and WHICH scenarios it best/worst
  *  handled — the evidence a blind `Mutator` cannot see. */
-export interface GenerationCandidate {
+interface GenerationCandidate {
     surfaceHash: string;
     composite: number;
     ci95: [number, number];
@@ -484,7 +486,7 @@ export interface GenerationCandidate {
      *  Present when the proposer returned a `ProposedCandidate`. */
     rationale?: string;
 }
-export interface CampaignAggregates {
+interface CampaignAggregates {
     byJudge: Record<string, JudgeAggregate>;
     byScenario: Record<string, ScenarioAggregate>;
     totalCostUsd: number;
@@ -493,7 +495,7 @@ export interface CampaignAggregates {
     cellsCached: number;
     cellsFailed: number;
 }
-export interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scenario> {
+interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scenario> {
     /** sha256(scenarios, judges, dispatch source ref, optimizer config, seed). Stable identity for reruns. */
     manifestHash: string;
     seed: number;
@@ -516,4 +518,5 @@ export interface CampaignResult<TArtifact = unknown, TScenario extends Scenario
      *  want narrowed types when extending `CampaignResult`. */
     scenarios: Array<Pick<TScenario, 'id' | 'kind'>>;
 }
-//# sourceMappingURL=types.d.ts.map
+
+export { type JudgeAggregate as A, type ScenarioAggregate as B, type CampaignResult as C, type DispatchFn as D, isProposedCandidate as E, labelTrustRank as F, type GateResult as G, type JudgeScore as J, type LabeledScenarioStore as L, type MutableSurface as M, type OptimizationProposer as O, type ParetoParent as P, type RedactionStatus as R, type Scenario as S, type TraceSpan as T, type JudgeConfig as a, type DispatchContext as b, type CampaignTraceWriter as c, type GenerationRecord as d, type SurfaceProposer as e, type Gate as f, type GateContext as g, type Mutator as h, type GateDecision as i, type CampaignAggregates as j, type CampaignArtifactWriter as k, type CampaignCellResult as l, type CampaignCostMeter as m, type CodeSurface as n, type GenerationCandidate as o, type JudgeDimension as p, type OptimizerConfig as q, type SessionScript as r, type LabeledScenarioWrite as s, type LabeledScenarioSampleArgs as t, type LabeledScenarioRecord as u, type LabelTrust as v, type ProposedCandidate as w, type ProposeContext as x, type LabeledScenarioSource as y, type CampaignTokenUsage as z };

package/dist/{matrix/types.d.ts → types-BUxNaJ8c.d.ts}

@@ -1,3 +1,5 @@
+import { D as DefaultVerdict } from './verdict-C9MlYujm.js';
+
 /**
  * N-axis cartesian matrix over substrate types — types module.
  *
@@ -7,11 +9,10 @@
  * and aggregates per-axis pass/score/cost summaries. Substrate types are
  * imported at the boundary by JSDoc only; the matrix never wraps them.
  */
-import type { DefaultVerdict } from '../verdict';
-export type { DefaultVerdict } from '../verdict';
+
 /** One axis = one dimension to iterate. `V` is the value type — pass any
  *  substrate type (AgentProfile, Driver, Validator, rubric record). */
-export interface MatrixAxis<V> {
+interface MatrixAxis<V> {
     /** Axis name. Becomes the key in `MatrixResult.byAxis`. */
     name: string;
     /** Stable id per value. Used as the bucket key in aggregation. */
@@ -24,7 +25,7 @@ export interface MatrixAxis<V> {
     label?: (value: V, id: string) => string;
 }
 /** A cell carries one picked value from each axis, keyed by axis name. */
-export interface MatrixCell {
+interface MatrixCell {
     axes: Record<string, {
         id: string;
         value: unknown;
@@ -34,7 +35,7 @@ export interface MatrixCell {
     /** Stable sort key — preserves cartesian order across concurrent execution. */
     ordinal: number;
 }
-export interface CellResult<Output> {
+interface CellResult<Output> {
     output: Output;
     verdict: DefaultVerdict;
     costUsd: number;
@@ -47,7 +48,7 @@ export interface CellResult<Output> {
         kind: string;
     };
 }
-export interface AxisSummary {
+interface AxisSummary {
     axisName: string;
     axisValue: string;
     cells: number;
@@ -58,7 +59,7 @@ export interface AxisSummary {
     totalCostUsd: number;
     meanDurationMs: number;
 }
-export interface MatrixResult<Output> {
+interface MatrixResult<Output> {
     cells: Array<{
         cell: MatrixCell;
         runs: CellResult<Output>[];
@@ -80,7 +81,7 @@ export interface MatrixResult<Output> {
     /** Stable id-like string generated at the end of the run. */
     matrixId: string;
 }
-export interface RunAgentMatrixOptions<Output> {
+interface RunAgentMatrixOptions<Output> {
     axes: MatrixAxis<unknown>[];
     /** User-supplied cell executor. May throw; the matrix captures throws as
      *  `CellResult.error` and continues. */
@@ -103,4 +104,5 @@ export interface RunAgentMatrixOptions<Output> {
      *  and suppresses scheduling of new ones. */
     signal?: AbortSignal;
 }
-//# sourceMappingURL=types.d.ts.map
+
+export type { AxisSummary as A, CellResult as C, MatrixResult as M, RunAgentMatrixOptions as R, MatrixAxis as a, MatrixCell as b };