@tangle-network/agent-eval 0.129.0 → 0.130.0

package/dist/default-registry-CNPo-Vsb.d.ts

@@ -0,0 +1,540 @@
+import { a as RunRecord, n as RunCostProvenance, u as RunTokenUsage } from "./run-record-CnZu_gjl.js";
+import { c as CostLedgerHandle } from "./cost-ledger-Dye6jCgg.js";
+import { A as ChatClient, m as JudgeInput } from "./types-DGsxbAEd.js";
+import { t as TraceAnalysisStore } from "./store-CxJry_cs.js";
+import { AxAIService, AxFunction } from "@ax-llm/ax";
+import { z } from "zod";
+//#region src/analyst/types.d.ts
+/**
+ * Unified envelope every analyst emits. Schema-versioned so renderers
+ * and time-series diffs survive future field additions.
+ */
+interface AnalystFinding {
+  schema_version: '1.0.0';
+  /**
+   * Stable hash over identity-defining fields (analyst_id + canonical
+   * claim + area + optional subject). Two findings from two runs that
+   * "are the same finding" share this id — that's what `diffFindings`
+   * uses to compute appeared/disappeared sets across runs.
+   */
+  finding_id: string;
+  analyst_id: string;
+  produced_at: string;
+  severity: AnalystSeverity;
+  /**
+   * Coarse classification. Renderers group by this. Free-form so
+   * domain-specific analysts can introduce categories without a
+   * schema change ('agent-reasoning', 'verification', 'cost',
+   * 'tool-use', 'safety', 'latency', 'data-quality', ...).
+   */
+  area: string;
+  claim: string;
+  rationale?: string;
+  evidence_refs: EvidenceRef[];
+  recommended_action?: string;
+  validation_plan?: string;
+  /** 0..1 — the analyst's own confidence. Not calibrated across analysts. */
+  confidence: number;
+  /**
+   * Optional subject the finding is about — leaf id, agent id, request
+   * id. Included in finding_id when present so per-subject findings
+   * diff cleanly across runs.
+   */
+  subject?: string;
+  /** FIREWALL provenance (docs/learning-flywheel.md): true iff this finding was
+   *  lifted from a JUDGE verdict (an acceptance score), not OBSERVED from the
+   *  agent's behavior. A judge-derived finding must NEVER be admitted as a
+   *  steering input — that is the held-out judge leaking into the loop. Set at
+   *  the lift site (createJudgeAdapter); checked by `assertNoJudgeVerdict`.
+   *  Provenance, not evidence presence, is the correct discriminator: an
+   *  evidence-less trace-analyst observation legitimately steers, while a judge
+   *  verdict that happens to cite an artifact must not. */
+  derived_from_judge?: boolean;
+  /** Analyst-private extras; renderers ignore unless they know the analyst. */
+  metadata?: Record<string, unknown>;
+}
+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;
+   * `finding` to another AnalystFinding (cross-analyst chaining);
+   * `metric` to a named scalar reading the renderer knows how to read.
+   */
+  kind: 'span' | 'event' | 'artifact' | 'finding' | 'metric';
+  uri: string;
+  excerpt?: string;
+}
+/**
+ * The discriminator the registry uses to pass the right input.
+ * `custom` is the escape hatch — analysts that need something else
+ * (e.g. an embedding cache, a partner SDK handle) read it from
+ * `AnalystRunInputs.custom[<analyst id>]`.
+ */
+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. */
+  est_usd_per_run?: number;
+  /** Models the analyst expects to use (informational). */
+  models?: string[];
+  /** Maximum post-cancellation wait for provider usage. Model analysts default to 5 seconds. */
+  settlement_timeout_ms?: number;
+}
+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']). */
+  capabilities?: string[];
+}
+/**
+ * What's passed to every analyst call. The registry resolves which
+ * field the analyst's `inputKind` selects and asserts it's present.
+ */
+interface AnalystRunInputs {
+  traceStore?: TraceAnalysisStore;
+  artifactDir?: string;
+  runRecord?: RunRecord;
+  judgeInput?: JudgeInput;
+  /** Keyed by analyst id; populated by callers that registered custom analysts. */
+  custom?: Record<string, unknown>;
+}
+interface AnalystContext {
+  runId: string;
+  /** Stable correlation id so logs from a single registry.run() share a tag. */
+  correlationId: string;
+  /** Enforced wall-clock deadline (epoch ms). */
+  deadlineMs?: number;
+  /** Per-analyst USD budget. Analysts MAY check before issuing LLM calls. */
+  budgetUsd?: number;
+  /** Shared paid-call account when the analyst runs inside a larger campaign. */
+  costLedger?: CostLedgerHandle;
+  /** Attribution phase used when writing to the shared paid-call account. */
+  costPhase?: string;
+  /**
+   * Shared chat client. Analysts that call an LLM go through this so
+   * the operator picks transport (sandbox-sdk | router | cli-bridge |
+   * direct-provider | mock) at the registry boundary without touching
+   * analyst code.
+   */
+  chat?: ChatClient;
+  /**
+   * Findings from a prior run the operator wants the analyst to see as
+   * retrieval context. Kinds that take advantage of cross-run memory
+   * (failure-mode "I saw this cluster last run", knowledge-gap "the wiki
+   * page I asked for is still missing") render these into the actor's
+   * working set. Filtering is the operator's job: pass the slice that
+   * matches the analyst's id, or pass everything and let the kind
+   * filter. Empty / absent means no cross-run context.
+   */
+  priorFindings?: ReadonlyArray<AnalystFinding>;
+  /**
+   * Findings emitted by analysts that completed earlier in this registry run.
+   * This is separate from `priorFindings`: upstream findings are dependency
+   * context for the current pass, while prior findings are cross-run memory.
+   * The registry populates this only when `RegistryRunOpts.chainFindings` is on.
+   */
+  upstreamFindings?: ReadonlyArray<AnalystFinding>;
+  /**
+   * Report metered work independently of findings. This keeps an empty finding
+   * set from erasing token/cost telemetry. Multiple receipts are accumulated.
+   */
+  recordUsage?: (receipt: AnalystUsageReceipt) => void;
+  /** Free-form runtime tags (env, host, op). Findings can echo these into metadata. */
+  tags?: Record<string, string>;
+  /** Logger callback — analysts SHOULD prefer this over console.* for testability. */
+  log?: (msg: string, fields?: Record<string, unknown>) => void;
+  /** Optional abort signal. Analysts SHOULD pass it through to LLM calls. */
+  signal?: AbortSignal;
+}
+/**
+ * The minimal contract. Concrete analysts can refine `TInput` so
+ * implementations stay type-safe (e.g. a trace analyst's `TInput` is
+ * `TraceAnalysisStore`); the registry passes the right field from
+ * `AnalystRunInputs` based on `inputKind`.
+ */
+interface Analyst<TInput = unknown> {
+  /** Stable identifier — appears in finding_id, telemetry, and registry exclusion lists. */
+  readonly id: string;
+  /** Human-readable. One sentence. */
+  readonly description: string;
+  readonly inputKind: AnalystInputKind;
+  readonly cost: AnalystCost;
+  readonly requires?: AnalystRequirements;
+  /** Bump on breaking changes to claim wording or area so old finding_ids don't collide. */
+  readonly version: string;
+  analyze(input: TInput, ctx: AnalystContext): Promise<AnalystFinding[]>;
+}
+/** Metered work performed by one analyst call. */
+interface AnalystUsageReceipt {
+  /** Number of model-usage records observed at the provider boundary. */
+  calls: number | null;
+  /** Null when the provider did not return token accounting. */
+  tokens: RunTokenUsage | null;
+  /** Observed, estimated, or explicitly uncaptured dollar cost. */
+  cost: RunCostProvenance;
+  /** Known lower bound when one or more calls have uncaptured cost. */
+  knownCostUsd?: number;
+}
+/**
+ * Compute the stable finding_id from the identity-defining fields.
+ * Default implementation hashes {analyst_id, area, subject, normalized claim}.
+ * Analysts that emit findings whose claim text varies per run (timestamps,
+ * counts) SHOULD either: (a) pass an explicit `id_basis` to fix the hash,
+ * or (b) move the variable part into `rationale`/`metadata` and keep the
+ * `claim` static.
+ */
+declare function computeFindingId(input: {
+  analyst_id: string;
+  area: string;
+  subject?: string;
+  claim: string;
+  /** Override the claim for hashing — use when the displayed claim has run-specific bits. */
+  id_basis?: string;
+}): string;
+/**
+ * Convenience factory: produce a fully-formed AnalystFinding with the
+ * id computed automatically. Analyst code stays terse.
+ */
+declare function makeFinding(init: Omit<AnalystFinding, 'schema_version' | 'finding_id' | 'produced_at'> & {
+  id_basis?: string;
+  produced_at?: string;
+}): AnalystFinding;
+interface AnalystRunSummary {
+  analyst_id: string;
+  status: 'ok' | 'skipped' | 'failed';
+  /** Why skipped — missing input, budget exceeded, capability unmet. */
+  reason?: string;
+  findings_count: number;
+  latency_ms: number;
+  /** Additive model usage and cost provenance for this analyst. */
+  usage: AnalystUsageReceipt;
+  /** When `status='failed'`: the error class + message, never the full stack. */
+  error?: {
+    class: string;
+    message: string;
+  };
+}
+interface AnalystRunResult {
+  run_id: string;
+  correlation_id: string;
+  started_at: string;
+  ended_at: string;
+  findings: AnalystFinding[];
+  per_analyst: AnalystRunSummary[];
+  /** Total LLM cost in USD across all analysts in this registry.run(). */
+  total_cost_usd: number;
+  /**
+   * Provenance for `total_cost_usd`. When uncaptured, the numeric field is only
+   * the known subtotal and must not be treated as the run's total spend.
+   */
+  total_cost_provenance?: RunCostProvenance;
+}
+/**
+ * Events emitted by `AnalystRegistry.runStream(...)` in real time as
+ * the registry executes. UIs subscribe via `for await (const ev of
+ * registry.runStream(...))`; `registry.run(...)` is a thin collector
+ * over the same stream, so the two surfaces share their invariants.
+ *
+ * Per-finding events are intentionally omitted — analyzers are batch
+ * operations (an Ax actor returns the full `findings:json[]` at the
+ * end of the responder), so streaming inside one analyst would only
+ * emit partial JSON consumers can't render. The kind-completion event
+ * is the right granularity; subscribers wanting per-finding rendering
+ * iterate `event.findings` themselves.
+ */
+type AnalystRunEvent = {
+  type: 'run-started';
+  run_id: string;
+  correlation_id: string;
+  started_at: string;
+  /** The ordered list of analyst ids the registry will run. */
+  analyst_ids: ReadonlyArray<string>;
+} | {
+  type: 'analyst-skipped';
+  summary: AnalystRunSummary;
+} | {
+  type: 'analyst-started';
+  analyst_id: string;
+  started_at: string;
+} | {
+  type: 'analyst-completed';
+  /** `summary.status` is `'ok'` for clean completion or `'failed'` for thrown analysts. */
+  summary: AnalystRunSummary;
+  findings: ReadonlyArray<AnalystFinding>;
+} | {
+  type: 'run-completed';
+  result: AnalystRunResult;
+};
+//#endregion
+//#region src/analyst/finding-signature.d.ts
+declare const ANALYST_SEVERITIES: readonly ['critical', 'high', 'medium', 'low', 'info'];
+declare const RawAnalystEvidenceSchema: z.ZodObject<{
+  uri: z.ZodString;
+  excerpt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type RawAnalystEvidence = z.infer<typeof RawAnalystEvidenceSchema>;
+declare const RawAnalystFindingSchema: z.ZodObject<{
+  severity: z.ZodEnum<{
+    critical: "critical";
+    high: "high";
+    info: "info";
+    low: "low";
+    medium: "medium";
+  }>;
+  claim: z.ZodString;
+  subject: z.ZodOptional<z.ZodString>;
+  confidence: z.ZodNumber;
+  rationale: z.ZodOptional<z.ZodString>;
+  recommended_action: z.ZodOptional<z.ZodString>;
+  evidence: z.ZodArray<z.ZodObject<{
+    uri: z.ZodString;
+    excerpt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+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.
+ */
+declare const RAW_FINDING_SCHEMA_PROMPT = "Each finding MUST be a strict JSON object with:\n  - severity: \"critical\" | \"high\" | \"medium\" | \"low\" | \"info\"\n  - claim: one-sentence statement (max 2000 chars)\n  - subject?: one exact subject form listed by this kind; omit rather than guess\n  - evidence: REQUIRED non-empty array of {\"uri\": string, \"excerpt\"?: string}. Use real identifiers with span://, event://, artifact://, metric://, or finding://. Include a short exact quote in excerpt when available. If nothing is citable, do not emit the finding.\n  - confidence: number 0..1 (0.9+ exact evidence; 0.6-0.8 inferred pattern; <0.5 speculative)\n  - rationale?: one or two reasoning sentences\n  - recommended_action?: concrete imperative change; omit for descriptive findings\n\nUnknown fields are rejected. Do not emit area; the factory assigns it. Emit [] when there are no findings. Never fabricate evidence.";
+/** Convert raw citations into the public finding evidence envelope. */
+declare function evidenceRefsFromRawFinding(finding: RawAnalystFinding): EvidenceRef[];
+declare function parseRawFinding(row: unknown, log?: (msg: string, fields?: Record<string, unknown>) => void): RawAnalystFinding | null;
+//#endregion
+//#region src/analyst/kind-factory.d.ts
+/**
+ * Per-kind specification. The factory turns this into a regular
+ * `Analyst<TraceAnalysisStore>` ready for `AnalystRegistry.register()`.
+ */
+interface TraceAnalystKindSpec {
+  /** Stable id. Appears in finding_id, telemetry, and registry exclusions. */
+  id: string;
+  /** One-sentence description shown in `registry.list()`. */
+  description: string;
+  /** Coarse classification stamped on every emitted finding (`failure-mode`, `knowledge-gap`, ...). */
+  area: string;
+  /** Bump on any breaking change to the actor prompt or output schema. */
+  version: string;
+  /** Actor system prompt. Must instruct the LLM to emit `findings` per the schema. */
+  actorDescription: string;
+  /** Tool functions the actor may call. Pick narrow subsets via `ANALYST_TOOL_GROUPS`. */
+  buildTools: (store: TraceAnalysisStore) => AxFunction[];
+  /** Bounded semantic subqueries. `maxCalls: 0` disables model fan-out. */
+  subqueries?: {
+    maxCalls: number;
+    maxParallel?: number;
+  };
+  /** Actor turn cap. Default 12. */
+  maxTurns?: number;
+  /** Runtime char cap. Default 6000. */
+  maxRuntimeChars?: number;
+  /** Maximum output tokens for every actor and subquery model call. Default 4096. */
+  maxOutputTokens?: number;
+  /** Cost classification surfaced in `registry.list()` and budget enforcement. */
+  cost: AnalystCost;
+  /** Per-finding-row hook — kinds may reject / rewrite before lifting. */
+  postProcess?: (row: RawAnalystFinding, ctx: AnalystContext) => RawAnalystFinding | null;
+  /** Minimum citations per finding. Default 1; rows below it are rejected. */
+  minimumEvidenceCitations?: number;
+  /** Optional optimizer hook — populated when a kind wants to fit its prompt against labeled examples. */
+  goldens?: TraceAnalystGolden[];
+}
+/**
+ * One labeled example consumed by Ax optimizers (MIPRO / GEPA / Bootstrap).
+ * Each input is the same `{question}` an analyst would receive; `expected`
+ * is the ground-truth finding set a fitted prompt should produce on this
+ * input. Metric: kind-specific (default: F1 on `finding_id` overlap).
+ */
+interface TraceAnalystGolden {
+  question: string;
+  expected: ReadonlyArray<Omit<RawAnalystFinding, 'confidence'>>;
+}
+interface CreateTraceAnalystKindOpts {
+  /** AxAIService bound at registration time. */
+  ai: AxAIService;
+  /** Required unless `ai` was created by {@link createAnalystAi}. */
+  model?: string;
+  /** Override the spec's `version` (e.g. when an optimizer has fitted a new prompt). */
+  versionSuffix?: string;
+  /**
+   * Optional two-phase recovery: when the agentic harvest is empty but the
+   * actor produced a substantive free-form `report`, extract findings from that
+   * prose via a tolerant chat-completions pass (`structureFindings`) — no
+   * strict-emission contract, so it works on weak models. Omit to leave the
+   * actor's harvest as-is (the report is still surfaced fail-loud either way).
+   */
+  recovery?: {
+    baseUrl: string;
+    apiKey?: string;
+    model?: string;
+    fetchImpl?: typeof fetch;
+  };
+  /** Maximum post-cancellation wait for a provider receipt. Default 5 seconds. */
+  settlementTimeoutMs?: number;
+}
+/**
+ * Build an `Analyst<TraceAnalysisStore>` from a kind spec.
+ *
+ * Lifts the Ax pipeline once at registration time so the registry
+ * gets a stateless analyst. The Ax agent is freshly constructed per
+ * `analyze()` call (the agent carries chat-log + usage state we don't
+ * want shared across analyst runs).
+ */
+declare function createTraceAnalystKind(spec: TraceAnalystKindSpec, opts: CreateTraceAnalystKindOpts): Analyst<TraceAnalysisStore>;
+/**
+ * Render a compact prior-findings block the actor reads alongside its
+ * brief. Each row is one line so the actor can scan dozens cheaply.
+ * The kind's prompt instructs the actor to (a) check whether a new
+ * cluster matches a prior `finding_id` (carry the id forward via
+ * `id_basis` to keep diffs stable) and (b) raise severity / confidence
+ * when a prior finding has reappeared without remediation.
+ *
+ * Returns the empty string when there are no prior findings — most
+ * runs are "first-of-its-kind" and the prompt stays unchanged.
+ *
+ * Exported for tests + for consumers that build their own actor
+ * prompts (e.g. specialized analysts living outside the default kinds).
+ */
+declare function renderPriorFindings(prior: AnalystContext['priorFindings']): string;
+/** Render findings produced earlier in this same registry run. */
+declare function renderUpstreamFindings(upstream: AnalystContext['upstreamFindings']): string;
+//#endregion
+//#region src/analyst/registry.d.ts
+interface AnalystHooks {
+  /** Before analyze() — last chance to mutate ctx (e.g. inject tags, override budget). */
+  onBeforeAnalyze?(args: {
+    analyst: Analyst;
+    ctx: AnalystContext;
+    runId: string;
+  }): void | Promise<void>;
+  /** After every analyst (ok | failed | skipped). Use for telemetry, ingestion, rotation. */
+  onAfterAnalyze?(args: {
+    analyst: Analyst;
+    summary: AnalystRunSummary;
+    findings: AnalystFinding[];
+    runId: string;
+  }): void | Promise<void>;
+  /**
+   * On analyst exception. Hook MAY return findings to convert the
+   * error into structured findings; the summary still reports 'failed'.
+   * Return void to keep the default empty-findings behavior.
+   */
+  onError?(args: {
+    analyst: Analyst;
+    error: Error;
+    runId: string;
+  }): AnalystFinding[] | undefined | Promise<AnalystFinding[] | undefined>;
+  /** Once after registry.run() completes. Use for final aggregation, persistence. */
+  onComplete?(args: {
+    result: AnalystRunResult;
+  }): void | Promise<void>;
+}
+interface BudgetPolicy {
+  /** Overall USD cap across the registry.run(). */
+  totalUsd?: number;
+  /** Per-analyst weight for the default allocator. Missing ids get weight 1. */
+  weights?: Record<string, number>;
+  /**
+   * Custom allocator — receives the analyst, remaining/total budget, and
+   * the count of analysts that will run. Returns the per-analyst budget
+   * (or undefined only when the run has no overall cap). Overrides weights
+   * when set.
+   */
+  allocate?: (args: {
+    analyst: Analyst;
+    totalUsd: number | undefined;
+    remainingUsd: number | undefined;
+    runningCount: number;
+  }) => number | undefined;
+}
+interface AnalystRegistryOptions {
+  /** Shared chat client passed to every LLM analyst via AnalystContext. */
+  chat?: ChatClient;
+  /** Logger callback. Defaults to a no-op. */
+  log?: (msg: string, fields?: Record<string, unknown>) => void;
+  /** Hooks invoked around analyze() — observability + customization seam. */
+  hooks?: AnalystHooks;
+  /** Default budget when run() doesn't override. */
+  defaultBudget?: BudgetPolicy;
+}
+interface RegistryRunOpts {
+  /** Restrict to a subset of registered analysts by id. */
+  only?: string[];
+  /** Skip these analysts even if registered. Useful for cheap iteration. */
+  skip?: string[];
+  /** Budget policy — totalUsd + optional weights/allocator. Falls back to options.defaultBudget. */
+  budget?: BudgetPolicy;
+  /** Active-work cap for the complete registry run. Model receipt settlement may follow. */
+  timeoutMs?: number;
+  /** Abort signal — forwarded into every analyst's context. */
+  signal?: AbortSignal;
+  /** Shared paid-call account forwarded to every analyst. */
+  costLedger?: CostLedgerHandle;
+  /** Attribution phase for calls written to `costLedger`. */
+  costPhase?: string;
+  /** Tags echoed into AnalystContext.tags — useful for tracking environment/version in findings. */
+  tags?: Record<string, string>;
+  /**
+   * Prior-run findings made available as retrieval context to every
+   * analyst via `ctx.priorFindings`. The registry forwards the slice
+   * whose `analyst_id` matches each registered analyst so a kind sees
+   * only its own history. Pass `{ '*': findings }` to broadcast to
+   * every analyst (useful when several kinds share the same historical
+   * context). For findings from this run, use `chainFindings` instead.
+   */
+  priorFindings?: ReadonlyArray<AnalystFinding> | Record<string, ReadonlyArray<AnalystFinding>>;
+  /**
+   * Pass findings produced earlier in this registry run to each later analyst
+   * via `ctx.upstreamFindings`. Registration order is dependency order.
+   * Disabled by default because independent analyst suites must opt in.
+   */
+  chainFindings?: boolean;
+}
+declare class AnalystRegistry {
+  private readonly analysts;
+  private readonly options;
+  constructor(options?: AnalystRegistryOptions);
+  register(analyst: Analyst): void;
+  list(): ReadonlyArray<{
+    id: string;
+    description: string;
+    version: string;
+    cost: Analyst['cost'];
+  }>;
+  run(runId: string, inputs: AnalystRunInputs, runOpts?: RegistryRunOpts): Promise<AnalystRunResult>;
+  /**
+   * Streaming counterpart to `run()`. Emits `AnalystRunEvent` values
+   * in real time — `run-started`, then per-analyst `skipped` /
+   * `started` / `completed`, then a terminal `run-completed` whose
+   * payload is the full `AnalystRunResult`. UIs use this to render
+   * progress; persistence consumers use `run()` and read the result.
+   *
+   * Hooks (`onBeforeAnalyze` / `onAfterAnalyze` / `onError` /
+   * `onComplete`) fire as before — streaming is additive, not a hook
+   * replacement.
+   */
+  runStream(runId: string, inputs: AnalystRunInputs, runOpts?: RegistryRunOpts): AsyncGenerator<AnalystRunEvent, void, void>;
+  private selectAnalysts;
+  private routeInput;
+}
+//#endregion
+//#region src/analyst/default-registry.d.ts
+interface DefaultAnalystRegistryOptions {
+  /** Ax service for the agentic RLM kinds. Omit → only the deterministic analyst. */
+  ai?: AxAIService;
+  /** Required unless `ai` was created by `createAnalystAi`. */
+  model?: string;
+  /** Which agentic kinds to register when `ai` is present. Default = the shipped suite. */
+  kinds?: readonly TraceAnalystKindSpec[];
+  /** Set false to omit the deterministic behavioral analyst (default: include). */
+  includeBehavioral?: boolean;
+  /** Forwarded to the AnalystRegistry constructor (signal, tags, priorFindings). */
+  registry?: AnalystRegistryOptions;
+}
+declare function buildDefaultAnalystRegistry(opts?: DefaultAnalystRegistryOptions): AnalystRegistry;
+//#endregion
+export { AnalystRunResult as A, AnalystContext as C, AnalystRequirements as D, AnalystInputKind as E, computeFindingId as F, makeFinding as I, AnalystSeverity as M, AnalystUsageReceipt as N, AnalystRunEvent as O, EvidenceRef as P, Analyst as S, AnalystFinding as T, RawAnalystEvidenceSchema as _, AnalystRegistryOptions as a, evidenceRefsFromRawFinding as b, CreateTraceAnalystKindOpts as c, createTraceAnalystKind as d, renderPriorFindings as f, RawAnalystEvidence as g, RAW_FINDING_SCHEMA_PROMPT as h, AnalystRegistry as i, AnalystRunSummary as j, AnalystRunInputs as k, TraceAnalystGolden as l, ANALYST_SEVERITIES as m, buildDefaultAnalystRegistry as n, BudgetPolicy as o, renderUpstreamFindings as p, AnalystHooks as r, RegistryRunOpts as s, DefaultAnalystRegistryOptions as t, TraceAnalystKindSpec as u, RawAnalystFinding as v, AnalystCost as w, parseRawFinding as x, RawAnalystFindingSchema as y };
+//# sourceMappingURL=default-registry-CNPo-Vsb.d.ts.map

package/dist/default-registry-CNPo-Vsb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-registry-CNPo-Vsb.d.ts","names":[],"sources":["../src/analyst/types.ts","../src/analyst/finding-signature.ts","../src/analyst/kind-factory.ts","../src/analyst/registry.ts","../src/analyst/default-registry.ts"],"mappings":"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"}