@tangle-network/agent-eval 0.94.0 → 0.95.0

package/dist/chunk-Q5LIB7BC.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/analyst/finding-subject.ts","../src/analyst/parse-tolerant.ts","../src/analyst/finding-signature.ts","../src/analyst/structure-findings.ts","../src/analyst/kind-factory.ts","../src/analyst/tool-groups.ts","../src/analyst/kinds/failure-mode.ts","../src/analyst/kinds/improvement.ts","../src/analyst/kinds/knowledge-gap.ts","../src/analyst/kinds/knowledge-poisoning.ts","../src/analyst/kinds/index.ts","../src/analyst/registry.ts"],"sourcesContent":["/**\n * Typed `FindingSubject` — the canonical grammar every analyst kind emits.\n *\n * Background: kind actor prompts have always documented a subject grammar\n * (e.g. `system-prompt:<section>`, `agent-knowledge:wiki:<slug>`) but the\n * LLM was unconstrained — it could emit `subject: \"fix the prompt\"`\n * (prose) and downstream adapters routed on `startsWith(...)` would\n * silently skip it. Every per-vertical `ImprovementAdapter` had a\n * routing table that mostly caught nothing.\n *\n * This module fixes that:\n *   - `parseFindingSubject(raw)` — returns the typed `FindingSubject`\n *     when `raw` matches the grammar, else `null`. Used at the\n *     `RawAnalystFindingSchema` boundary so malformed subjects are\n *     rejected loudly instead of silently lifted into the registry.\n *   - `FindingSubjectKind` — the union of valid locus categories. Each\n *     variant carries the typed components downstream adapters resolve\n *     against the agent's surface manifest (no string parsing in the\n *     adapter).\n *   - `FINDING_SUBJECT_GRAMMAR_PROMPT` — single source of truth for the\n *     grammar string embedded in kind actor prompts. Drift between\n *     prompt and parser is impossible if every kind imports this.\n *\n * The grammar is intentionally NARROW — only loci the substrate's\n * default `ImprovementAdapter` / `KnowledgeAdapter` can act on. A\n * finding with a subject outside this set fails the parser; the kind\n * author either extends the grammar here (and adds adapter routing)\n * or rephrases the prompt to map onto an existing variant.\n *\n * `failure-mode` is the one exception — its subjects are free-form\n * cluster labels, not loci. The schema preserves them as\n * `{ kind: 'cluster', label }` and the adapters skip them (cluster\n * findings are evidence, not actionable mutations).\n */\n\nimport { z } from 'zod'\n\n// ── canonical grammar ─────────────────────────────────────────────────\n\n/**\n * Discriminated union of every locus the substrate can route findings to.\n *\n * Adapters narrow on `kind` and use the typed components (no string\n * parsing). Adding a variant here REQUIRES updating the parser, the\n * grammar prompt, and at least one adapter — by design.\n */\nexport type FindingSubject =\n  // ── agent-knowledge:* — routed to the KnowledgeAdapter ──\n  | { kind: 'knowledge.wiki'; slug: string; heading?: string }\n  | { kind: 'knowledge.claim'; topic: string }\n  | { kind: 'knowledge.raw'; sourceId: string }\n  | { kind: 'knowledge.stale'; slug: string }\n  // ── system-prompt / tool / new-tool / rag / memory / scaffolding / output-schema ──\n  // routed to the ImprovementAdapter\n  | { kind: 'system-prompt'; section: string }\n  | { kind: 'tool-doc'; tool: string; aspect?: string }\n  | { kind: 'new-tool'; name: string }\n  | { kind: 'rag'; corpus: string; docId: string }\n  | { kind: 'memory'; key: string }\n  | { kind: 'scaffolding'; concern: string }\n  | { kind: 'output-schema'; field: string }\n  // ── websearch / prior-run-summary — routed to the KnowledgeAdapter as stale signals\n  | { kind: 'websearch.outdated'; topic: string }\n  | { kind: 'prior-run-summary'; topic: string }\n  // ── failure-mode cluster label — preserved verbatim, not routed\n  | { kind: 'cluster'; label: string }\n\nexport type FindingSubjectKind = FindingSubject['kind']\n\nexport const FINDING_SUBJECT_KINDS: ReadonlyArray<FindingSubjectKind> = [\n  'knowledge.wiki',\n  'knowledge.claim',\n  'knowledge.raw',\n  'knowledge.stale',\n  'system-prompt',\n  'tool-doc',\n  'new-tool',\n  'rag',\n  'memory',\n  'scaffolding',\n  'output-schema',\n  'websearch.outdated',\n  'prior-run-summary',\n  'cluster',\n]\n\n// ── parser ────────────────────────────────────────────────────────────\n\n/**\n * Parse a raw subject string emitted by an analyst kind's actor.\n *\n * Returns the typed `FindingSubject` when `raw` matches the grammar,\n * else `null`. Callers use the `null` return as a signal to either\n * (a) reject the finding at parse time (kinds that emit typed loci —\n * knowledge-gap, improvement, knowledge-poisoning) or (b) lift it as\n * a cluster label (failure-mode).\n *\n * Slugs are constrained to `[a-z0-9-]+` (lowercase kebab) to keep file\n * paths sane downstream. Topics / keys / sections allow any non-empty\n * string (free-form for the LLM's voice) but get trimmed.\n *\n * Empty / whitespace-only inputs return `null`. `undefined` returns\n * `null`. Both are surfaced by the caller as a rejected subject.\n */\nexport function parseFindingSubject(raw: string | null | undefined): FindingSubject | null {\n  if (raw === null || raw === undefined) return null\n  const trimmed = raw.trim()\n  if (trimmed.length === 0) return null\n\n  // agent-knowledge:wiki:<slug>[#<heading>]\n  const wiki = trimmed.match(\n    /^agent-knowledge:wiki:([a-z0-9][a-z0-9-]*)(?:#([a-z0-9][a-z0-9-]*))?$/,\n  )\n  if (wiki)\n    return { kind: 'knowledge.wiki', slug: wiki[1]!, ...(wiki[2] ? { heading: wiki[2] } : {}) }\n\n  // agent-knowledge:claim:<topic>\n  const claim = trimmed.match(/^agent-knowledge:claim:(.+)$/)\n  if (claim && claim[1]!.trim().length > 0)\n    return { kind: 'knowledge.claim', topic: claim[1]!.trim() }\n\n  // agent-knowledge:raw:<source-id>\n  const raw_ = trimmed.match(/^agent-knowledge:raw:(.+)$/)\n  if (raw_ && raw_[1]!.trim().length > 0)\n    return { kind: 'knowledge.raw', sourceId: raw_[1]!.trim() }\n\n  // agent-knowledge:stale:<slug>\n  const stale = trimmed.match(/^agent-knowledge:stale:([a-z0-9][a-z0-9-]*)$/)\n  if (stale) return { kind: 'knowledge.stale', slug: stale[1]! }\n\n  // system-prompt:<section>\n  const sp = trimmed.match(/^system-prompt:(.+)$/)\n  if (sp && sp[1]!.trim().length > 0) return { kind: 'system-prompt', section: sp[1]!.trim() }\n\n  // tool-doc:<tool>[:<aspect>]\n  const tdAspect = trimmed.match(/^tool-doc:([a-z0-9][a-z0-9_-]*):(.+)$/)\n  if (tdAspect && tdAspect[2]!.trim().length > 0) {\n    return { kind: 'tool-doc', tool: tdAspect[1]!, aspect: tdAspect[2]!.trim() }\n  }\n  const td = trimmed.match(/^tool-doc:([a-z0-9][a-z0-9_-]*)$/)\n  if (td) return { kind: 'tool-doc', tool: td[1]! }\n\n  // new-tool:<name>\n  const nt = trimmed.match(/^new-tool:([a-z0-9][a-z0-9_-]*)$/)\n  if (nt) return { kind: 'new-tool', name: nt[1]! }\n\n  // rag:<corpus>:<doc-id>\n  const rag = trimmed.match(/^rag:([a-z0-9][a-z0-9_-]*):(.+)$/)\n  if (rag && rag[2]!.trim().length > 0) {\n    return { kind: 'rag', corpus: rag[1]!, docId: rag[2]!.trim() }\n  }\n\n  // memory:<key>\n  const mem = trimmed.match(/^memory:(.+)$/)\n  if (mem && mem[1]!.trim().length > 0) return { kind: 'memory', key: mem[1]!.trim() }\n\n  // scaffolding:<concern>\n  const sc = trimmed.match(/^scaffolding:(.+)$/)\n  if (sc && sc[1]!.trim().length > 0) return { kind: 'scaffolding', concern: sc[1]!.trim() }\n\n  // output-schema:<field>\n  const os = trimmed.match(/^output-schema:(.+)$/)\n  if (os && os[1]!.trim().length > 0) return { kind: 'output-schema', field: os[1]!.trim() }\n\n  // websearch:outdated:<topic>\n  const ws = trimmed.match(/^websearch:outdated:(.+)$/)\n  if (ws && ws[1]!.trim().length > 0) return { kind: 'websearch.outdated', topic: ws[1]!.trim() }\n\n  // prior-run-summary:<topic>\n  const prs = trimmed.match(/^prior-run-summary:(.+)$/)\n  if (prs && prs[1]!.trim().length > 0) return { kind: 'prior-run-summary', topic: prs[1]!.trim() }\n\n  // cluster (no prefix — a free-form evidence label, never a routed locus, so\n  // it admits dotted/underscored identifiers like `appworld.task.530b157_1`.\n  // ':' stays excluded so it cannot collide with the prefixed grammars above.)\n  if (/^[a-z0-9][a-z0-9._-]*$/.test(trimmed) && trimmed.length <= 80) {\n    return { kind: 'cluster', label: trimmed }\n  }\n\n  return null\n}\n\n/**\n * Render the parsed subject back to its canonical string form. Inverse\n * of `parseFindingSubject`; useful when the substrate constructs new\n * findings programmatically (e.g. for tests, replays, or\n * `id_basis` carry-forward).\n */\nexport function renderFindingSubject(s: FindingSubject): string {\n  switch (s.kind) {\n    case 'knowledge.wiki':\n      return s.heading\n        ? `agent-knowledge:wiki:${s.slug}#${s.heading}`\n        : `agent-knowledge:wiki:${s.slug}`\n    case 'knowledge.claim':\n      return `agent-knowledge:claim:${s.topic}`\n    case 'knowledge.raw':\n      return `agent-knowledge:raw:${s.sourceId}`\n    case 'knowledge.stale':\n      return `agent-knowledge:stale:${s.slug}`\n    case 'system-prompt':\n      return `system-prompt:${s.section}`\n    case 'tool-doc':\n      return s.aspect ? `tool-doc:${s.tool}:${s.aspect}` : `tool-doc:${s.tool}`\n    case 'new-tool':\n      return `new-tool:${s.name}`\n    case 'rag':\n      return `rag:${s.corpus}:${s.docId}`\n    case 'memory':\n      return `memory:${s.key}`\n    case 'scaffolding':\n      return `scaffolding:${s.concern}`\n    case 'output-schema':\n      return `output-schema:${s.field}`\n    case 'websearch.outdated':\n      return `websearch:outdated:${s.topic}`\n    case 'prior-run-summary':\n      return `prior-run-summary:${s.topic}`\n    case 'cluster':\n      return s.label\n  }\n}\n\n// ── grammar prompt — single source of truth for actor instructions ──\n\n/**\n * The grammar text embedded into kind actor prompts. Kinds opt into\n * the subset of variants they emit (e.g. `improvement` excludes the\n * cluster variant; `failure-mode` includes ONLY the cluster variant).\n *\n * Drift between prompt and parser is impossible: every kind imports\n * this constant + the matching `expects` set, and the unit tests below\n * lock the table to the parser.\n */\nexport const FINDING_SUBJECT_GRAMMAR_PROMPT = [\n  'Subjects MUST match this grammar — anything else is rejected at parse time and your work is wasted:',\n  '',\n  '  Knowledge loci (write to the agent-knowledge base):',\n  '    agent-knowledge:wiki:<slug>[#<heading>]   create / update a wiki page',\n  '    agent-knowledge:claim:<topic>             draft a claim / relation triple',\n  '    agent-knowledge:raw:<source-id>           lift a raw source into a curated page',\n  '    agent-knowledge:stale:<slug>              mark a page superseded',\n  '',\n  '  Runtime mutable surfaces (write to prompts / tools / scaffolding):',\n  '    system-prompt:<section>                   add / replace a system-prompt section',\n  '    tool-doc:<tool>[:<aspect>]                rewrite a tool description',\n  '    new-tool:<name>                           propose a new tool surface',\n  '    rag:<corpus>:<doc-id>                     ingest / correct a RAG document',\n  '    memory:<key>                              invalidate / set a memory entry',\n  '    scaffolding:<concern>                     change a precondition / retry / verifier',\n  '    output-schema:<field>                     constrain the agent output shape',\n  '',\n  '  Stale signals (knowledge-poisoning only):',\n  '    websearch:outdated:<topic>                stale web result',\n  '    prior-run-summary:<topic>                 stale prior-run summary',\n  '',\n  '  Cluster label (failure-mode only):',\n  '    <kebab-case-label>                        short cluster id, e.g. \"tool-call-loop\"',\n  '',\n  'Slugs / tool ids: [a-z0-9-]+ (lowercase kebab). Topics / keys / sections: free-form, trimmed.',\n].join('\\n')\n\n// ── kind expects sets ─────────────────────────────────────────────────\n\n/**\n * The variants each kind is allowed to emit. Used at the kind factory\n * boundary so a knowledge-gap finding can't sneak in a `system-prompt:*`\n * subject (the improvement-analyst's job) and vice versa.\n *\n * `failure-mode` is restricted to `cluster` — the only kind that emits\n * a non-locus subject.\n */\nexport const KIND_EXPECTED_SUBJECTS: Record<string, ReadonlyArray<FindingSubjectKind>> = {\n  'failure-mode': ['cluster'],\n  'knowledge-gap': [\n    'knowledge.wiki',\n    'knowledge.claim',\n    'knowledge.raw',\n    'knowledge.stale',\n    'tool-doc',\n    'system-prompt',\n    'memory',\n    'websearch.outdated',\n    'prior-run-summary',\n  ],\n  'knowledge-poisoning': [\n    'knowledge.wiki',\n    'knowledge.claim',\n    'knowledge.raw',\n    'tool-doc',\n    'system-prompt',\n    'memory',\n    'websearch.outdated',\n    'prior-run-summary',\n  ],\n  improvement: [\n    'system-prompt',\n    'tool-doc',\n    'new-tool',\n    'rag',\n    'memory',\n    'scaffolding',\n    'output-schema',\n    'knowledge.wiki',\n    'knowledge.claim',\n  ],\n}\n\n// ── Zod schema for boundary validation ───────────────────────────────\n\n/**\n * Zod schema that validates a raw subject string and returns the parsed\n * `FindingSubject`. Embedded in `RawAnalystFindingSchema` via\n * `transform`, so `subject` arrives at the kind factory either as a\n * typed locus or as a parse error attached to a single Zod issue.\n *\n * Optionality is preserved: subjects ARE optional on the wire (some\n * findings are descriptive, not actionable). When present, they MUST\n * parse — emitting a malformed subject is a contract violation, not a\n * soft signal.\n */\nexport const FindingSubjectStringSchema = z\n  .string()\n  .refine((s) => parseFindingSubject(s) !== null, {\n    message: 'subject does not match the finding-subject grammar',\n  })\n","/**\n * Forgiving pre-parse for analyst findings. Weak models routinely emit\n * schema-correct content in an unusable wrapper — fenced ```json blocks, a\n * single object where an array is expected, trailing commas. Measured: GPT-4o\n * drops to 0% usable output purely from markdown-fence wrapping\n * (arXiv:2605.02363). A five-line de-fence recovers most of it. This module is\n * the de-fence/coerce step that runs BEFORE Zod, so a recoverable finding is\n * repaired, not dropped.\n *\n * Pure + deterministic. No model, no network.\n */\n\n/** Strip a ```lang ... ``` (or bare ``` ... ```) code fence, if the string is one. */\nexport function stripCodeFences(text: string): string {\n  const t = text.trim()\n  const fence = /^```[a-zA-Z0-9]*\\s*\\n?([\\s\\S]*?)\\n?```$/\n  const m = t.match(fence)\n  return m ? m[1]!.trim() : t\n}\n\n/** Remove trailing commas before } or ] — the most common near-JSON defect. */\nfunction dropTrailingCommas(s: string): string {\n  return s.replace(/,(\\s*[}\\]])/g, '$1')\n}\n\n/**\n * Best-effort parse of a string into JSON. De-fences, drops trailing commas,\n * then `JSON.parse`. Returns `undefined` (never throws) when unrecoverable.\n */\nexport function coerceJson(text: string): unknown {\n  const candidate = dropTrailingCommas(stripCodeFences(text))\n  try {\n    return JSON.parse(candidate)\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Coerce arbitrary actor/structurer output into an array of candidate finding\n * rows: a JSON string → parse; a single object → 1-element array; an array →\n * as-is; anything else → []. Callers still run each row through Zod\n * (`parseRawFinding`) — this only fixes the SHAPE, never invents fields.\n */\nexport function coerceToFindingRows(raw: unknown): unknown[] {\n  let value = raw\n  if (typeof value === 'string') {\n    const parsed = coerceJson(value)\n    if (parsed === undefined) return []\n    value = parsed\n  }\n  if (Array.isArray(value)) return value\n  if (value && typeof value === 'object') {\n    // Some models wrap the array as { findings: [...] } — unwrap that one case.\n    const inner = (value as Record<string, unknown>).findings\n    if (Array.isArray(inner)) return inner\n    return [value]\n  }\n  return []\n}\n","/**\n * Typed Ax output for analyst findings.\n *\n * Replaces the legacy `findings:string[]` pattern (where every bullet\n * became a flat-severity `AnalystFinding`) with a structured object\n * array. Ax binds the field as `findings:json[]` so the provider emits\n * native structured output; at the kind-factory boundary we Zod-validate\n * each emitted finding so malformed rows fail loud instead of being\n * silently lifted with default severity.\n *\n * Why not `f.object().array()` directly in the signature? The Ax\n * signature string `question:string -> findings:json[]` already lets\n * the provider emit JSON arrays. A Zod boundary is required either\n * way (the provider can return any JSON), and Zod gives us a single\n * validation surface independent of which Ax version is installed.\n */\n\nimport { z } from 'zod'\nimport { parseFindingSubject } from './finding-subject'\nimport { coerceJson } from './parse-tolerant'\n\nexport const ANALYST_SEVERITIES = ['critical', 'high', 'medium', 'low', 'info'] as const\n\nexport const RawAnalystFindingSchema = z\n  .object({\n    severity: z.enum(ANALYST_SEVERITIES),\n    claim: z.string().min(1).max(2000),\n    /**\n     * Subject locus the finding is about. Validated at parse time\n     * against the documented grammar (`finding-subject.ts`). Findings\n     * with a malformed subject are rejected — they would have been\n     * silently skipped by every downstream adapter, so failing loud at\n     * parse time turns a hidden no-op into a kind-prompt audit signal.\n     *\n     * Optional because purely descriptive findings (no actionable\n     * locus) are legitimate; they just don't route through the\n     * KnowledgeAdapter / ImprovementAdapter.\n     */\n    subject: z\n      .string()\n      .max(400)\n      .refine((s) => parseFindingSubject(s) !== null, {\n        message: 'subject does not match the finding-subject grammar',\n      })\n      .optional(),\n    evidence_uri: z.string().min(1).max(2000),\n    evidence_excerpt: z.string().max(2000).optional(),\n    confidence: z.number().min(0).max(1),\n    rationale: z.string().max(4000).optional(),\n    recommended_action: z.string().max(2000).optional(),\n  })\n  .strict()\n\nexport type RawAnalystFinding = z.infer<typeof RawAnalystFindingSchema>\n\n/**\n * Description embedded into the actor prompt so the LLM knows what\n * shape to emit. Kept here so kinds share one source of truth rather\n * than restating the schema in every prompt.\n */\nexport 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 — 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) — 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 — 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 ...\") — omit when the finding is purely descriptive\n\nEmit an empty array when the question has no findings to report. Do not fabricate evidence.`\n\n/**\n * Validate one row emitted by the LLM. Returns the typed finding on\n * success; returns `null` and logs the reason on failure so the kind\n * factory can skip-and-count rather than abort the whole analyst run.\n */\nexport function parseRawFinding(\n  row: unknown,\n  log?: (msg: string, fields?: Record<string, unknown>) => void,\n): RawAnalystFinding | null {\n  const result = RawAnalystFindingSchema.safeParse(row)\n  if (result.success) return result.data\n  // A schema-correct finding in an unusable wrapper (a JSON string, a fenced\n  // block) should be repaired, not dropped. Coerce the shape and retry ONCE.\n  if (typeof row === 'string') {\n    const coerced = coerceJson(row)\n    if (coerced !== undefined) {\n      const retry = RawAnalystFindingSchema.safeParse(coerced)\n      if (retry.success) return retry.data\n    }\n  }\n  log?.('finding rejected: schema failure', {\n    issues: result.error.issues.map((i) => ({\n      path: i.path.join('.'),\n      code: i.code,\n      message: i.message,\n    })),\n  })\n  return null\n}\n","/**\n * `structureFindings` — the deferred structuring pass (DSPy TwoStepAdapter /\n * HALO `synthesize_traces` analog). The agentic actor reasons FREE-FORM and\n * emits a prose `report` (which any model does reliably); this separate, cheap\n * call's ONLY job is to turn that report into `AnalystFinding[]`. Decoupling\n * reasoning from structuring is what makes the SEMANTIC findings model-agnostic\n * — the reasoning model never has to satisfy a strict typed-array contract\n * while it diagnoses.\n *\n * Forgiving: the response runs through `coerceToFindingRows` (de-fence, lift\n * single→array) before Zod, and on a zero-finding extraction from a substantive\n * report it reasks ONCE with the schema restated. Returns a typed outcome so a\n * legitimate \"nothing to report\" is distinguishable from a failed extraction\n * (no silent empty).\n */\n\nimport { callLlm, type LlmClientOptions } from '../llm-client'\nimport { parseRawFinding, type RawAnalystFinding } from './finding-signature'\nimport { coerceToFindingRows } from './parse-tolerant'\nimport { type AnalystFinding, makeFinding } from './types'\n\nexport interface StructureFindingsOptions {\n  /** The actor's free-form diagnosis prose. */\n  report: string\n  analystId: string\n  /** Coarse classification stamped on every extracted finding. */\n  area: string\n  model: string\n  baseUrl: string\n  apiKey?: string\n  /** Max reask attempts after a zero/invalid extraction. Default 1. */\n  maxReasks?: number\n  /** Test seam: inject a fetch (no network in unit tests). */\n  fetchImpl?: LlmClientOptions['fetch']\n}\n\nexport interface StructureFindingsResult {\n  findings: AnalystFinding[]\n  outcome: 'ok' | 'extraction_failed'\n}\n\nconst SYSTEM = [\n  'You convert a free-form trace-analysis report into a STRICT JSON array of findings.',\n  'Output ONLY the JSON array — no prose, no code fences.',\n  'Each element: {\"severity\":\"critical|high|medium|low|info\",\"claim\":string,\"evidence_uri\":string,',\n  '\"subject\"?:string,\"rationale\"?:string,\"recommended_action\"?:string,\"confidence\":number(0..1)}.',\n  'evidence_uri cites the trace element the report referenced (e.g. \"span://<trace>/<span>\") or \"report://summary\".',\n  'If the report asserts NO problems, output exactly [].',\n].join(' ')\n\nfunction buildRows(raw: unknown, analystId: string, area: string): AnalystFinding[] {\n  const rows = coerceToFindingRows(raw)\n  const out: AnalystFinding[] = []\n  for (const row of rows) {\n    // Recovery findings are extracted from PROSE — the report itself is the\n    // evidence. A weak model often returns a sound claim + severity but omits\n    // `evidence_uri`; default it to the report rather than dropping the row\n    // (the strict evidence_uri requirement is a recovery yield-killer).\n    const normalized =\n      row &&\n      typeof row === 'object' &&\n      !Array.isArray(row) &&\n      !(row as Record<string, unknown>).evidence_uri\n        ? { ...(row as Record<string, unknown>), evidence_uri: 'report://summary' }\n        : row\n    const parsed: RawAnalystFinding | null = parseRawFinding(normalized)\n    if (!parsed) continue\n    out.push(\n      makeFinding({\n        analyst_id: analystId,\n        area,\n        subject: parsed.subject,\n        claim: parsed.claim,\n        rationale: parsed.rationale,\n        severity: parsed.severity,\n        confidence: parsed.confidence,\n        evidence_refs: [\n          {\n            kind: parsed.evidence_uri.startsWith('span://') ? 'span' : 'artifact',\n            uri: parsed.evidence_uri,\n            excerpt: parsed.evidence_excerpt,\n          },\n        ],\n        recommended_action: parsed.recommended_action,\n      }),\n    )\n  }\n  return out\n}\n\nexport async function structureFindings(\n  opts: StructureFindingsOptions,\n): Promise<StructureFindingsResult> {\n  const maxReasks = opts.maxReasks ?? 1\n  const llm = { baseUrl: opts.baseUrl, apiKey: opts.apiKey, fetch: opts.fetchImpl }\n  let user = `TRACE-ANALYSIS REPORT:\\n${opts.report}\\n\\nReturn the findings JSON array.`\n\n  for (let attempt = 0; attempt <= maxReasks; attempt++) {\n    const res = await callLlm(\n      {\n        model: opts.model,\n        messages: [\n          { role: 'system', content: SYSTEM },\n          { role: 'user', content: user },\n        ],\n      },\n      llm,\n    )\n    const text = res.content.trim()\n    const findings = buildRows(text, opts.analystId, opts.area)\n    if (findings.length > 0) return { findings, outcome: 'ok' }\n    // A report that asserts nothing is a legitimate empty — only reask when the\n    // report is substantive (the extraction, not the diagnosis, likely failed).\n    if (opts.report.trim().length < 200) return { findings: [], outcome: 'ok' }\n    user = `${user}\\n\\nThat produced no valid findings. The report DOES describe issues — re-extract them as the strict JSON array described in the system prompt. Output ONLY the array.`\n  }\n  return { findings: [], outcome: 'extraction_failed' }\n}\n","/**\n * Analyst-kind factory — the typed, focused replacement for the\n * legacy `createTraceAnalystAdapter`.\n *\n * A \"kind\" is a specialized analyst whose actor prompt, tool subset,\n * and Ax recursion config target one failure-mode lens (failure-mode\n * classification, knowledge gap discovery, knowledge poisoning, recursive\n * self-improvement, ...). Kinds emit findings in the typed `RawAnalystFinding`\n * shape via a JSON-array Ax output; the factory validates each row with\n * Zod and lifts it into `AnalystFinding[]` with no shape guessing.\n *\n * Composition rules:\n *   - Each kind owns its actor description. No generic \"answer this\n *     question\" prompt — the prompt names the failure lens.\n *   - Each kind picks a narrow tool subset from `ANALYST_TOOL_GROUPS`.\n *     A kind that never needs full-trace dumps can drop `viewTrace` /\n *     `viewSpans` and stay cheap.\n *   - Each kind declares its recursion + parallelism budget. Discovery-\n *     heavy kinds (failure-mode) get higher `maxDepth`; lens kinds\n *     (poisoning) usually stay at 0 since they have a tighter brief.\n *\n * Optimizer hook: kinds may declare `goldens` — labeled examples used\n * by `AxMiPRO` / `AxBootstrapFewShot` / `AxGEPA` to fit the actor\n * description programmatically. Stored on the kind, not the registry,\n * because the right metric is kind-specific.\n */\n\nimport type { AxAIService, AxFunction } from '@ax-llm/ax'\nimport { AxJSRuntime, agent } from '@ax-llm/ax'\nimport type { TraceAnalysisStore } from '../trace-analyst/store'\nimport { TraceFileMissingError } from '../trace-analyst/store-otlp'\nimport {\n  parseRawFinding,\n  RAW_FINDING_SCHEMA_PROMPT,\n  type RawAnalystFinding,\n} from './finding-signature'\nimport { KIND_EXPECTED_SUBJECTS, parseFindingSubject } from './finding-subject'\nimport { structureFindings } from './structure-findings'\nimport type { Analyst, AnalystContext, AnalystCost, AnalystFinding } from './types'\nimport { makeFinding } from './types'\n\n/**\n * Per-kind specification. The factory turns this into a regular\n * `Analyst<TraceAnalysisStore>` ready for `AnalystRegistry.register()`.\n */\nexport interface TraceAnalystKindSpec {\n  /** Stable id. Appears in finding_id, telemetry, and registry exclusions. */\n  id: string\n  /** One-sentence description shown in `registry.list()`. */\n  description: string\n  /** Coarse classification stamped on every emitted finding (`failure-mode`, `knowledge-gap`, ...). */\n  area: string\n  /** Bump on any breaking change to the actor prompt or output schema. */\n  version: string\n  /** Actor system prompt. Must instruct the LLM to emit `findings` per the schema. */\n  actorDescription: string\n  /** Responder system prompt; falls back to a minimal \"format the findings\" instruction. */\n  responderDescription?: string\n  /** Tool functions the actor may call. Pick narrow subsets via `ANALYST_TOOL_GROUPS`. */\n  buildTools: (store: TraceAnalysisStore) => AxFunction[]\n  /** Recursion budget. `maxDepth: 0` disables subagents. */\n  recursion?: { maxDepth: number; maxParallelSubagents?: number }\n  /** Actor turn cap. Default 12. */\n  maxTurns?: number\n  /** Runtime char cap. Default 6000. */\n  maxRuntimeChars?: number\n  /** Cost classification surfaced in `registry.list()` and budget enforcement. */\n  cost: AnalystCost\n  /** Per-finding-row hook — kinds may reject / rewrite before lifting. */\n  postProcess?: (row: RawAnalystFinding, ctx: AnalystContext) => RawAnalystFinding | null\n  /** Optional optimizer hook — populated when a kind wants to fit its prompt against labeled examples. */\n  goldens?: TraceAnalystGolden[]\n}\n\n/**\n * One labeled example consumed by Ax optimizers (MIPRO / GEPA / Bootstrap).\n * Each input is the same `{question}` an analyst would receive; `expected`\n * is the ground-truth finding set a fitted prompt should produce on this\n * input. Metric: kind-specific (default: F1 on `finding_id` overlap).\n */\nexport interface TraceAnalystGolden {\n  question: string\n  expected: ReadonlyArray<Omit<RawAnalystFinding, 'confidence'>>\n}\n\nexport interface CreateTraceAnalystKindOpts {\n  /** AxAIService bound at registration time. */\n  ai: AxAIService\n  /** Optional model override; falls back to the AI service's default. */\n  model?: string\n  /** Override the spec's `version` (e.g. when an optimizer has fitted a new prompt). */\n  versionSuffix?: string\n  /**\n   * Optional two-phase recovery: when the agentic harvest is empty but the\n   * actor produced a substantive free-form `report`, extract findings from that\n   * prose via a tolerant chat-completions pass (`structureFindings`) — no\n   * strict-emission contract, so it works on weak models. Omit to leave the\n   * actor's harvest as-is (the report is still surfaced fail-loud either way).\n   */\n  recovery?: { baseUrl: string; apiKey?: string; model?: string; fetchImpl?: typeof fetch }\n}\n\n/**\n * Build an `Analyst<TraceAnalysisStore>` from a kind spec.\n *\n * Lifts the Ax pipeline once at registration time so the registry\n * gets a stateless analyst. The Ax agent is freshly constructed per\n * `analyze()` call (the agent carries chat-log + usage state we don't\n * want shared across analyst runs).\n */\nexport function createTraceAnalystKind(\n  spec: TraceAnalystKindSpec,\n  opts: CreateTraceAnalystKindOpts,\n): Analyst<TraceAnalysisStore> {\n  const version = opts.versionSuffix ? `${spec.version}+${opts.versionSuffix}` : spec.version\n  return {\n    id: spec.id,\n    description: spec.description,\n    inputKind: 'trace-store',\n    cost: spec.cost,\n    version,\n    async analyze(store, ctx) {\n      const tools = spec.buildTools(store)\n      const maxDepth = spec.recursion?.maxDepth ?? 0\n      const maxParallel = spec.recursion?.maxParallelSubagents ?? 2\n      const priorContext = renderPriorFindings(ctx.priorFindings)\n\n      const actorDescription =\n        spec.actorDescription.trim() +\n        priorContext +\n        '\\n\\n' +\n        RAW_FINDING_SCHEMA_PROMPT +\n        '\\n\\nFirst write `report`: a concise free-form prose diagnosis of what ' +\n        'the traces show — what succeeded, what was suboptimal or failed — with ' +\n        'concrete trace ids and numbers. THEN return the structured `findings` ' +\n        'array (it MAY be empty when there is nothing to report). Use `final(...)` ' +\n        'with the `{ report, findings }` payload when you are done.'\n\n      const ax = agent<{ question: string }, { report: string; findings: unknown[] }>(\n        'question:string -> report:string, findings:json[]',\n        {\n          agentIdentity: {\n            name: spec.id,\n            description: spec.description,\n          },\n          contextFields: ['question'],\n          runtime: new AxJSRuntime({\n            permissions: [],\n            blockDynamicImport: true,\n            allowedModules: [],\n            freezeIntrinsics: true,\n            blockShadowRealm: true,\n            preventGlobalThisExtensions: false,\n          }),\n          mode: maxDepth > 0 ? 'advanced' : 'simple',\n          recursionOptions: maxDepth > 0 ? { maxDepth } : undefined,\n          maxTurns: spec.maxTurns ?? 12,\n          maxRuntimeChars: spec.maxRuntimeChars ?? 6000,\n          maxBatchedLlmQueryConcurrency: maxParallel,\n          promptLevel: 'detailed',\n          // Trace analysis depends on exact prior tool results and runtime variables.\n          contextPolicy: { preset: 'full', budget: 'balanced' },\n          functions: { local: tools },\n          actorOptions: {\n            description: actorDescription,\n            ...(opts.model ? { model: opts.model } : {}),\n            showThoughts: false,\n            thinkingTokenBudget: 'none',\n          },\n          responderOptions: {\n            description:\n              spec.responderDescription ??\n              \"Pass through the actor's `report` prose verbatim, and format the `findings` array exactly as the actor produced it. Do not add, drop, or summarize entries.\",\n            ...(opts.model ? { model: opts.model } : {}),\n            showThoughts: false,\n          },\n          bubbleErrors: [TraceFileMissingError],\n        },\n      )\n\n      ctx.log?.(`analyst.kind ${spec.id} forward`, {\n        max_depth: maxDepth,\n        tool_count: tools.length,\n        tags: ctx.tags,\n      })\n\n      const result = await ax.forward(opts.ai, { question: deriveQuestion(ctx, spec) })\n\n      const expectedSubjects = KIND_EXPECTED_SUBJECTS[spec.id]\n      const out: AnalystFinding[] = []\n      const rawRows = Array.isArray(result.findings) ? result.findings : []\n      let rejectedWrongKind = 0\n      for (const row of rawRows) {\n        const parsed = parseRawFinding(row, ctx.log)\n        if (!parsed) continue\n        // Subject-grammar check: if the kind has a declared expects-set\n        // (every shipped kind does), the finding's subject MUST parse to\n        // one of the declared variants. A wrong-kind subject is a\n        // contract violation — the actor's prompt drifted from the\n        // grammar — and we count it for prompt-audit visibility.\n        if (expectedSubjects && parsed.subject !== undefined) {\n          const parsedSubject = parseFindingSubject(parsed.subject)\n          if (parsedSubject === null) {\n            ctx.log?.('finding rejected: subject failed to parse', {\n              kind: spec.id,\n              subject: parsed.subject,\n            })\n            rejectedWrongKind += 1\n            continue\n          }\n          if (!expectedSubjects.includes(parsedSubject.kind)) {\n            ctx.log?.('finding rejected: subject variant not allowed for this kind', {\n              kind: spec.id,\n              subject_kind: parsedSubject.kind,\n              subject: parsed.subject,\n              allowed: expectedSubjects,\n            })\n            rejectedWrongKind += 1\n            continue\n          }\n        }\n        const postProcessed = spec.postProcess?.(parsed, ctx) ?? parsed\n        if (!postProcessed) continue\n        out.push(toAnalystFinding(spec, postProcessed))\n      }\n\n      ctx.log?.(`analyst.kind ${spec.id} done`, {\n        emitted: rawRows.length,\n        accepted: out.length,\n        rejected_wrong_subject: rejectedWrongKind,\n      })\n\n      // Two-phase recovery / fail-loud. The actor reasons free-form (the\n      // `report`); a weak model often produces a sound diagnosis but fails the\n      // strict findings emission (or the rows get rejected). If the harvest is\n      // empty but the report is substantive, recover findings from the prose\n      // via the tolerant structuring pass (opt-in), and — either way — surface\n      // the report as a visible info finding so an empty harvest is never a\n      // silent zero. A genuinely empty diagnosis (short/no report) stays empty.\n      const report = typeof result.report === 'string' ? result.report : ''\n      if (out.length === 0 && report.trim().length >= 200) {\n        if (opts.recovery) {\n          const recovered = await structureFindings({\n            report,\n            analystId: spec.id,\n            area: spec.area,\n            model: opts.recovery.model ?? opts.model ?? '',\n            baseUrl: opts.recovery.baseUrl,\n            apiKey: opts.recovery.apiKey,\n            fetchImpl: opts.recovery.fetchImpl,\n          })\n          out.push(...recovered.findings)\n          ctx.log?.(`analyst.kind ${spec.id} recovery`, {\n            outcome: recovered.outcome,\n            recovered: recovered.findings.length,\n          })\n        }\n        if (out.length === 0) {\n          out.push(\n            makeFinding({\n              analyst_id: spec.id,\n              area: spec.area,\n              claim: 'Analyst produced a diagnosis but no structured findings — see report.',\n              rationale: report.slice(0, 1500),\n              severity: 'info',\n              confidence: 0.3,\n              evidence_refs: [\n                { kind: 'artifact', uri: 'report://summary', excerpt: report.slice(0, 2000) },\n              ],\n              metadata: { outcome: 'extraction_failed' },\n            }),\n          )\n        }\n      }\n      return out\n    },\n  }\n}\n\nfunction deriveQuestion(ctx: AnalystContext, spec: TraceAnalystKindSpec): string {\n  // The actor's user message must orient it at the task, not echo the kind id.\n  // A bare id like \"failure-mode\" gives the actor nothing to act on, so it\n  // spends turns inspecting the input instead of reading traces. Operators can\n  // still steer with `tags.focus = \"leaf-X\"`, appended to the task directive.\n  const focus = ctx.tags?.focus?.trim()\n  const task = `Analyze this trace dataset with the available tools and report ${spec.area} findings. ${spec.description}`\n  return focus ? `${task} Focus: ${focus}.` : task\n}\n\nfunction toAnalystFinding(spec: TraceAnalystKindSpec, raw: RawAnalystFinding): AnalystFinding {\n  return makeFinding({\n    analyst_id: spec.id,\n    area: spec.area,\n    subject: raw.subject,\n    claim: raw.claim,\n    rationale: raw.rationale,\n    severity: raw.severity,\n    confidence: raw.confidence,\n    evidence_refs: [\n      {\n        kind: evidenceKindFromUri(raw.evidence_uri),\n        uri: raw.evidence_uri,\n        excerpt: raw.evidence_excerpt,\n      },\n    ],\n    recommended_action: raw.recommended_action,\n    metadata: { kind_version: spec.version },\n  })\n}\n\nfunction evidenceKindFromUri(uri: string): 'span' | 'artifact' | 'metric' | 'event' | 'finding' {\n  if (uri.startsWith('span://')) return 'span'\n  if (uri.startsWith('artifact://')) return 'artifact'\n  if (uri.startsWith('metric://')) return 'metric'\n  if (uri.startsWith('event://')) return 'event'\n  if (uri.startsWith('finding://')) return 'finding'\n  return 'artifact'\n}\n\n/**\n * Render a compact prior-findings block the actor reads alongside its\n * brief. Each row is one line so the actor can scan dozens cheaply.\n * The kind's prompt instructs the actor to (a) check whether a new\n * cluster matches a prior `finding_id` (carry the id forward via\n * `id_basis` to keep diffs stable) and (b) raise severity / confidence\n * when a prior finding has reappeared without remediation.\n *\n * Returns the empty string when there are no prior findings — most\n * runs are \"first-of-its-kind\" and the prompt stays unchanged.\n *\n * Exported for tests + for consumers that build their own actor\n * prompts (e.g. specialized analysts living outside the default kinds).\n */\nexport function renderPriorFindings(prior: AnalystContext['priorFindings']): string {\n  if (!prior || prior.length === 0) return ''\n  const MAX_ROWS = 40 // keep the block under ~2KB; older history is summarized externally\n  const rows = prior.slice(0, MAX_ROWS).map((f) => {\n    const subject = f.subject ? ` [${f.subject}]` : ''\n    return `  - id=${f.finding_id} ${f.severity}${subject} ${truncateForContext(f.claim, 160)}`\n  })\n  const overflow =\n    prior.length > MAX_ROWS\n      ? `\\n  ... +${prior.length - MAX_ROWS} more prior findings (older history truncated)`\n      : ''\n  return [\n    '',\n    '',\n    'PRIOR FINDINGS (from a previous run on related data):',\n    'When the work you do now matches a row below, REUSE the `finding_id` (pass it as `id_basis`) so the cross-run diff stays stable.',\n    'A finding that reappears with no remediation evidence SHOULD raise its `confidence` and may justify a higher `severity`.',\n    ...rows,\n    overflow,\n  ]\n    .filter(Boolean)\n    .join('\\n')\n}\n\nfunction truncateForContext(s: string, max: number): string {\n  if (s.length <= max) return s\n  return `${s.slice(0, max - 1).trimEnd()}…`\n}\n","/**\n * Pre-curated tool subsets for analyst kinds.\n *\n * The full trace-analyst tool set is seven functions. Most kinds only\n * need three or four. Picking from named groups instead of importing\n * the whole bundle keeps every kind's actor-context budget tight and\n * makes \"what can this analyst see?\" obvious at registration time.\n *\n * Each function in the group keeps its full `name`/`description` from\n * `buildTraceAnalystTools` — we filter, we don't re-implement.\n */\n\nimport type { AxFunction } from '@ax-llm/ax'\nimport type { TraceAnalysisStore } from '../trace-analyst/store'\nimport { buildTraceAnalystTools } from '../trace-analyst/tools'\n\n/** Named tool sets. Kinds pass `tools: TRACE_TOOL_GROUPS.failureForensics` etc. */\nexport type TraceToolGroupName =\n  /** All seven tools. Use for open-ended discovery kinds. */\n  | 'all'\n  /** Overview + paginated query + count. No deep reads. Cheap. */\n  | 'discovery'\n  /** Discovery + viewTrace + viewSpans. Deep-read but no regex search. */\n  | 'discoveryAndRead'\n  /** Discovery + search tools. For pattern-matching across many traces. */\n  | 'discoveryAndSearch'\n  /** Discovery + viewSpans + searchSpan. Targeted-span work after another kind narrows down. */\n  | 'targeted'\n\nconst TOOL_NAMES_BY_GROUP: Record<TraceToolGroupName, ReadonlySet<string>> = {\n  all: new Set(),\n  discovery: new Set(['getDatasetOverview', 'queryTraces', 'countTraces']),\n  discoveryAndRead: new Set([\n    'getDatasetOverview',\n    'queryTraces',\n    'countTraces',\n    'viewTrace',\n    'viewSpans',\n  ]),\n  discoveryAndSearch: new Set([\n    'getDatasetOverview',\n    'queryTraces',\n    'countTraces',\n    'searchTrace',\n    'searchSpan',\n  ]),\n  targeted: new Set(['getDatasetOverview', 'queryTraces', 'viewSpans', 'searchSpan']),\n}\n\n/**\n * Build the tool set for a named group bound to a specific trace store.\n *\n * `all` returns every tool. Other groups filter `buildTraceAnalystTools`\n * by name to the documented subset. An unrecognised group name throws —\n * silently returning all tools would defeat the cost-control point.\n */\nexport function buildTraceToolsForGroup(\n  group: TraceToolGroupName,\n  store: TraceAnalysisStore,\n): AxFunction[] {\n  const all = buildTraceAnalystTools({ store })\n  if (group === 'all') return all\n  const allow = TOOL_NAMES_BY_GROUP[group]\n  if (!allow) throw new Error(`unknown trace tool group: ${group}`)\n  return all.filter((tool) => allow.has((tool as { name: string }).name))\n}\n","/**\n * Failure-mode analyst — classifies what went wrong and why.\n *\n * Brief: read the trace dataset, identify the top failure modes across\n * runs, classify each with severity + evidence, and surface them as\n * findings. The actor's job is *taxonomy + evidence*, not fix-design —\n * that's the improvement-analyst's job.\n *\n * Recursion is deep (`maxDepth: 3`) because real failure-mode\n * discovery is genuinely tree-shaped: the actor splits the dataset\n * into candidate clusters, each cluster spawns a focused investigator\n * that drills into representative traces, and a deeply-recursed\n * investigator may itself split a confounded mode into two sub-modes.\n * Each level fans out 4-way, so the analyst can investigate up to\n * ~16 leaf clusters before hitting the depth ceiling.\n */\n\nimport type { TraceAnalystKindSpec } from '../kind-factory'\nimport { buildTraceToolsForGroup } from '../tool-groups'\n\nconst ACTOR_PROMPT = `You are a failure-mode classifier for an OTLP trace dataset. Your job is to identify the **distinct ways agents failed** in this dataset, not to grade individual runs.\n\nDISCOVERY → CLUSTER → CITE protocol:\n\n1. Call \\`traces.getDatasetOverview({})\\` first. Use \\`has_errors\\`, \\`models\\`, \\`agent_names\\`, \\`tools\\`, and \\`sample_trace_ids\\` to size the failure surface.\n2. Use \\`traces.queryTraces({ filters: { has_errors: true }, limit })\\` to pull error-bearing traces. Combine with \\`traces.countTraces\\` to see what fraction of the dataset failed.\n3. For each candidate failure cluster, use \\`traces.searchTrace\\` with regex like \\`STATUS_CODE_ERROR\\`, \\`MaxTurnsExceeded\\`, \\`assertion\\`, \\`unauthorized\\`, \\`timeout\\`, \\`429\\`, \\`5\\\\d\\\\d\\`, the agent's specific error strings, or the names of its tools. Pull one or two representative traces per cluster, **not all** of them.\n4. **Cluster, do not enumerate.** Two failures with the same root cause should be ONE finding citing both traces, not two findings. The point of this analyst is to compress N runs into K modes.\n5. For each cluster you can defend with evidence, emit ONE finding with:\n   - \\`area\\` = \"failure-mode\"\n   - \\`subject\\` = a short label for the cluster (\"tool-call-loop\", \"auth-revoked-mid-run\", \"agent-asked-clarification-too-late\", ...)\n   - \\`claim\\` = one sentence stating the mode\n   - \\`severity\\` = \"critical\" when it blocks the run, \"high\" when the run finished degraded, \"medium\" when it slowed convergence\n   - \\`evidence_uri\\` = \\`span://<trace_id>/<span_id>\\` of the most representative span\n   - \\`evidence_excerpt\\` = the exact quote (e.g. error message, stuck tool call payload, contradictory turn output)\n   - \\`confidence\\` = 0.85+ when multiple traces show the same shape; 0.6-0.8 for a single-trace inference; <0.5 for speculative.\n   - \\`recommended_action\\` = imperative-phrased fix idea (kept short — the improvement-analyst will expand on these)\n\nIf the dataset has no failures, return an empty findings array — do NOT pad with low-confidence speculation.\n\n**Delegate aggressively.** The recursion budget is there to be used:\n- After your first \\`getDatasetOverview\\` + \\`queryTraces\\` calls, you should have 3-6 candidate failure clusters in mind. Spawn one \\`llmQuery\\` per cluster in a single batch — they investigate in parallel.\n- A sub-investigator that finds its cluster is actually two distinct modes should split again at its own level. Recursion is meant to discover sub-modes, not to do trivial drilling that the parent could do in-line.\n- Pass narrow context to each subagent: { question: 'investigate the auth-revoked-mid-run cluster', context: { trace_ids: ['abc', 'def'], suspected_root_cause: 'token refresh skipped on idle sessions' } }. Subagents need enough context to skip re-discovery but not the whole conversation.\n- Each subagent returns its findings as JSON; the parent merges them. Do NOT have subagents call \\`final()\\` — they return their findings list to you, and you call \\`final()\\` once at the top.\n\nOBSERVABILITY rules:\n- Each non-final turn must emit at least one \\`console.log\\` for evidence.\n- Reuse runtime variables across turns; don't recompute.\n- Call \\`final({ findings: [...] })\\` exactly once, after you've gathered evidence for every cluster you intend to report.`\n\nexport const FAILURE_MODE_KIND_SPEC: TraceAnalystKindSpec = {\n  id: 'failure-mode',\n  description:\n    'Clusters trace-dataset failures into distinct failure modes with cited evidence and a short recommended action.',\n  area: 'failure-mode',\n  version: '1.0.0',\n  actorDescription: ACTOR_PROMPT,\n  buildTools: (store) => buildTraceToolsForGroup('all', store),\n  recursion: { maxDepth: 3, maxParallelSubagents: 4 },\n  maxTurns: 24,\n  cost: { kind: 'llm' },\n}\n","/**\n * Improvement analyst — actionable, recursive self-improvement findings.\n *\n * Brief: read findings from upstream analysts (failure-mode,\n * knowledge-gap, knowledge-poisoning) AND the trace dataset itself,\n * then propose **concrete edits** to the agent's runtime: prompt\n * additions, RAG documents to ingest, tool descriptions to rewrite,\n * scaffolding changes to make, memory entries to invalidate. Each\n * finding is one proposed edit with the locus, the diff, and the\n * expected effect.\n *\n * This is the recursive-self-improvement loop's last mile: the prior\n * kinds describe *what's wrong*; this kind describes *what to change*.\n *\n * Recursion is deep (`maxDepth: 3`) because real improvement proposals\n * are competitive: for each failure-mode there are usually 2-3 viable\n * fix directions (tighten prompt vs add tool vs adjust scaffolding),\n * and the actor should explore each with a focused subagent before\n * picking the highest-leverage one to recommend.\n */\n\nimport type { TraceAnalystKindSpec } from '../kind-factory'\nimport { buildTraceToolsForGroup } from '../tool-groups'\n\nconst ACTOR_PROMPT = `You are a recursive-self-improvement analyst. Your job is to propose **concrete, locus-named edits** the agent's runtime should adopt to fix the failure modes, knowledge gaps, and poisonings present in this dataset.\n\nUpstream analysts have already classified the problems. Your job is to convert each problem into a *change to make* and grade its expected leverage. Each finding is one proposed edit.\n\nDISCOVERY → CANDIDATE-FIXES → COMPETE → CITE protocol:\n\n1. \\`traces.getDatasetOverview({})\\` first. Note the agents, tools, and any system-prompt fingerprints (look for the prompt text echoed in early spans).\n2. For each high-severity failure pattern, generate 2-3 candidate fixes. Real candidate axes:\n   - **System-prompt edit** — add an instruction, remove a misleading one, restructure precedence\n   - **Tool description edit** — rewrite a tool's description so the agent picks it correctly / passes valid args\n   - **New tool** — add a tool the agent kept emulating in code\n   - **RAG ingestion** — add a document or correct a stale one\n   - **Memory invalidation** — clear cached prior-run decisions that no longer apply\n   - **Scaffolding** — add a precondition check, a retry policy, a turn budget, a verification step\n   - **Output schema** — narrow the agent's output to forbid the failure shape\n3. **Compete candidate fixes via subagents.** For each failure cluster, spawn one \\`llmQuery\\` per candidate-fix axis you want to evaluate. Each subagent's job: simulate the fix on the cited traces and report (i) likely effect, (ii) side effects, (iii) implementation cost as small/medium/large. Pass the cluster's failing trace_ids and the candidate axis as context.\n4. After subagents return, **pick the winning candidate per cluster** based on (effect / cost) and emit ONE finding. Discard the losing candidates — the output is the recommendation, not the candidate set.\n5. **Cross-reference upstream findings.** If a finding cites a prior failure-mode or knowledge-gap finding, use \\`evidence_uri = \"finding://<prior-finding-id>\"\\` (the registry supports this kind). This builds the dependency graph that lets the dashboard show \"fix #X resolves failure modes A, B, C.\"\n\nFor each winning recommendation, emit ONE finding with:\n- \\`area\\` = \"improvement\"\n- \\`subject\\` = the locus to edit: \\`system-prompt:<section>\\`, \\`tool-doc:<tool-name>\\`, \\`new-tool:<proposed-name>\\`, \\`rag:<corpus>:<doc-id>\\`, \\`memory:<key>\\`, \\`scaffolding:<concern>\\`, \\`output-schema:<field>\\`\n- \\`claim\\` = one sentence stating the edit (\"Add a precondition check to refuse tool X calls without arg Y\")\n- \\`severity\\` = leverage rating: \"critical\" when fix resolves a critical failure mode; \"high\" when it resolves a high; \"medium\" when it's a quality-of-life win; \"info\" when it's a cleanup with no behavioral effect\n- \\`evidence_uri\\` = the failure-mode finding id this fix targets (\\`finding://<id>\\`) when it exists; else the most representative span\n- \\`evidence_excerpt\\` = a fragment showing the problem the fix targets\n- \\`confidence\\` = 0.85+ when the fix is mechanical and the failure mode is well-evidenced; 0.6-0.8 when the fix requires judgment; <0.5 for speculative\n- \\`rationale\\` = why this candidate beat its alternatives (2 sentences max)\n- \\`recommended_action\\` = the **literal edit**, phrased as a diff or a quoted replacement: \"Replace section X with: '...'\" or \"Add tool with description: '...'\" or \"Set retry policy to max_attempts=3 with exponential backoff\"\n\nIf no upstream failure findings exist in this run, derive your own from the trace dataset using the failure-mode protocol inline (\\`searchTrace\\` for STATUS_CODE_ERROR / MaxTurnsExceeded / etc.). But prefer to consume upstream findings when present — the kinds are designed to chain.\n\nDo NOT propose a fix you cannot defend with evidence. \"Tighten the prompt\" is not a finding; \"Add 'When the user asks for X, always Y' to the system prompt section \"request-classification\"\" is.\n\nOBSERVABILITY rules:\n- Each non-final turn must emit at least one \\`console.log\\` for evidence.\n- Call \\`final({ findings: [...] })\\` exactly once at the top level.`\n\nexport const IMPROVEMENT_KIND_SPEC: TraceAnalystKindSpec = {\n  id: 'improvement',\n  description:\n    'Converts upstream failure / gap / poisoning findings into concrete locus-named edits (prompt, tool-doc, RAG, scaffolding) with leverage grades.',\n  area: 'improvement',\n  version: '1.0.0',\n  actorDescription: ACTOR_PROMPT,\n  buildTools: (store) => buildTraceToolsForGroup('all', store),\n  recursion: { maxDepth: 3, maxParallelSubagents: 4 },\n  maxTurns: 30,\n  maxRuntimeChars: 12000,\n  cost: { kind: 'llm' },\n}\n","/**\n * Knowledge-gap analyst — what did the agent NOT know that it needed?\n *\n * Brief: find moments in the trace where the agent had to guess, ask\n * the user to fill in context, recover from a wrong assumption, or\n * loop on a retrieval. Each finding names a *missing or outdated piece\n * of knowledge* the agent's curated knowledge base should have held —\n * or a downstream lookup (web, docs, tool description) that surfaced\n * stale or outdated information.\n *\n * The primary expected store is `@tangle-network/agent-knowledge`: a\n * Karpathy-style wiki the agent maintains with raw ↔ curated pages,\n * source anchors, and claim/relation triples. A gap is anything the\n * agent had to discover at run-time that should already have lived\n * there. Secondary loci: web-search results that returned outdated\n * pages, tool descriptions that omitted critical behavior, system-\n * prompt sections that didn't cover the case.\n *\n * Distinct from failure-mode: failure-mode classifies *how* it broke;\n * knowledge-gap names the *information* whose absence (or staleness)\n * caused the break. One failure-mode often maps to several gaps.\n *\n * Recursion (`maxDepth: 2`) is enough to fan out one subagent per\n * candidate gap-source layer; each subagent runs a focused detection.\n */\n\nimport type { TraceAnalystKindSpec } from '../kind-factory'\nimport { buildTraceToolsForGroup } from '../tool-groups'\n\nconst ACTOR_PROMPT = `You are a knowledge-gap analyst for an OTLP trace dataset. Your job is to identify the **specific pieces of information the agent lacked, or that were stale**, that caused poor decisions.\n\nThe agent under analysis maintains a curated knowledge base via \\`@tangle-network/agent-knowledge\\` — a wiki of \\`KnowledgePage\\`s with raw source anchors, claims, and relations. The primary expected store of agent-knowable facts IS that wiki. A \"knowledge gap\" is anything the agent had to discover or guess at run-time that the wiki should have held — or an outdated/contradictory fact the agent picked up from a non-wiki source.\n\nDISCOVERY → ATTRIBUTE-TO-LAYER → CITE protocol:\n\n1. \\`traces.getDatasetOverview({})\\` first. Note which agents, tools, and models appear.\n2. Pull traces where the agent shows gap signals. The strongest signals are:\n   - Self-correction turns (\"I assumed X but…\", \"let me re-check\", \"actually,\")\n   - Clarifying-question turns where the agent asked the user something the runtime should have surfaced\n   - Repeated retrieval / lookup calls for the same artifact with slightly varied queries\n   - Tool errors that name a missing argument or unknown resource\n   - Web-search calls returning pages dated before a known cutoff for content that changes (versioned APIs, schemas, policies)\n   - Agent quoting a tool's docs / system prompt incorrectly because the actual text was insufficient\n   - Fabricated identifiers that don't appear in dataset \\`sample_trace_ids\\`\n   Use \\`traces.searchTrace\\` with patterns like \\`I (don.?t|do not) know\\`, \\`assumed\\`, \\`unclear\\`, \\`could you (clarify|tell me|provide)\\`, \\`not found\\`, \\`undefined\\`, \\`unknown\\`, \\`null\\`, dates older than the analysis window, or the agent's specific clarification phrases.\n3. For each gap, identify the **layer of the runtime that should have prevented it**. The locus is the value of \\`subject\\` on the finding. Use one of:\n   - \\`agent-knowledge:wiki:<page-slug>\\` — the wiki page that should exist but doesn't, or exists but lacks the claim\n   - \\`agent-knowledge:wiki:<page-slug>#<heading>\\` — wiki page exists but a specific section is missing\n   - \\`agent-knowledge:claim:<topic>\\` — a specific claim/relation triple that should be in the wiki\n   - \\`agent-knowledge:raw:<source-id>\\` — raw source captured but never lifted into a curated page\n   - \\`agent-knowledge:stale:<page-slug>\\` — wiki page exists but contradicts ground-truth evidence in this trace (the wiki itself drifted)\n   - \\`websearch:outdated:<topic>\\` — agent relied on a web result that was stale; wiki should have superseded it\n   - \\`tool-doc:<tool-name>:<aspect>\\` — tool description missed a behavior aspect (return shape, failure modes, side effects)\n   - \\`system-prompt:<section>\\` — system prompt should have stated the rule directly\n   - \\`memory:<key>\\` — prior-run memory should have surfaced an earlier decision\n4. For each gap you can defend with evidence, emit ONE finding with:\n   - \\`area\\` = \"knowledge-gap\"\n   - \\`subject\\` = the locus string from the list above\n   - \\`claim\\` = a sentence naming the missing or stale knowledge (\"wiki has no page on invoice line-item shape, agent had to re-derive it from raw spans\")\n   - \\`severity\\` = \"high\" when the gap caused a failure or a clarifying question; \"medium\" when it caused unnecessary turns; \"low\" when it caused minor inefficiency\n   - \\`evidence_uri\\` = \\`span://<trace_id>/<span_id>\\` of the moment the gap surfaced (the question, the self-correction, the retrieval miss, the stale web result)\n   - \\`evidence_excerpt\\` = exact quote where the agent showed the gap\n   - \\`confidence\\` = 0.85+ when the agent itself articulated the gap; 0.6-0.8 when inferred from behavior\n   - \\`recommended_action\\` = phrased as a wiki edit when the locus is \\`agent-knowledge:*\\` (\"Create wiki page \\`invoice-line-items\\` with claims: ...\"), or as a prompt/tool-doc edit otherwise\n\n**Delegate per layer.** After your first scan, you should have candidates spread across \\`agent-knowledge:*\\`, \\`websearch:outdated\\`, \\`tool-doc:*\\`, \\`system-prompt:*\\`, and \\`memory:*\\`. Spawn one \\`llmQuery\\` per layer in parallel — each subagent runs a focused detection (e.g. the \\`agent-knowledge\\` subagent looks for both missing-pages AND stale-pages; the \\`websearch\\` subagent looks specifically for date staleness signals; the \\`tool-doc\\` subagent looks for tool-call argument errors a fuller description would have prevented). Subagents return findings; you merge and emit one \\`final({ findings })\\` at the top.\n\nDo NOT report a gap that the agent later recovered from cleanly within the same turn — that's resilience, not a gap. Cite the *non-recovery* version when both exist.\n\nOBSERVABILITY rules:\n- Each non-final turn must emit at least one \\`console.log\\` for evidence.\n- Call \\`final({ findings: [...] })\\` exactly once at the top level.`\n\nexport const KNOWLEDGE_GAP_KIND_SPEC: TraceAnalystKindSpec = {\n  id: 'knowledge-gap',\n  description:\n    'Identifies missing or stale pieces of knowledge — primarily against the agent-knowledge wiki — and attributes each to the runtime layer (wiki page, claim, raw source, websearch, tool-doc, system-prompt, memory) that should have held it.',\n  area: 'knowledge-gap',\n  version: '1.0.0',\n  actorDescription: ACTOR_PROMPT,\n  buildTools: (store) => buildTraceToolsForGroup('discoveryAndSearch', store),\n  recursion: { maxDepth: 2, maxParallelSubagents: 4 },\n  maxTurns: 18,\n  cost: { kind: 'llm' },\n}\n","/**\n * Knowledge-poisoning analyst — what FALSE information misled the agent?\n *\n * Brief: find moments where the agent acted on information that was\n * *wrong* — stale memory, RAG documents that contradicted ground truth,\n * tool descriptions that lied about return shapes, system-prompt\n * instructions that no longer matched reality, prior-run summaries that\n * cached a wrong decision.\n *\n * Distinct from knowledge-gap: a gap is \"the agent didn't know X\"; a\n * poisoning is \"the agent confidently used X, but X was wrong.\" Gaps\n * surface as questions / self-correction; poisonings surface as\n * confident-but-wrong actions that downstream evidence contradicts.\n *\n * Recursion is moderate (`maxDepth: 2`) because each candidate\n * poisoning typically needs two sub-investigations: one to confirm\n * the agent acted on the false belief, one to confirm the belief\n * itself is actually false in ground truth.\n */\n\nimport type { TraceAnalystKindSpec } from '../kind-factory'\nimport { buildTraceToolsForGroup } from '../tool-groups'\n\nconst ACTOR_PROMPT = `You are a knowledge-poisoning analyst for an OTLP trace dataset. Your job is to identify cases where the agent **confidently used wrong information** — not where it lacked information (that's the knowledge-gap analyst).\n\nDISCOVERY → DUAL-VERIFY → CITE protocol:\n\n1. \\`traces.getDatasetOverview({})\\` first. Identify the agents, models, and tools.\n2. Pull traces where the agent's confident action was later contradicted. Strongest signals:\n   - Agent stated a fact in one span; a later span surfaced contradictory evidence; the agent then proceeded anyway or fabricated reconciliation.\n   - Tool call with stale arguments (an id that no longer exists, an API shape that changed).\n   - Agent cited an \\`agent-knowledge\\` wiki page or claim whose content contradicts the trace's own evidence — the wiki itself drifted.\n   - Web-search result the agent cited that returned an outdated page; agent treated it as canonical.\n   - System-prompt instruction the agent followed that ground-truth evidence in the trace contradicts (e.g. prompt says \"use endpoint A\"; tool reply says \"endpoint A deprecated, use B\").\n   - Repeated wrong-shape parsing despite the tool's actual output proving the shape.\n3. Use \\`traces.searchTrace\\` with regex on phrases like \\`actually\\`, \\`turns out\\`, \\`previously assumed\\`, \\`old version\\`, \\`deprecated\\`, \\`updated to\\`, \\`now uses\\`, or specific entity names you suspect have changed.\n4. For each candidate poisoning, **DUAL-VERIFY**:\n   - Confirm the agent actually acted on the false belief (cite the span where it did)\n   - Confirm the belief is actually false in this trace's own evidence (cite the span that contradicts it)\n   Only emit a finding when both halves are nailed down. If you can only nail one, drop it — single-evidence poisoning findings are too speculative to be useful.\n\n**Delegate the dual-verify.** Use the recursion budget so each candidate poisoning gets one subagent investigating \"did the agent act?\" and one investigating \"is the belief false?\". After your first scan, fire off N parallel \\`llmQuery\\` pairs (one cluster per pair). Subagents return their findings; you accept only the ones where BOTH halves of the pair were confirmed.\n\nFor each confirmed poisoning, emit ONE finding with:\n- \\`area\\` = \"knowledge-poisoning\"\n- \\`subject\\` = the source of the false belief, one of: \\`agent-knowledge:wiki:<page-slug>\\` (wiki page contradicts current ground truth), \\`agent-knowledge:claim:<topic>\\` (a specific claim/relation went stale), \\`agent-knowledge:raw:<source-id>\\` (the raw source is outdated and the wiki inherited the drift), \\`websearch:outdated:<url-or-topic>\\`, \\`tool-doc:<tool>\\`, \\`system-prompt:<section>\\`, \\`memory:<key>\\`, \\`prior-run-summary:<topic>\\`\n- \\`claim\\` = one sentence: \"agent believed X (from source S); evidence in trace shows X is false\"\n- \\`severity\\` = \"critical\" when poisoning caused a wrong user-visible action; \"high\" when caught internally but wasted significant work; \"medium\" for inefficiency only\n- \\`evidence_uri\\` = \\`span://<trace_id>/<span_id>\\` of the action span (the moment the agent acted on the false belief)\n- \\`evidence_excerpt\\` = exact quote of the confident-but-wrong claim or action\n- \\`confidence\\` = 0.85+ when both halves are exact-quote backed; 0.6-0.8 when one half is inferred\n- \\`recommended_action\\` = where the source should be updated and how (\"Update wiki page \\`X\\` claim \\`Y\\` to '...'\", \"Invalidate raw source \\`Z\\` and re-curate\", \"Replace system-prompt section X with 'tool foo now returns Y'\")\n\nDo NOT report a finding if the agent caught and corrected the false belief in the same turn — that's the system working. Reserve poisoning for cases where the false belief shaped downstream action.\n\nOBSERVABILITY rules:\n- Each non-final turn must emit at least one \\`console.log\\` for evidence.\n- Call \\`final({ findings: [...] })\\` exactly once at the top level.`\n\nexport const KNOWLEDGE_POISONING_KIND_SPEC: TraceAnalystKindSpec = {\n  id: 'knowledge-poisoning',\n  description:\n    'Identifies confident-but-wrong actions caused by stale memory, contradicting RAG, deprecated tool docs, or outdated system-prompt instructions.',\n  area: 'knowledge-poisoning',\n  version: '1.0.0',\n  actorDescription: ACTOR_PROMPT,\n  buildTools: (store) => buildTraceToolsForGroup('all', store),\n  recursion: { maxDepth: 2, maxParallelSubagents: 4 },\n  maxTurns: 20,\n  cost: { kind: 'llm' },\n}\n","/**\n * Default analyst kinds focused on agent failure + recursive\n * self-improvement.\n *\n * The four kinds chain: failure-mode classifies; knowledge-gap and\n * knowledge-poisoning explain *why* in two orthogonal ways; improvement\n * proposes concrete edits. Register all four against the same trace\n * store and the registry runs them in dependency order if the operator\n * pipes findings between them.\n */\n\nexport { FAILURE_MODE_KIND_SPEC } from './failure-mode'\nexport { IMPROVEMENT_KIND_SPEC } from './improvement'\nexport { KNOWLEDGE_GAP_KIND_SPEC } from './knowledge-gap'\nexport { KNOWLEDGE_POISONING_KIND_SPEC } from './knowledge-poisoning'\n\nimport type { TraceAnalystKindSpec } from '../kind-factory'\nimport { FAILURE_MODE_KIND_SPEC } from './failure-mode'\nimport { IMPROVEMENT_KIND_SPEC } from './improvement'\nimport { KNOWLEDGE_GAP_KIND_SPEC } from './knowledge-gap'\nimport { KNOWLEDGE_POISONING_KIND_SPEC } from './knowledge-poisoning'\n\n/**\n * The default kind suite. Order is the run order operators should\n * use: failure-mode first (no upstream deps), gap + poisoning next\n * (both depend on failures), improvement last (chains all three).\n */\nexport const DEFAULT_TRACE_ANALYST_KINDS: readonly TraceAnalystKindSpec[] = [\n  FAILURE_MODE_KIND_SPEC,\n  KNOWLEDGE_GAP_KIND_SPEC,\n  KNOWLEDGE_POISONING_KIND_SPEC,\n  IMPROVEMENT_KIND_SPEC,\n] as const\n","/**\n * AnalystRegistry — orchestrate N analysts against one run.\n *\n * Owns three responsibilities and only three:\n *   1. Registration — ids must be unique; bad registrations fail loudly\n *      at register-time, not run-time.\n *   2. Routing — each analyst declares its `inputKind`; the registry\n *      picks the matching field from AnalystRunInputs and skips the\n *      analyst with a logged reason if it's missing.\n *   3. Isolation — one analyst's exception MUST NOT stop other analysts.\n *      Failed analysts produce zero findings + a 'failed' summary row.\n *\n * Cross-cutting concerns (telemetry, error → finding conversion, cost\n * ingestion, storage rotation) live in `AnalystHooks`. Budget shaping\n * (equal split vs weighted vs custom) lives in `BudgetPolicy`. Both\n * have sensible defaults; consumers override only what they need.\n */\n\nimport { randomUUID } from 'node:crypto'\nimport type { ChatClient } from './chat-client'\nimport type {\n  Analyst,\n  AnalystContext,\n  AnalystFinding,\n  AnalystRunEvent,\n  AnalystRunInputs,\n  AnalystRunResult,\n  AnalystRunSummary,\n} from './types'\n\n// ── Hook + policy surfaces ─────────────────────────────────────────\n\nexport interface AnalystHooks {\n  /** Before analyze() — last chance to mutate ctx (e.g. inject tags, override budget). */\n  onBeforeAnalyze?(args: {\n    analyst: Analyst\n    ctx: AnalystContext\n    runId: string\n  }): void | Promise<void>\n  /** After every analyst (ok | failed | skipped). Use for telemetry, ingestion, rotation. */\n  onAfterAnalyze?(args: {\n    analyst: Analyst\n    summary: AnalystRunSummary\n    findings: AnalystFinding[]\n    runId: string\n  }): void | Promise<void>\n  /**\n   * On analyst exception. Hook MAY return findings to convert the\n   * error into structured findings; the summary still reports 'failed'.\n   * Return void to keep the default empty-findings behavior.\n   */\n  onError?(args: {\n    analyst: Analyst\n    error: Error\n    runId: string\n  }): AnalystFinding[] | undefined | Promise<AnalystFinding[] | undefined>\n  /** Once after registry.run() completes. Use for final aggregation, persistence. */\n  onComplete?(args: { result: AnalystRunResult }): void | Promise<void>\n}\n\nexport interface BudgetPolicy {\n  /** Overall USD cap across the registry.run(). */\n  totalUsd?: number\n  /** Per-analyst weight for the default allocator. Missing ids get weight 1. */\n  weights?: Record<string, number>\n  /**\n   * Custom allocator — receives the analyst, remaining/total budget, and\n   * the count of analysts that will run. Returns the per-analyst budget\n   * (or undefined to leave it uncapped). Overrides weights when set.\n   */\n  allocate?: (args: {\n    analyst: Analyst\n    totalUsd: number | undefined\n    remainingUsd: number | undefined\n    runningCount: number\n  }) => number | undefined\n}\n\nexport interface AnalystRegistryOptions {\n  /** Shared chat client passed to every LLM analyst via AnalystContext. */\n  chat?: ChatClient\n  /** Logger callback. Defaults to a no-op. */\n  log?: (msg: string, fields?: Record<string, unknown>) => void\n  /** Hooks invoked around analyze() — observability + customization seam. */\n  hooks?: AnalystHooks\n  /** Default budget when run() doesn't override. */\n  defaultBudget?: BudgetPolicy\n}\n\nexport interface RegistryRunOpts {\n  /** Restrict to a subset of registered analysts by id. */\n  only?: string[]\n  /** Skip these analysts even if registered. Useful for cheap iteration. */\n  skip?: string[]\n  /** Budget policy — totalUsd + optional weights/allocator. Falls back to options.defaultBudget. */\n  budget?: BudgetPolicy\n  /** Wall-clock cap. Analysts SHOULD honor `ctx.deadlineMs`. */\n  timeoutMs?: number\n  /** Abort signal — forwarded into every analyst's context. */\n  signal?: AbortSignal\n  /** Tags echoed into AnalystContext.tags — useful for tracking environment/version in findings. */\n  tags?: Record<string, string>\n  /**\n   * Prior-run findings made available as retrieval context to every\n   * analyst via `ctx.priorFindings`. The registry forwards the slice\n   * whose `analyst_id` matches each registered analyst so a kind sees\n   * only its own history. Pass `{ '*': findings }` to broadcast to\n   * every analyst (useful for cross-kind chaining where the improvement\n   * analyst consumes upstream failure findings).\n   */\n  priorFindings?: ReadonlyArray<AnalystFinding> | Record<string, ReadonlyArray<AnalystFinding>>\n}\n\nexport class AnalystRegistry {\n  private readonly analysts = new Map<string, Analyst>()\n  private readonly options: AnalystRegistryOptions\n\n  constructor(options: AnalystRegistryOptions = {}) {\n    this.options = options\n  }\n\n  register(analyst: Analyst): void {\n    if (!analyst.id) throw new Error('AnalystRegistry.register: analyst.id is required')\n    if (this.analysts.has(analyst.id)) {\n      throw new Error(`AnalystRegistry.register: duplicate analyst id \"${analyst.id}\"`)\n    }\n    if (!analyst.version) {\n      throw new Error(`AnalystRegistry.register: analyst \"${analyst.id}\" must declare a version`)\n    }\n    this.analysts.set(analyst.id, analyst)\n  }\n\n  list(): ReadonlyArray<{\n    id: string\n    description: string\n    version: string\n    cost: Analyst['cost']\n  }> {\n    return Array.from(this.analysts.values()).map((a) => ({\n      id: a.id,\n      description: a.description,\n      version: a.version,\n      cost: a.cost,\n    }))\n  }\n\n  async run(\n    runId: string,\n    inputs: AnalystRunInputs,\n    runOpts: RegistryRunOpts = {},\n  ): Promise<AnalystRunResult> {\n    // Thin collector over `runStream`. Both surfaces share the same\n    // loop body so they cannot drift on isolation / hook order / cost.\n    for await (const ev of this.runStream(runId, inputs, runOpts)) {\n      if (ev.type === 'run-completed') return ev.result\n    }\n    throw new Error('AnalystRegistry.run: stream completed without run-completed event')\n  }\n\n  /**\n   * Streaming counterpart to `run()`. Emits `AnalystRunEvent` values\n   * in real time — `run-started`, then per-analyst `skipped` /\n   * `started` / `completed`, then a terminal `run-completed` whose\n   * payload is the full `AnalystRunResult`. UIs use this to render\n   * progress; persistence consumers use `run()` and read the result.\n   *\n   * Hooks (`onBeforeAnalyze` / `onAfterAnalyze` / `onError` /\n   * `onComplete`) fire as before — streaming is additive, not a hook\n   * replacement.\n   */\n  async *runStream(\n    runId: string,\n    inputs: AnalystRunInputs,\n    runOpts: RegistryRunOpts = {},\n  ): AsyncGenerator<AnalystRunEvent, void, void> {\n    const correlationId = `ar_${randomUUID().slice(0, 12)}`\n    const log = this.options.log ?? (() => {})\n    const hooks = this.options.hooks ?? {}\n    const startedAt = new Date().toISOString()\n    const started = Date.now()\n    const deadlineMs = runOpts.timeoutMs ? started + runOpts.timeoutMs : undefined\n\n    const selected = this.selectAnalysts(runOpts)\n    const budget = runOpts.budget ?? this.options.defaultBudget\n\n    yield {\n      type: 'run-started',\n      run_id: runId,\n      correlation_id: correlationId,\n      started_at: startedAt,\n      analyst_ids: selected.map((a) => a.id),\n    }\n\n    const summaries: AnalystRunSummary[] = []\n    const allFindings: AnalystFinding[] = []\n    let totalCost = 0\n    let remainingUsd = budget?.totalUsd\n\n    // Budget is split only across analysts that actually run. Analysts skipped\n    // for missing input never spend, so counting them would under-budget the\n    // ones that do. routeInput is pure, so the pre-count is safe.\n    const runnableCount = selected.filter(\n      (a) => this.routeInput(a, inputs).kind !== 'missing',\n    ).length\n\n    for (const analyst of selected) {\n      const t0 = Date.now()\n      const input = this.routeInput(analyst, inputs)\n      if (input.kind === 'missing') {\n        const summary: AnalystRunSummary = {\n          analyst_id: analyst.id,\n          status: 'skipped',\n          reason: `missing input of kind '${analyst.inputKind}'`,\n          findings_count: 0,\n          latency_ms: 0,\n          cost_usd: 0,\n        }\n        summaries.push(summary)\n        log(`[analyst] skip ${analyst.id} — missing input`, { runId, kind: analyst.inputKind })\n        await hooks.onAfterAnalyze?.({ analyst, summary, findings: [], runId })\n        yield { type: 'analyst-skipped', summary }\n        continue\n      }\n\n      const perBudget = allocateBudget(budget, {\n        analyst,\n        remainingUsd,\n        runningCount: runnableCount,\n      })\n\n      const ctx: AnalystContext = {\n        runId,\n        correlationId,\n        deadlineMs,\n        budgetUsd: perBudget,\n        chat: this.options.chat,\n        tags: runOpts.tags,\n        log: (msg, fields) => log(`[${analyst.id}] ${msg}`, { runId, correlationId, ...fields }),\n        signal: runOpts.signal,\n        priorFindings: selectPriorFindings(runOpts.priorFindings, analyst.id),\n      }\n\n      await hooks.onBeforeAnalyze?.({ analyst, ctx, runId })\n      yield {\n        type: 'analyst-started',\n        analyst_id: analyst.id,\n        started_at: new Date(t0).toISOString(),\n      }\n\n      try {\n        const findings = await (analyst as Analyst<unknown>).analyze(input.value, ctx)\n        const latency = Date.now() - t0\n        const cost = sumFindingCost(findings)\n        totalCost += cost\n        if (typeof remainingUsd === 'number') remainingUsd = Math.max(0, remainingUsd - cost)\n        allFindings.push(...findings)\n        const summary: AnalystRunSummary = {\n          analyst_id: analyst.id,\n          status: 'ok',\n          findings_count: findings.length,\n          latency_ms: latency,\n          cost_usd: cost,\n        }\n        summaries.push(summary)\n        log(`[analyst] ok ${analyst.id}`, {\n          runId,\n          findings: findings.length,\n          latency_ms: latency,\n          cost_usd: cost,\n        })\n        await hooks.onAfterAnalyze?.({ analyst, summary, findings, runId })\n        yield { type: 'analyst-completed', summary, findings }\n      } catch (err) {\n        const latency = Date.now() - t0\n        const e = err instanceof Error ? err : new Error(String(err))\n        // Hook gets first chance to convert the error into findings.\n        const hookFindings = (await hooks.onError?.({ analyst, error: e, runId })) ?? []\n        if (hookFindings.length) allFindings.push(...hookFindings)\n        const summary: AnalystRunSummary = {\n          analyst_id: analyst.id,\n          status: 'failed',\n          findings_count: hookFindings.length,\n          latency_ms: latency,\n          cost_usd: 0,\n          error: { class: e.constructor.name, message: e.message },\n        }\n        summaries.push(summary)\n        log(`[analyst] FAIL ${analyst.id}`, {\n          runId,\n          error_class: e.constructor.name,\n          error: e.message,\n        })\n        await hooks.onAfterAnalyze?.({ analyst, summary, findings: hookFindings, runId })\n        yield { type: 'analyst-completed', summary, findings: hookFindings }\n        // Continue — isolation invariant.\n      }\n    }\n\n    const result: AnalystRunResult = {\n      run_id: runId,\n      correlation_id: correlationId,\n      started_at: startedAt,\n      ended_at: new Date().toISOString(),\n      findings: allFindings,\n      per_analyst: summaries,\n      total_cost_usd: totalCost,\n    }\n    await hooks.onComplete?.({ result })\n    yield { type: 'run-completed', result }\n  }\n\n  private selectAnalysts(opts: RegistryRunOpts): Analyst[] {\n    let candidates = Array.from(this.analysts.values())\n    if (opts.only?.length) {\n      const only = new Set(opts.only)\n      candidates = candidates.filter((a) => only.has(a.id))\n    }\n    if (opts.skip?.length) {\n      const skip = new Set(opts.skip)\n      candidates = candidates.filter((a) => !skip.has(a.id))\n    }\n    return candidates\n  }\n\n  private routeInput(\n    analyst: Analyst,\n    inputs: AnalystRunInputs,\n  ): { kind: 'present'; value: unknown } | { kind: 'missing' } {\n    switch (analyst.inputKind) {\n      case 'trace-store':\n        return inputs.traceStore\n          ? { kind: 'present', value: inputs.traceStore }\n          : { kind: 'missing' }\n      case 'artifact-dir':\n        return inputs.artifactDir\n          ? { kind: 'present', value: inputs.artifactDir }\n          : { kind: 'missing' }\n      case 'run-record':\n        return inputs.runRecord ? { kind: 'present', value: inputs.runRecord } : { kind: 'missing' }\n      case 'judge-input':\n        return inputs.judgeInput\n          ? { kind: 'present', value: inputs.judgeInput }\n          : { kind: 'missing' }\n      case 'custom': {\n        const v = inputs.custom?.[analyst.id]\n        return v !== undefined ? { kind: 'present', value: v } : { kind: 'missing' }\n      }\n    }\n  }\n}\n\n/**\n * Default budget allocator: prefer the custom `allocate` callback if\n * provided; else weighted split when weights are set; else equal split\n * across `runningCount`. Returns undefined when no totalUsd is known.\n */\nfunction allocateBudget(\n  policy: BudgetPolicy | undefined,\n  args: { analyst: Analyst; remainingUsd: number | undefined; runningCount: number },\n): number | undefined {\n  if (!policy) return undefined\n  if (policy.allocate) {\n    return policy.allocate({\n      analyst: args.analyst,\n      totalUsd: policy.totalUsd,\n      remainingUsd: args.remainingUsd,\n      runningCount: args.runningCount,\n    })\n  }\n  if (policy.totalUsd == null) return undefined\n  if (policy.weights) {\n    // Weighted split: caller-supplied weights, default 1 for missing ids.\n    // We can only normalize against the analysts in this run, but the\n    // registry doesn't know all ids at allocator-time without passing\n    // them. We approximate by treating `runningCount` as the count of\n    // weight=1 analysts when the weight map omits ids. The exact split\n    // is left to consumers that need precision via `allocate`.\n    const w = policy.weights[args.analyst.id] ?? 1\n    const totalWeight = Math.max(1, args.runningCount) // see note above\n    return (policy.totalUsd * w) / totalWeight\n  }\n  return policy.totalUsd / Math.max(1, args.runningCount)\n}\n\n/**\n * Findings may carry their cost in `metadata.cost_usd` when the analyst\n * tracks it (the LLM-driven adapters do this — they sum chat-client\n * responses). Deterministic findings have no cost field.\n */\nfunction sumFindingCost(findings: AnalystFinding[]): number {\n  let sum = 0\n  for (const f of findings) {\n    const c = f.metadata?.cost_usd\n    if (typeof c === 'number' && Number.isFinite(c)) sum += c\n  }\n  return sum\n}\n\n/**\n * Resolve the `priorFindings` slice an analyst sees.\n *\n *   - Array form  → the analyst sees only findings whose `analyst_id`\n *                   matches its own id, so a kind never reads\n *                   another kind's history by accident.\n *   - Record form → the analyst gets the entry keyed by its id, with\n *                   the `'*'` wildcard appended (in that order). Use\n *                   the wildcard for cross-kind chaining, e.g. when\n *                   `improvement` should see all upstream failure /\n *                   gap / poisoning findings.\n */\nfunction selectPriorFindings(\n  source: RegistryRunOpts['priorFindings'],\n  analystId: string,\n): ReadonlyArray<AnalystFinding> | undefined {\n  if (!source) return undefined\n  if (Array.isArray(source)) {\n    const own = source.filter((f) => f.analyst_id === analystId)\n    return own.length > 0 ? own : undefined\n  }\n  const record = source as Record<string, ReadonlyArray<AnalystFinding>>\n  const own = record[analystId] ?? []\n  const wildcard = record['*'] ?? []\n  const merged = [...own, ...wildcard]\n  return merged.length > 0 ? merged : undefined\n}\n"],"mappings":"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","names":["z","z","ACTOR_PROMPT","ACTOR_PROMPT","ACTOR_PROMPT","own"]}

package/dist/chunk-QMUEXQJS.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/trace-analyst/otlp-span.ts","../src/trace-analyst/types.ts","../src/trace-analyst/store-otlp.ts","../src/trace-analyst/store.ts","../src/trace-analyst/tools.ts"],"sourcesContent":["/**\n * Canonical OTLP-flat-line readers shared by every consumer of the\n * OTLP-JSONL wire shape (one OTLP span per line; the form\n * `flattenOtlpExportToNdjson` produces and the form AppWorld / HALO\n * emit via their OpenInference OTLP exporter).\n *\n * `OtlpFileTraceStore` indexes spans with these; `otlpToRunRecords`\n * aggregates spans into `RunRecord`s with the same readers. One parser,\n * one vocabulary — a divergence between the analyst's view of a trace and\n * the RunRecord projected from it is a class of bug this consolidation\n * removes by construction.\n *\n * Vocabulary. The readers understand BOTH dialects that appear in the\n * wild:\n *   - the substrate's own `llm.*` / `tool.*` / `span.kind` attributes\n *     (`flattenSpanAttributes` in `trace/otel.ts`), and\n *   - the OpenInference / inference-export attributes AppWorld / HALO\n *     emit (`openinference.span.kind`, `inference.observation_kind`,\n *     `inference.llm.input_tokens`, `llm.token_count.prompt`, …).\n *\n * Pure, no I/O.\n */\n\nimport type { TraceAnalystSpanKind, TraceAnalystSpanStatus } from './types'\n\n/**\n * The structural fields a flat OTLP-JSONL line projects to. `attributes`\n * is the merged resource+span attribute map (span overrides resource);\n * the named fields are the pivots every reader of a trace needs without\n * paying the full attribute materialisation.\n */\nexport interface ProjectedOtlpSpan {\n  trace_id: string\n  span_id: string\n  parent_span_id: string | null\n  name: string\n  kind: TraceAnalystSpanKind\n  start_time: string\n  end_time: string\n  duration_ms: number\n  status: TraceAnalystSpanStatus\n  status_message: string | undefined\n  service_name: string | null\n  agent_name: string | null\n  model_name: string | null\n  tool_name: string | null\n  /** Merged resource + span attributes, span winning on overlap. */\n  attributes: Record<string, unknown>\n}\n\n/**\n * Project one parsed OTLP-JSONL object to `ProjectedOtlpSpan`, or `null`\n * when the line is missing the mandatory `trace_id` + `span_id`.\n */\nexport function projectOtlpFlatLine(raw: Record<string, unknown>): ProjectedOtlpSpan | null {\n  const trace_id = stringField(raw, 'trace_id') ?? stringField(raw, 'traceId')\n  const span_id = stringField(raw, 'span_id') ?? stringField(raw, 'spanId')\n  if (!trace_id || !span_id) return null\n\n  const parent_id = stringField(raw, 'parent_span_id') ?? stringField(raw, 'parentSpanId') ?? null\n  const name = stringField(raw, 'name') ?? 'unknown'\n  const start_time = stringField(raw, 'start_time') ?? stringField(raw, 'startTime') ?? ''\n  const end_time = stringField(raw, 'end_time') ?? stringField(raw, 'endTime') ?? start_time\n\n  const status = readOtlpStatus(raw)\n  const attributes = extractOtlpAttributes(raw)\n\n  const service_name =\n    asString(attributes['service.name']) ??\n    asString(attributes['resource.attributes.service.name']) ??\n    null\n  const agent_name =\n    asString(attributes['agent.name']) ??\n    asString(attributes['inference.agent.name']) ??\n    asString(attributes['inference.agent_name']) ??\n    null\n  const model_name =\n    asString(attributes['llm.model_name']) ??\n    asString(attributes['inference.llm.model_name']) ??\n    asString(attributes['llm.model']) ??\n    null\n  const tool_name =\n    asString(attributes['tool.name']) ?? asString(attributes['inference.tool.name']) ?? null\n\n  const kind = inferOtlpKind(attributes)\n\n  let duration_ms = 0\n  if (start_time && end_time) {\n    const a = Date.parse(start_time)\n    const b = Date.parse(end_time)\n    if (!Number.isNaN(a) && !Number.isNaN(b)) duration_ms = Math.max(0, b - a)\n  }\n\n  return {\n    trace_id,\n    span_id,\n    parent_span_id: parent_id && parent_id.length > 0 ? parent_id : null,\n    name,\n    kind,\n    start_time,\n    end_time,\n    duration_ms,\n    status: status.code,\n    status_message: status.message,\n    service_name,\n    agent_name,\n    model_name,\n    tool_name,\n    attributes,\n  }\n}\n\nexport function readOtlpStatus(raw: Record<string, unknown>): {\n  code: TraceAnalystSpanStatus\n  message: string | undefined\n} {\n  const status = raw.status\n  if (status && typeof status === 'object' && !Array.isArray(status)) {\n    const codeRaw = (status as Record<string, unknown>).code\n    const code: TraceAnalystSpanStatus =\n      codeRaw === 'STATUS_CODE_OK' || codeRaw === 'OK'\n        ? 'OK'\n        : codeRaw === 'STATUS_CODE_ERROR' || codeRaw === 'ERROR'\n          ? 'ERROR'\n          : 'UNSET'\n    const messageRaw = (status as Record<string, unknown>).message\n    const message = typeof messageRaw === 'string' && messageRaw.length > 0 ? messageRaw : undefined\n    return { code, message }\n  }\n  return { code: 'UNSET', message: undefined }\n}\n\nexport function inferOtlpKind(attrs: Record<string, unknown>): TraceAnalystSpanKind {\n  const opik =\n    asString(attrs['openinference.span.kind']) ?? asString(attrs['inference.observation_kind'])\n  if (opik) {\n    const upper = opik.toUpperCase()\n    if (\n      upper === 'AGENT' ||\n      upper === 'LLM' ||\n      upper === 'TOOL' ||\n      upper === 'CHAIN' ||\n      upper === 'GUARDRAIL' ||\n      upper === 'SPAN'\n    ) {\n      return upper as TraceAnalystSpanKind\n    }\n  }\n  return 'UNKNOWN'\n}\n\n/**\n * Flatten OTLP `attributes` + `resource.attributes` into a single\n * dotted-key map. Span attributes override resource attributes when keys\n * overlap. Nested objects/arrays are preserved as-is.\n */\nexport function extractOtlpAttributes(raw: Record<string, unknown>): Record<string, unknown> {\n  const out: Record<string, unknown> = {}\n  const resource = raw.resource\n  if (resource && typeof resource === 'object' && !Array.isArray(resource)) {\n    const ra = (resource as Record<string, unknown>).attributes\n    if (ra && typeof ra === 'object' && !Array.isArray(ra)) {\n      for (const [k, v] of Object.entries(ra as Record<string, unknown>)) {\n        out[k] = v\n      }\n    }\n  }\n  const spanAttrs = raw.attributes\n  if (spanAttrs && typeof spanAttrs === 'object' && !Array.isArray(spanAttrs)) {\n    for (const [k, v] of Object.entries(spanAttrs as Record<string, unknown>)) {\n      out[k] = v\n    }\n  }\n  return out\n}\n\nexport function stringField(raw: Record<string, unknown>, key: string): string | undefined {\n  const v = raw[key]\n  return typeof v === 'string' ? v : undefined\n}\n\nexport function asString(v: unknown): string | null {\n  return typeof v === 'string' && v.length > 0 ? v : null\n}\n\n/** Read a numeric attribute, tolerating numeric strings; `null` if absent/NaN. */\nexport function asNumber(v: unknown): number | null {\n  if (typeof v === 'number') return Number.isFinite(v) ? v : null\n  if (typeof v === 'string' && v.length > 0) {\n    const n = Number(v)\n    return Number.isFinite(n) ? n : null\n  }\n  return null\n}\n\n/** First finite numeric value across a list of candidate attribute keys. */\nexport function firstNumberAttr(\n  attrs: Record<string, unknown>,\n  keys: readonly string[],\n): number | null {\n  for (const k of keys) {\n    const n = asNumber(attrs[k])\n    if (n !== null) return n\n  }\n  return null\n}\n\n/** First non-empty string value across a list of candidate attribute keys. */\nexport function firstStringAttr(\n  attrs: Record<string, unknown>,\n  keys: readonly string[],\n): string | null {\n  for (const k of keys) {\n    const s = asString(attrs[k])\n    if (s !== null) return s\n  }\n  return null\n}\n\n/**\n * Parse a span timestamp to epoch millis, or null when empty/unparseable. The\n * OTLP readers accept BOTH ISO-8601 and epoch-millis-string dialects, so raw\n * string comparison (`<`, `localeCompare`) mis-orders across dialects and\n * `Date.parse` returns NaN for a bare epoch-millis string.\n */\nexport function spanEpochMillis(ts: string | undefined | null): number | null {\n  if (!ts) return null\n  if (/^\\d+$/.test(ts)) return Number(ts)\n  const n = Date.parse(ts)\n  return Number.isNaN(n) ? null : n\n}\n\n/**\n * Order comparator for span timestamps across mixed ISO/epoch dialects.\n * Unparseable timestamps sort as epoch 0 (earliest), never NaN (which would\n * make the sort non-deterministic).\n */\nexport function compareSpanTime(a: string, b: string): number {\n  return (spanEpochMillis(a) ?? 0) - (spanEpochMillis(b) ?? 0)\n}\n","/**\n * Shared types for the trace-analyst module.\n *\n * Wire format. The store interface speaks `OtlpSpanLike` rows — one JSONL\n * line per span, OTLP-shaped. We do NOT depend on a specific tracing\n * vendor at the type level. Adapter\n * layers map upstream shapes onto this interface.\n *\n * Design constraint. Every read operation that can return arbitrary\n * payload must carry a byte budget so the agent's tool result stays\n * bounded regardless of input trace size. Oversized responses\n * substitute a deterministic summary instead of bytes — see\n * `ViewTraceOversized`.\n */\n\n/** OTLP span kind (subset we actually use). */\nexport type TraceAnalystSpanKind =\n  | 'AGENT'\n  | 'LLM'\n  | 'TOOL'\n  | 'CHAIN'\n  | 'GUARDRAIL'\n  | 'SPAN'\n  | 'UNKNOWN'\n\nexport type TraceAnalystSpanStatus = 'OK' | 'ERROR' | 'UNSET'\n\n/** Subset of OTLP span fields the analyst exposes to the agent. The\n *  store's job is to project upstream's full span shape down to this\n *  view — the analyst never sees vendor extensions directly. */\nexport interface TraceAnalystSpan {\n  trace_id: string\n  span_id: string\n  parent_span_id: string | null\n  name: string\n  kind: TraceAnalystSpanKind\n  start_time: string\n  end_time: string\n  duration_ms: number\n  status: TraceAnalystSpanStatus\n  status_message?: string\n  service_name: string | null\n  agent_name: string | null\n  model_name: string | null\n  tool_name: string | null\n  /** Raw JSON-serialisable attribute map. May contain large strings;\n   *  callers must respect the per-attribute byte cap. */\n  attributes: Record<string, unknown>\n}\n\nexport interface TraceAnalystTraceSummary {\n  trace_id: string\n  service_name: string | null\n  agent_name: string | null\n  span_count: number\n  has_errors: boolean\n  start_time: string\n  end_time: string\n  duration_ms: number\n  raw_jsonl_bytes: number\n  models: string[]\n  tools: string[]\n}\n\nexport interface TraceAnalystFilters {\n  /** Restrict to traces that contain at least one error span. */\n  has_errors?: boolean\n  /** Match if any span's `service.name` is in this list. */\n  service_names?: string[]\n  /** Match if any span's `agent.name` is in this list. */\n  agent_names?: string[]\n  /** Match if any LLM span's `llm.model_name` is in this list. */\n  model_names?: string[]\n  /** Match if any tool span's `tool.name` is in this list. */\n  tool_names?: string[]\n  /** ISO-8601 lower bound on the trace's earliest start time. */\n  start_time_after?: string\n  /** ISO-8601 upper bound on the trace's earliest start time. */\n  start_time_before?: string\n  /** Single regex applied to raw JSONL bytes for the trace. Opt-in;\n   *  expensive on large datasets. Use the indexed filters above first. */\n  regex_pattern?: string\n}\n\n/** One distinct error signature across the dataset — the deterministic unit of\n *  failure coverage. Signatures normalize volatile tokens (digits, hex/uuids,\n *  paths, durations) out of the span `status_message` so semantically identical\n *  failures collapse into one cluster. An analyst that accounts for every\n *  cluster has, by construction, covered every distinct failure mode. */\nexport interface ErrorCluster {\n  /** Normalized status_message — the cluster key. */\n  signature: string\n  /** A verbatim, un-normalized exemplar message (for exact-string citation). */\n  status_message_sample: string\n  /** The span name that most often carries this signature, if any. */\n  span_name: string | null\n  /** The tool that most often carries this signature, if any. */\n  tool_name: string | null\n  trace_count: number\n  span_count: number\n  /** trace_count / total error traces in the matched set (0..1). */\n  prevalence: number\n  /** Real trace ids carrying this signature (capped), passable to view/search. */\n  exemplar_trace_ids: string[]\n  /** Real span ids carrying this signature (capped). */\n  exemplar_span_ids: string[]\n}\n\nexport interface DatasetOverview {\n  total_traces: number\n  raw_jsonl_bytes: number\n  services: string[]\n  agents: string[]\n  models: string[]\n  tool_names: string[]\n  /** Up to 20 real trace ids the agent may pass to view/search tools. */\n  sample_trace_ids: string[]\n  errors: { trace_count: number; span_count: number }\n  /** The COMPLETE deterministic error-signature population, sorted by\n   *  trace_count desc. This is the failure-coverage checklist: an analysis is\n   *  complete only when every cluster here is accounted for. Empty when the\n   *  matched set has no error spans. */\n  error_clusters: ErrorCluster[]\n  time_range: { earliest: string; latest: string } | null\n}\n\nexport interface QueryTracesPage {\n  traces: TraceAnalystTraceSummary[]\n  total: number\n  has_more: boolean\n}\n\n/** Full-trace view. When the response would exceed the per-call byte\n *  budget, `oversized` is populated INSTEAD of `spans` so the agent\n *  knows to switch to `searchTrace` / `viewSpans`. */\nexport interface ViewTraceResult {\n  trace_id: string\n  spans?: TraceAnalystSpan[]\n  oversized?: ViewTraceOversized\n}\n\nexport interface ViewTraceOversized {\n  span_count: number\n  /** Names with their counts, sorted desc. Capped at 20 entries. */\n  top_span_names: Array<[string, number]>\n  /** Largest single span body (bytes after attribute-cap projection). */\n  span_response_bytes_max: number\n  error_span_count: number\n}\n\nexport interface ViewSpansResult {\n  trace_id: string\n  spans: TraceAnalystSpan[]\n  /** Number of requested span ids that were not found in the trace. */\n  missing_span_ids: string[]\n  /** Number of attribute fields truncated to fit the per-attribute cap. */\n  truncated_attribute_count: number\n}\n\nexport interface SpanMatchRecord {\n  trace_id: string\n  span_id: string\n  span_name: string\n  span_kind: TraceAnalystSpanKind\n  /** JSON pointer-style path to the matched value, e.g.\n   *  `attributes.\"llm.input_messages\"[2].content`. */\n  attribute_path: string\n  matched_text: string\n  context_before: string\n  context_after: string\n  match_offset: number\n}\n\nexport interface SearchTraceResult {\n  trace_id: string\n  hits: SpanMatchRecord[]\n  total_matches: number\n  has_more: boolean\n}\n\nexport interface SearchSpanResult {\n  trace_id: string\n  span_id: string\n  hits: SpanMatchRecord[]\n  total_matches: number\n  has_more: boolean\n}\n\n/** Tunable byte budgets for bounded RLM tool output. */\nexport interface TraceAnalystByteBudgets {\n  /** Max bytes any single tool response may emit. Hard ceiling enforced\n   *  by the store; oversized → summary. Default 150_000. */\n  perCallByteCeiling: number\n  /** Per-attribute string truncation cap on `viewTrace` (discovery scan).\n   *  Default 4096. */\n  perAttributeViewBudget: number\n  /** Per-attribute string truncation cap on `viewSpans` (surgical reads).\n   *  Default 16384. */\n  perAttributeSpanBudget: number\n  /** Per-attribute cap on a single match record's `matched_text` and\n   *  context window. Default 1024. */\n  perMatchTextBudget: number\n}\n\nexport const DEFAULT_TRACE_ANALYST_BUDGETS: TraceAnalystByteBudgets = {\n  perCallByteCeiling: 150_000,\n  perAttributeViewBudget: 4_096,\n  perAttributeSpanBudget: 16_384,\n  perMatchTextBudget: 1_024,\n}\n\n/** Marker substituted in place of truncated string payloads. Callers\n *  parsing tool output can detect it deterministically. */\nexport const TRACE_ANALYST_TRUNCATION_MARKER_PREFIX = '[trace-analyst truncated:'\n","/**\n * `OtlpFileTraceStore` — read-only OTLP-JSONL trace store for the\n * trace-analyst.\n *\n * Wire shape. Each line of the input file is one OTLP-shaped span. The\n * store understands flattened OTLP JSONL plus the OpenInference vocab.\n * We project upstream's full\n * span shape down to `TraceAnalystSpan` lazily — full materialisation\n * only happens for the spans the agent actually requests.\n *\n * Indexing. On first read the store builds an in-memory index keyed\n * by `trace_id` carrying:\n *   - byte offsets + lengths for each span line (for surgical reads\n *     without re-parsing the whole file)\n *   - a `TraceAnalystTraceSummary` rollup\n *   - sets of services / agents / models / tools / has_errors\n *   - byte size of the trace's JSONL slab\n *\n * Memory bound. The index keeps span metadata only — names, kinds,\n * offsets, status. Attribute payloads stay on disk until requested.\n * For a 50MB JSONL with 50k spans, the index is ~5MB.\n *\n * Concurrency. The store builds the index once on first read and\n * caches it. Subsequent reads reuse the index. The file is opened on\n * each read; we never hold a long-lived FD.\n */\n\nimport { readFile, stat } from 'node:fs/promises'\nimport { NotFoundError } from '../errors'\nimport {\n  compareSpanTime,\n  extractOtlpAttributes,\n  projectOtlpFlatLine,\n  spanEpochMillis,\n} from './otlp-span'\nimport { compileSearchRegex, type TraceAnalysisStore, truncateForBudget } from './store'\nimport {\n  type DatasetOverview,\n  DEFAULT_TRACE_ANALYST_BUDGETS,\n  type ErrorCluster,\n  type QueryTracesPage,\n  type SearchSpanResult,\n  type SearchTraceResult,\n  type SpanMatchRecord,\n  type TraceAnalystFilters,\n  type TraceAnalystSpan,\n  type TraceAnalystSpanKind,\n  type TraceAnalystSpanStatus,\n  type TraceAnalystTraceSummary,\n  type ViewSpansResult,\n  type ViewTraceOversized,\n  type ViewTraceResult,\n} from './types'\n\n/** Lines indexed between event-loop yields. Bounded synchronous work per\n *  tick keeps the index build from starving other tasks on large files\n *  while staying coarse enough that the yields are cheap. */\nconst INDEX_YIELD_LINES = 5000\n\n/** Hand control back to the event loop without busy-waiting. */\nfunction yieldToEventLoop(): Promise<void> {\n  return new Promise((resolve) => setImmediate(resolve))\n}\n\ninterface SpanIndexEntry {\n  span_id: string\n  parent_span_id: string | null\n  name: string\n  kind: TraceAnalystSpanKind\n  start_time: string\n  end_time: string\n  duration_ms: number\n  status: TraceAnalystSpanStatus\n  status_message: string | undefined\n  service_name: string | null\n  agent_name: string | null\n  model_name: string | null\n  tool_name: string | null\n  /** Byte offset in the raw JSONL file to the start of this span's line. */\n  line_byte_offset: number\n  /** Length of this line in bytes (excluding the trailing newline). */\n  line_byte_length: number\n}\n\ninterface TraceIndexEntry {\n  trace_id: string\n  service_name: string | null\n  agent_name: string | null\n  span_count: number\n  has_errors: boolean\n  start_time: string\n  end_time: string\n  duration_ms: number\n  raw_jsonl_bytes: number\n  models: Set<string>\n  tools: Set<string>\n  spans: SpanIndexEntry[]\n  /** Sorted by line offset for stable iteration. */\n}\n\ninterface DatasetIndex {\n  byTrace: Map<string, TraceIndexEntry>\n  totalRawBytes: number\n  // Pre-computed sorted trace_ids for sample/query stability.\n  sortedTraceIds: string[]\n}\n\nexport interface OtlpFileTraceStoreOptions {\n  /** Path to the OTLP-JSONL file. */\n  path: string\n  /** Override the discovery (`viewTrace`) per-attribute byte cap. */\n  perAttributeViewBudget?: number\n  /** Override the surgical (`viewSpans`) per-attribute byte cap. */\n  perAttributeSpanBudget?: number\n  /** Override the per-call ceiling that triggers oversized summaries. */\n  perCallByteCeiling?: number\n  /** Override the per-match text budget. */\n  perMatchTextBudget?: number\n  /**\n   * Hard ceiling on the trace file size in bytes. The store reads the\n   * whole file into one Buffer and indexes it in memory, so an\n   * unbounded file OOMs the process. Above this size the store fails\n   * loud with `TraceFileTooLargeError` instead of degrading silently.\n   * Default 256 MiB.\n   */\n  maxFileBytes?: number\n}\n\n/** Default ceiling for {@link OtlpFileTraceStoreOptions.maxFileBytes}. */\nexport const DEFAULT_MAX_TRACE_FILE_BYTES = 256 * 1024 * 1024\n\nexport class OtlpFileTraceStore implements TraceAnalysisStore {\n  private readonly path: string\n  private readonly perAttributeViewBudget: number\n  private readonly perAttributeSpanBudget: number\n  private readonly perCallByteCeiling: number\n  private readonly perMatchTextBudget: number\n  private readonly maxFileBytes: number\n  private indexPromise?: Promise<DatasetIndex>\n  /** Cached UTF-8 buffer of the file. We pin it once because every\n   *  read needs slice access and re-reading on each call balloons the\n   *  syscall count. */\n  private bufferPromise?: Promise<Buffer>\n\n  constructor(opts: OtlpFileTraceStoreOptions) {\n    this.path = opts.path\n    this.perAttributeViewBudget =\n      opts.perAttributeViewBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perAttributeViewBudget\n    this.perAttributeSpanBudget =\n      opts.perAttributeSpanBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perAttributeSpanBudget\n    this.perCallByteCeiling =\n      opts.perCallByteCeiling ?? DEFAULT_TRACE_ANALYST_BUDGETS.perCallByteCeiling\n    this.perMatchTextBudget =\n      opts.perMatchTextBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perMatchTextBudget\n    this.maxFileBytes = opts.maxFileBytes ?? DEFAULT_MAX_TRACE_FILE_BYTES\n  }\n\n  // ─── Public API ────────────────────────────────────────────────────\n\n  async getOverview(filters?: TraceAnalystFilters): Promise<DatasetOverview> {\n    const idx = await this.index()\n    const matched = await this.matchedTraces(idx, filters)\n\n    const services = new Set<string>()\n    const agents = new Set<string>()\n    const models = new Set<string>()\n    const tools = new Set<string>()\n    let rawBytes = 0\n    let earliest: string | null = null\n    let latest: string | null = null\n    let errorTraceCount = 0\n    let errorSpanCount = 0\n    const clusters = new Map<string, ErrorClusterAccumulator>()\n\n    for (const t of matched) {\n      if (t.service_name) services.add(t.service_name)\n      if (t.agent_name) agents.add(t.agent_name)\n      for (const m of t.models) models.add(m)\n      for (const tn of t.tools) tools.add(tn)\n      rawBytes += t.raw_jsonl_bytes\n      if (!earliest || compareSpanTime(t.start_time, earliest) < 0) earliest = t.start_time\n      if (!latest || compareSpanTime(t.end_time, latest) > 0) latest = t.end_time\n      if (t.has_errors) {\n        errorTraceCount += 1\n        for (const s of t.spans) {\n          if (s.status !== 'ERROR') continue\n          errorSpanCount += 1\n          accumulateErrorCluster(clusters, t.trace_id, s)\n        }\n      }\n    }\n\n    const sample_trace_ids = matched.slice(0, 20).map((t) => t.trace_id)\n    return {\n      total_traces: matched.length,\n      raw_jsonl_bytes: rawBytes,\n      services: [...services].sort(),\n      agents: [...agents].sort(),\n      models: [...models].sort(),\n      tool_names: [...tools].sort(),\n      sample_trace_ids,\n      errors: { trace_count: errorTraceCount, span_count: errorSpanCount },\n      error_clusters: finalizeErrorClusters(clusters, errorTraceCount),\n      time_range: earliest && latest ? { earliest, latest } : null,\n    }\n  }\n\n  async queryTraces(opts: {\n    filters?: TraceAnalystFilters\n    limit: number\n    offset?: number\n  }): Promise<QueryTracesPage> {\n    if (!Number.isInteger(opts.limit) || opts.limit < 1 || opts.limit > 200) {\n      throw new RangeError(`queryTraces.limit must be 1..200, got ${opts.limit}`)\n    }\n    const offset = opts.offset ?? 0\n    if (!Number.isInteger(offset) || offset < 0) {\n      throw new RangeError(`queryTraces.offset must be >=0, got ${offset}`)\n    }\n\n    const idx = await this.index()\n    const matched = await this.matchedTraces(idx, opts.filters)\n    const slice = matched.slice(offset, offset + opts.limit)\n    return {\n      traces: slice.map((t) => this.toSummary(t)),\n      total: matched.length,\n      has_more: offset + slice.length < matched.length,\n    }\n  }\n\n  async countTraces(filters?: TraceAnalystFilters): Promise<number> {\n    const idx = await this.index()\n    const matched = await this.matchedTraces(idx, filters)\n    return matched.length\n  }\n\n  async viewTrace(opts: {\n    trace_id: string\n    per_attribute_byte_cap?: number\n  }): Promise<ViewTraceResult> {\n    const idx = await this.index()\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) {\n      throw new TraceNotFoundError(opts.trace_id)\n    }\n    const cap = opts.per_attribute_byte_cap ?? this.perAttributeViewBudget\n\n    // Probe size first — if the materialised payload would exceed\n    // the per-call ceiling we return an oversized summary rather than\n    // blowing the agent's context.\n    const buf = await this.buffer()\n    const spans: TraceAnalystSpan[] = []\n    let runningBytes = 0\n    let span_response_bytes_max = 0\n    const counter: TruncationCounter = { value: 0 }\n    for (const s of trace.spans) {\n      const projected = this.projectSpan(buf, trace.trace_id, s, cap, counter)\n      const bytes = Buffer.byteLength(JSON.stringify(projected), 'utf8')\n      span_response_bytes_max = Math.max(span_response_bytes_max, bytes)\n      runningBytes += bytes\n      if (runningBytes > this.perCallByteCeiling) {\n        return {\n          trace_id: trace.trace_id,\n          oversized: this.buildOversizedSummary(trace, span_response_bytes_max),\n        }\n      }\n      spans.push(projected)\n    }\n    return { trace_id: trace.trace_id, spans }\n  }\n\n  async viewSpans(opts: {\n    trace_id: string\n    span_ids: readonly string[]\n    per_attribute_byte_cap?: number\n  }): Promise<ViewSpansResult> {\n    const idx = await this.index()\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) throw new TraceNotFoundError(opts.trace_id)\n    if (opts.span_ids.length === 0) {\n      return {\n        trace_id: trace.trace_id,\n        spans: [],\n        missing_span_ids: [],\n        truncated_attribute_count: 0,\n      }\n    }\n    if (opts.span_ids.length > 100) {\n      throw new RangeError(`viewSpans.span_ids cap is 100, got ${opts.span_ids.length}`)\n    }\n    const cap = opts.per_attribute_byte_cap ?? this.perAttributeSpanBudget\n\n    const wantSet = new Set(opts.span_ids)\n    const found = trace.spans.filter((s) => wantSet.has(s.span_id))\n    const missing = opts.span_ids.filter((id) => !found.some((f) => f.span_id === id))\n\n    const buf = await this.buffer()\n    const spans: TraceAnalystSpan[] = []\n    const counter: TruncationCounter = { value: 0 }\n    let runningBytes = 0\n    for (const s of found) {\n      const projected = this.projectSpan(buf, trace.trace_id, s, cap, counter)\n      const bytes = Buffer.byteLength(JSON.stringify(projected), 'utf8')\n      runningBytes += bytes\n      if (runningBytes > this.perCallByteCeiling) {\n        // Stop adding further spans rather than truncate mid-list.\n        // Callers can refetch the rest with a smaller `span_ids`.\n        break\n      }\n      spans.push(projected)\n    }\n    return {\n      trace_id: trace.trace_id,\n      spans,\n      missing_span_ids: missing,\n      truncated_attribute_count: counter.value,\n    }\n  }\n\n  async searchTrace(opts: {\n    trace_id: string\n    regex_pattern: string\n    max_matches?: number\n  }): Promise<SearchTraceResult> {\n    const max_matches = opts.max_matches ?? 50\n    if (!Number.isInteger(max_matches) || max_matches < 1 || max_matches > 500) {\n      throw new RangeError(`searchTrace.max_matches must be 1..500, got ${max_matches}`)\n    }\n    const idx = await this.index()\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) throw new TraceNotFoundError(opts.trace_id)\n    const re = compileSearchRegex(opts.regex_pattern)\n\n    const buf = await this.buffer()\n    const hits: SpanMatchRecord[] = []\n    let total = 0\n    let capped = false\n    for (const s of trace.spans) {\n      const remaining = max_matches - hits.length\n      const localHits = await this.scanSpanForMatches(\n        buf,\n        trace.trace_id,\n        s,\n        re,\n        this.perMatchTextBudget,\n        remaining,\n      )\n      total += localHits.total\n      for (const h of localHits.records) {\n        if (hits.length >= max_matches) break\n        hits.push(h)\n      }\n      if (hits.length >= max_matches) {\n        // Capped: we stopped scanning, so `total` is a lower bound on the\n        // real match count — never report it as exact. has_more signals\n        // \"more exist\"; total_matches mirrors hits so callers don't read a\n        // fabricated number.\n        capped = true\n        break\n      }\n    }\n    return {\n      trace_id: trace.trace_id,\n      hits,\n      // Uncapped: every span scanned to completion, so `total` is exact.\n      total_matches: capped ? hits.length : total,\n      has_more: capped || total > hits.length,\n    }\n  }\n\n  async searchSpan(opts: {\n    trace_id: string\n    span_id: string\n    regex_pattern: string\n    max_matches?: number\n  }): Promise<SearchSpanResult> {\n    const max_matches = opts.max_matches ?? 50\n    if (!Number.isInteger(max_matches) || max_matches < 1 || max_matches > 500) {\n      throw new RangeError(`searchSpan.max_matches must be 1..500, got ${max_matches}`)\n    }\n    const idx = await this.index()\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) throw new TraceNotFoundError(opts.trace_id)\n    const span = trace.spans.find((s) => s.span_id === opts.span_id)\n    if (!span) {\n      throw new SpanNotFoundError(opts.trace_id, opts.span_id)\n    }\n    const re = compileSearchRegex(opts.regex_pattern)\n    const buf = await this.buffer()\n    const localHits = await this.scanSpanForMatches(\n      buf,\n      trace.trace_id,\n      span,\n      re,\n      this.perMatchTextBudget,\n      max_matches,\n    )\n    return {\n      trace_id: trace.trace_id,\n      span_id: span.span_id,\n      hits: localHits.records,\n      total_matches: localHits.total,\n      has_more: localHits.total > localHits.records.length,\n    }\n  }\n\n  // ─── Index building ────────────────────────────────────────────────\n\n  /** Force the index to materialise. Useful to amortise startup cost\n   *  before the first agent call. */\n  async ensureIndexed(): Promise<void> {\n    await this.index()\n  }\n\n  private async buffer(): Promise<Buffer> {\n    if (!this.bufferPromise) {\n      this.bufferPromise = this.readGuarded()\n    }\n    return this.bufferPromise\n  }\n\n  /** Stat-then-read so an oversized file fails loud BEFORE we allocate a\n   *  multi-hundred-MB Buffer and OOM the process. A missing file surfaces\n   *  as TraceFileMissingError; any other stat/read error propagates. */\n  private async readGuarded(): Promise<Buffer> {\n    let stats: Awaited<ReturnType<typeof stat>>\n    try {\n      stats = await stat(this.path)\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException)?.code === 'ENOENT') {\n        throw new TraceFileMissingError(this.path)\n      }\n      throw err\n    }\n    if (stats.size > this.maxFileBytes) {\n      throw new TraceFileTooLargeError(this.path, stats.size, this.maxFileBytes)\n    }\n    return readFile(this.path)\n  }\n\n  private async index(): Promise<DatasetIndex> {\n    if (!this.indexPromise) {\n      this.indexPromise = this.buildIndex()\n    }\n    return this.indexPromise\n  }\n\n  private async buildIndex(): Promise<DatasetIndex> {\n    // readGuarded surfaces missing/oversized files as typed errors.\n    const buf = await this.buffer()\n\n    const byTrace = new Map<string, TraceIndexEntry>()\n    let cursor = 0\n    let sinceYield = 0\n    while (cursor < buf.length) {\n      // Yield to the event loop every INDEX_YIELD_LINES lines so a huge\n      // file doesn't monopolise the thread for the whole index build.\n      if (++sinceYield >= INDEX_YIELD_LINES) {\n        sinceYield = 0\n        await yieldToEventLoop()\n      }\n      const newlineIndex = buf.indexOf(0x0a, cursor) // \\n\n      const lineEnd = newlineIndex === -1 ? buf.length : newlineIndex\n      const lineLength = lineEnd - cursor\n      if (lineLength === 0) {\n        cursor = lineEnd + 1\n        continue\n      }\n      const lineSlice = buf.subarray(cursor, lineEnd).toString('utf8')\n      const lineOffset = cursor\n      cursor = lineEnd + 1\n\n      let parsed: unknown\n      try {\n        parsed = JSON.parse(lineSlice)\n      } catch {\n        // Skip malformed lines silently. The agent shouldn't see them\n        // but we don't want one bad line to nuke an entire dataset.\n        continue\n      }\n      if (!parsed || typeof parsed !== 'object') continue\n      const span = projectOtlpFlatLine(parsed as Record<string, unknown>)\n      if (!span) continue\n\n      let entry = byTrace.get(span.trace_id)\n      if (!entry) {\n        entry = {\n          trace_id: span.trace_id,\n          service_name: span.service_name,\n          agent_name: span.agent_name,\n          span_count: 0,\n          has_errors: false,\n          start_time: span.start_time,\n          end_time: span.end_time,\n          duration_ms: 0,\n          raw_jsonl_bytes: 0,\n          models: new Set(),\n          tools: new Set(),\n          spans: [],\n        }\n        byTrace.set(span.trace_id, entry)\n      } else {\n        // Pin the trace's service/agent to the first AGENT span we\n        // Prefer the first agent/service fields that appear in the trace.\n        if (!entry.service_name && span.service_name) entry.service_name = span.service_name\n        if (!entry.agent_name && span.agent_name) entry.agent_name = span.agent_name\n      }\n\n      const indexEntry: SpanIndexEntry = {\n        span_id: span.span_id,\n        parent_span_id: span.parent_span_id,\n        name: span.name,\n        kind: span.kind,\n        start_time: span.start_time,\n        end_time: span.end_time,\n        duration_ms: span.duration_ms,\n        status: span.status,\n        status_message: span.status_message,\n        service_name: span.service_name,\n        agent_name: span.agent_name,\n        model_name: span.model_name,\n        tool_name: span.tool_name,\n        line_byte_offset: lineOffset,\n        line_byte_length: lineLength,\n      }\n      entry.spans.push(indexEntry)\n      entry.span_count += 1\n      entry.raw_jsonl_bytes += lineLength + 1 // +1 newline byte\n      if (span.status === 'ERROR') entry.has_errors = true\n      if (compareSpanTime(span.start_time, entry.start_time) < 0) entry.start_time = span.start_time\n      if (compareSpanTime(span.end_time, entry.end_time) > 0) entry.end_time = span.end_time\n      if (span.model_name) entry.models.add(span.model_name)\n      if (span.tool_name) entry.tools.add(span.tool_name)\n    }\n\n    // Compute trace duration once, sort spans by start time for\n    // stable iteration.\n    let totalRawBytes = 0\n    for (const t of byTrace.values()) {\n      totalRawBytes += t.raw_jsonl_bytes\n      t.spans.sort(\n        (a, b) =>\n          compareSpanTime(a.start_time, b.start_time) || a.line_byte_offset - b.line_byte_offset,\n      )\n      // Duration is 0 unless BOTH bounds parse — a missing/garbage timestamp\n      // yields 0, never a NaN (→ null in JSON) or a bogus epoch-from-zero span.\n      const startMs = spanEpochMillis(t.start_time)\n      const endMs = spanEpochMillis(t.end_time)\n      t.duration_ms = startMs === null || endMs === null ? 0 : Math.max(0, endMs - startMs)\n    }\n    const sortedTraceIds = [...byTrace.keys()].sort()\n\n    return { byTrace, totalRawBytes, sortedTraceIds }\n  }\n\n  // ─── Filter pipeline ───────────────────────────────────────────────\n\n  private async matchedTraces(\n    idx: DatasetIndex,\n    filters: TraceAnalystFilters | undefined,\n  ): Promise<TraceIndexEntry[]> {\n    const traces = idx.sortedTraceIds.map((id) => idx.byTrace.get(id)).filter(isPresent)\n    if (!filters) return traces\n\n    const indexedFiltered = traces.filter((t) => {\n      if (filters.has_errors !== undefined && t.has_errors !== filters.has_errors) return false\n      if (filters.service_names && filters.service_names.length > 0) {\n        if (!t.service_name || !filters.service_names.includes(t.service_name)) return false\n      }\n      if (filters.agent_names && filters.agent_names.length > 0) {\n        if (!t.agent_name || !filters.agent_names.includes(t.agent_name)) return false\n      }\n      if (filters.model_names && filters.model_names.length > 0) {\n        if (![...t.models].some((m) => filters.model_names!.includes(m))) return false\n      }\n      if (filters.tool_names && filters.tool_names.length > 0) {\n        if (![...t.tools].some((tn) => filters.tool_names!.includes(tn))) return false\n      }\n      if (filters.start_time_after && t.start_time < filters.start_time_after) return false\n      if (filters.start_time_before && t.start_time > filters.start_time_before) return false\n      return true\n    })\n\n    if (!filters.regex_pattern) return indexedFiltered\n\n    // Opt-in raw-bytes scan — only over the already-narrowed set.\n    const re = compileSearchRegex(filters.regex_pattern)\n    const buf = await this.buffer()\n    const out: TraceIndexEntry[] = []\n    for (const t of indexedFiltered) {\n      let matched = false\n      for (const s of t.spans) {\n        const slice = buf.subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length)\n        // Buffer.toString allocates; tolerate it because regex_pattern\n        // is opt-in. Future optimisation: byte-level fast-path for\n        // ASCII-only patterns.\n        if (re.test(slice.toString('utf8'))) {\n          matched = true\n          break\n        }\n      }\n      if (matched) out.push(t)\n    }\n    return out\n  }\n\n  private toSummary(t: TraceIndexEntry): TraceAnalystTraceSummary {\n    return {\n      trace_id: t.trace_id,\n      service_name: t.service_name,\n      agent_name: t.agent_name,\n      span_count: t.span_count,\n      has_errors: t.has_errors,\n      start_time: t.start_time,\n      end_time: t.end_time,\n      duration_ms: t.duration_ms,\n      raw_jsonl_bytes: t.raw_jsonl_bytes,\n      models: [...t.models].sort(),\n      tools: [...t.tools].sort(),\n    }\n  }\n\n  // ─── Span projection (lazy attribute reads) ────────────────────────\n\n  private projectSpan(\n    buf: Buffer,\n    trace_id: string,\n    s: SpanIndexEntry,\n    perAttrCap: number,\n    counter: TruncationCounter,\n  ): TraceAnalystSpan {\n    const slice = buf\n      .subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length)\n      .toString('utf8')\n    let raw: Record<string, unknown> = {}\n    try {\n      const parsed = JSON.parse(slice)\n      if (parsed && typeof parsed === 'object') raw = parsed as Record<string, unknown>\n    } catch {\n      // Should not happen — index pre-validated.\n    }\n    const attrs = extractOtlpAttributes(raw)\n    const projected: Record<string, unknown> = {}\n    for (const [k, v] of Object.entries(attrs)) {\n      if (typeof v === 'string') {\n        const trunc = truncateForBudget(v, perAttrCap)\n        if (trunc !== v) counter.value += 1\n        projected[k] = trunc\n      } else if (Array.isArray(v) || (v && typeof v === 'object')) {\n        const json = JSON.stringify(v)\n        const trunc = truncateForBudget(json, perAttrCap)\n        if (trunc !== json) {\n          counter.value += 1\n          projected[k] = trunc\n        } else {\n          projected[k] = v\n        }\n      } else {\n        projected[k] = v\n      }\n    }\n    return {\n      trace_id,\n      span_id: s.span_id,\n      parent_span_id: s.parent_span_id,\n      name: s.name,\n      kind: s.kind,\n      start_time: s.start_time,\n      end_time: s.end_time,\n      duration_ms: s.duration_ms,\n      status: s.status,\n      status_message: s.status_message,\n      service_name: s.service_name,\n      agent_name: s.agent_name,\n      model_name: s.model_name,\n      tool_name: s.tool_name,\n      attributes: projected,\n    }\n  }\n\n  private buildOversizedSummary(\n    t: TraceIndexEntry,\n    span_response_bytes_max: number,\n  ): ViewTraceOversized {\n    const counts = new Map<string, number>()\n    let errorCount = 0\n    for (const s of t.spans) {\n      counts.set(s.name, (counts.get(s.name) ?? 0) + 1)\n      if (s.status === 'ERROR') errorCount += 1\n    }\n    const top = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20)\n    return {\n      span_count: t.span_count,\n      top_span_names: top,\n      span_response_bytes_max,\n      error_span_count: errorCount,\n    }\n  }\n\n  private async scanSpanForMatches(\n    buf: Buffer,\n    trace_id: string,\n    s: SpanIndexEntry,\n    re: RegExp,\n    textBudget: number,\n    recordCap: number,\n  ): Promise<{ records: SpanMatchRecord[]; total: number; hasMore: boolean }> {\n    // We scan against the original raw JSONL slice for each span and\n    // record byte positions; the matched_text + context window is\n    // truncated to `textBudget` bytes per record so total tool output\n    // stays bounded even if hits cluster.\n    const slice = buf\n      .subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length)\n      .toString('utf8')\n    const records: SpanMatchRecord[] = []\n    const globalRe = new RegExp(re.source, re.flags.includes('g') ? re.flags : `${re.flags}g`)\n    let total = 0\n    let hasMore = false\n    let m: RegExpExecArray | null = globalRe.exec(slice)\n    while (m !== null) {\n      total += 1\n      if (m.index === globalRe.lastIndex) globalRe.lastIndex += 1 // zero-width guard\n      if (records.length >= recordCap) {\n        hasMore = true\n        break\n      }\n      const before = slice.slice(Math.max(0, m.index - textBudget / 2), m.index)\n      const after = slice.slice(\n        m.index + m[0].length,\n        m.index + m[0].length + Math.floor(textBudget / 2),\n      )\n      records.push({\n        trace_id,\n        span_id: s.span_id,\n        span_name: s.name,\n        span_kind: s.kind,\n        attribute_path: bestAttributePathForOffset(slice, m.index) ?? 'span.raw',\n        matched_text: truncateForBudget(m[0], textBudget),\n        context_before: truncateForBudget(before, textBudget),\n        context_after: truncateForBudget(after, textBudget),\n        match_offset: m.index,\n      })\n      m = globalRe.exec(slice)\n    }\n    return { records, total, hasMore }\n  }\n}\n\n// ─── Errors ──────────────────────────────────────────────────────────\n\nexport class TraceFileMissingError extends NotFoundError {\n  constructor(path: string) {\n    super(`trace file not found: ${path}`)\n  }\n}\nexport class TraceFileTooLargeError extends Error {\n  readonly path: string\n  readonly size_bytes: number\n  readonly max_bytes: number\n  constructor(path: string, size_bytes: number, max_bytes: number) {\n    super(\n      `trace file ${path} is ${size_bytes} bytes, over the ${max_bytes}-byte limit; ` +\n        'raise OtlpFileTraceStoreOptions.maxFileBytes or pre-split the file',\n    )\n    this.path = path\n    this.size_bytes = size_bytes\n    this.max_bytes = max_bytes\n  }\n}\nexport class TraceNotFoundError extends NotFoundError {\n  readonly trace_id: string\n  constructor(trace_id: string) {\n    super(`trace not found: ${trace_id}`)\n    this.trace_id = trace_id\n  }\n}\nexport class SpanNotFoundError extends NotFoundError {\n  readonly trace_id: string\n  readonly span_id: string\n  constructor(trace_id: string, span_id: string) {\n    super(`span ${span_id} not found in trace ${trace_id}`)\n    this.trace_id = trace_id\n    this.span_id = span_id\n  }\n}\n\n// ─── OTLP shape readers ──────────────────────────────────────────────\n//\n// The per-line projection lives in `./otlp-span` so the index here and\n// `otlpToRunRecords` read the same vocabulary off the same parser.\n\nfunction isPresent<T>(v: T | undefined): v is T {\n  return v !== undefined\n}\n\n// Per-call truncation counter. Each public read that projects spans\n// owns one of these and threads it through projectSpan; a store-keyed\n// counter would let two concurrent reads on the same store report each\n// other's truncation counts.\ninterface TruncationCounter {\n  value: number\n}\n\n/** A `\"` at `idx` is a real JSON delimiter only when the run of `\\`\n *  immediately preceding it is even-length; an odd run means the quote\n *  is escaped (`\\\"`) and is part of a string value, not a boundary. */\nfunction isUnescapedQuote(slice: string, idx: number): boolean {\n  if (slice[idx] !== '\"') return false\n  let backslashes = 0\n  let b = idx - 1\n  while (b >= 0 && slice[b] === '\\\\') {\n    backslashes += 1\n    b -= 1\n  }\n  return backslashes % 2 === 0\n}\n\n/** Scan backwards from `from` (inclusive) for the nearest UNescaped `\"`.\n *  Returns its index, or -1 when none is found. */\nfunction prevUnescapedQuote(slice: string, from: number): number {\n  for (let i = from; i >= 0; i -= 1) {\n    if (slice[i] === '\"' && isUnescapedQuote(slice, i)) return i\n  }\n  return -1\n}\n\n/**\n * Best-effort: locate the JSON path for the substring at `offset` in\n * a single span's JSONL slice. The slice is '...,\"key\":\"value...\"' — we\n * walk back from `offset` to the value-opening quote, past the `:`, to\n * the key's closing then opening quote, skipping `\\\"`-escaped quotes that\n * live inside string values. Returns `null` when the offset doesn't fall\n * inside a recognisable string field.\n */\nfunction bestAttributePathForOffset(slice: string, offset: number): string | null {\n  // Value-opening quote: nearest unescaped '\"' at or before the offset.\n  const valueQuote = prevUnescapedQuote(slice, Math.min(offset, slice.length - 1))\n  if (valueQuote < 1) return null\n  // The ':' separating key and value sits before the value quote.\n  let j = valueQuote - 1\n  while (j >= 0 && slice[j] !== ':') j -= 1\n  if (j < 1) return null\n  // Key closing quote, then key opening quote — both unescaped.\n  const keyClose = prevUnescapedQuote(slice, j - 1)\n  if (keyClose < 1) return null\n  const keyOpen = prevUnescapedQuote(slice, keyClose - 1)\n  if (keyOpen < 0) return null\n  return slice.slice(keyOpen + 1, keyClose)\n}\n\n// ─── Error-cluster extraction ────────────────────────────────────────\n//\n// Deterministic failure-coverage population. The error-span loop in\n// getOverview already visits every ERROR span; bucketing them by a\n// normalized status_message signature turns \"N error spans\" into \"K\n// distinct failure modes\" — the checklist an analyst must close. No LLM.\n\nconst ERROR_CLUSTER_MAX = 50\nconst ERROR_CLUSTER_EXEMPLARS = 5\nconst SIGNATURE_MAX_CHARS = 160\n\ninterface ErrorClusterAccumulator {\n  signature: string\n  sample: string\n  traceIds: Set<string>\n  spanIds: string[]\n  spanCount: number\n  spanNames: Map<string, number>\n  toolNames: Map<string, number>\n}\n\n/** Collapse volatile tokens so semantically identical failures share a key:\n *  hex/uuid ids → <id>, numbers → #, quoted/abs paths → <path>, durations →\n *  <dur>, whitespace collapsed. Empty/absent messages fall back to the span\n *  name so a no-message error still forms a real cluster. */\nfunction normalizeErrorSignature(message: string | undefined, spanName: string): string {\n  const raw = (message ?? '').trim()\n  const base = raw.length > 0 ? raw : `(${spanName || 'error'} — no message)`\n  const norm = base\n    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '<id>')\n    .replace(/\\b[0-9a-f]{12,}\\b/gi, '<id>')\n    .replace(/(?:\\/[\\w.\\-@]+){2,}/g, '<path>')\n    .replace(/\\b\\d+(?:\\.\\d+)?(ms|s|m|h|kb|mb|gb)?\\b/gi, (_m, u) => (u ? `#${u}` : '#'))\n    .replace(/\\s+/g, ' ')\n    .trim()\n  return norm.length > SIGNATURE_MAX_CHARS ? `${norm.slice(0, SIGNATURE_MAX_CHARS)}…` : norm\n}\n\nfunction bump(map: Map<string, number>, key: string | null): void {\n  if (!key) return\n  map.set(key, (map.get(key) ?? 0) + 1)\n}\n\nfunction topKey(map: Map<string, number>): string | null {\n  let best: string | null = null\n  let bestN = 0\n  for (const [k, n] of map)\n    if (n > bestN) {\n      best = k\n      bestN = n\n    }\n  return best\n}\n\nfunction accumulateErrorCluster(\n  clusters: Map<string, ErrorClusterAccumulator>,\n  traceId: string,\n  span: SpanIndexEntry,\n): void {\n  const signature = normalizeErrorSignature(span.status_message, span.name)\n  let acc = clusters.get(signature)\n  if (!acc) {\n    acc = {\n      signature,\n      sample: (span.status_message ?? span.name ?? '').slice(0, 500),\n      traceIds: new Set(),\n      spanIds: [],\n      spanCount: 0,\n      spanNames: new Map(),\n      toolNames: new Map(),\n    }\n    clusters.set(signature, acc)\n  }\n  acc.traceIds.add(traceId)\n  acc.spanCount += 1\n  if (acc.spanIds.length < ERROR_CLUSTER_EXEMPLARS && !acc.spanIds.includes(span.span_id)) {\n    acc.spanIds.push(span.span_id)\n  }\n  bump(acc.spanNames, span.name)\n  bump(acc.toolNames, span.tool_name)\n}\n\nfunction finalizeErrorClusters(\n  clusters: Map<string, ErrorClusterAccumulator>,\n  errorTraceCount: number,\n): ErrorCluster[] {\n  const out = [...clusters.values()].map(\n    (acc): ErrorCluster => ({\n      signature: acc.signature,\n      status_message_sample: acc.sample,\n      span_name: topKey(acc.spanNames),\n      tool_name: topKey(acc.toolNames),\n      trace_count: acc.traceIds.size,\n      span_count: acc.spanCount,\n      prevalence: errorTraceCount > 0 ? acc.traceIds.size / errorTraceCount : 0,\n      exemplar_trace_ids: [...acc.traceIds].slice(0, ERROR_CLUSTER_EXEMPLARS),\n      exemplar_span_ids: acc.spanIds.slice(0, ERROR_CLUSTER_EXEMPLARS),\n    }),\n  )\n  out.sort((a, b) => b.trace_count - a.trace_count || b.span_count - a.span_count)\n  return out.slice(0, ERROR_CLUSTER_MAX)\n}\n","/**\n * `TraceAnalysisStore` — read-side interface the trace-analyst calls\n * through. Six operations, all bounded:\n *\n *   - `getOverview(filters?)` — dataset rollup + sample trace ids.\n *   - `queryTraces(filters?, limit, offset)` — paginated summaries.\n *   - `countTraces(filters?)` — cheap count without materialisation.\n *   - `viewTrace(trace_id, perAttrCap)` — full span list, oversized → summary.\n *   - `viewSpans(trace_id, span_ids, perAttrCap)` — surgical span fetch.\n *   - `searchTrace(trace_id, regex, max_matches)` — bounded regex hits.\n *   - `searchSpan(trace_id, span_id, regex, max_matches)` — single-span search.\n *\n * Multiple implementations ship in the core (`OtlpFileTraceStore`).\n * Downstream callers can supply their own — e.g. a DuckDB-backed\n * adapter or an in-memory adapter for tests — by implementing this\n * interface.\n *\n * Filters compose with AND semantics. Empty/undefined fields impose\n * no constraint. `regex_pattern` is the only opt-in raw-bytes scan —\n * implementations may skip it via `count`/`overview` when not set.\n */\n\nimport type {\n  DatasetOverview,\n  QueryTracesPage,\n  SearchSpanResult,\n  SearchTraceResult,\n  TraceAnalystFilters,\n  ViewSpansResult,\n  ViewTraceResult,\n} from './types'\n\nexport interface TraceAnalysisStore {\n  getOverview(filters?: TraceAnalystFilters): Promise<DatasetOverview>\n\n  queryTraces(opts: {\n    filters?: TraceAnalystFilters\n    limit: number\n    offset?: number\n  }): Promise<QueryTracesPage>\n\n  countTraces(filters?: TraceAnalystFilters): Promise<number>\n\n  viewTrace(opts: {\n    trace_id: string\n    /** Override per-attribute byte cap. Defaults to discovery budget. */\n    per_attribute_byte_cap?: number\n  }): Promise<ViewTraceResult>\n\n  viewSpans(opts: {\n    trace_id: string\n    span_ids: readonly string[]\n    /** Override per-attribute byte cap. Defaults to surgical budget. */\n    per_attribute_byte_cap?: number\n  }): Promise<ViewSpansResult>\n\n  searchTrace(opts: {\n    trace_id: string\n    regex_pattern: string\n    /** Hard cap on matches returned. Default 50. */\n    max_matches?: number\n  }): Promise<SearchTraceResult>\n\n  searchSpan(opts: {\n    trace_id: string\n    span_id: string\n    regex_pattern: string\n    max_matches?: number\n  }): Promise<SearchSpanResult>\n}\n\n/** Compile a regex with the same anchoring + flags semantics across\n *  implementations. Throws on invalid pattern — callers should surface\n *  that to the agent so it can refine instead of looping. */\nexport function compileSearchRegex(pattern: string): RegExp {\n  let source = pattern\n  let flags = 'm'\n  if (source.startsWith('(?i)')) {\n    source = source.slice(4)\n    flags += 'i'\n  }\n  return new RegExp(source, flags)\n}\n\n/** Truncate string payload deterministically for tool responses.\n *  Marker is parseable so downstream consumers can detect truncation\n *  and decide whether to fetch surgically. */\nexport function truncateForBudget(value: string, byteCap: number): string {\n  // We measure UTF-8 byte length conservatively via Buffer.byteLength;\n  // for predictability the truncation point is in CHARS, never inside\n  // a code point.\n  const original = Buffer.byteLength(value, 'utf8')\n  if (original <= byteCap) return value\n\n  // Step back from the cap until we're at a valid char boundary.\n  // Slice by char count proportional to byte ratio, then re-measure.\n  const ratio = byteCap / original\n  let cut = Math.max(0, Math.floor(value.length * ratio))\n  while (cut > 0 && Buffer.byteLength(value.slice(0, cut), 'utf8') > byteCap) {\n    cut -= 1\n  }\n  return `${value.slice(0, cut)}\\n[trace-analyst truncated: original ${original} bytes]`\n}\n","/**\n * Trace-analyst tool surface — six namespaced AxFunctions the analyst\n * agent calls from generated JS code via `traces.<name>(...)`.\n *\n * Discovery → narrow → deep-read protocol. Tool names + ordering\n * support RLM discovery:\n *\n *   1. `getDatasetOverview` (cheap)  — first call, sizes the dataset\n *   2. `queryTraces`                 — paginated summaries with `raw_jsonl_bytes`\n *   3. `countTraces`                 — cheap pre-flight before regex\n *   4. `viewTrace`                   — full span list, oversized → summary\n *   5. `viewSpans`                   — surgical 16KB-cap reads\n *   6. `searchTrace` / `searchSpan`  — bounded regex hits\n *\n * Failure mode. Tool handlers throw on bad input (invalid trace ids,\n * out-of-range pagination, malformed regex). Ax converts thrown errors\n * into actor-visible `[ERROR]` strings so the analyst can adjust on\n * the next turn instead of looping.\n */\n\nimport type { AxFunction } from '@ax-llm/ax'\nimport { f, fn } from '@ax-llm/ax'\n\nimport type { TraceAnalysisStore } from './store'\nimport type { TraceAnalystFilters } from './types'\n\nconst NAMESPACE = 'traces'\n\ninterface BuildTraceAnalystToolsOpts {\n  store: TraceAnalysisStore\n  /** Override the default sample-trace-id slot count (20). Mostly for tests. */\n  sampleTraceLimit?: number\n}\n\nconst filtersField = f\n  .json('Filter set. ALL fields are AND-composed. Leave empty to scan everything.')\n  .optional()\n\n/**\n * Build the trace-analyst function set. Pass the result into\n * `agent(...).functions.local`.\n */\nexport function buildTraceAnalystTools(opts: BuildTraceAnalystToolsOpts): AxFunction[] {\n  const { store } = opts\n\n  const getDatasetOverview = fn('getDatasetOverview')\n    .description(\n      'Dataset rollup: total traces, raw_jsonl_bytes, services, agents, ' +\n        'models, tools, and sample_trace_ids (real ids passable to ' +\n        'view/search). Always call this FIRST without a regex_pattern.',\n    )\n    .namespace(NAMESPACE)\n    .arg('filters', filtersField)\n    .returns(f.json('DatasetOverview'))\n    .handler(async ({ filters }) => store.getOverview(parseFilters(filters)))\n    .build()\n\n  const queryTraces = fn('queryTraces')\n    .description(\n      'Paginated trace summaries. Each summary carries raw_jsonl_bytes — ' +\n        'use it to size traces BEFORE calling viewTrace. Narrow with indexed ' +\n        'filters before adding regex_pattern.',\n    )\n    .namespace(NAMESPACE)\n    .arg('filters', filtersField)\n    .arg('limit', f.number('Page size, 1..200'))\n    .arg('offset', f.number('Page offset; default 0').optional())\n    .returns(f.json('QueryTracesPage'))\n    .handler(async ({ filters, limit, offset }) =>\n      store.queryTraces({\n        filters: parseFilters(filters),\n        limit: assertPageLimit(limit),\n        offset: assertOffset(offset),\n      }),\n    )\n    .build()\n\n  const countTraces = fn('countTraces')\n    .description(\n      'Count traces matching `filters`. Use as a cheap pre-flight ' +\n        'before opting into a regex_pattern scan.',\n    )\n    .namespace(NAMESPACE)\n    .arg('filters', filtersField)\n    .returns(f.number('count'))\n    .handler(async ({ filters }) => store.countTraces(parseFilters(filters)))\n    .build()\n\n  const viewTrace = fn('viewTrace')\n    .description(\n      'Return ALL spans for a single trace, with each attribute capped at ' +\n        '~4KB. If the response would exceed the per-call ceiling the result ' +\n        'carries `oversized` instead of `spans` — DO NOT retry with the same ' +\n        'trace_id; switch to searchTrace / viewSpans.',\n    )\n    .namespace(NAMESPACE)\n    .arg('trace_id', f.string('Real trace id from a prior overview/query'))\n    .returns(f.json('ViewTraceResult'))\n    .handler(async ({ trace_id }) =>\n      store.viewTrace({ trace_id: assertString(trace_id, 'trace_id') }),\n    )\n    .build()\n\n  const viewSpans = fn('viewSpans')\n    .description(\n      'Surgical read of specific spans within a trace, with each ' +\n        'attribute capped at ~16KB (4× the discovery cap). Use after ' +\n        'searchTrace narrows to specific span_ids.',\n    )\n    .namespace(NAMESPACE)\n    .arg('trace_id', f.string('Real trace id'))\n    .arg('span_ids', f.string('Span ids to fetch').array())\n    .returns(f.json('ViewSpansResult'))\n    .handler(async ({ trace_id, span_ids }) =>\n      store.viewSpans({\n        trace_id: assertString(trace_id, 'trace_id'),\n        span_ids: assertStringArray(span_ids, 'span_ids'),\n      }),\n    )\n    .build()\n\n  const searchTrace = fn('searchTrace')\n    .description(\n      'Regex search across all spans of one trace. Returns ' +\n        '`{trace_id, hits: SpanMatchRecord[], total_matches, has_more}`. ' +\n        '**Iterate `result.hits`, NOT `result.matches`** — the field is ' +\n        '`hits`. Each hit has `{span_id, span_name, span_kind, ' +\n        'attribute_path, matched_text, context_before, context_after, ' +\n        'match_offset}`. Bounded regardless of trace size by max_matches ' +\n        '(1..500, default 50). If has_more=true, REFINE the regex rather ' +\n        'than blindly raising max_matches.',\n    )\n    .namespace(NAMESPACE)\n    .arg('trace_id', f.string('Real trace id'))\n    .arg('regex_pattern', f.string('JS-compatible regex, multiline'))\n    .arg('max_matches', f.number('Max records returned, 1..500; default 50').optional())\n    .returns(f.json('SearchTraceResult'))\n    .handler(async ({ trace_id, regex_pattern, max_matches }) =>\n      store.searchTrace({\n        trace_id: assertString(trace_id, 'trace_id'),\n        regex_pattern: assertRegex(regex_pattern),\n        max_matches: assertMaxMatches(max_matches),\n      }),\n    )\n    .build()\n\n  const searchSpan = fn('searchSpan')\n    .description(\n      'Regex search inside a single span. Use when viewSpans returned ' +\n        'a 16KB-truncated payload and you need to narrow further. ' +\n        'Returns `{trace_id, span_id, hits: SpanMatchRecord[], ' +\n        'total_matches, has_more}` — iterate `result.hits`, NOT ' +\n        '`result.matches`.',\n    )\n    .namespace(NAMESPACE)\n    .arg('trace_id', f.string('Real trace id'))\n    .arg('span_id', f.string('Real span id within trace'))\n    .arg('regex_pattern', f.string('JS-compatible regex, multiline'))\n    .arg('max_matches', f.number('Max records, 1..500; default 50').optional())\n    .returns(f.json('SearchSpanResult'))\n    .handler(async ({ trace_id, span_id, regex_pattern, max_matches }) =>\n      store.searchSpan({\n        trace_id: assertString(trace_id, 'trace_id'),\n        span_id: assertString(span_id, 'span_id'),\n        regex_pattern: assertRegex(regex_pattern),\n        max_matches: assertMaxMatches(max_matches),\n      }),\n    )\n    .build()\n\n  return [\n    getDatasetOverview,\n    queryTraces,\n    countTraces,\n    viewTrace,\n    viewSpans,\n    searchTrace,\n    searchSpan,\n  ]\n}\n\n/**\n * Convenience: same shape as `buildTraceAnalystTools` but returns the\n * grouped form expected when registering trace tools alongside other\n * agent function modules. */\nexport function traceAnalystFunctionGroup(opts: BuildTraceAnalystToolsOpts): {\n  namespace: string\n  title: string\n  selectionCriteria: string\n  description: string\n  functions: AxFunction[]\n} {\n  return {\n    namespace: NAMESPACE,\n    title: 'Trace Analysis',\n    selectionCriteria: 'Use for any inspection of OTLP-shaped trace data.',\n    description:\n      'Discovery → narrow → deep-read tools over a JSONL trace dataset. ' +\n      'Always call getDatasetOverview first.',\n    functions: buildTraceAnalystTools(opts),\n  }\n}\n\n// ─── Argument validation ─────────────────────────────────────────────\n\nfunction parseFilters(input: unknown): TraceAnalystFilters | undefined {\n  if (input == null) return undefined\n  if (typeof input !== 'object' || Array.isArray(input)) {\n    throw new TypeError(`filters must be an object, got ${typeof input}`)\n  }\n  const f = input as Record<string, unknown>\n  const out: TraceAnalystFilters = {}\n  if (typeof f.has_errors === 'boolean') out.has_errors = f.has_errors\n  out.service_names = stringArrayOrUndefined(f.service_names, 'service_names')\n  out.agent_names = stringArrayOrUndefined(f.agent_names, 'agent_names')\n  out.model_names = stringArrayOrUndefined(f.model_names, 'model_names')\n  out.tool_names = stringArrayOrUndefined(f.tool_names, 'tool_names')\n  if (typeof f.start_time_after === 'string') out.start_time_after = f.start_time_after\n  if (typeof f.start_time_before === 'string') out.start_time_before = f.start_time_before\n  if (typeof f.regex_pattern === 'string') {\n    if (f.regex_pattern.length === 0) {\n      throw new TypeError('filters.regex_pattern cannot be empty')\n    }\n    out.regex_pattern = f.regex_pattern\n  }\n  return out\n}\n\nfunction stringArrayOrUndefined(v: unknown, label: string): string[] | undefined {\n  if (v === undefined || v === null) return undefined\n  if (!Array.isArray(v)) throw new TypeError(`${label} must be an array of strings`)\n  if (v.some((x) => typeof x !== 'string')) {\n    throw new TypeError(`${label} entries must be strings`)\n  }\n  return v as string[]\n}\n\nfunction assertPageLimit(limit: unknown): number {\n  if (typeof limit !== 'number' || !Number.isInteger(limit) || limit < 1 || limit > 200) {\n    throw new RangeError(`limit must be an integer 1..200`)\n  }\n  return limit\n}\nfunction assertOffset(offset: unknown): number | undefined {\n  if (offset === undefined) return undefined\n  if (typeof offset !== 'number' || !Number.isInteger(offset) || offset < 0) {\n    throw new RangeError(`offset must be a non-negative integer`)\n  }\n  return offset\n}\nfunction assertRegex(pattern: unknown): string {\n  if (typeof pattern !== 'string' || pattern.length === 0) {\n    throw new TypeError(`regex_pattern must be a non-empty string`)\n  }\n  // Compile-and-discard to fail fast — store will recompile, but we\n  // want a deterministic error from the agent's side rather than\n  // a downstream exception.\n  // eslint-disable-next-line no-new\n  new RegExp(pattern, 'm')\n  return pattern\n}\nfunction assertMaxMatches(n: unknown): number | undefined {\n  if (n === undefined) return undefined\n  if (typeof n !== 'number' || !Number.isInteger(n) || n < 1 || n > 500) {\n    throw new RangeError(`max_matches must be an integer 1..500`)\n  }\n  return n\n}\n\nfunction assertString(v: unknown, label: string): string {\n  if (typeof v !== 'string' || v.length === 0) {\n    throw new TypeError(`${label} must be a non-empty string`)\n  }\n  return v\n}\n\nfunction assertStringArray(v: unknown, label: string): string[] {\n  if (!Array.isArray(v)) throw new TypeError(`${label} must be an array of strings`)\n  if (v.some((x) => typeof x !== 'string')) {\n    throw new TypeError(`${label} entries must be strings`)\n  }\n  return v as string[]\n}\n"],"mappings":"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","names":["f","f"]}