@tangle-network/agent-eval 0.94.0 → 0.95.0

package/dist/agent-profile-cell.d.ts

@@ -0,0 +1,101 @@
+import type { AgentProfile } from '@tangle-network/agent-interface';
+import { ValidationError } from './errors';
+export type AgentProfileCellSchemaVersion = 'agent-profile-cell/v1';
+export type AgentProfileJson = string | number | boolean | null | AgentProfileJson[] | {
+    [key: string]: AgentProfileJson;
+};
+export type AgentProfileDimensionValue = string | number | boolean | null;
+export interface AgentProfileSource {
+    /** Runtime/profile contract being fingerprinted, e.g. `agent-interface-profile`. */
+    kind: string;
+    /** sha256 over the canonical source profile object. */
+    hash: string;
+}
+export 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;
+}
+export interface AgentProfileHarness {
+    id: string;
+    version?: string;
+    hash?: string;
+}
+export interface AgentProfileCellInput {
+    profileId: string;
+    sourceProfile: AgentProfileSourceInput;
+    harness?: AgentProfileHarness;
+    model?: string;
+    promptHash?: string;
+    dimensions?: Record<string, AgentProfileDimensionValue>;
+}
+export interface AgentProfileCell {
+    schemaVersion: AgentProfileCellSchemaVersion;
+    cellId: string;
+    profileId: string;
+    sourceProfile: AgentProfileSource;
+    harness?: AgentProfileHarness;
+    model?: string;
+    promptHash?: string;
+    dimensions?: Record<string, AgentProfileDimensionValue>;
+}
+export declare class AgentProfileCellValidationError extends ValidationError {
+    readonly path: string;
+    constructor(message: string, path?: string);
+}
+export declare function buildAgentProfileCell(input: AgentProfileCellInput): Promise<AgentProfileCell>;
+export declare function agentProfileCellHashMaterial(cell: AgentProfileCell): Omit<AgentProfileCell, 'cellId'>;
+export declare function verifyAgentProfileCell(cell: AgentProfileCell): Promise<boolean>;
+export declare function validateAgentProfileCell(input: unknown): AgentProfileCell;
+export declare function requireAgentProfileCell(record: {
+    runId: string;
+    agentProfile?: AgentProfileCell;
+}): AgentProfileCell;
+export declare function agentProfileCellKey(record: {
+    runId: string;
+    agentProfile?: AgentProfileCell;
+}): string;
+export declare function assertRunAgentProfileCell(record: {
+    runId: string;
+    model: string;
+    promptHash: string;
+    agentProfile?: AgentProfileCell;
+}): Promise<AgentProfileCell>;
+export 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. */
+export 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";
+};
+export 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. */
+export declare function toAgentProfileJson(value: unknown): AgentProfileJson;
+/** Canonical AgentProfile shape required when deriving a stable cell id. */
+export 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). */
+export declare function buildAgentInterfaceProfileCell(profile: AgentInterfaceProfileLike, input: Omit<AgentProfileCellInput, 'profileId' | 'sourceProfile'>): Promise<AgentProfileCell>;
+//# sourceMappingURL=agent-profile-cell.d.ts.map

package/dist/agent-profile-cell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-profile-cell.d.ts","sourceRoot":"","sources":["../src/agent-profile-cell.ts"],"names":[],"mappings":"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"}

package/dist/agent-profile.d.ts

@@ -0,0 +1,27 @@
+import type { AgentProfile } from '@tangle-network/agent-interface';
+export type { AgentProfile } from '@tangle-network/agent-interface';
+/**
+ * Collision-resistant, path-safe, human-readable profile id for eval artifacts.
+ * Scorecard joins still use `agentProfileHash`; this id is for run ids, matrix
+ * keys, and directory names where two profiles must not collapse onto one row.
+ * The suffix is the first 64 bits of the behaviour hash, enough for ordinary
+ * eval matrices while keeping filenames readable.
+ */
+export declare function agentProfileId(profile: AgentProfile): string;
+/**
+ * Model snapshot used for `RunRecord.model`. Eval surfaces require a concrete
+ * model id because run records reject bare/missing model aliases.
+ */
+export declare function agentProfileModelId(profile: AgentProfile): string;
+/**
+ * Deterministic behaviour identity for the canonical
+ * `@tangle-network/agent-interface` AgentProfile.
+ *
+ * `name` and `description` are labels and do not affect the hash. Profile
+ * `version`, prompt, model hints, tools, resources, hooks, modes, permissions,
+ * and extensions do affect the hash. Resource array order is hash-bearing
+ * because mount order can change agent behaviour. Undefined fields are treated
+ * as absent; explicit `null` fields remain hash-bearing.
+ */
+export declare function agentProfileHash(profile: AgentProfile): string;
+//# sourceMappingURL=agent-profile.d.ts.map

package/dist/agent-profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-profile.d.ts","sourceRoot":"","sources":["../src/agent-profile.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AAInE,YAAY,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AAEnE;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAG5D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CASjE;AAuBD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAY9D"}

package/dist/agent-profile.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agent-profile.test.d.ts.map

package/dist/agent-profile.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-profile.test.d.ts","sourceRoot":"","sources":["../src/agent-profile.test.ts"],"names":[],"mappings":""}

package/dist/analyst/adapters.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Adapter factories — lift each existing agent-eval primitive into the
+ * Analyst contract without re-implementing it.
+ *
+ * Five primitives, five factories. Each one:
+ *   - Builds an Analyst with a stable id (caller chooses; defaults
+ *     given), a sensible default `inputKind`, a version derived from
+ *     the wrapped primitive's version + an adapter revision, and an
+ *     `analyze()` that calls the primitive and lifts its output to
+ *     AnalystFinding[] using `makeFinding()`.
+ *   - Maps severities: the existing `Severity` ('critical' | 'major' |
+ *     'minor' | 'info') projects onto AnalystSeverity ('critical' |
+ *     'high' | 'medium' | 'low' | 'info'); 'major' → 'high', 'minor' →
+ *     'medium'. Domain analysts that want finer-grained mapping override.
+ *
+ * Adapters never own state. Calling the same factory twice with the
+ * same primitive instance is safe.
+ */
+import type { Severity as LayerSeverity, MultiLayerVerifier, VerifyOptions } from '../multi-layer-verifier';
+import { RunCritic, type RunTrace } from '../run-critic';
+import { type SemanticConceptJudgeInput, type SemanticConceptJudgeOptions } from '../semantic-concept-judge';
+import type { JudgeFn, JudgeInput, TCloud } from '../types';
+import type { Analyst, AnalystSeverity } from './types';
+export declare function liftSeverity(s: LayerSeverity): AnalystSeverity;
+export interface VerifierAdapterOpts<Env> {
+    id?: string;
+    area?: string;
+    verifier: MultiLayerVerifier<Env>;
+    /**
+     * The verifier expects an `env` per run. Adapters take it from
+     * `AnalystRunInputs.custom[<id>]` via the registry's 'custom' routing.
+     */
+    options?: Omit<VerifyOptions<Env>, 'env'>;
+}
+export declare function createVerifierAdapter<Env>(opts: VerifierAdapterOpts<Env>): Analyst<Env>;
+export interface RunCriticAdapterOpts {
+    id?: string;
+    area?: string;
+    critic?: RunCritic;
+    /** Optional threshold below which a dimension is reported as a finding. Default 0.5. */
+    threshold?: number;
+}
+export declare function createRunCriticAdapter(opts?: RunCriticAdapterOpts): Analyst<RunTrace>;
+export interface JudgeAdapterOpts {
+    id?: string;
+    area?: string;
+    judge: JudgeFn;
+    /** TCloud handle the JudgeFn calls. */
+    tcloud: TCloud;
+    /** Optional cost classification — most judges call an LLM. */
+    cost?: Analyst['cost'];
+    /** Optional threshold below which a JudgeScore becomes a finding. Default 6 (on 0-10 scale). */
+    threshold?: number;
+}
+export declare function createJudgeAdapter(opts: JudgeAdapterOpts): Analyst<JudgeInput>;
+export interface SemanticConceptJudgeAdapterOpts {
+    id?: string;
+    area?: string;
+    options?: SemanticConceptJudgeOptions;
+}
+export declare function createSemanticConceptJudgeAdapter(opts?: SemanticConceptJudgeAdapterOpts): Analyst<SemanticConceptJudgeInput>;
+//# sourceMappingURL=adapters.d.ts.map

package/dist/analyst/adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../../src/analyst/adapters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAEV,QAAQ,IAAI,aAAa,EACzB,kBAAkB,EAClB,aAAa,EACd,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxD,OAAO,EAGL,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EACjC,MAAM,2BAA2B,CAAA;AAClC,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAc,MAAM,EAAE,MAAM,UAAU,CAAA;AACvE,OAAO,KAAK,EAAE,OAAO,EAAkB,eAAe,EAAE,MAAM,SAAS,CAAA;AAOvE,wBAAgB,YAAY,CAAC,CAAC,EAAE,aAAa,GAAG,eAAe,CAW9D;AAID,MAAM,WAAW,mBAAmB,CAAC,GAAG;IACtC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,kBAAkB,CAAC,GAAG,CAAC,CAAA;IACjC;;;OAGG;IACH,OAAO,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAA;CAC1C;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,IAAI,EAAE,mBAAmB,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAgDvF;AAwBD,MAAM,WAAW,oBAAoB;IACnC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,wFAAwF;IACxF,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,wBAAgB,sBAAsB,CAAC,IAAI,GAAE,oBAAyB,GAAG,OAAO,CAAC,QAAQ,CAAC,CA6DzF;AAID,MAAM,WAAW,gBAAgB;IAC/B,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAA;IACd,8DAA8D;IAC9D,IAAI,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;IACtB,gGAAgG;IAChG,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,CAkB9E;AAiCD,MAAM,WAAW,+BAA+B;IAC9C,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,2BAA2B,CAAA;CACtC;AAED,wBAAgB,iCAAiC,CAC/C,IAAI,GAAE,+BAAoC,GACzC,OAAO,CAAC,yBAAyB,CAAC,CAuDpC"}

package/dist/analyst/analyst.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=analyst.test.d.ts.map

package/dist/analyst/analyst.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyst.test.d.ts","sourceRoot":"","sources":["../../src/analyst/analyst.test.ts"],"names":[],"mappings":""}

package/dist/analyst/ax-service.d.ts

@@ -0,0 +1,27 @@
+import type { AxAIService } from '@ax-llm/ax';
+export interface CreateAnalystAiConfig {
+    /** OpenAI-compatible API key forwarded as `Authorization: Bearer`.
+     *  cli-bridge ignores the value on loopback but Ax requires a non-empty string. */
+    apiKey: string;
+    /** OpenAI-compatible base URL — e.g. `https://router.tangle.tools/v1` or a
+     *  cli-bridge loopback. */
+    baseUrl: string;
+    /** Model id forwarded to the analyst actor + responder. */
+    model: string;
+    /** Ax provider name. Defaults to the OpenAI-compatible client. */
+    provider?: 'openai' | 'anthropic';
+}
+/**
+ * Construct the `AxAIService` an analyst kind calls through
+ * (`createTraceAnalystKind({ ai })`).
+ *
+ * Ax's `ai()` pins `config.model` to the OpenAI catalog enum, but every
+ * OpenAI-compatible router an analyst points at (router.tangle.tools,
+ * cli-bridge) accepts arbitrary model ids (claude-code/sonnet, openai/gpt-5.4,
+ * …). Consumers were each re-rolling `ai({ name, apiKey, apiURL, config })`
+ * behind an `as (a: any) => any` cast to dodge the enum; this is the one
+ * canonical constructor so they don't have to — and don't take a direct
+ * `@ax-llm/ax` dependency for it.
+ */
+export declare function createAnalystAi(config: CreateAnalystAiConfig): AxAIService;
+//# sourceMappingURL=ax-service.d.ts.map

package/dist/analyst/ax-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ax-service.d.ts","sourceRoot":"","sources":["../../src/analyst/ax-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAG7C,MAAM,WAAW,qBAAqB;IACpC;uFACmF;IACnF,MAAM,EAAE,MAAM,CAAA;IACd;+BAC2B;IAC3B,OAAO,EAAE,MAAM,CAAA;IACf,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAA;IACb,kEAAkE;IAClE,QAAQ,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAA;CAClC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,WAAW,CAO1E"}

package/dist/analyst/behavioral-analyst.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `behavioralAnalyst` — a DETERMINISTIC analyst (cost.kind = 'deterministic',
+ * never calls the LLM). It produces the efficiency/behavioral findings a
+ * tolerant agentic analyzer (HALO) re-derives per run inside the model —
+ * context bloat, output decay, tool monoculture, missing self-verification —
+ * directly from arithmetic over spans (`computeTraceMetrics`).
+ *
+ * Why it matters: these findings are model-agnostic BY CONSTRUCTION (no model
+ * in the loop), so they cannot return 0 on a weak model the way the Ax-RLM
+ * does — and they are strictly more reliable than HALO, which spends tokens
+ * re-deriving the same numbers and can hallucinate the trend. The agentic
+ * RLM kinds remain for SEMANTIC findings that genuinely need a model; this
+ * analyst owns the behavioral class.
+ */
+import { type BehavioralMetrics } from '../trace-analyst/behavioral-metrics';
+import type { TraceAnalysisStore } from '../trace-analyst/store';
+import { type Analyst, type AnalystFinding } from './types';
+/**
+ * Map computed signals → structured AnalystFindings. Pure: no LLM, no clock
+ * dependence beyond `produced_at` (overridable for deterministic tests).
+ */
+export declare function deriveEfficiencyFindings(metrics: BehavioralMetrics, opts?: {
+    analystId?: string;
+    producedAt?: string;
+}): AnalystFinding[];
+/** The deterministic behavioral/efficiency analyst (no LLM, any-model). */
+export declare function behavioralAnalyst(): Analyst<TraceAnalysisStore>;
+//# sourceMappingURL=behavioral-analyst.d.ts.map

package/dist/analyst/behavioral-analyst.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"behavioral-analyst.d.ts","sourceRoot":"","sources":["../../src/analyst/behavioral-analyst.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,qCAAqC,CAAA;AAC5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAEhE,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,cAAc,EAAe,MAAM,SAAS,CAAA;AAexE;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,iBAAiB,EAC1B,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GACrD,cAAc,EAAE,CAuBlB;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAkB/D"}

package/dist/analyst/chat-client.d.ts

@@ -0,0 +1,91 @@
+/**
+ * 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.
+ */
+import { type LlmCallRequest, type LlmCallResult } from '../llm-client';
+/**
+ * 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).
+ */
+export 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>;
+}
+export type ChatTransport = 'router' | 'sandbox-sdk' | 'cli-bridge' | 'direct-provider' | 'mock';
+export interface ChatRequest extends Omit<LlmCallRequest, 'model'> {
+    /** Optional — falls back to ChatClient.defaultModel. */
+    model?: string;
+}
+export type ChatResponse = LlmCallResult;
+export 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;
+}
+export type CreateChatClientOpts = RouterTransportOpts | CliBridgeTransportOpts | DirectProviderTransportOpts | SandboxSdkTransportOpts | MockTransportOpts;
+interface BaseTransportOpts {
+    defaultModel?: string;
+}
+export interface RouterTransportOpts extends BaseTransportOpts {
+    transport: 'router';
+    baseUrl?: string;
+    apiKey: string;
+}
+export interface CliBridgeTransportOpts extends BaseTransportOpts {
+    transport: 'cli-bridge';
+    baseUrl?: string;
+    bearer?: string;
+}
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export declare function createChatClient(opts: CreateChatClientOpts): ChatClient;
+export {};
+//# sourceMappingURL=chat-client.d.ts.map

package/dist/analyst/chat-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-client.d.ts","sourceRoot":"","sources":["../../src/analyst/chat-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,aAAa,EAGnB,MAAM,eAAe,CAAA;AAEtB;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAA;IACjC,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAE9B,IAAI,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;CACnE;AAED,MAAM,MAAM,aAAa,GACrB,QAAQ,GACR,aAAa,GACb,YAAY,GACZ,iBAAiB,GACjB,MAAM,CAAA;AAEV,MAAM,WAAW,WAAY,SAAQ,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC;IAChE,wDAAwD;IACxD,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,MAAM,YAAY,GAAG,aAAa,CAAA;AAExC,MAAM,WAAW,YAAY;IAC3B,oCAAoC;IACpC,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,uGAAuG;IACvG,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,8EAA8E;IAC9E,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAID,MAAM,MAAM,oBAAoB,GAC5B,mBAAmB,GACnB,sBAAsB,GACtB,2BAA2B,GAC3B,uBAAuB,GACvB,iBAAiB,CAAA;AAErB,UAAU,iBAAiB;IACzB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC5D,SAAS,EAAE,QAAQ,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D,SAAS,EAAE,YAAY,CAAA;IACvB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,2BAA4B,SAAQ,iBAAiB;IACpE,SAAS,EAAE,iBAAiB,CAAA;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,uBAAwB,SAAQ,iBAAiB;IAChE,SAAS,EAAE,aAAa,CAAA;IACxB,IAAI,EAAE,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,YAAY,CAAC,CAAA;CACvE;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAkB,SAAQ,iBAAiB;IAC1D,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,YAAY,CAAC,CAAA;CAC1E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,GAAG,UAAU,CA0CvE"}

package/dist/analyst/default-registry.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `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.
+ */
+import type { AxAIService } from '@ax-llm/ax';
+import { type TraceAnalystKindSpec } from './kind-factory';
+import { AnalystRegistry, type AnalystRegistryOptions } from './registry';
+export 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;
+}
+export declare function buildDefaultAnalystRegistry(opts?: DefaultAnalystRegistryOptions): AnalystRegistry;
+//# sourceMappingURL=default-registry.d.ts.map

package/dist/analyst/default-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-registry.d.ts","sourceRoot":"","sources":["../../src/analyst/default-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,OAAO,EAA0B,KAAK,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAElF,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAEzE,MAAM,WAAW,6BAA6B;IAC5C,mFAAmF;IACnF,EAAE,CAAC,EAAE,WAAW,CAAA;IAChB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,yFAAyF;IACzF,KAAK,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAA;IACvC,iFAAiF;IACjF,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,kFAAkF;IAClF,QAAQ,CAAC,EAAE,sBAAsB,CAAA;CAClC;AAED,wBAAgB,2BAA2B,CACzC,IAAI,GAAE,6BAAkC,GACvC,eAAe,CAYjB"}

package/dist/analyst/default-registry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=default-registry.test.d.ts.map

package/dist/analyst/default-registry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-registry.test.d.ts","sourceRoot":"","sources":["../../src/analyst/default-registry.test.ts"],"names":[],"mappings":""}

package/dist/analyst/finding-signature.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Typed Ax output for analyst findings.
+ *
+ * Replaces the legacy `findings:string[]` pattern (where every bullet
+ * became a flat-severity `AnalystFinding`) with a structured object
+ * array. Ax binds the field as `findings:json[]` so the provider emits
+ * native structured output; at the kind-factory boundary we Zod-validate
+ * each emitted finding so malformed rows fail loud instead of being
+ * silently lifted with default severity.
+ *
+ * Why not `f.object().array()` directly in the signature? The Ax
+ * signature string `question:string -> findings:json[]` already lets
+ * the provider emit JSON arrays. A Zod boundary is required either
+ * way (the provider can return any JSON), and Zod gives us a single
+ * validation surface independent of which Ax version is installed.
+ */
+import { z } from 'zod';
+export declare const ANALYST_SEVERITIES: readonly ["critical", "high", "medium", "low", "info"];
+export declare const RawAnalystFindingSchema: z.ZodObject<{
+    severity: z.ZodEnum<{
+        info: "info";
+        critical: "critical";
+        medium: "medium";
+        low: "low";
+        high: "high";
+    }>;
+    claim: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    evidence_uri: z.ZodString;
+    evidence_excerpt: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodNumber;
+    rationale: z.ZodOptional<z.ZodString>;
+    recommended_action: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RawAnalystFinding = z.infer<typeof RawAnalystFindingSchema>;
+/**
+ * Description embedded into the actor prompt so the LLM knows what
+ * shape to emit. Kept here so kinds share one source of truth rather
+ * than restating the schema in every prompt.
+ */
+export declare const RAW_FINDING_SCHEMA_PROMPT = "Each finding MUST be a JSON object with these fields:\n  - severity: one of \"critical\" | \"high\" | \"medium\" | \"low\" | \"info\"\n  - claim: one-sentence statement (max 2000 chars)\n  - subject?: the routing locus this finding is about. It MUST be one of the exact subject forms listed in this kind's instructions above (e.g. `system-prompt:<section>`, `agent-knowledge:wiki:<slug>`, `tool-doc:<tool>`). A free phrase, a bare noun, or any form not in that list is REJECTED at parse time and the finding is discarded \u2014 omit subject entirely rather than guess a form.\n  - evidence_uri: REQUIRED, never blank. Exactly one of \"span://<trace_id>/<span_id>\" (trace evidence), \"artifact://<relative-path>\" (files), \"metric://<name>\" (named scalars) \u2014 ALWAYS cite a real id surfaced by the tools. If you have no citable id, do not emit the finding.\n  - evidence_excerpt?: short quote (<=2000 chars) from the cited span/artifact\n  - confidence: number 0..1 \u2014 0.9+ when backed by exact quotes, 0.6-0.8 for inferred patterns, <0.5 for speculative\n  - rationale?: one or two sentences explaining the reasoning\n  - recommended_action?: concrete change phrased as an imperative (\"Add ...\", \"Replace ...\", \"Stop ...\") \u2014 omit when the finding is purely descriptive\n\nEmit an empty array when the question has no findings to report. Do not fabricate evidence.";
+/**
+ * Validate one row emitted by the LLM. Returns the typed finding on
+ * success; returns `null` and logs the reason on failure so the kind
+ * factory can skip-and-count rather than abort the whole analyst run.
+ */
+export declare function parseRawFinding(row: unknown, log?: (msg: string, fields?: Record<string, unknown>) => void): RawAnalystFinding | null;
+//# sourceMappingURL=finding-signature.d.ts.map

package/dist/analyst/finding-signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finding-signature.d.ts","sourceRoot":"","sources":["../../src/analyst/finding-signature.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,kBAAkB,wDAAyD,CAAA;AAExF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;kBA4BzB,CAAA;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,82CAUsD,CAAA;AAE5F;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,OAAO,EACZ,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GAC5D,iBAAiB,GAAG,IAAI,CAoB1B"}

package/dist/analyst/finding-subject.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Typed `FindingSubject` — the canonical grammar every analyst kind emits.
+ *
+ * Background: kind actor prompts have always documented a subject grammar
+ * (e.g. `system-prompt:<section>`, `agent-knowledge:wiki:<slug>`) but the
+ * LLM was unconstrained — it could emit `subject: "fix the prompt"`
+ * (prose) and downstream adapters routed on `startsWith(...)` would
+ * silently skip it. Every per-vertical `ImprovementAdapter` had a
+ * routing table that mostly caught nothing.
+ *
+ * This module fixes that:
+ *   - `parseFindingSubject(raw)` — returns the typed `FindingSubject`
+ *     when `raw` matches the grammar, else `null`. Used at the
+ *     `RawAnalystFindingSchema` boundary so malformed subjects are
+ *     rejected loudly instead of silently lifted into the registry.
+ *   - `FindingSubjectKind` — the union of valid locus categories. Each
+ *     variant carries the typed components downstream adapters resolve
+ *     against the agent's surface manifest (no string parsing in the
+ *     adapter).
+ *   - `FINDING_SUBJECT_GRAMMAR_PROMPT` — single source of truth for the
+ *     grammar string embedded in kind actor prompts. Drift between
+ *     prompt and parser is impossible if every kind imports this.
+ *
+ * The grammar is intentionally NARROW — only loci the substrate's
+ * default `ImprovementAdapter` / `KnowledgeAdapter` can act on. A
+ * finding with a subject outside this set fails the parser; the kind
+ * author either extends the grammar here (and adds adapter routing)
+ * or rephrases the prompt to map onto an existing variant.
+ *
+ * `failure-mode` is the one exception — its subjects are free-form
+ * cluster labels, not loci. The schema preserves them as
+ * `{ kind: 'cluster', label }` and the adapters skip them (cluster
+ * findings are evidence, not actionable mutations).
+ */
+import { z } from 'zod';
+/**
+ * Discriminated union of every locus the substrate can route findings to.
+ *
+ * Adapters narrow on `kind` and use the typed components (no string
+ * parsing). Adding a variant here REQUIRES updating the parser, the
+ * grammar prompt, and at least one adapter — by design.
+ */
+export type FindingSubject = {
+    kind: 'knowledge.wiki';
+    slug: string;
+    heading?: string;
+} | {
+    kind: 'knowledge.claim';
+    topic: string;
+} | {
+    kind: 'knowledge.raw';
+    sourceId: string;
+} | {
+    kind: 'knowledge.stale';
+    slug: string;
+} | {
+    kind: 'system-prompt';
+    section: string;
+} | {
+    kind: 'tool-doc';
+    tool: string;
+    aspect?: string;
+} | {
+    kind: 'new-tool';
+    name: string;
+} | {
+    kind: 'rag';
+    corpus: string;
+    docId: string;
+} | {
+    kind: 'memory';
+    key: string;
+} | {
+    kind: 'scaffolding';
+    concern: string;
+} | {
+    kind: 'output-schema';
+    field: string;
+} | {
+    kind: 'websearch.outdated';
+    topic: string;
+} | {
+    kind: 'prior-run-summary';
+    topic: string;
+} | {
+    kind: 'cluster';
+    label: string;
+};
+export type FindingSubjectKind = FindingSubject['kind'];
+export declare const FINDING_SUBJECT_KINDS: ReadonlyArray<FindingSubjectKind>;
+/**
+ * Parse a raw subject string emitted by an analyst kind's actor.
+ *
+ * Returns the typed `FindingSubject` when `raw` matches the grammar,
+ * else `null`. Callers use the `null` return as a signal to either
+ * (a) reject the finding at parse time (kinds that emit typed loci —
+ * knowledge-gap, improvement, knowledge-poisoning) or (b) lift it as
+ * a cluster label (failure-mode).
+ *
+ * Slugs are constrained to `[a-z0-9-]+` (lowercase kebab) to keep file
+ * paths sane downstream. Topics / keys / sections allow any non-empty
+ * string (free-form for the LLM's voice) but get trimmed.
+ *
+ * Empty / whitespace-only inputs return `null`. `undefined` returns
+ * `null`. Both are surfaced by the caller as a rejected subject.
+ */
+export declare function parseFindingSubject(raw: string | null | undefined): FindingSubject | null;
+/**
+ * Render the parsed subject back to its canonical string form. Inverse
+ * of `parseFindingSubject`; useful when the substrate constructs new
+ * findings programmatically (e.g. for tests, replays, or
+ * `id_basis` carry-forward).
+ */
+export declare function renderFindingSubject(s: FindingSubject): string;
+/**
+ * The grammar text embedded into kind actor prompts. Kinds opt into
+ * the subset of variants they emit (e.g. `improvement` excludes the
+ * cluster variant; `failure-mode` includes ONLY the cluster variant).
+ *
+ * Drift between prompt and parser is impossible: every kind imports
+ * this constant + the matching `expects` set, and the unit tests below
+ * lock the table to the parser.
+ */
+export declare const FINDING_SUBJECT_GRAMMAR_PROMPT: string;
+/**
+ * The variants each kind is allowed to emit. Used at the kind factory
+ * boundary so a knowledge-gap finding can't sneak in a `system-prompt:*`
+ * subject (the improvement-analyst's job) and vice versa.
+ *
+ * `failure-mode` is restricted to `cluster` — the only kind that emits
+ * a non-locus subject.
+ */
+export declare const KIND_EXPECTED_SUBJECTS: Record<string, ReadonlyArray<FindingSubjectKind>>;
+/**
+ * Zod schema that validates a raw subject string and returns the parsed
+ * `FindingSubject`. Embedded in `RawAnalystFindingSchema` via
+ * `transform`, so `subject` arrives at the kind factory either as a
+ * typed locus or as a parse error attached to a single Zod issue.
+ *
+ * Optionality is preserved: subjects ARE optional on the wire (some
+ * findings are descriptive, not actionable). When present, they MUST
+ * parse — emitting a malformed subject is a contract violation, not a
+ * soft signal.
+ */
+export declare const FindingSubjectStringSchema: z.ZodString;
+//# sourceMappingURL=finding-subject.d.ts.map

package/dist/analyst/finding-subject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finding-subject.d.ts","sourceRoot":"","sources":["../../src/analyst/finding-subject.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAEtB;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC3C;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAGzC;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACnD;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC9C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAExC;IAAE,IAAI,EAAE,oBAAoB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAE5C;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtC,MAAM,MAAM,kBAAkB,GAAG,cAAc,CAAC,MAAM,CAAC,CAAA;AAEvD,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,kBAAkB,CAenE,CAAA;AAID;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,cAAc,GAAG,IAAI,CA4EzF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,cAAc,GAAG,MAAM,CAiC9D;AAID;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,QA0B/B,CAAA;AAIZ;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAkCpF,CAAA;AAID;;;;;;;;;;GAUG;AACH,eAAO,MAAM,0BAA0B,aAInC,CAAA"}

package/dist/analyst/finding-subject.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=finding-subject.test.d.ts.map

package/dist/analyst/finding-subject.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finding-subject.test.d.ts","sourceRoot":"","sources":["../../src/analyst/finding-subject.test.ts"],"names":[],"mappings":""}