@tangle-network/agent-eval 0.93.0 → 0.95.0

package/dist/{kind-factory-5b7xXXOr.d.ts → analyst/kind-factory.d.ts}

@@ -1,59 +1,5 @@
-import { AxAIService, AxFunction } from '@ax-llm/ax';
-import { T as TraceAnalysisStore } from './store-C1YxJDEK.js';
-import { z } from 'zod';
-import { g as AnalystCost, a as AnalystContext, A as Analyst } from './types-2VVIL04s.js';
-
 /**
- * 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.
- */
-
-declare const ANALYST_SEVERITIES: readonly ["critical", "high", "medium", "low", "info"];
-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>;
-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 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.
- */
-declare function parseRawFinding(row: unknown, log?: (msg: string, fields?: Record<string, unknown>) => void): RawAnalystFinding | null;
-
-/**
- * Analyst-kind factory — the typed, focused replacement for the
- * legacy `createTraceAnalystAdapter`.
+ * Analyst-kind factory — the typed way to define trace analysts.
  *
  * A "kind" is a specialized analyst whose actor prompt, tool subset,
  * and Ax recursion config target one failure-mode lens (failure-mode
@@ -77,12 +23,15 @@ declare function parseRawFinding(row: unknown, log?: (msg: string, fields?: Reco
  * description programmatically. Stored on the kind, not the registry,
  * because the right metric is kind-specific.
  */
-
+import type { AxAIService, AxFunction } from '@ax-llm/ax';
+import type { TraceAnalysisStore } from '../trace-analyst/store';
+import { type RawAnalystFinding } from './finding-signature';
+import type { Analyst, AnalystContext, AnalystCost } from './types';
 /**
  * Per-kind specification. The factory turns this into a regular
  * `Analyst<TraceAnalysisStore>` ready for `AnalystRegistry.register()`.
  */
-interface TraceAnalystKindSpec {
+export interface TraceAnalystKindSpec {
     /** Stable id. Appears in finding_id, telemetry, and registry exclusions. */
     id: string;
     /** One-sentence description shown in `registry.list()`. */
@@ -119,11 +68,11 @@ interface TraceAnalystKindSpec {
  * 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 {
+export interface TraceAnalystGolden {
     question: string;
     expected: ReadonlyArray<Omit<RawAnalystFinding, 'confidence'>>;
 }
-interface CreateTraceAnalystKindOpts {
+export interface CreateTraceAnalystKindOpts {
     /** AxAIService bound at registration time. */
     ai: AxAIService;
     /** Optional model override; falls back to the AI service's default. */
@@ -152,7 +101,7 @@ interface CreateTraceAnalystKindOpts {
  * `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>;
+export 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.
@@ -167,6 +116,5 @@ declare function createTraceAnalystKind(spec: TraceAnalystKindSpec, opts: Create
  * 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;
-
-export { ANALYST_SEVERITIES as A, type CreateTraceAnalystKindOpts as C, RAW_FINDING_SCHEMA_PROMPT as R, type TraceAnalystKindSpec as T, type RawAnalystFinding as a, RawAnalystFindingSchema as b, type TraceAnalystGolden as c, createTraceAnalystKind as d, parseRawFinding as p, renderPriorFindings as r };
+export declare function renderPriorFindings(prior: AnalystContext['priorFindings']): string;
+//# sourceMappingURL=kind-factory.d.ts.map

package/dist/analyst/kind-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind-factory.d.ts","sourceRoot":"","sources":["../../src/analyst/kind-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAEzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAEhE,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAA;AAG5B,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,WAAW,EAAkB,MAAM,SAAS,CAAA;AAGnF;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,4EAA4E;IAC5E,EAAE,EAAE,MAAM,CAAA;IACV,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAA;IACnB,qGAAqG;IACrG,IAAI,EAAE,MAAM,CAAA;IACZ,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAA;IACf,oFAAoF;IACpF,gBAAgB,EAAE,MAAM,CAAA;IACxB,0FAA0F;IAC1F,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,wFAAwF;IACxF,UAAU,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,UAAU,EAAE,CAAA;IACvD,0DAA0D;IAC1D,SAAS,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,oBAAoB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC/D,kCAAkC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,sCAAsC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,gFAAgF;IAChF,IAAI,EAAE,WAAW,CAAA;IACjB,wEAAwE;IACxE,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,iBAAiB,EAAE,GAAG,EAAE,cAAc,KAAK,iBAAiB,GAAG,IAAI,CAAA;IACvF,wGAAwG;IACxG,OAAO,CAAC,EAAE,kBAAkB,EAAE,CAAA;CAC/B;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC,CAAA;CAC/D;AAED,MAAM,WAAW,0BAA0B;IACzC,8CAA8C;IAC9C,EAAE,EAAE,WAAW,CAAA;IACf,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,sFAAsF;IACtF,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAA;KAAE,CAAA;CAC1F;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,oBAAoB,EAC1B,IAAI,EAAE,0BAA0B,GAC/B,OAAO,CAAC,kBAAkB,CAAC,CAoK7B;AA0CD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,cAAc,CAAC,eAAe,CAAC,GAAG,MAAM,CAsBlF"}

package/dist/analyst/kinds/failure-mode.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Failure-mode analyst — classifies what went wrong and why.
+ *
+ * Brief: read the trace dataset, identify the top failure modes across
+ * runs, classify each with severity + evidence, and surface them as
+ * findings. The actor's job is *taxonomy + evidence*, not fix-design —
+ * that's the improvement-analyst's job.
+ *
+ * Recursion is deep (`maxDepth: 3`) because real failure-mode
+ * discovery is genuinely tree-shaped: the actor splits the dataset
+ * into candidate clusters, each cluster spawns a focused investigator
+ * that drills into representative traces, and a deeply-recursed
+ * investigator may itself split a confounded mode into two sub-modes.
+ * Each level fans out 4-way, so the analyst can investigate up to
+ * ~16 leaf clusters before hitting the depth ceiling.
+ */
+import type { TraceAnalystKindSpec } from '../kind-factory';
+export declare const FAILURE_MODE_KIND_SPEC: TraceAnalystKindSpec;
+//# sourceMappingURL=failure-mode.d.ts.map

package/dist/analyst/kinds/failure-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure-mode.d.ts","sourceRoot":"","sources":["../../../src/analyst/kinds/failure-mode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAkC3D,eAAO,MAAM,sBAAsB,EAAE,oBAWpC,CAAA"}

package/dist/analyst/kinds/improvement.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Improvement analyst — actionable, recursive self-improvement findings.
+ *
+ * Brief: read findings from upstream analysts (failure-mode,
+ * knowledge-gap, knowledge-poisoning) AND the trace dataset itself,
+ * then propose **concrete edits** to the agent's runtime: prompt
+ * additions, RAG documents to ingest, tool descriptions to rewrite,
+ * scaffolding changes to make, memory entries to invalidate. Each
+ * finding is one proposed edit with the locus, the diff, and the
+ * expected effect.
+ *
+ * This is the recursive-self-improvement loop's last mile: the prior
+ * kinds describe *what's wrong*; this kind describes *what to change*.
+ *
+ * Recursion is deep (`maxDepth: 3`) because real improvement proposals
+ * are competitive: for each failure-mode there are usually 2-3 viable
+ * fix directions (tighten prompt vs add tool vs adjust scaffolding),
+ * and the actor should explore each with a focused subagent before
+ * picking the highest-leverage one to recommend.
+ */
+import type { TraceAnalystKindSpec } from '../kind-factory';
+export declare const IMPROVEMENT_KIND_SPEC: TraceAnalystKindSpec;
+//# sourceMappingURL=improvement.d.ts.map

package/dist/analyst/kinds/improvement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"improvement.d.ts","sourceRoot":"","sources":["../../../src/analyst/kinds/improvement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAyC3D,eAAO,MAAM,qBAAqB,EAAE,oBAYnC,CAAA"}

package/dist/analyst/kinds/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Default analyst kinds focused on agent failure + recursive
+ * self-improvement.
+ *
+ * The four kinds chain: failure-mode classifies; knowledge-gap and
+ * knowledge-poisoning explain *why* in two orthogonal ways; improvement
+ * proposes concrete edits. Register all four against the same trace
+ * store and the registry runs them in dependency order if the operator
+ * pipes findings between them.
+ */
+export { FAILURE_MODE_KIND_SPEC } from './failure-mode';
+export { IMPROVEMENT_KIND_SPEC } from './improvement';
+export { KNOWLEDGE_GAP_KIND_SPEC } from './knowledge-gap';
+export { KNOWLEDGE_POISONING_KIND_SPEC } from './knowledge-poisoning';
+import type { TraceAnalystKindSpec } from '../kind-factory';
+/**
+ * The default kind suite. Order is the run order operators should
+ * use: failure-mode first (no upstream deps), gap + poisoning next
+ * (both depend on failures), improvement last (chains all three).
+ */
+export declare const DEFAULT_TRACE_ANALYST_KINDS: readonly TraceAnalystKindSpec[];
+//# sourceMappingURL=index.d.ts.map

package/dist/analyst/kinds/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/analyst/kinds/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AACvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AACrD,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAA;AACzD,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAA;AAErE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAM3D;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,EAAE,SAAS,oBAAoB,EAK7D,CAAA"}

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

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

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

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

package/dist/analyst/kinds/knowledge-gap.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Knowledge-gap analyst — what did the agent NOT know that it needed?
+ *
+ * Brief: find moments in the trace where the agent had to guess, ask
+ * the user to fill in context, recover from a wrong assumption, or
+ * loop on a retrieval. Each finding names a *missing or outdated piece
+ * of knowledge* the agent's curated knowledge base should have held —
+ * or a downstream lookup (web, docs, tool description) that surfaced
+ * stale or outdated information.
+ *
+ * The primary expected store is `@tangle-network/agent-knowledge`: a
+ * Karpathy-style wiki the agent maintains with raw ↔ curated pages,
+ * source anchors, and claim/relation triples. A gap is anything the
+ * agent had to discover at run-time that should already have lived
+ * there. Secondary loci: web-search results that returned outdated
+ * pages, tool descriptions that omitted critical behavior, system-
+ * prompt sections that didn't cover the case.
+ *
+ * Distinct from failure-mode: failure-mode classifies *how* it broke;
+ * knowledge-gap names the *information* whose absence (or staleness)
+ * caused the break. One failure-mode often maps to several gaps.
+ *
+ * Recursion (`maxDepth: 2`) is enough to fan out one subagent per
+ * candidate gap-source layer; each subagent runs a focused detection.
+ */
+import type { TraceAnalystKindSpec } from '../kind-factory';
+export declare const KNOWLEDGE_GAP_KIND_SPEC: TraceAnalystKindSpec;
+//# sourceMappingURL=knowledge-gap.d.ts.map

package/dist/analyst/kinds/knowledge-gap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-gap.d.ts","sourceRoot":"","sources":["../../../src/analyst/kinds/knowledge-gap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AA+C3D,eAAO,MAAM,uBAAuB,EAAE,oBAWrC,CAAA"}

package/dist/analyst/kinds/knowledge-poisoning.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Knowledge-poisoning analyst — what FALSE information misled the agent?
+ *
+ * Brief: find moments where the agent acted on information that was
+ * *wrong* — stale memory, RAG documents that contradicted ground truth,
+ * tool descriptions that lied about return shapes, system-prompt
+ * instructions that no longer matched reality, prior-run summaries that
+ * cached a wrong decision.
+ *
+ * Distinct from knowledge-gap: a gap is "the agent didn't know X"; a
+ * poisoning is "the agent confidently used X, but X was wrong." Gaps
+ * surface as questions / self-correction; poisonings surface as
+ * confident-but-wrong actions that downstream evidence contradicts.
+ *
+ * Recursion is moderate (`maxDepth: 2`) because each candidate
+ * poisoning typically needs two sub-investigations: one to confirm
+ * the agent acted on the false belief, one to confirm the belief
+ * itself is actually false in ground truth.
+ */
+import type { TraceAnalystKindSpec } from '../kind-factory';
+export declare const KNOWLEDGE_POISONING_KIND_SPEC: TraceAnalystKindSpec;
+//# sourceMappingURL=knowledge-poisoning.d.ts.map

package/dist/analyst/kinds/knowledge-poisoning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-poisoning.d.ts","sourceRoot":"","sources":["../../../src/analyst/kinds/knowledge-poisoning.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAuC3D,eAAO,MAAM,6BAA6B,EAAE,oBAW3C,CAAA"}

package/dist/analyst/kinds/skill-usage.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Skill-usage analyst — a DETERMINISTIC `Analyst` over a Claude/Codex skill
+ * library + its trace corpus. Unlike the trace-store kinds (failure-mode,
+ * improvement, ...) this kind calls no LLM: it mines real usage and skill
+ * structure and emits findings by rule.
+ *
+ * It exists because the naive "Skill-tool invocation count" lies low — it
+ * misses orchestrated sub-dispatch (a leaf skill run BY /pursue or /governor
+ * logs under the parent), slash-command entry, local-script bypass, and
+ * on-disk artifacts. The 2026-05-30 skill audit found 39/53 skills at zero
+ * direct invocations, yet only one was a genuine cut: the rest were
+ * measurement-invisible or discovery-limited. This analyst encodes that
+ * lesson as a multi-signal usage model so a cheap repeatable pass can keep
+ * the library honest, and so the expensive audit workflow's verdicts can
+ * GEPA-distill it toward agreement (see `gold/skill-verdicts.gold.jsonl`).
+ *
+ * Report-building (`buildSkillUsageReport`, an fs scan) is separated from
+ * finding emission (`SkillUsageAnalyst.analyze`, pure) so the slow scan runs
+ * once at the registry boundary and the rule logic stays unit-testable.
+ */
+import type { Analyst, AnalystContext, AnalystFinding } from '../types';
+export type SkillKind = 'public' | 'private';
+/** One skill's multi-signal usage + structure. All counts are deterministic. */
+export interface SkillUsageRecord {
+    name: string;
+    kind: SkillKind;
+    /** Absolute path to the skill's SKILL.md. */
+    path: string;
+    lines: number;
+    /** `"skill":"<name>"` Skill-tool invocations across the trace corpus. */
+    directInvocations: number;
+    /** `<command-name>/<name>` slash invocations across the trace corpus. */
+    slashInvocations: number;
+    /** Sibling skills whose SKILL.md dispatches to this one (`/<name>`). Proxy
+     *  for orchestrated sub-dispatch the per-skill counter cannot see. */
+    inboundRefs: number;
+    /** On-disk artifacts attributable to the skill (e.g. `.evolve/<name>/**`). */
+    artifactCount: number;
+    /** Tangle-private reference count in the body (leak signal for public skills). */
+    tanglePrivateRefs: number;
+    hasReferencesDir: boolean;
+    hasEvalsDir: boolean;
+    /** Body mentions `skill-runs.jsonl` (visible to /reflect + /governor). */
+    logsRuns: boolean;
+    /** Description carries an explicit `Triggers:` clause / trigger phrases. */
+    hasTriggerPhrases: boolean;
+}
+export interface SkillUsageReport {
+    generatedFromTraces: number;
+    records: SkillUsageRecord[];
+}
+export interface SkillUsageScanConfig {
+    /** Dirs holding `*.jsonl` transcripts (Claude `~/.claude/projects`, Codex sessions). */
+    transcriptDirs: string[];
+    /** Skill roots to scan; each dir directly under `root` with a `SKILL.md` is a skill. */
+    skillRoots: {
+        root: string;
+        kind: SkillKind;
+    }[];
+    /** Roots scanned for `<root>/.evolve/<skill>` artifact dirs. */
+    artifactRoots?: string[];
+    /** Token-prefixed mappings: skill name → extra artifact subpaths under an artifactRoot
+     *  (e.g. reflect → `.evolve/reflections`). Catches non-eponymous artifact dirs. */
+    artifactAliases?: Record<string, string[]>;
+    /** Cap files read per transcript dir (bounds a huge corpus); 0 = unbounded. */
+    maxTranscriptsPerDir?: number;
+}
+/** Scan the corpus + skill roots into a {@link SkillUsageReport}. Deterministic. */
+export declare function buildSkillUsageReport(config: SkillUsageScanConfig): SkillUsageReport;
+/** Pure rule pass over a report → findings. Exported for direct/unit use. */
+export declare function emitSkillUsageFindings(report: SkillUsageReport, producedAt: string): AnalystFinding[];
+export declare class SkillUsageAnalyst implements Analyst<SkillUsageReport> {
+    readonly id = "skill-usage";
+    readonly description = "Deterministic multi-signal skill-usage analysis: flags dead skills, measurement-invisible (orchestrated) usage, discovery gaps, public-repo leaks, bloat, missing evals, and missing run-logging.";
+    readonly inputKind: "custom";
+    readonly cost: {
+        kind: "deterministic";
+        est_usd_per_run: number;
+    };
+    readonly version = "1.0.0";
+    analyze(input: SkillUsageReport, ctx: AnalystContext): Promise<AnalystFinding[]>;
+}
+export declare const SKILL_USAGE_ANALYST: SkillUsageAnalyst;
+//# sourceMappingURL=skill-usage.d.ts.map

package/dist/analyst/kinds/skill-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-usage.d.ts","sourceRoot":"","sources":["../../../src/analyst/kinds/skill-usage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,EAAmB,MAAM,UAAU,CAAA;AAKxF,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAA;AAE5C,gFAAgF;AAChF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,SAAS,CAAA;IACf,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,yEAAyE;IACzE,iBAAiB,EAAE,MAAM,CAAA;IACzB,yEAAyE;IACzE,gBAAgB,EAAE,MAAM,CAAA;IACxB;0EACsE;IACtE,WAAW,EAAE,MAAM,CAAA;IACnB,8EAA8E;IAC9E,aAAa,EAAE,MAAM,CAAA;IACrB,kFAAkF;IAClF,iBAAiB,EAAE,MAAM,CAAA;IACzB,gBAAgB,EAAE,OAAO,CAAA;IACzB,WAAW,EAAE,OAAO,CAAA;IACpB,0EAA0E;IAC1E,QAAQ,EAAE,OAAO,CAAA;IACjB,4EAA4E;IAC5E,iBAAiB,EAAE,OAAO,CAAA;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,mBAAmB,EAAE,MAAM,CAAA;IAC3B,OAAO,EAAE,gBAAgB,EAAE,CAAA;CAC5B;AAED,MAAM,WAAW,oBAAoB;IACnC,wFAAwF;IACxF,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,wFAAwF;IACxF,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,SAAS,CAAA;KAAE,EAAE,CAAA;IAC/C,gEAAgE;IAChE,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB;uFACmF;IACnF,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IAC1C,+EAA+E;IAC/E,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B;AAyED,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,oBAAoB,GAAG,gBAAgB,CA+EpF;AAiCD,6EAA6E;AAC7E,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,gBAAgB,EACxB,UAAU,EAAE,MAAM,GACjB,cAAc,EAAE,CAuHlB;AAID,qBAAa,iBAAkB,YAAW,OAAO,CAAC,gBAAgB,CAAC;IACjE,QAAQ,CAAC,EAAE,iBAAa;IACxB,QAAQ,CAAC,WAAW,uMACiL;IACrM,QAAQ,CAAC,SAAS,EAAG,QAAQ,CAAS;IACtC,QAAQ,CAAC,IAAI;;;MAAyD;IACtE,QAAQ,CAAC,OAAO,WAAU;IAEpB,OAAO,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;CAOvF;AAED,eAAO,MAAM,mBAAmB,mBAA0B,CAAA"}

package/dist/analyst/kinds/skill-usage.test.d.ts

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

package/dist/analyst/kinds/skill-usage.test.d.ts.map

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

package/dist/analyst/parse-tolerant.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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. */
+export 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.
+ */
+export 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.
+ */
+export declare function coerceToFindingRows(raw: unknown): unknown[];
+//# sourceMappingURL=parse-tolerant.d.ts.map

package/dist/analyst/parse-tolerant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-tolerant.d.ts","sourceRoot":"","sources":["../../src/analyst/parse-tolerant.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKpD;AAOD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOhD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,EAAE,CAe3D"}

package/dist/analyst/parse-tolerant.test.d.ts

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

package/dist/analyst/parse-tolerant.test.d.ts.map

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

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

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

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

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

package/dist/{default-registry-zoGHUQEH.d.ts → analyst/registry.d.ts}

@@ -1,7 +1,3 @@
-import { AxAIService } from '@ax-llm/ax';
-import { T as TraceAnalystKindSpec } from './kind-factory-5b7xXXOr.js';
-import { A as Analyst, a as AnalystContext, b as AnalystRunSummary, c as AnalystFinding, d as AnalystRunResult, C as ChatClient, e as AnalystRunInputs, f as AnalystRunEvent } from './types-2VVIL04s.js';
-
 /**
  * AnalystRegistry — orchestrate N analysts against one run.
  *
@@ -19,8 +15,9 @@ import { A as Analyst, a as AnalystContext, b as AnalystRunSummary, c as Analyst
  * (equal split vs weighted vs custom) lives in `BudgetPolicy`. Both
  * have sensible defaults; consumers override only what they need.
  */
-
-interface AnalystHooks {
+import type { ChatClient } from './chat-client';
+import type { Analyst, AnalystContext, AnalystFinding, AnalystRunEvent, AnalystRunInputs, AnalystRunResult, AnalystRunSummary } from './types';
+export interface AnalystHooks {
     /** Before analyze() — last chance to mutate ctx (e.g. inject tags, override budget). */
     onBeforeAnalyze?(args: {
         analyst: Analyst;
@@ -49,7 +46,7 @@ interface AnalystHooks {
         result: AnalystRunResult;
     }): void | Promise<void>;
 }
-interface BudgetPolicy {
+export interface BudgetPolicy {
     /** Overall USD cap across the registry.run(). */
     totalUsd?: number;
     /** Per-analyst weight for the default allocator. Missing ids get weight 1. */
@@ -66,7 +63,7 @@ interface BudgetPolicy {
         runningCount: number;
     }) => number | undefined;
 }
-interface AnalystRegistryOptions {
+export interface AnalystRegistryOptions {
     /** Shared chat client passed to every LLM analyst via AnalystContext. */
     chat?: ChatClient;
     /** Logger callback. Defaults to a no-op. */
@@ -76,7 +73,7 @@ interface AnalystRegistryOptions {
     /** Default budget when run() doesn't override. */
     defaultBudget?: BudgetPolicy;
 }
-interface RegistryRunOpts {
+export interface RegistryRunOpts {
     /** Restrict to a subset of registered analysts by id. */
     only?: string[];
     /** Skip these analysts even if registered. Useful for cheap iteration. */
@@ -99,7 +96,7 @@ interface RegistryRunOpts {
      */
     priorFindings?: ReadonlyArray<AnalystFinding> | Record<string, ReadonlyArray<AnalystFinding>>;
 }
-declare class AnalystRegistry {
+export declare class AnalystRegistry {
     private readonly analysts;
     private readonly options;
     constructor(options?: AnalystRegistryOptions);
@@ -126,30 +123,4 @@ declare class AnalystRegistry {
     private selectAnalysts;
     private routeInput;
 }
-
-/**
- * `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.
- */
-
-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;
-}
-declare function buildDefaultAnalystRegistry(opts?: DefaultAnalystRegistryOptions): AnalystRegistry;
-
-export { AnalystRegistry as A, type BudgetPolicy as B, type DefaultAnalystRegistryOptions as D, type RegistryRunOpts as R, type AnalystHooks as a, buildDefaultAnalystRegistry as b, type AnalystRegistryOptions as c };
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/analyst/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC/C,OAAO,KAAK,EACV,OAAO,EACP,cAAc,EACd,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,SAAS,CAAA;AAIhB,MAAM,WAAW,YAAY;IAC3B,wFAAwF;IACxF,eAAe,CAAC,CAAC,IAAI,EAAE;QACrB,OAAO,EAAE,OAAO,CAAA;QAChB,GAAG,EAAE,cAAc,CAAA;QACnB,KAAK,EAAE,MAAM,CAAA;KACd,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACxB,2FAA2F;IAC3F,cAAc,CAAC,CAAC,IAAI,EAAE;QACpB,OAAO,EAAE,OAAO,CAAA;QAChB,OAAO,EAAE,iBAAiB,CAAA;QAC1B,QAAQ,EAAE,cAAc,EAAE,CAAA;QAC1B,KAAK,EAAE,MAAM,CAAA;KACd,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACxB;;;;OAIG;IACH,OAAO,CAAC,CAAC,IAAI,EAAE;QACb,OAAO,EAAE,OAAO,CAAA;QAChB,KAAK,EAAE,KAAK,CAAA;QACZ,KAAK,EAAE,MAAM,CAAA;KACd,GAAG,cAAc,EAAE,GAAG,SAAS,GAAG,OAAO,CAAC,cAAc,EAAE,GAAG,SAAS,CAAC,CAAA;IACxE,mFAAmF;IACnF,UAAU,CAAC,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,gBAAgB,CAAA;KAAE,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACtE;AAED,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE;QAChB,OAAO,EAAE,OAAO,CAAA;QAChB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;QAC5B,YAAY,EAAE,MAAM,GAAG,SAAS,CAAA;QAChC,YAAY,EAAE,MAAM,CAAA;KACrB,KAAK,MAAM,GAAG,SAAS,CAAA;CACzB;AAED,MAAM,WAAW,sBAAsB;IACrC,yEAAyE;IACzE,IAAI,CAAC,EAAE,UAAU,CAAA;IACjB,4CAA4C;IAC5C,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IAC7D,2EAA2E;IAC3E,KAAK,CAAC,EAAE,YAAY,CAAA;IACpB,kDAAkD;IAClD,aAAa,CAAC,EAAE,YAAY,CAAA;CAC7B;AAED,MAAM,WAAW,eAAe;IAC9B,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,0EAA0E;IAC1E,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,kGAAkG;IAClG,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,kGAAkG;IAClG,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,cAAc,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC,CAAA;CAC9F;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;gBAEpC,OAAO,GAAE,sBAA2B;IAIhD,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAWhC,IAAI,IAAI,aAAa,CAAC;QACpB,EAAE,EAAE,MAAM,CAAA;QACV,WAAW,EAAE,MAAM,CAAA;QACnB,OAAO,EAAE,MAAM,CAAA;QACf,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;KACtB,CAAC;IASI,GAAG,CACP,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,gBAAgB,CAAC;IAS5B;;;;;;;;;;OAUG;IACI,SAAS,CACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,eAAoB,GAC5B,cAAc,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,CAAC;IAyI9C,OAAO,CAAC,cAAc;IAatB,OAAO,CAAC,UAAU;CAyBnB"}

package/dist/analyst/steer-firewall.d.ts

@@ -0,0 +1,35 @@
+import type { AnalystFinding } from './types';
+/** 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. */
+export 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. */
+export 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.
+ */
+export declare function assertNoJudgeVerdict(findings: ReadonlyArray<AnalystFinding>, context?: string): ReadonlyArray<AnalystFinding>;
+//# sourceMappingURL=steer-firewall.d.ts.map

package/dist/analyst/steer-firewall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steer-firewall.d.ts","sourceRoot":"","sources":["../../src/analyst/steer-firewall.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,SAAS,CAAA;AAU1D;;;;;;;wBAOwB;AACxB,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAElE;AAED;;kCAEkC;AAClC,wBAAgB,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAE/D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,aAAa,CAAC,cAAc,CAAC,EACvC,OAAO,SAAU,GAChB,aAAa,CAAC,cAAc,CAAC,CAW/B"}

package/dist/analyst/steer-firewall.test.d.ts

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

package/dist/analyst/steer-firewall.test.d.ts.map

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

package/dist/analyst/structure-findings.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `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).
+ */
+import { type LlmClientOptions } from '../llm-client';
+import { type AnalystFinding } from './types';
+export 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'];
+}
+export interface StructureFindingsResult {
+    findings: AnalystFinding[];
+    outcome: 'ok' | 'extraction_failed';
+}
+export declare function structureFindings(opts: StructureFindingsOptions): Promise<StructureFindingsResult>;
+//# sourceMappingURL=structure-findings.d.ts.map

package/dist/analyst/structure-findings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structure-findings.d.ts","sourceRoot":"","sources":["../../src/analyst/structure-findings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAW,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAG9D,OAAO,EAAE,KAAK,cAAc,EAAe,MAAM,SAAS,CAAA;AAE1D,MAAM,WAAW,wBAAwB;IACvC,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,4DAA4D;IAC5D,SAAS,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;CACtC;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,cAAc,EAAE,CAAA;IAC1B,OAAO,EAAE,IAAI,GAAG,mBAAmB,CAAA;CACpC;AAmDD,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,wBAAwB,GAC7B,OAAO,CAAC,uBAAuB,CAAC,CAyBlC"}

package/dist/analyst/structure-findings.test.d.ts

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

package/dist/analyst/structure-findings.test.d.ts.map

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