@tangle-network/agent-eval 0.95.0 → 0.96.0

package/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to `@tangle-network/agent-eval` and its sibling `agent-eval-
 
 ---
 
+## [0.95.0] — 2026-06-21 — FAPO proposer + public-surface prune
+
+### Added
+
+- **FAPO proposer policy** in the campaign proposer family — feeds `runImprovementLoop` / `runCampaign` proposer-driven self-improvement (`gepaProposer` at `src/campaign/proposers/gepa.ts`).
+
+### Changed
+
+- Profile handling finalized on the canonical `@tangle-network/agent-interface` `AgentProfile` — completes the migration in 0.94.0. Per-run profile cells are built via `buildAgentInterfaceProfileCell` with `sourceProfile.kind = 'agent-interface-profile'`.
+- Proposer and trace plumbing cleaned up across the campaign surface.
+
+### Removed
+
+- **Pruned stale public exports.** Loop / proposer / ship-gate primitives (`runImprovementLoop`, `gepaProposer`, `defaultProductionGate`, `defineAgentEval`, `runCampaign`, …) are reached via the `@tangle-network/agent-eval/contract` subpath; importing them from the package root no longer resolves.
+
+---
+
 ## [0.94.0] — 2026-06-21 — canonical AgentProfile + defineAgentEval DX
 
 ### Changed

package/dist/adapters/http.d.ts

@@ -1,3 +1,9 @@
+import { S as Scenario, D as DispatchFn, b as DispatchContext } from '../types-BMahhhio.js';
+import '../run-record-CP2ObebC.js';
+import '@tangle-network/agent-interface';
+import '../errors-CzMUYo7b.js';
+import '../schema-m0gsnbt3.js';
+
 /**
  * # `@tangle-network/agent-eval/adapters/http` — distributed Dispatch over HTTP.
  *
@@ -30,8 +36,8 @@
  * (holds optimization state across generations); workers are stateless
  * HTTP services that can scale horizontally per cell.
  */
-import type { Dispatch, DispatchContext, Scenario } from '../contract';
-export interface HttpDispatchOptions<TScenario extends Scenario, _TArtifact> {
+
+interface HttpDispatchOptions<TScenario extends Scenario, _TArtifact> {
     /** Static endpoint URL. Mutually exclusive with `resolveUrl`. */
     url?: string;
     /**
@@ -55,7 +61,7 @@ export interface HttpDispatchOptions<TScenario extends Scenario, _TArtifact> {
     /** Optional fetch override (auth wrappers, custom agent, mocks). */
     fetchImpl?: typeof fetch;
 }
-export interface HttpDispatchRequestBody<TScenario extends Scenario> {
+interface HttpDispatchRequestBody<TScenario extends Scenario> {
     scenario: TScenario;
     cellId: string;
     rep: number;
@@ -64,7 +70,7 @@ export interface HttpDispatchRequestBody<TScenario extends Scenario> {
     placement?: string;
     cycleId?: string;
 }
-export interface HttpDispatchResponseBody<TArtifact> {
+interface HttpDispatchResponseBody<TArtifact> {
     artifact: TArtifact;
 }
 /**
@@ -75,10 +81,10 @@ export interface HttpDispatchResponseBody<TArtifact> {
  * server's `runDispatchServer` translates the resulting `AbortError` into
  * a 499 (client-closed) so the client doesn't retry.
  */
-export declare function httpDispatch<TScenario extends Scenario, TArtifact>(opts: HttpDispatchOptions<TScenario, TArtifact>): Dispatch<TScenario, TArtifact>;
-export interface RunDispatchServerOptions<TScenario extends Scenario, TArtifact> {
+declare function httpDispatch<TScenario extends Scenario, TArtifact>(opts: HttpDispatchOptions<TScenario, TArtifact>): DispatchFn<TScenario, TArtifact>;
+interface RunDispatchServerOptions<TScenario extends Scenario, TArtifact> {
     /** The Dispatch this server exposes — what runs when a request lands. */
-    dispatch: Dispatch<TScenario, TArtifact>;
+    dispatch: DispatchFn<TScenario, TArtifact>;
     /** TCP port to bind. */
     port: number;
     /** Optional bind host; defaults to 0.0.0.0. */
@@ -107,7 +113,7 @@ export interface RunDispatchServerOptions<TScenario extends Scenario, TArtifact>
         error?: unknown;
     }) => void;
 }
-export interface DispatchServerHandle {
+interface DispatchServerHandle {
     /** The actual bound port (useful when `port: 0` requests an ephemeral port). */
     port: number;
     /** Stop accepting new connections and drain existing ones. */
@@ -131,5 +137,6 @@ export interface DispatchServerHandle {
  * The server is `node:http`-based to keep the runtime dependency surface
  * minimal — works in plain Node, sandbox, or any container.
  */
-export declare function runDispatchServer<TScenario extends Scenario, TArtifact>(opts: RunDispatchServerOptions<TScenario, TArtifact>): Promise<DispatchServerHandle>;
-//# sourceMappingURL=http.d.ts.map
+declare function runDispatchServer<TScenario extends Scenario, TArtifact>(opts: RunDispatchServerOptions<TScenario, TArtifact>): Promise<DispatchServerHandle>;
+
+export { type DispatchServerHandle, type HttpDispatchOptions, type HttpDispatchRequestBody, type HttpDispatchResponseBody, type RunDispatchServerOptions, httpDispatch, runDispatchServer };

package/dist/adapters/langchain.d.ts

@@ -1,3 +1,9 @@
+import { S as Scenario, J as JudgeScore, D as DispatchFn, a as JudgeConfig } from '../types-BMahhhio.js';
+import '../run-record-CP2ObebC.js';
+import '@tangle-network/agent-interface';
+import '../errors-CzMUYo7b.js';
+import '../schema-m0gsnbt3.js';
+
 /**
  * # `@tangle-network/agent-eval/adapters/langchain` — wrap any LangChain
  * Runnable as a `Dispatch` (or `JudgeConfig`).
@@ -14,14 +20,14 @@
  * is one function. Wrap your existing Runnable, pass the Dispatch into
  * `runEval` / `runImprovementLoop`, ship.
  */
-import type { Dispatch, JudgeConfig, JudgeScore, Scenario } from '../contract';
-export interface RunnableLike<TInput, TOutput> {
+
+interface RunnableLike<TInput, TOutput> {
     invoke(input: TInput, config?: {
         signal?: AbortSignal;
         [key: string]: unknown;
     }): Promise<TOutput>;
 }
-export interface LangchainDispatchOptions<TScenario extends Scenario, TArtifact> {
+interface LangchainDispatchOptions<TScenario extends Scenario, TArtifact> {
     /** The Runnable (or RunnableSequence, or anything `.invoke`able). */
     runnable: RunnableLike<TScenario, TArtifact>;
     /**
@@ -42,8 +48,8 @@ export interface LangchainDispatchOptions<TScenario extends Scenario, TArtifact>
  *   const dispatch = langchainDispatch({ runnable: chain })
  *   await runEval({ scenarios, dispatch, judges: [...], storage, runDir })
  */
-export declare function langchainDispatch<TScenario extends Scenario, TArtifact>(opts: LangchainDispatchOptions<TScenario, TArtifact>): Dispatch<TScenario, TArtifact>;
-export interface LangchainJudgeOptions<TArtifact, TScenario extends Scenario> {
+declare function langchainDispatch<TScenario extends Scenario, TArtifact>(opts: LangchainDispatchOptions<TScenario, TArtifact>): DispatchFn<TScenario, TArtifact>;
+interface LangchainJudgeOptions<TArtifact, TScenario extends Scenario> {
     /** Judge name; appears in `CampaignResult.aggregates.byJudge`. */
     name: string;
     /**
@@ -84,5 +90,6 @@ export interface LangchainJudgeOptions<TArtifact, TScenario extends Scenario> {
  *     runnable: judgeChain,
  *   })
  */
-export declare function langchainJudge<TArtifact, TScenario extends Scenario>(opts: LangchainJudgeOptions<TArtifact, TScenario>): JudgeConfig<TArtifact, TScenario>;
-//# sourceMappingURL=langchain.d.ts.map
+declare function langchainJudge<TArtifact, TScenario extends Scenario>(opts: LangchainJudgeOptions<TArtifact, TScenario>): JudgeConfig<TArtifact, TScenario>;
+
+export { type LangchainDispatchOptions, type LangchainJudgeOptions, type RunnableLike, langchainDispatch, langchainJudge };

package/dist/adapters/otel.d.ts

@@ -1,3 +1,15 @@
+import { TraceSpanEvent, HostedClient } from '../hosted/index.js';
+import '../types-BMahhhio.js';
+import '../run-record-CP2ObebC.js';
+import '@tangle-network/agent-interface';
+import '../errors-CzMUYo7b.js';
+import '../schema-m0gsnbt3.js';
+import '../insight-report-BnRjTibG.js';
+import '../summary-report-CInXwsza.js';
+import '../failure-cluster-DH9Flgcf.js';
+import '../store-BcFXE6LG.js';
+import '../judge-calibration-0p2QcWNE.js';
+
 /**
  * # `@tangle-network/agent-eval/adapters/otel` — OTel→hosted bridge.
  *
@@ -29,24 +41,23 @@
  * `parentSpanId` as a top-level field rather than via `parentSpanContext()`,
  * the adapter accepts both forms.
  */
-import type { HostedClient } from '../hosted/client';
-import type { TraceSpanEvent } from '../hosted/types';
+
 /**
  * `[seconds, nanoseconds]` — the OTel SDK's `HrTime` shape. Spans emitted
  * by the OTel SDK carry timestamps in this representation; we convert to
  * a single unix-nano number for the wire format.
  */
-export type HrTime = [number, number];
+type HrTime = [number, number];
 /** Standard OTel `SpanStatusCode` numeric values: 0 = UNSET, 1 = OK, 2 = ERROR. */
-export declare const OTEL_STATUS_UNSET = 0;
-export declare const OTEL_STATUS_OK = 1;
-export declare const OTEL_STATUS_ERROR = 2;
-export type OtelAttributeValue = string | number | boolean | null | undefined | Array<string> | Array<number> | Array<boolean>;
+declare const OTEL_STATUS_UNSET = 0;
+declare const OTEL_STATUS_OK = 1;
+declare const OTEL_STATUS_ERROR = 2;
+type OtelAttributeValue = string | number | boolean | null | undefined | Array<string> | Array<number> | Array<boolean>;
 /**
  * Structural surface compatible with `@opentelemetry/sdk-trace-base`'s
  * `ReadableSpan`. Consumers pass instances they get from their OTel SDK.
  */
-export interface OtelLikeSpan {
+interface OtelLikeSpan {
     spanContext: () => {
         traceId: string;
         spanId: string;
@@ -73,8 +84,8 @@ export interface OtelLikeSpan {
     };
 }
 /** `[seconds, nanoseconds]` → unix-nano number. */
-export declare function hrTimeToUnixNano(hr: HrTime): number;
-export interface OtelBridgeOptions {
+declare function hrTimeToUnixNano(hr: HrTime): number;
+interface OtelBridgeOptions {
     /** Hosted client to forward spans to. */
     client: HostedClient;
     /** When set, spans missing a `tangle.runId` attribute receive this value
@@ -89,12 +100,13 @@ export interface OtelBridgeOptions {
      *  this when you need backpressure or to spill to a fallback. */
     onError?: (err: unknown, batch: TraceSpanEvent[]) => void | Promise<void>;
 }
-export interface OtelBridge {
+interface OtelBridge {
     /** Convert + ingest a batch of OTel-shape spans. */
     ingest(spans: OtelLikeSpan[]): Promise<void>;
     /** Convert one OTel span to the wire-format event. Useful for tests or
      *  custom batching pipelines. */
     spanToEvent(span: OtelLikeSpan): TraceSpanEvent;
 }
-export declare function createOtelBridge(opts: OtelBridgeOptions): OtelBridge;
-//# sourceMappingURL=otel.d.ts.map
+declare function createOtelBridge(opts: OtelBridgeOptions): OtelBridge;
+
+export { type HrTime, OTEL_STATUS_ERROR, OTEL_STATUS_OK, OTEL_STATUS_UNSET, type OtelAttributeValue, type OtelBridge, type OtelBridgeOptions, type OtelLikeSpan, createOtelBridge, hrTimeToUnixNano };

package/dist/{rl/adversarial.d.ts → adversarial-DIVcDoI_.d.ts}

@@ -22,7 +22,7 @@
  * criteria). The adversarial primitive is just the *scenario-mutation
  * meta-loop* on top of that machinery.
  */
-export interface AdversarialScenario<S> {
+interface AdversarialScenario<S> {
     /** Stable id — used for deduplication and lineage tracking. */
     id: string;
     /** Generation index — 0 for seeds, 1 for first round of mutations, etc. */
@@ -35,7 +35,7 @@ export interface AdversarialScenario<S> {
     /** Strategy that produced this mutation, for diagnostics. */
     mutationStrategy: string | null;
 }
-export interface AdversarialMutation<S> {
+interface AdversarialMutation<S> {
     id: string;
     /**
      * Mutate one scenario. Return null to skip; return one or more new
@@ -43,7 +43,7 @@ export interface AdversarialMutation<S> {
      */
     mutate(parent: S, rng: () => number): Promise<S[]> | S[];
 }
-export interface AdversarialSearchOptions<S> {
+interface AdversarialSearchOptions<S> {
     /** Initial scenarios — typically those the policy currently passes. */
     seeds: S[];
     /** Stable identifier extraction. */
@@ -69,7 +69,7 @@ export interface AdversarialSearchOptions<S> {
     /** Seed for the deterministic RNG. Default 1. */
     seed?: number;
 }
-export interface AdversarialSearchReport<S> {
+interface AdversarialSearchReport<S> {
     scenarios: AdversarialScenario<S>[];
     /** Discovered failures sorted by score ascending. */
     failures: AdversarialScenario<S>[];
@@ -83,5 +83,6 @@ export interface AdversarialSearchReport<S> {
     /** Total scoreFn invocations consumed. */
     scoreCalls: number;
 }
-export declare function adversarialScenarioSearch<S>(opts: AdversarialSearchOptions<S>): Promise<AdversarialSearchReport<S>>;
-//# sourceMappingURL=adversarial.d.ts.map
+declare function adversarialScenarioSearch<S>(opts: AdversarialSearchOptions<S>): Promise<AdversarialSearchReport<S>>;
+
+export { type AdversarialMutation as A, type AdversarialScenario as a, type AdversarialSearchOptions as b, type AdversarialSearchReport as c, adversarialScenarioSearch as d };

package/dist/analyst/index.d.ts

@@ -1,28 +1,236 @@
-export type { JudgeAdapterOpts, RunCriticAdapterOpts, SemanticConceptJudgeAdapterOpts, VerifierAdapterOpts, } from './adapters';
-export { createJudgeAdapter, createRunCriticAdapter, createSemanticConceptJudgeAdapter, createVerifierAdapter, liftSeverity, } from './adapters';
-export { type CreateAnalystAiConfig, createAnalystAi } from './ax-service';
-export { behavioralAnalyst, deriveEfficiencyFindings } from './behavioral-analyst';
-export type { ChatCallOpts, ChatClient, ChatRequest, ChatResponse, ChatTransport, CliBridgeTransportOpts, CreateChatClientOpts, DirectProviderTransportOpts, MockTransportOpts, RouterTransportOpts, SandboxSdkTransportOpts, } from './chat-client';
-export { createChatClient } from './chat-client';
-export { buildDefaultAnalystRegistry, type DefaultAnalystRegistryOptions, } from './default-registry';
-export type { RawAnalystFinding } from './finding-signature';
-export { ANALYST_SEVERITIES, parseRawFinding, RAW_FINDING_SCHEMA_PROMPT, RawAnalystFindingSchema, } from './finding-signature';
-export type { FindingSubject, FindingSubjectKind } from './finding-subject';
-export { FINDING_SUBJECT_GRAMMAR_PROMPT, FINDING_SUBJECT_KINDS, FindingSubjectStringSchema, KIND_EXPECTED_SUBJECTS, parseFindingSubject, renderFindingSubject, } from './finding-subject';
-export type { DiffPolicy, FindingsDiff, PersistedFinding } from './findings-store';
-export { defaultIsMaterial, diffFindings, FindingsStore } from './findings-store';
-export type { CreateTraceAnalystKindOpts, TraceAnalystGolden, TraceAnalystKindSpec, } from './kind-factory';
-export { createTraceAnalystKind, renderPriorFindings } from './kind-factory';
-export { DEFAULT_TRACE_ANALYST_KINDS, FAILURE_MODE_KIND_SPEC, IMPROVEMENT_KIND_SPEC, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, } from './kinds';
-export type { SkillUsageRecord, SkillUsageReport, SkillUsageScanConfig, } from './kinds/skill-usage';
-export { buildSkillUsageReport, emitSkillUsageFindings, SKILL_USAGE_ANALYST, SkillUsageAnalyst, } from './kinds/skill-usage';
-export { coerceJson, coerceToFindingRows, stripCodeFences } from './parse-tolerant';
-export type { AnalystHooks, AnalystRegistryOptions, BudgetPolicy, RegistryRunOpts, } from './registry';
-export { AnalystRegistry } from './registry';
-export { assertNoJudgeVerdict, isJudgeVerdict, isTraceObservable } from './steer-firewall';
-export { type StructureFindingsOptions, type StructureFindingsResult, structureFindings, } from './structure-findings';
-export type { TraceToolGroupName } from './tool-groups';
-export { buildTraceToolsForGroup } from './tool-groups';
-export type { Analyst, AnalystContext, AnalystCost, AnalystFinding, AnalystInputKind, AnalystRequirements, AnalystRunEvent, AnalystRunInputs, AnalystRunResult, AnalystRunSummary, AnalystSeverity, EvidenceRef, } from './types';
-export { computeFindingId, makeFinding } from './types';
-//# sourceMappingURL=index.d.ts.map
+import { M as MultiLayerVerifier, V as VerifyOptions, S as Severity } from '../multi-layer-verifier-DUZXrPDA.js';
+import { c as RunCritic, a as RunTrace } from '../run-critic-CmMf05uV.js';
+import { S as SemanticConceptJudgeOptions, a as SemanticConceptJudgeInput, B as BehavioralMetrics } from '../semantic-concept-judge-DSBB2Cfp.js';
+export { C as CreateAnalystAiConfig, D as DEFAULT_TRACE_ANALYST_KINDS, b as DiffPolicy, F as FAILURE_MODE_KIND_SPEC, c as FINDING_SUBJECT_GRAMMAR_PROMPT, d as FINDING_SUBJECT_KINDS, e as FindingSubject, f as FindingSubjectKind, g as FindingSubjectStringSchema, h as FindingsDiff, i as FindingsStore, I as IMPROVEMENT_KIND_SPEC, K as KIND_EXPECTED_SUBJECTS, j as KNOWLEDGE_GAP_KIND_SPEC, k as KNOWLEDGE_POISONING_KIND_SPEC, P as PersistedFinding, l as SKILL_USAGE_ANALYST, m as SkillUsageAnalyst, n as SkillUsageRecord, o as SkillUsageReport, p as SkillUsageScanConfig, q as buildSkillUsageReport, r as createAnalystAi, s as defaultIsMaterial, t as diffFindings, u as emitSkillUsageFindings, v as parseFindingSubject, w as renderFindingSubject } from '../semantic-concept-judge-DSBB2Cfp.js';
+import { b as JudgeFn, a as JudgeInput } from '../types-C7DGg5ex.js';
+import { A as Analyst, h as AnalystSeverity, c as AnalystFinding } from '../types-B5x54y6n.js';
+export { a as AnalystContext, g as AnalystCost, i as AnalystInputKind, j as AnalystRequirements, f as AnalystRunEvent, e as AnalystRunInputs, d as AnalystRunResult, b as AnalystRunSummary, k as ChatCallOpts, C as ChatClient, l as ChatRequest, m as ChatResponse, n as ChatTransport, o as CliBridgeTransportOpts, p as CreateChatClientOpts, D as DirectProviderTransportOpts, E as EvidenceRef, M as MockTransportOpts, R as RouterTransportOpts, S as SandboxSdkTransportOpts, q as computeFindingId, r as createChatClient, s as makeFinding } from '../types-B5x54y6n.js';
+import { TCloud } from '@tangle-network/tcloud';
+import { T as TraceAnalysisStore } from '../store-C1YxJDEK.js';
+export { a as AnalystHooks, A as AnalystRegistry, b as AnalystRegistryOptions, B as BudgetPolicy, D as DefaultAnalystRegistryOptions, R as RegistryRunOpts, c as buildDefaultAnalystRegistry } from '../default-registry-GyE8X5SP.js';
+export { A as ANALYST_SEVERITIES, C as CreateTraceAnalystKindOpts, R as RAW_FINDING_SCHEMA_PROMPT, a as RawAnalystFinding, b as RawAnalystFindingSchema, c as TraceAnalystGolden, T as TraceAnalystKindSpec, d as createTraceAnalystKind, p as parseRawFinding, r as renderPriorFindings } from '../kind-factory-X3eDYbKn.js';
+import { L as LlmClientOptions } from '../llm-client-Bj7g0rqu.js';
+import { AxFunction } from '@ax-llm/ax';
+import '../verdict-C9MlYujm.js';
+import '../schema-m0gsnbt3.js';
+import '../store-BcFXE6LG.js';
+import 'zod';
+import '../run-record-CP2ObebC.js';
+import '@tangle-network/agent-interface';
+import '../errors-CzMUYo7b.js';
+import '../raw-provider-sink-C46HDghv.js';
+
+/**
+ * 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.
+ */
+
+declare function liftSeverity(s: Severity): AnalystSeverity;
+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'>;
+}
+declare function createVerifierAdapter<Env>(opts: VerifierAdapterOpts<Env>): Analyst<Env>;
+interface RunCriticAdapterOpts {
+    id?: string;
+    area?: string;
+    critic?: RunCritic;
+    /** Optional threshold below which a dimension is reported as a finding. Default 0.5. */
+    threshold?: number;
+}
+declare function createRunCriticAdapter(opts?: RunCriticAdapterOpts): Analyst<RunTrace>;
+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;
+}
+declare function createJudgeAdapter(opts: JudgeAdapterOpts): Analyst<JudgeInput>;
+interface SemanticConceptJudgeAdapterOpts {
+    id?: string;
+    area?: string;
+    options?: SemanticConceptJudgeOptions;
+}
+declare function createSemanticConceptJudgeAdapter(opts?: SemanticConceptJudgeAdapterOpts): Analyst<SemanticConceptJudgeInput>;
+
+/**
+ * `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.
+ */
+
+/**
+ * Map computed signals → structured AnalystFindings. Pure: no LLM, no clock
+ * dependence beyond `produced_at` (overridable for deterministic tests).
+ */
+declare function deriveEfficiencyFindings(metrics: BehavioralMetrics, opts?: {
+    analystId?: string;
+    producedAt?: string;
+}): AnalystFinding[];
+/** The deterministic behavioral/efficiency analyst (no LLM, any-model). */
+declare function behavioralAnalyst(): Analyst<TraceAnalysisStore>;
+
+/**
+ * Forgiving pre-parse for analyst findings. Weak models routinely emit
+ * schema-correct content in an unusable wrapper — fenced ```json blocks, a
+ * single object where an array is expected, trailing commas. Measured: GPT-4o
+ * drops to 0% usable output purely from markdown-fence wrapping
+ * (arXiv:2605.02363). A five-line de-fence recovers most of it. This module is
+ * the de-fence/coerce step that runs BEFORE Zod, so a recoverable finding is
+ * repaired, not dropped.
+ *
+ * Pure + deterministic. No model, no network.
+ */
+/** Strip a ```lang ... ``` (or bare ``` ... ```) code fence, if the string is one. */
+declare function stripCodeFences(text: string): string;
+/**
+ * Best-effort parse of a string into JSON. De-fences, drops trailing commas,
+ * then `JSON.parse`. Returns `undefined` (never throws) when unrecoverable.
+ */
+declare function coerceJson(text: string): unknown;
+/**
+ * Coerce arbitrary actor/structurer output into an array of candidate finding
+ * rows: a JSON string → parse; a single object → 1-element array; an array →
+ * as-is; anything else → []. Callers still run each row through Zod
+ * (`parseRawFinding`) — this only fixes the SHAPE, never invents fields.
+ */
+declare function coerceToFindingRows(raw: unknown): unknown[];
+
+/** DESCRIPTIVE predicate: does the finding cite at least one observable
+ *  (span/event/artifact) evidence ref. Useful for ranking evidence quality or
+ *  rendering — it is NOT the steer gate. Evidence presence is the WRONG
+ *  discriminator for steering: a legitimate trace-analyst observation may cite
+ *  nothing (it would be wrongly rejected), and a judge verdict may cite an
+ *  artifact (it would be wrongly admitted). Use `assertNoJudgeVerdict` to gate
+ *  steering; use this only where "is this grounded in observable evidence" is the
+ *  literal question. */
+declare function isTraceObservable(finding: AnalystFinding): boolean;
+/** True iff the finding is a JUDGE VERDICT (an acceptance score lifted into a
+ *  finding), identified by provenance set at the lift site — independent of
+ *  whatever evidence it cites. */
+declare function isJudgeVerdict(finding: AnalystFinding): boolean;
+/**
+ * THE steer firewall. Fail-loud guard for any path that admits analyst findings
+ * as STEERING input (the `f(trace)` role): rejects — naming the offenders — any
+ * finding whose provenance is a judge verdict, rather than let `J` leak into the
+ * loop. Returns the findings unchanged for chaining.
+ *
+ * Call this at the chokepoint where a detector that ALSO scores/gates has its
+ * findings turned into a steer (the judge-and-steer dual-role case). It keys on
+ * provenance, so it correctly admits evidence-less trace-analyst observations and
+ * correctly rejects an artifact-citing judge verdict — the cases an evidence
+ * check gets backwards.
+ *
+ * It is necessary, not sufficient: it stops PROVENANCE-tagged verdicts. A judge
+ * whose output is laundered through a hand-built finding with no provenance flag
+ * is out of its reach — provenance must be honestly set at every judge→finding
+ * lift (today: createJudgeAdapter). That is why the integrity rule lives at the
+ * lift site, and why ProposeContext.judgeScores?: never is the complementary
+ * compile-time tripwire on the obvious direct channel.
+ */
+declare function assertNoJudgeVerdict(findings: ReadonlyArray<AnalystFinding>, context?: string): ReadonlyArray<AnalystFinding>;
+
+/**
+ * `structureFindings` — the deferred structuring pass (DSPy TwoStepAdapter /
+ * HALO `synthesize_traces` analog). The agentic actor reasons FREE-FORM and
+ * emits a prose `report` (which any model does reliably); this separate, cheap
+ * call's ONLY job is to turn that report into `AnalystFinding[]`. Decoupling
+ * reasoning from structuring is what makes the SEMANTIC findings model-agnostic
+ * — the reasoning model never has to satisfy a strict typed-array contract
+ * while it diagnoses.
+ *
+ * Forgiving: the response runs through `coerceToFindingRows` (de-fence, lift
+ * single→array) before Zod, and on a zero-finding extraction from a substantive
+ * report it reasks ONCE with the schema restated. Returns a typed outcome so a
+ * legitimate "nothing to report" is distinguishable from a failed extraction
+ * (no silent empty).
+ */
+
+interface StructureFindingsOptions {
+    /** The actor's free-form diagnosis prose. */
+    report: string;
+    analystId: string;
+    /** Coarse classification stamped on every extracted finding. */
+    area: string;
+    model: string;
+    baseUrl: string;
+    apiKey?: string;
+    /** Max reask attempts after a zero/invalid extraction. Default 1. */
+    maxReasks?: number;
+    /** Test seam: inject a fetch (no network in unit tests). */
+    fetchImpl?: LlmClientOptions['fetch'];
+}
+interface StructureFindingsResult {
+    findings: AnalystFinding[];
+    outcome: 'ok' | 'extraction_failed';
+}
+declare function structureFindings(opts: StructureFindingsOptions): Promise<StructureFindingsResult>;
+
+/**
+ * Pre-curated tool subsets for analyst kinds.
+ *
+ * The full trace-analyst tool set is seven functions. Most kinds only
+ * need three or four. Picking from named groups instead of importing
+ * the whole bundle keeps every kind's actor-context budget tight and
+ * makes "what can this analyst see?" obvious at registration time.
+ *
+ * Each function in the group keeps its full `name`/`description` from
+ * `buildTraceAnalystTools` — we filter, we don't re-implement.
+ */
+
+/** Named tool sets. Kinds pass `tools: TRACE_TOOL_GROUPS.failureForensics` etc. */
+type TraceToolGroupName = 
+/** All seven tools. Use for open-ended discovery kinds. */
+'all'
+/** Overview + paginated query + count. No deep reads. Cheap. */
+ | 'discovery'
+/** Discovery + viewTrace + viewSpans. Deep-read but no regex search. */
+ | 'discoveryAndRead'
+/** Discovery + search tools. For pattern-matching across many traces. */
+ | 'discoveryAndSearch'
+/** Discovery + viewSpans + searchSpan. Targeted-span work after another kind narrows down. */
+ | 'targeted';
+/**
+ * Build the tool set for a named group bound to a specific trace store.
+ *
+ * `all` returns every tool. Other groups filter `buildTraceAnalystTools`
+ * by name to the documented subset. An unrecognised group name throws —
+ * silently returning all tools would defeat the cost-control point.
+ */
+declare function buildTraceToolsForGroup(group: TraceToolGroupName, store: TraceAnalysisStore): AxFunction[];
+
+export { Analyst, AnalystFinding, AnalystSeverity, type JudgeAdapterOpts, type RunCriticAdapterOpts, type SemanticConceptJudgeAdapterOpts, type StructureFindingsOptions, type StructureFindingsResult, type TraceToolGroupName, type VerifierAdapterOpts, assertNoJudgeVerdict, behavioralAnalyst, buildTraceToolsForGroup, coerceJson, coerceToFindingRows, createJudgeAdapter, createRunCriticAdapter, createSemanticConceptJudgeAdapter, createVerifierAdapter, deriveEfficiencyFindings, isJudgeVerdict, isTraceObservable, liftSeverity, stripCodeFences, structureFindings };

package/dist/analyst/index.js

@@ -16,7 +16,7 @@ import {
   behavioralAnalyst,
   buildDefaultAnalystRegistry,
   deriveEfficiencyFindings
-} from "../chunk-AQ5WQAIV.js";
+} from "../chunk-3NHEO6ZC.js";
 import "../chunk-DJWX3GVS.js";
 import {
   ANALYST_SEVERITIES,

package/dist/{trace-analyst/analyst.d.ts → analyst-C8HHvfJp.d.ts}

@@ -1,11 +1,12 @@
-import { type AxAIService } from '@ax-llm/ax';
-import type { TraceAnalysisStore } from './store';
-export interface AnalyzeTracesInput {
+import { AxAIService } from '@ax-llm/ax';
+import { T as TraceAnalysisStore } from './store-C1YxJDEK.js';
+
+interface AnalyzeTracesInput {
     /** The user-facing question. Domain framing belongs here, not in the
      *  actor description. */
     question: string;
 }
-export interface AnalyzeTracesResult {
+interface AnalyzeTracesResult {
     /** The responder's prose answer. */
     answer: string;
     /** Bulleted findings extracted from the responder's structured output. */
@@ -21,21 +22,21 @@ export interface AnalyzeTracesResult {
     /** Prompt version that produced this run. */
     actorPromptVersion: string;
 }
-export interface TraceAnalystUsage {
+interface TraceAnalystUsage {
     actor: TraceAnalystUsageEntry[];
     responder: TraceAnalystUsageEntry[];
 }
-export interface TraceAnalystUsageEntry {
+interface TraceAnalystUsageEntry {
     [key: string]: unknown;
 }
-export interface TraceAnalystChatLog {
+interface TraceAnalystChatLog {
     actor: TraceAnalystChatMessage[];
     responder: TraceAnalystChatMessage[];
 }
-export interface TraceAnalystChatMessage {
+interface TraceAnalystChatMessage {
     [key: string]: unknown;
 }
-export interface AnalyzeTracesTurnSnapshot {
+interface AnalyzeTracesTurnSnapshot {
     turn: number;
     isError: boolean;
     /** The JS code the actor produced for this turn. */
@@ -46,7 +47,7 @@ export interface AnalyzeTracesTurnSnapshot {
      *  provider returns it). */
     thought?: string;
 }
-export interface AnalyzeTracesOptions {
+interface AnalyzeTracesOptions {
     /** Trace data source. Pass either an OTLP-JSONL path or a custom store. */
     source: string | TraceAnalysisStore;
     /** Caller-provided AxAIService. */
@@ -82,5 +83,6 @@ export interface AnalyzeTracesOptions {
  *   - `AxAgentClarificationError` if the analyst asks for clarification.
  *   - Provider errors (auth, rate limits) propagate from the AI service.
  */
-export declare function analyzeTraces(input: AnalyzeTracesInput, options: AnalyzeTracesOptions): Promise<AnalyzeTracesResult>;
-//# sourceMappingURL=analyst.d.ts.map
+declare function analyzeTraces(input: AnalyzeTracesInput, options: AnalyzeTracesOptions): Promise<AnalyzeTracesResult>;
+
+export { type AnalyzeTracesOptions as A, type AnalyzeTracesInput as a, type AnalyzeTracesResult as b, type AnalyzeTracesTurnSnapshot as c, analyzeTraces as d };

package/dist/{contract/analyze-runs.d.ts → analyze-runs-DtT6F_6T.d.ts}

@@ -1,3 +1,8 @@
+import { A as AnalystRegistry } from './default-registry-GyE8X5SP.js';
+import { a as DatasetScenario } from './dataset-BbGkaN2I.js';
+import { R as RunRecord } from './run-record-CP2ObebC.js';
+import { I as InsightReport } from './insight-report-BnRjTibG.js';
+
 /**
  * # `analyzeRuns()` — turn a set of agent runs into an actionable decision packet.
  *
@@ -19,12 +24,8 @@
  * The `recommendations` array is the human-readable layer; everything
  * else is the evidence backing each recommendation.
  */
-import type { AnalystRegistry } from '../analyst/registry';
-import type { DatasetScenario } from '../dataset';
-import type { RunRecord } from '../run-record';
-import { type ParetoFigureSpec } from '../summary-report';
-import type { InsightReport } from './insight-report';
-export interface AnalyzeRunsOptions {
+
+interface AnalyzeRunsOptions {
     /** The runs to analyze. */
     runs: RunRecord[];
     /** Which split to score against when reading composite from RunOutcome.
@@ -75,6 +76,6 @@ export interface AnalyzeRunsOptions {
      *  days", "vs v3.1 release". Surfaces in recommendations + UI. */
     baselineLabel?: string;
 }
-export declare function analyzeRuns(opts: AnalyzeRunsOptions): Promise<InsightReport>;
-export type { ParetoFigureSpec };
-//# sourceMappingURL=analyze-runs.d.ts.map
+declare function analyzeRuns(opts: AnalyzeRunsOptions): Promise<InsightReport>;
+
+export { type AnalyzeRunsOptions as A, analyzeRuns as a };