@tangle-network/agent-eval 0.72.0 → 0.72.4

package/dist/{chunk-ODGETRTM.js → chunk-VUINJM5M.js}

@@ -1,82 +1,116 @@
 import {
-  canonicalize,
-  hashJson
-} from "./chunk-VSMTAMNK.js";
-import {
-  defaultProviderRedactor,
-  providerFromBaseUrl
-} from "./chunk-PC4UYEBM.js";
-import {
-  NotFoundError,
-  ReplayError
+  NotFoundError
 } from "./chunk-3BFEG2F6.js";
 
-// src/trace-analyst/prompts.ts
-var TRACE_ANALYST_ACTOR_DESCRIPTION = `You answer questions about an OTLP-shaped JSONL trace dataset using the trace tools provided in the \`traces\` namespace.
-
-DISCOVERY \u2192 NARROW \u2192 DEEP-READ protocol \u2014 follow exactly:
-
-1. ALWAYS call \`traces.getDatasetOverview({})\` FIRST without a regex_pattern. The result tells you total_traces, raw_jsonl_bytes, services, agents, models, and sample_trace_ids (real ids \u2014 never fabricate one).
-
-2. Use raw_jsonl_bytes to gauge how expensive raw scans will be. \`filters.regex_pattern\` is the one scan-heavy filter on getDatasetOverview / queryTraces / countTraces \u2014 narrow with indexed fields (has_errors, model_names, service_names, agent_names, time bounds) BEFORE adding a regex on a large dataset.
-
-3. To list more traces than the sample, call \`traces.queryTraces({ filters?, limit, offset? })\`. Each summary carries raw_jsonl_bytes \u2014 use it to choose between viewTrace and searchTrace BEFORE calling either.
-
-4. Per-trace inspection:
-   - SMALL trace (raw_jsonl_bytes well under 150_000): call \`traces.viewTrace({ trace_id })\`. Returns all spans. Per-attribute payloads are head-capped at ~4KB; large \`input.value\` / \`output.value\` / \`llm.input_messages\` will show a \`[trace-analyst truncated: N bytes]\` marker.
-   - LARGE trace (raw_jsonl_bytes near or above 150_000, or you saw an \`oversized\` response): use \`traces.searchTrace({ trace_id, regex_pattern })\` to get bounded SpanMatchRecords (span metadata + matched text + surrounding context). Then call \`traces.viewSpans({ trace_id, span_ids: [...] })\` for surgical reads (~16KB cap, 4\xD7 higher than discovery), or \`traces.searchSpan({ trace_id, span_id, regex_pattern })\` for one large span. Stays bounded regardless of trace size.
-   - Useful regex patterns: \`STATUS_CODE_ERROR\` (failures), tool names like \`grep\` or \`view_trace\`, error strings like \`MaxTurnsExceeded\`, model names, attribute keys.
-
-5. ONLY call viewTrace / viewSpans / searchTrace / searchSpan with trace/span ids you have already seen in sample_trace_ids, a queryTraces page, or a previous search result. Never invent ids.
-
-5a. **Result-shape contract** \u2014 searchTrace and searchSpan return \`{ trace_id, hits, total_matches, has_more }\`. Iterate \`result.hits\` (NOT result.matches). Each hit has \`{ span_id, span_name, span_kind, attribute_path, matched_text, context_before, context_after, match_offset }\`. viewTrace returns \`{ trace_id, spans }\` (or \`oversized\`). viewSpans returns \`{ trace_id, spans, missing_span_ids, truncated_attribute_count }\`. Never assume a field name \u2014 log the result shape first if unsure.
-
-6. If viewTrace returns an \`oversized\` summary instead of \`spans\`, DO NOT retry the same call. Read the summary's top_span_names, span_count, span_response_bytes_max, error_span_count to plan a follow-up: switch to searchTrace (or searchSpan for one large span), then viewSpans on a smaller, surgical span_ids set.
-
-7. If searchTrace or searchSpan returns has_more=true, REFINE the regex to be more specific rather than blindly raising max_matches.
-
-8. If a tool errors (invalid regex, range error), STOP and reconsider \u2014 don't retry with a guessed id or argument. Use the discovery tools above to recover.
-
-9. If a ~4KB-truncated payload from viewTrace / searchTrace matters for your answer, first try viewSpans on that span id (~16KB cap). If a 16KB-truncated payload from viewSpans still matters, narrow further with searchSpan against a more specific regex rather than asking for the full payload again.
-
-10. If maxDepth > 0 and the question splits into independent semantic branches, delegate well-defined subtasks to subagents using \`await llmQuery(...)\`. Pass narrow context and a focused query. Examples:
-
-    const reviews = await llmQuery([
-      { query: 'Drill into trace abc123 \u2014 what tool calls preceded the failure?', context: { trace_id: 'abc123' } },
-      { query: 'Drill into trace def456 \u2014 same failure mode?', context: { trace_id: 'def456' } },
-    ]);
-
-OBSERVABILITY rules:
-- Each non-final actor turn must emit at least one \`console.log(...)\` for evidence. Up to 3 logs per turn is fine when correlating multiple data sources (e.g. one log for findings list, one for source-file content, one for derived analysis).
-- Do NOT combine \`console.log\` with \`final(...)\` or \`askClarification(...)\` in the same turn \u2014 finish gathering data first, then call final on its own turn.
-- Reuse runtime variables across turns; don't recompute.
-- When done, call \`await final(answer)\` with the fully-formed report. The responder rewrites the answer into output fields; if you only pass a vague summary string the responder has nothing concrete to format.
-
-CRITICAL \u2014 \`final()\` payload contract for evidence-grounded analysis tasks:
-- Pass a STRUCTURED object as the second arg with the actual data the responder needs to format the answer. Do NOT pass abstract instructions; pass evidence.
-- Example for per-item verdict tasks:
-  \`\`\`js
-  await final("Format the per-item verdict report from the evidence below.", {
-    findings: [
-      { id: 'sub-1-finding-1', claim: '...', verdict: 'TRUE-POSITIVE', evidence: 'lines 42-45 of contracts/X.sol show ...' },
-      ...all items
-    ],
-    systemic_summary: '3 sentences I wrote based on the evidence above'
-  });
-  \`\`\`
-- Calling \`final("answer", {})\` with no evidence is a failure mode \u2014 the responder will hallucinate or echo back the field names. Always include the gathered data.
-- Premature final after a single viewSpans call is INSUFFICIENT for per-finding analysis tasks. Read the requested attributes (e.g. \`spans[i].attributes['redteam.finding.title']\`), and for each one perform the requested cross-reference (e.g. read the source SPAN's \`attributes['source.content']\`).
-
-OUTPUT contract \u2014 your final answer must include:
-- A clear prose conclusion answering the user's question.
-- Trace ids and span ids cited as evidence for each claim.
-- Failure modes named in the user's domain language, with frequency and concrete examples.
-
-Do NOT invent trace ids, span ids, error messages, or model names. Every fact must be traceable to a tool result.`;
-var TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION = "trace-analyst-actor-v5-2026-05-06";
-var TRACE_ANALYST_SUBAGENT_DESCRIPTION = `You are a trace-analyst subagent. Your parent has delegated a focused trace-inspection question. Use the same DISCOVERY \u2192 NARROW \u2192 DEEP-READ protocol but stay tightly scoped: do exactly what was asked, return a concise compact answer, do NOT spawn further subagents unless the parent's question is genuinely multi-branch.
-
-Cite trace ids and span ids for every claim. Do NOT invent ids.`;
+// src/trace-analyst/otlp-span.ts
+function projectOtlpFlatLine(raw) {
+  const trace_id = stringField(raw, "trace_id") ?? stringField(raw, "traceId");
+  const span_id = stringField(raw, "span_id") ?? stringField(raw, "spanId");
+  if (!trace_id || !span_id) return null;
+  const parent_id = stringField(raw, "parent_span_id") ?? stringField(raw, "parentSpanId") ?? null;
+  const name = stringField(raw, "name") ?? "unknown";
+  const start_time = stringField(raw, "start_time") ?? stringField(raw, "startTime") ?? "";
+  const end_time = stringField(raw, "end_time") ?? stringField(raw, "endTime") ?? start_time;
+  const status = readOtlpStatus(raw);
+  const attributes = extractOtlpAttributes(raw);
+  const service_name = asString(attributes["service.name"]) ?? asString(attributes["resource.attributes.service.name"]) ?? null;
+  const agent_name = asString(attributes["agent.name"]) ?? asString(attributes["inference.agent.name"]) ?? asString(attributes["inference.agent_name"]) ?? null;
+  const model_name = asString(attributes["llm.model_name"]) ?? asString(attributes["inference.llm.model_name"]) ?? asString(attributes["llm.model"]) ?? null;
+  const tool_name = asString(attributes["tool.name"]) ?? asString(attributes["inference.tool.name"]) ?? null;
+  const kind = inferOtlpKind(attributes);
+  let duration_ms = 0;
+  if (start_time && end_time) {
+    const a = Date.parse(start_time);
+    const b = Date.parse(end_time);
+    if (!Number.isNaN(a) && !Number.isNaN(b)) duration_ms = Math.max(0, b - a);
+  }
+  return {
+    trace_id,
+    span_id,
+    parent_span_id: parent_id && parent_id.length > 0 ? parent_id : null,
+    name,
+    kind,
+    start_time,
+    end_time,
+    duration_ms,
+    status: status.code,
+    status_message: status.message,
+    service_name,
+    agent_name,
+    model_name,
+    tool_name,
+    attributes
+  };
+}
+function readOtlpStatus(raw) {
+  const status = raw.status;
+  if (status && typeof status === "object" && !Array.isArray(status)) {
+    const codeRaw = status.code;
+    const code = codeRaw === "STATUS_CODE_OK" || codeRaw === "OK" ? "OK" : codeRaw === "STATUS_CODE_ERROR" || codeRaw === "ERROR" ? "ERROR" : "UNSET";
+    const messageRaw = status.message;
+    const message = typeof messageRaw === "string" && messageRaw.length > 0 ? messageRaw : void 0;
+    return { code, message };
+  }
+  return { code: "UNSET", message: void 0 };
+}
+function inferOtlpKind(attrs) {
+  const opik = asString(attrs["openinference.span.kind"]) ?? asString(attrs["inference.observation_kind"]);
+  if (opik) {
+    const upper = opik.toUpperCase();
+    if (upper === "AGENT" || upper === "LLM" || upper === "TOOL" || upper === "CHAIN" || upper === "GUARDRAIL" || upper === "SPAN") {
+      return upper;
+    }
+  }
+  return "UNKNOWN";
+}
+function extractOtlpAttributes(raw) {
+  const out = {};
+  const resource = raw.resource;
+  if (resource && typeof resource === "object" && !Array.isArray(resource)) {
+    const ra = resource.attributes;
+    if (ra && typeof ra === "object" && !Array.isArray(ra)) {
+      for (const [k, v] of Object.entries(ra)) {
+        out[k] = v;
+      }
+    }
+  }
+  const spanAttrs = raw.attributes;
+  if (spanAttrs && typeof spanAttrs === "object" && !Array.isArray(spanAttrs)) {
+    for (const [k, v] of Object.entries(spanAttrs)) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function stringField(raw, key) {
+  const v = raw[key];
+  return typeof v === "string" ? v : void 0;
+}
+function asString(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function asNumber(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  if (typeof v === "string" && v.length > 0) {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function firstNumberAttr(attrs, keys) {
+  for (const k of keys) {
+    const n = asNumber(attrs[k]);
+    if (n !== null) return n;
+  }
+  return null;
+}
+function firstStringAttr(attrs, keys) {
+  for (const k of keys) {
+    const s = asString(attrs[k]);
+    if (s !== null) return s;
+  }
+  return null;
+}
 
 // src/trace-analyst/types.ts
 var DEFAULT_TRACE_ANALYST_BUDGETS = {
@@ -385,7 +419,7 @@ var OtlpFileTraceStore = class {
         continue;
       }
       if (!parsed || typeof parsed !== "object") continue;
-      const span = readOtlpSpan(parsed);
+      const span = projectOtlpFlatLine(parsed);
       if (!span) continue;
       let entry = byTrace.get(span.trace_id);
       if (!entry) {
@@ -508,7 +542,7 @@ var OtlpFileTraceStore = class {
       if (parsed && typeof parsed === "object") raw = parsed;
     } catch {
     }
-    const attrs = extractAttributes(raw);
+    const attrs = extractOtlpAttributes(raw);
     const projected = {};
     for (const [k, v] of Object.entries(attrs)) {
       if (typeof v === "string") {
@@ -617,91 +651,6 @@ var SpanNotFoundError = class extends NotFoundError {
     this.span_id = span_id;
   }
 };
-function readOtlpSpan(raw) {
-  const trace_id = stringField(raw, "trace_id") ?? stringField(raw, "traceId");
-  const span_id = stringField(raw, "span_id") ?? stringField(raw, "spanId");
-  if (!trace_id || !span_id) return null;
-  const parent_id = stringField(raw, "parent_span_id") ?? stringField(raw, "parentSpanId") ?? null;
-  const name = stringField(raw, "name") ?? "unknown";
-  const start_time = stringField(raw, "start_time") ?? stringField(raw, "startTime") ?? "";
-  const end_time = stringField(raw, "end_time") ?? stringField(raw, "endTime") ?? start_time;
-  const status = readStatus(raw);
-  const attrs = extractAttributes(raw);
-  const service_name = asString(attrs["service.name"]) ?? asString(attrs["resource.attributes.service.name"]) ?? null;
-  const agent_name = asString(attrs["agent.name"]) ?? asString(attrs["inference.agent.name"]) ?? null;
-  const model_name = asString(attrs["llm.model_name"]) ?? asString(attrs["inference.llm.model_name"]) ?? null;
-  const tool_name = asString(attrs["tool.name"]) ?? asString(attrs["inference.tool.name"]) ?? null;
-  const kind = inferKind(attrs);
-  let duration_ms = 0;
-  if (start_time && end_time) {
-    const a = Date.parse(start_time);
-    const b = Date.parse(end_time);
-    if (!Number.isNaN(a) && !Number.isNaN(b)) duration_ms = Math.max(0, b - a);
-  }
-  return {
-    trace_id,
-    span_id,
-    parent_span_id: parent_id && parent_id.length > 0 ? parent_id : null,
-    name,
-    kind,
-    start_time,
-    end_time,
-    duration_ms,
-    status: status.code,
-    status_message: status.message,
-    service_name,
-    agent_name,
-    model_name,
-    tool_name
-  };
-}
-function readStatus(raw) {
-  const status = raw.status;
-  if (status && typeof status === "object" && !Array.isArray(status)) {
-    const codeRaw = status.code;
-    const code = codeRaw === "STATUS_CODE_OK" || codeRaw === "OK" ? "OK" : codeRaw === "STATUS_CODE_ERROR" || codeRaw === "ERROR" ? "ERROR" : "UNSET";
-    const messageRaw = status.message;
-    const message = typeof messageRaw === "string" && messageRaw.length > 0 ? messageRaw : void 0;
-    return { code, message };
-  }
-  return { code: "UNSET", message: void 0 };
-}
-function inferKind(attrs) {
-  const opik = asString(attrs["openinference.span.kind"]) ?? asString(attrs["inference.observation_kind"]);
-  if (opik) {
-    const upper = opik.toUpperCase();
-    if (upper === "AGENT" || upper === "LLM" || upper === "TOOL" || upper === "CHAIN" || upper === "GUARDRAIL" || upper === "SPAN") {
-      return upper;
-    }
-  }
-  return "UNKNOWN";
-}
-function extractAttributes(raw) {
-  const out = {};
-  const resource = raw.resource;
-  if (resource && typeof resource === "object" && !Array.isArray(resource)) {
-    const ra = resource.attributes;
-    if (ra && typeof ra === "object" && !Array.isArray(ra)) {
-      for (const [k, v] of Object.entries(ra)) {
-        out[k] = v;
-      }
-    }
-  }
-  const spanAttrs = raw.attributes;
-  if (spanAttrs && typeof spanAttrs === "object" && !Array.isArray(spanAttrs)) {
-    for (const [k, v] of Object.entries(spanAttrs)) {
-      out[k] = v;
-    }
-  }
-  return out;
-}
-function stringField(raw, key) {
-  const v = raw[key];
-  return typeof v === "string" ? v : void 0;
-}
-function asString(v) {
-  return typeof v === "string" && v.length > 0 ? v : null;
-}
 function isPresent(v) {
   return v !== void 0;
 }
@@ -944,42 +893,109 @@ function assertStringArray(v, label) {
   return v;
 }
 
-// src/trace-analyst/analyst.ts
-import { AxJSRuntime, agent } from "@ax-llm/ax";
-async function analyzeTraces(input, options) {
-  if (!input.question || typeof input.question !== "string") {
-    throw new TypeError("analyzeTraces: input.question must be a non-empty string");
-  }
-  const store = typeof options.source === "string" ? new OtlpFileTraceStore({ path: options.source }) : options.source;
-  if (store instanceof OtlpFileTraceStore) {
-    await store.ensureIndexed();
-  }
-  const tools = buildTraceAnalystTools({ store });
-  const turns = [];
-  let progressFs;
-  if (options.progressLogPath) {
-    const { createWriteStream } = await import("fs");
-    const { mkdir } = await import("fs/promises");
-    const { dirname } = await import("path");
-    await mkdir(dirname(options.progressLogPath), { recursive: true });
-    progressFs = createWriteStream(options.progressLogPath, { flags: "a" });
-  }
-  const actorTurnCallback = async (turn) => {
-    const snap = {
-      turn: turn.turn,
-      isError: turn.isError,
-      code: turn.code,
-      output: turn.output,
-      thought: turn.thought
-    };
-    turns.push(snap);
-    if (progressFs) {
-      try {
-        progressFs.write(`${JSON.stringify({ ...snap, ts: Date.now() })}
-`);
-      } catch {
-      }
-    }
+// src/trace-analyst/prompts.ts
+var TRACE_ANALYST_ACTOR_DESCRIPTION = `You answer questions about an OTLP-shaped JSONL trace dataset using the trace tools provided in the \`traces\` namespace.
+
+DISCOVERY \u2192 NARROW \u2192 DEEP-READ protocol \u2014 follow exactly:
+
+1. ALWAYS call \`traces.getDatasetOverview({})\` FIRST without a regex_pattern. The result tells you total_traces, raw_jsonl_bytes, services, agents, models, and sample_trace_ids (real ids \u2014 never fabricate one).
+
+2. Use raw_jsonl_bytes to gauge how expensive raw scans will be. \`filters.regex_pattern\` is the one scan-heavy filter on getDatasetOverview / queryTraces / countTraces \u2014 narrow with indexed fields (has_errors, model_names, service_names, agent_names, time bounds) BEFORE adding a regex on a large dataset.
+
+3. To list more traces than the sample, call \`traces.queryTraces({ filters?, limit, offset? })\`. Each summary carries raw_jsonl_bytes \u2014 use it to choose between viewTrace and searchTrace BEFORE calling either.
+
+4. Per-trace inspection:
+   - SMALL trace (raw_jsonl_bytes well under 150_000): call \`traces.viewTrace({ trace_id })\`. Returns all spans. Per-attribute payloads are head-capped at ~4KB; large \`input.value\` / \`output.value\` / \`llm.input_messages\` will show a \`[trace-analyst truncated: N bytes]\` marker.
+   - LARGE trace (raw_jsonl_bytes near or above 150_000, or you saw an \`oversized\` response): use \`traces.searchTrace({ trace_id, regex_pattern })\` to get bounded SpanMatchRecords (span metadata + matched text + surrounding context). Then call \`traces.viewSpans({ trace_id, span_ids: [...] })\` for surgical reads (~16KB cap, 4\xD7 higher than discovery), or \`traces.searchSpan({ trace_id, span_id, regex_pattern })\` for one large span. Stays bounded regardless of trace size.
+   - Useful regex patterns: \`STATUS_CODE_ERROR\` (failures), tool names like \`grep\` or \`view_trace\`, error strings like \`MaxTurnsExceeded\`, model names, attribute keys.
+
+5. ONLY call viewTrace / viewSpans / searchTrace / searchSpan with trace/span ids you have already seen in sample_trace_ids, a queryTraces page, or a previous search result. Never invent ids.
+
+5a. **Result-shape contract** \u2014 searchTrace and searchSpan return \`{ trace_id, hits, total_matches, has_more }\`. Iterate \`result.hits\` (NOT result.matches). Each hit has \`{ span_id, span_name, span_kind, attribute_path, matched_text, context_before, context_after, match_offset }\`. viewTrace returns \`{ trace_id, spans }\` (or \`oversized\`). viewSpans returns \`{ trace_id, spans, missing_span_ids, truncated_attribute_count }\`. Never assume a field name \u2014 log the result shape first if unsure.
+
+6. If viewTrace returns an \`oversized\` summary instead of \`spans\`, DO NOT retry the same call. Read the summary's top_span_names, span_count, span_response_bytes_max, error_span_count to plan a follow-up: switch to searchTrace (or searchSpan for one large span), then viewSpans on a smaller, surgical span_ids set.
+
+7. If searchTrace or searchSpan returns has_more=true, REFINE the regex to be more specific rather than blindly raising max_matches.
+
+8. If a tool errors (invalid regex, range error), STOP and reconsider \u2014 don't retry with a guessed id or argument. Use the discovery tools above to recover.
+
+9. If a ~4KB-truncated payload from viewTrace / searchTrace matters for your answer, first try viewSpans on that span id (~16KB cap). If a 16KB-truncated payload from viewSpans still matters, narrow further with searchSpan against a more specific regex rather than asking for the full payload again.
+
+10. If maxDepth > 0 and the question splits into independent semantic branches, delegate well-defined subtasks to subagents using \`await llmQuery(...)\`. Pass narrow context and a focused query. Examples:
+
+    const reviews = await llmQuery([
+      { query: 'Drill into trace abc123 \u2014 what tool calls preceded the failure?', context: { trace_id: 'abc123' } },
+      { query: 'Drill into trace def456 \u2014 same failure mode?', context: { trace_id: 'def456' } },
+    ]);
+
+OBSERVABILITY rules:
+- Each non-final actor turn must emit at least one \`console.log(...)\` for evidence. Up to 3 logs per turn is fine when correlating multiple data sources (e.g. one log for findings list, one for source-file content, one for derived analysis).
+- Do NOT combine \`console.log\` with \`final(...)\` or \`askClarification(...)\` in the same turn \u2014 finish gathering data first, then call final on its own turn.
+- Reuse runtime variables across turns; don't recompute.
+- When done, call \`await final(answer)\` with the fully-formed report. The responder rewrites the answer into output fields; if you only pass a vague summary string the responder has nothing concrete to format.
+
+CRITICAL \u2014 \`final()\` payload contract for evidence-grounded analysis tasks:
+- Pass a STRUCTURED object as the second arg with the actual data the responder needs to format the answer. Do NOT pass abstract instructions; pass evidence.
+- Example for per-item verdict tasks:
+  \`\`\`js
+  await final("Format the per-item verdict report from the evidence below.", {
+    findings: [
+      { id: 'sub-1-finding-1', claim: '...', verdict: 'TRUE-POSITIVE', evidence: 'lines 42-45 of contracts/X.sol show ...' },
+      ...all items
+    ],
+    systemic_summary: '3 sentences I wrote based on the evidence above'
+  });
+  \`\`\`
+- Calling \`final("answer", {})\` with no evidence is a failure mode \u2014 the responder will hallucinate or echo back the field names. Always include the gathered data.
+- Premature final after a single viewSpans call is INSUFFICIENT for per-finding analysis tasks. Read the requested attributes (e.g. \`spans[i].attributes['redteam.finding.title']\`), and for each one perform the requested cross-reference (e.g. read the source SPAN's \`attributes['source.content']\`).
+
+OUTPUT contract \u2014 your final answer must include:
+- A clear prose conclusion answering the user's question.
+- Trace ids and span ids cited as evidence for each claim.
+- Failure modes named in the user's domain language, with frequency and concrete examples.
+
+Do NOT invent trace ids, span ids, error messages, or model names. Every fact must be traceable to a tool result.`;
+var TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION = "trace-analyst-actor-v5-2026-05-06";
+var TRACE_ANALYST_SUBAGENT_DESCRIPTION = `You are a trace-analyst subagent. Your parent has delegated a focused trace-inspection question. Use the same DISCOVERY \u2192 NARROW \u2192 DEEP-READ protocol but stay tightly scoped: do exactly what was asked, return a concise compact answer, do NOT spawn further subagents unless the parent's question is genuinely multi-branch.
+
+Cite trace ids and span ids for every claim. Do NOT invent ids.`;
+
+// src/trace-analyst/analyst.ts
+import { AxJSRuntime, agent } from "@ax-llm/ax";
+async function analyzeTraces(input, options) {
+  if (!input.question || typeof input.question !== "string") {
+    throw new TypeError("analyzeTraces: input.question must be a non-empty string");
+  }
+  const store = typeof options.source === "string" ? new OtlpFileTraceStore({ path: options.source }) : options.source;
+  if (store instanceof OtlpFileTraceStore) {
+    await store.ensureIndexed();
+  }
+  const tools = buildTraceAnalystTools({ store });
+  const turns = [];
+  let progressFs;
+  if (options.progressLogPath) {
+    const { createWriteStream } = await import("fs");
+    const { mkdir } = await import("fs/promises");
+    const { dirname } = await import("path");
+    await mkdir(dirname(options.progressLogPath), { recursive: true });
+    progressFs = createWriteStream(options.progressLogPath, { flags: "a" });
+  }
+  const actorTurnCallback = async (turn) => {
+    const snap = {
+      turn: turn.turn,
+      isError: turn.isError,
+      code: turn.code,
+      output: turn.output,
+      thought: turn.thought
+    };
+    turns.push(snap);
+    if (progressFs) {
+      try {
+        progressFs.write(`${JSON.stringify({ ...snap, ts: Date.now() })}
+`);
+      } catch {
+      }
+    }
     if (options.onTurn) await options.onTurn(snap);
   };
   const maxDepth = options.maxDepth ?? 1;
@@ -987,7 +1003,11 @@ async function analyzeTraces(input, options) {
   const maxParallelSubagents = options.maxParallelSubagents ?? 2;
   const maxRuntimeChars = options.maxRuntimeChars ?? 6e3;
   const analyst = agent(
-    "question:string -> answer:string, findings:string[]",
+    // `reasoning!` is an internal (Ax `!`) scratchpad field: generated first to
+    // force reason-before-conclude, stripped from the returned output — so the
+    // consumed shape stays { answer, findings }. Brings the trace-analyst to the
+    // same prose-first CoT ordering the kind-factory gets from its `report` field.
+    "question:string -> reasoning!:string, answer:string, findings:string[]",
     {
       agentIdentity: {
         name: "TraceAnalyst",
@@ -1060,1197 +1080,16 @@ function normalizeRecordArray(value) {
   );
 }
 
-// src/trace-analyst/hook.ts
-var DEFAULT_QUESTION = "Summarise what happened in this run. Surface any failure modes, surprising findings, or evidence that the run's verdict is wrong.";
-function traceAnalystOnRunComplete(opts) {
-  return async (ctx) => {
-    if (opts.shouldRun && !opts.shouldRun(ctx)) return;
-    const source = opts.analyze.source;
-    if (source === void 0) {
-      await ctx.store.appendEvent({
-        eventId: `analyst-skip-${ctx.runId}`,
-        runId: ctx.runId,
-        kind: "log",
-        timestamp: Date.now(),
-        payload: { source: "trace_analyst_hook", reason: "no source configured" }
-      });
-      return;
-    }
-    const result = await analyzeTraces({ question: opts.question ?? DEFAULT_QUESTION }, {
-      ...opts.analyze,
-      source
-    });
-    if (opts.save) await opts.save(result, ctx);
-    if (opts.gateOn && !opts.gateOn(result, ctx)) {
-      await ctx.store.appendEvent({
-        eventId: `analyst-gate-${ctx.runId}`,
-        runId: ctx.runId,
-        kind: "log",
-        timestamp: Date.now(),
-        payload: {
-          source: "trace_analyst_hook",
-          reason: "analyst_gate_failed",
-          findings: result.findings
-        }
-      });
-    }
-  };
-}
-
-// src/trace-analyst/insights.ts
-var DOMAIN_STOP_WORDS = /* @__PURE__ */ new Set([
-  "and",
-  "advanced",
-  "app",
-  "build",
-  "create",
-  "easy",
-  "expert",
-  "extreme",
-  "for",
-  "from",
-  "hard",
-  "implementation",
-  "integrate",
-  "medium",
-  "project",
-  "task",
-  "the",
-  "this",
-  "with",
-  "workflow"
-]);
-function tokenizeDomainWords(value) {
-  return [...value.matchAll(/[A-Za-z][A-Za-z0-9.+#-]{2,}/g)].map((match) => match[0].toLowerCase()).filter((word) => !DOMAIN_STOP_WORDS.has(word));
-}
-function inferDomainKeywords(suite) {
-  const suiteWords = new Set(tokenizeDomainWords(`${suite.name} ${suite.collectionId ?? ""}`));
-  const source = [
-    suite.name,
-    suite.collectionId ?? "",
-    ...suite.tasks.flatMap((task) => [
-      task.id,
-      task.name,
-      task.prompt ?? "",
-      task.difficulty ?? "",
-      ...task.tags ?? [],
-      ...task.gaps ?? []
-    ])
-  ].join(" ");
-  const counts = /* @__PURE__ */ new Map();
-  for (const word of tokenizeDomainWords(source)) counts.set(word, (counts.get(word) ?? 0) + 1);
-  return [...counts.entries()].filter(([word, count]) => count >= 2 || suiteWords.has(word)).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([word]) => word).slice(0, 18);
-}
-function domainEvidencePattern(keywords) {
-  const escaped = keywords.filter((keyword) => keyword.length >= 3).map((keyword) => keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-  return escaped.length > 0 ? new RegExp(`(?<![A-Za-z0-9])(?:${escaped.join("|")})(?![A-Za-z0-9])`, "i") : /(?<![A-Za-z0-9])(?:sdk|api|css|dns|xml|provider|client|service|integration|webhook|transaction|auth|oauth|graphql|rest)(?![A-Za-z0-9])/i;
-}
-function describeTraceInsightScope(suite) {
-  const taskLabel = suite.tasks.length === 1 ? "1 implementation task" : `${suite.tasks.length} implementation tasks`;
-  const tags = /* @__PURE__ */ new Map();
-  for (const task of suite.tasks) {
-    for (const tag of task.tags ?? []) tags.set(tag, (tags.get(tag) ?? 0) + 1);
-  }
-  const topTags = [...tags.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 8).map(([tag]) => tag);
-  if (topTags.length > 0) return `${taskLabel} across ${topTags.join(", ")}.`;
-  const difficulties = [
-    ...new Set(
-      suite.tasks.map((task) => task.difficulty).filter((value) => Boolean(value))
-    )
-  ].join(", ");
-  return `${taskLabel} across ${difficulties || "the selected benchmark scope"}.`;
-}
-function planTraceInsightQuestions(input) {
-  const hasFailures = input.suite.tasks.some((task) => task.outcome && task.outcome !== "satisfied");
-  const hasMultipleShots = input.suite.tasks.some(
-    (task) => (task.gaps ?? []).some((gap) => /shot|review|retry|continue/i.test(gap))
-  );
-  const questions = [
-    {
-      id: "execution-path",
-      question: "What did the worker actually do before the first meaningful implementation edit?",
-      why: "Separates grounded execution from polished but shallow output."
-    },
-    {
-      id: "research-grounding",
-      question: "Did the worker inspect docs, source, examples, or package references before committing to an implementation path?",
-      why: "Identifies whether failures came from weak retrieval, weak examples, or premature coding."
-    },
-    {
-      id: "domain-proof",
-      question: "Which tasks produced executable domain proof versus UI copy, placeholders, or inferred behavior?",
-      why: "Keeps product-quality claims tied to concrete evidence."
-    },
-    {
-      id: "root-cause",
-      question: "For each major failure cluster, is the likely root cause prompt/scaffold, docs/examples, SDK/API ergonomics, evaluator, runtime, or model behavior?",
-      why: "Turns trace observations into actionable ownership."
-    },
-    {
-      id: "evidence-quality",
-      question: "Which external-facing claims are directly supported by trace ids, span ids, verifier findings, reviewer notes, or generated code?",
-      why: "Prevents unsupported customer-report conclusions."
-    }
-  ];
-  if (hasMultipleShots) {
-    questions.push({
-      id: "reviewer-lift",
-      question: "Where did reviewer feedback improve score, stall, or regress across shots?",
-      why: "Shows whether the driver loop is learning or merely repeating work."
-    });
-  }
-  if (hasFailures) {
-    questions.push({
-      id: "optimization-targets",
-      question: "Which prompt, evaluator, scaffold, or workflow changes should feed the next GEPA/autoresearch optimization run?",
-      why: "Connects benchmark evidence to the optimization loop."
-    });
-  }
-  return questions;
-}
-function buildTraceInsightContext(input) {
-  return {
-    suite: input.suite,
-    scope: describeTraceInsightScope(input.suite),
-    keywords: inferDomainKeywords(input.suite),
-    questions: planTraceInsightQuestions(input),
-    panel: defaultTraceInsightPanel(),
-    findings: input.findings ?? [],
-    agent: input.agent ?? null,
-    totals: input.totals ?? null
-  };
-}
-function scoreTraceInsightReadiness(context) {
-  const failedTasks = context.suite.tasks.filter(
-    (task) => task.outcome && task.outcome !== "satisfied"
-  );
-  const findingTaskIds = new Set(context.findings.flatMap((finding) => finding.taskIds));
-  const failedTasksWithFindings = failedTasks.filter((task) => findingTaskIds.has(task.id));
-  const tasksWithGaps = context.suite.tasks.filter((task) => (task.gaps ?? []).length > 0);
-  const gates = [
-    {
-      id: "domain-context",
-      label: "Domain context inferred",
-      passed: context.keywords.length > 0,
-      severity: "high",
-      detail: context.keywords.length > 0 ? `${context.keywords.length} domain terms inferred: ${context.keywords.slice(0, 8).join(", ")}` : "No domain terms were inferred from suite, tasks, prompts, tags, or gaps."
-    },
-    {
-      id: "panel-coverage",
-      label: "Analyst panel planned",
-      passed: context.panel.length >= 4 && context.questions.length >= 5,
-      severity: "high",
-      detail: `${context.panel.length} panel roles and ${context.questions.length} investigation questions planned.`
-    },
-    {
-      id: "failure-coverage",
-      label: "Failures mapped to findings",
-      passed: failedTasks.length === 0 || failedTasksWithFindings.length / failedTasks.length >= 0.5,
-      severity: "critical",
-      detail: failedTasks.length === 0 ? "No failed tasks in suite." : `${failedTasksWithFindings.length}/${failedTasks.length} failed tasks appear in finding clusters.`
-    },
-    {
-      id: "gap-evidence",
-      label: "Task gaps captured",
-      passed: failedTasks.length === 0 || tasksWithGaps.length / failedTasks.length >= 0.5,
-      severity: "medium",
-      detail: `${tasksWithGaps.length} tasks include explicit evaluator or analyst gaps.`
-    }
-  ];
-  const penalty = gates.reduce((sum, gate) => {
-    if (gate.passed) return sum;
-    if (gate.severity === "critical") return sum + 35;
-    if (gate.severity === "high") return sum + 20;
-    if (gate.severity === "medium") return sum + 10;
-    return sum + 5;
-  }, 0);
-  const score = Math.max(0, Math.min(1, 1 - penalty / 100));
-  return {
-    score,
-    grade: score >= 0.9 ? "external-ready" : score >= 0.7 ? "internal-review" : "raw-analysis",
-    gates
-  };
-}
-function defaultTraceInsightPanel() {
-  return [
-    {
-      id: "trace-forensics",
-      name: "Trace Forensics",
-      responsibility: "Reconstruct what the worker did in order, including research, edits, reviewer interventions, verifier feedback, and stop reason."
-    },
-    {
-      id: "root-cause",
-      name: "Root Cause",
-      responsibility: "Map failures to prompt/scaffold, docs/examples, SDK/API/product ergonomics, evaluator, runtime, or model behavior."
-    },
-    {
-      id: "optimization",
-      name: "Optimization",
-      responsibility: "Identify prompt, reviewer, evaluator, scaffold, and GEPA/autoresearch changes that should be tested next."
-    },
-    {
-      id: "external-evidence",
-      name: "External Evidence",
-      responsibility: "Separate customer-safe claims from internal harness findings and reject conclusions without task, trace, span, code, reviewer, or verifier evidence."
-    }
-  ];
-}
-function buildTraceInsightPrompt(input) {
-  const context = buildTraceInsightContext(input);
-  const maxRepresentativeTraces = input.maxRepresentativeTraces ?? 6;
-  return `Analyze this benchmark run and produce evidence-backed trace intelligence.
-
-Audience:
-- internal AI/product leadership
-- possible customer-facing report for ${input.suite.name}
-
-Investigation plan:
-${context.questions.map((item, index) => `${index + 1}. ${item.question} (${item.why})`).join("\n")}
-
-Analyst panel:
-${context.panel.map((role) => `- ${role.name}: ${role.responsibility}`).join("\n")}
-
-If the task branches are independent, use subagents for the panel roles above and aggregate their findings. Do not run a panel role unless its answer will change the final report.
-
-Required output:
-1. Executive verdict: what this run proves and does not prove.
-2. The investigation questions you answered and the evidence used.
-3. Failure taxonomy: agent prompting, evaluator/harness, docs/examples, SDK/API/product integration, infra.
-4. Evidence-backed examples with trace ids/task ids and concrete verifier findings.
-5. Highest-ROI fixes for the benchmark harness, prompt/GEPA optimization, and customer-facing product/docs surface.
-6. What is safe for an external report versus what must stay internal.
-7. One rerun plan that would validate lift after optimization.
-
-Budget:
-- Inspect the dataset overview, the failure summary, and at most ${maxRepresentativeTraces} representative traces.
-- Prefer traces named in the failure summary over broad exploration.
-- Do not do exhaustive trace sweeps.
-- Return the final report as soon as the taxonomy and examples are supported.
-
-Run summary:
-${JSON.stringify(
-    {
-      suite: input.suite.name,
-      scope: context.scope,
-      inferredKeywords: context.keywords,
-      agent: context.agent,
-      totals: context.totals,
-      findings: context.findings.map((finding) => ({
-        kind: finding.kind,
-        severity: finding.severity,
-        taskCount: finding.taskIds.length,
-        proposedFixClass: finding.proposedFixClass
-      })),
-      failures: input.suite.tasks.filter((task) => task.outcome && task.outcome !== "satisfied").map((task) => ({
-        task: task.id,
-        difficulty: task.difficulty,
-        outcome: task.outcome,
-        score: task.score,
-        gaps: task.gaps ?? []
-      }))
-    },
-    null,
-    2
-  )}
-
-Use the trace tools. Do not invent facts. Cite task ids. Separate customer-facing claims from internal harness/model findings.`;
-}
-
-// src/trace-analyst/otlp-flatten.ts
-var DEFAULT_KIND_MAP = {
-  0: "SPAN_KIND_UNSPECIFIED",
-  1: "SPAN_KIND_INTERNAL",
-  2: "SPAN_KIND_SERVER",
-  3: "SPAN_KIND_CLIENT",
-  4: "SPAN_KIND_PRODUCER",
-  5: "SPAN_KIND_CONSUMER"
-};
-var STATUS_MAP = {
-  0: "STATUS_CODE_UNSET",
-  1: "STATUS_CODE_OK",
-  2: "STATUS_CODE_ERROR"
-};
-function attrValue(v) {
-  if (v.stringValue !== void 0) return v.stringValue;
-  if (v.intValue !== void 0) return Number(v.intValue);
-  if (v.doubleValue !== void 0) return v.doubleValue;
-  if (v.boolValue !== void 0) return v.boolValue;
-  return "";
-}
-function attrsToRecord(attrs) {
-  const out = {};
-  for (const a of attrs) out[a.key] = attrValue(a.value);
-  return out;
-}
-function nanoToIso(nano) {
-  const ms = Number(nano) / 1e6;
-  return Number.isFinite(ms) ? new Date(ms).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
-}
-function applyOpenInference(attrs) {
-  if ("llm.model" in attrs && !("llm.model_name" in attrs)) {
-    attrs["llm.model_name"] = attrs["llm.model"];
-  }
-  if ("tool.name" in attrs && !("inference.tool.name" in attrs)) {
-    attrs["inference.tool.name"] = attrs["tool.name"];
-  }
-  if ("span.kind" in attrs && !("openinference.span.kind" in attrs)) {
-    attrs["openinference.span.kind"] = String(attrs["span.kind"]).toUpperCase();
-  }
-}
-function flattenOtlpExportToNdjson(otlpExport, opts = {}) {
-  const vocab = opts.attributeVocabulary ?? "openinference";
-  const kindMap = { ...DEFAULT_KIND_MAP, ...opts.kindMap };
-  const lines = [];
-  for (const rs of otlpExport.resourceSpans ?? []) {
-    const resource = { attributes: attrsToRecord(rs.resource?.attributes ?? []) };
-    for (const scope of rs.scopeSpans ?? []) {
-      for (const span of scope.spans ?? []) {
-        const attributes = attrsToRecord(span.attributes ?? []);
-        if (vocab === "openinference") applyOpenInference(attributes);
-        const line = {
-          trace_id: span.traceId,
-          span_id: span.spanId,
-          parent_span_id: span.parentSpanId ?? null,
-          name: span.name,
-          kind: kindMap[span.kind] ?? "SPAN_KIND_UNSPECIFIED",
-          start_time: nanoToIso(span.startTimeUnixNano),
-          end_time: nanoToIso(span.endTimeUnixNano),
-          status: {
-            code: STATUS_MAP[span.status?.code ?? 0] ?? "STATUS_CODE_UNSET",
-            ...span.status?.message ? { message: span.status.message } : {}
-          },
-          resource,
-          attributes
-        };
-        if (span.events && span.events.length > 0) {
-          line.events = span.events.map((e) => ({
-            name: e.name,
-            timeUnixNano: e.timeUnixNano,
-            ...e.attributes ? { attributes: attrsToRecord(e.attributes) } : {}
-          }));
-        }
-        lines.push(line);
-      }
-    }
-  }
-  return lines;
-}
-
-// src/trace/store.ts
-var InMemoryTraceStore = class {
-  runs = /* @__PURE__ */ new Map();
-  allSpans = [];
-  allEvents = [];
-  allArtifacts = [];
-  allBudget = [];
-  async appendRun(run) {
-    if (this.runs.has(run.runId)) throw new Error(`run ${run.runId} already exists`);
-    this.runs.set(run.runId, { ...run });
-  }
-  async updateRun(runId, patch) {
-    const existing = this.runs.get(runId);
-    if (!existing) throw new Error(`run ${runId} not found`);
-    this.runs.set(runId, { ...existing, ...patch });
-  }
-  async appendSpan(span) {
-    this.allSpans.push({ ...span });
-  }
-  async updateSpan(spanId, patch) {
-    const idx = this.allSpans.findIndex((s) => s.spanId === spanId);
-    if (idx < 0) throw new Error(`span ${spanId} not found`);
-    this.allSpans[idx] = { ...this.allSpans[idx], ...patch };
-  }
-  async appendEvent(event) {
-    this.allEvents.push({ ...event });
-  }
-  async appendArtifact(artifact) {
-    this.allArtifacts.push({ ...artifact });
-  }
-  async appendBudgetEntry(entry) {
-    this.allBudget.push({ ...entry });
-  }
-  async getRun(runId) {
-    const r = this.runs.get(runId);
-    return r ? { ...r } : void 0;
-  }
-  async listRuns(filter = {}) {
-    return [...this.runs.values()].filter((r) => matchesRun(r, filter));
-  }
-  async spans(filter = {}) {
-    return this.allSpans.filter((s) => matchesSpan(s, filter)).map((s) => ({ ...s }));
-  }
-  async events(filter = {}) {
-    return this.allEvents.filter((e) => matchesEvent(e, filter)).map((e) => ({ ...e }));
-  }
-  async budget(runId) {
-    return this.allBudget.filter((b) => b.runId === runId).map((b) => ({ ...b }));
-  }
-  async artifacts(runId) {
-    return this.allArtifacts.filter((a) => a.runId === runId).map((a) => ({ ...a }));
-  }
-};
-function matchesRun(r, f2) {
-  if (f2.scenarioId && r.scenarioId !== f2.scenarioId) return false;
-  if (f2.variantId && r.variantId !== f2.variantId) return false;
-  if (f2.status && r.status !== f2.status) return false;
-  if (f2.since !== void 0 && r.startedAt < f2.since) return false;
-  if (f2.until !== void 0 && r.startedAt > f2.until) return false;
-  if (f2.tag && r.tags?.[f2.tag.key] !== f2.tag.value) return false;
-  if (f2.parentRunId && r.parentRunId !== f2.parentRunId) return false;
-  if (f2.projectId && r.projectId !== f2.projectId) return false;
-  if (f2.chatId && r.chatId !== f2.chatId) return false;
-  if (f2.layer && r.layer !== f2.layer) return false;
-  return true;
-}
-function matchesSpan(s, f2) {
-  if (f2.runId && s.runId !== f2.runId) return false;
-  if (f2.parentSpanId && s.parentSpanId !== f2.parentSpanId) return false;
-  if (f2.kind && s.kind !== f2.kind) return false;
-  if (f2.name && s.name !== f2.name) return false;
-  if (f2.toolName && (s.kind !== "tool" || s.toolName !== f2.toolName)) return false;
-  if (f2.judgeId && (s.kind !== "judge" || s.judgeId !== f2.judgeId)) return false;
-  if (f2.since !== void 0 && s.startedAt < f2.since) return false;
-  if (f2.until !== void 0 && s.startedAt > f2.until) return false;
-  return true;
-}
-function matchesEvent(e, f2) {
-  if (f2.runId && e.runId !== f2.runId) return false;
-  if (f2.spanId && e.spanId !== f2.spanId) return false;
-  if (f2.kind && e.kind !== f2.kind) return false;
-  if (f2.since !== void 0 && e.timestamp < f2.since) return false;
-  if (f2.until !== void 0 && e.timestamp > f2.until) return false;
-  return true;
-}
-var FileSystemTraceStore = class {
-  dir;
-  maxBytes;
-  /** Lazy in-memory index for queries — populated on first read. */
-  index;
-  loaded = false;
-  constructor(options) {
-    this.dir = options.dir;
-    this.maxBytes = options.maxBytes ?? 32 * 1024 * 1024;
-  }
-  async ensureDir() {
-    const fs = await import("fs/promises");
-    await fs.mkdir(this.dir, { recursive: true });
-  }
-  async append(name, record) {
-    await this.ensureDir();
-    const fs = await import("fs/promises");
-    const path = await import("path");
-    const active = path.join(this.dir, `${name}.ndjson`);
-    try {
-      const stat2 = await fs.stat(active);
-      if (stat2.size >= this.maxBytes) {
-        const rolled = path.join(this.dir, `${name}.${Date.now()}.ndjson`);
-        await fs.rename(active, rolled);
-      }
-    } catch {
-    }
-    await fs.appendFile(active, `${JSON.stringify(record)}
-`, "utf8");
-    if (this.index && !record?._update) {
-      void this.insertInto(name, record);
-    }
-  }
-  async insertInto(name, record) {
-    if (!this.index) return;
-    switch (name) {
-      case "runs":
-        await this.index.appendRun(record);
-        break;
-      case "spans":
-        await this.index.appendSpan(record);
-        break;
-      case "events":
-        await this.index.appendEvent(record);
-        break;
-      case "artifacts":
-        await this.index.appendArtifact(record);
-        break;
-      case "budget":
-        await this.index.appendBudgetEntry(record);
-        break;
-    }
-  }
-  async load() {
-    if (this.loaded && this.index) return this.index;
-    const fs = await import("fs/promises");
-    const path = await import("path");
-    const store = new InMemoryTraceStore();
-    try {
-      const entries = await fs.readdir(this.dir);
-      for (const file of entries) {
-        if (!file.endsWith(".ndjson")) continue;
-        const full = path.join(this.dir, file);
-        const content = await fs.readFile(full, "utf8");
-        const base = file.split(".")[0];
-        for (const line of content.split("\n")) {
-          if (!line.trim()) continue;
-          const record = JSON.parse(line);
-          if (base === "runs") {
-            try {
-              await store.appendRun(record);
-            } catch {
-              await store.updateRun(record.runId, record);
-            }
-          } else if (base === "spans") {
-            if (record?._update) {
-              try {
-                await store.updateSpan(record.spanId, record);
-              } catch {
-                await store.appendSpan(record);
-              }
-            } else {
-              await store.appendSpan(record);
-            }
-          } else if (base === "events") {
-            await store.appendEvent(record);
-          } else if (base === "artifacts") {
-            await store.appendArtifact(record);
-          } else if (base === "budget") {
-            await store.appendBudgetEntry(record);
-          }
-        }
-      }
-    } catch {
-    }
-    this.index = store;
-    this.loaded = true;
-    return store;
-  }
-  async appendRun(run) {
-    await this.append("runs", run);
-  }
-  async updateRun(runId, patch) {
-    await this.append("runs", { runId, ...patch, _update: true });
-    if (this.index) await this.index.updateRun(runId, patch);
-  }
-  async appendSpan(span) {
-    await this.append("spans", span);
-  }
-  async updateSpan(spanId, patch) {
-    await this.append("spans", { spanId, ...patch, _update: true });
-    if (this.index) await this.index.updateSpan(spanId, patch);
-  }
-  async appendEvent(event) {
-    await this.append("events", event);
-  }
-  async appendArtifact(artifact) {
-    await this.append("artifacts", artifact);
-  }
-  async appendBudgetEntry(entry) {
-    await this.append("budget", entry);
-  }
-  async getRun(runId) {
-    return (await this.load()).getRun(runId);
-  }
-  async listRuns(filter) {
-    return (await this.load()).listRuns(filter);
-  }
-  async spans(filter) {
-    return (await this.load()).spans(filter);
-  }
-  async events(filter) {
-    return (await this.load()).events(filter);
-  }
-  async budget(runId) {
-    return (await this.load()).budget(runId);
-  }
-  async artifacts(runId) {
-    return (await this.load()).artifacts(runId);
-  }
-};
-
-// src/trace/capture-fetch.ts
-var DEFAULT_BODY_CAP = 2 * 1024 * 1024;
-function headersToRecord(headers) {
-  if (!headers) return void 0;
-  const out = {};
-  headers.forEach((value, key) => {
-    out[key.toLowerCase()] = value;
-  });
-  return Object.keys(out).length > 0 ? out : void 0;
-}
-function parseMaybeJson(text) {
-  if (text.length === 0) return void 0;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-async function readRequestBody(input, init) {
-  if (typeof init?.body === "string") return parseMaybeJson(init.body);
-  if (init?.body != null) return void 0;
-  if (input instanceof Request) {
-    try {
-      return parseMaybeJson(await input.clone().text());
-    } catch {
-      return void 0;
-    }
-  }
-  return void 0;
-}
-function endpointFromUrl(url, baseUrl) {
-  const normalisedBase = baseUrl.replace(/\/+$/, "");
-  if (url.startsWith(normalisedBase)) return url.slice(normalisedBase.length) || "/";
-  try {
-    return new URL(url).pathname;
-  } catch {
-    return url;
-  }
-}
-function captureFetchToRawSink(fetch2, sink, ctx, opts = {}) {
-  const provider = ctx.provider ?? providerFromBaseUrl(ctx.baseUrl);
-  const redactor = opts.redactor ?? defaultProviderRedactor;
-  const bodyCap = opts.responseBodyByteCap ?? DEFAULT_BODY_CAP;
-  let warned = false;
-  const baseEvent = (direction, endpoint) => ({
-    eventId: crypto.randomUUID(),
-    runId: ctx.runId,
-    spanId: ctx.spanId,
-    provider,
-    model: ctx.model,
-    endpoint,
-    baseUrl: ctx.baseUrl,
-    attemptIndex: 0,
-    // retries are re-invocations one layer up; documented in 0.x
-    direction,
-    timestamp: Date.now(),
-    redactedFields: []
-  });
-  const record = async (event) => {
-    try {
-      await sink.record(redactor(event));
-    } catch (err) {
-      if (opts.failClosed) throw err;
-      if (!warned) {
-        warned = true;
-        console.warn(
-          `captureFetchToRawSink: sink.record failed (capture is best-effort) \u2014 ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-  };
-  return async (input, init) => {
-    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-    const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
-    const endpoint = endpointFromUrl(url, ctx.baseUrl);
-    const reqHeaders = new Headers(
-      init?.headers ?? (input instanceof Request ? input.headers : void 0)
-    );
-    await record({
-      ...baseEvent("request", endpoint),
-      requestHeaders: { ...headersToRecord(reqHeaders), "x-http-method": method },
-      requestBody: await readRequestBody(input, init)
-    });
-    const start = Date.now();
-    let response;
-    try {
-      response = await fetch2(input, init);
-    } catch (err) {
-      await record({
-        ...baseEvent("error", endpoint),
-        durationMs: Date.now() - start,
-        errorMessage: err instanceof Error ? err.message : String(err)
-      });
-      throw err;
-    }
-    let responseBody;
-    const redactedFields = [];
-    try {
-      const raw = await response.clone().text();
-      if (raw.length > bodyCap) {
-        responseBody = raw.slice(0, bodyCap);
-        redactedFields.push("body_truncated");
-      } else {
-        responseBody = parseMaybeJson(raw);
-      }
-    } catch {
-      responseBody = void 0;
-    }
-    await record({
-      ...baseEvent("response", endpoint),
-      durationMs: Date.now() - start,
-      statusCode: response.status,
-      responseHeaders: headersToRecord(response.headers),
-      responseBody,
-      redactedFields
-    });
-    return response;
-  };
-}
-
-// src/trace/otel.ts
-var OTEL_AGENT_EVAL_SCOPE = { name: "@tangle-network/agent-eval", version: "0.3.0" };
-async function exportRunAsOtlp(store, runId, resourceAttrs = {}) {
-  const run = await store.getRun(runId);
-  if (!run) throw new Error(`run ${runId} not found`);
-  const spans = await store.spans({ runId });
-  const events = await store.events({ runId });
-  const eventsBySpan = /* @__PURE__ */ new Map();
-  for (const e of events) {
-    if (!e.spanId) continue;
-    const arr = eventsBySpan.get(e.spanId) ?? [];
-    arr.push(e);
-    eventsBySpan.set(e.spanId, arr);
-  }
-  const traceId = runToTraceId(run);
-  const otlpSpans = spans.map(
-    (s) => spanToOtlp(s, traceId, eventsBySpan.get(s.spanId) ?? [])
-  );
-  return {
-    resourceSpans: [
-      {
-        resource: {
-          attributes: toAttributes({
-            "service.name": "agent-eval",
-            "run.id": run.runId,
-            "run.scenario_id": run.scenarioId,
-            "run.variant_id": run.variantId ?? "",
-            "run.dataset_version": run.datasetVersion ?? "",
-            "run.code_sha": run.codeSha ?? "",
-            "run.model_fingerprint": run.modelFingerprint ?? "",
-            ...resourceAttrs
-          })
-        },
-        scopeSpans: [{ scope: OTEL_AGENT_EVAL_SCOPE, spans: otlpSpans }]
-      }
-    ]
-  };
-}
-function spanToOtlp(span, traceId, events) {
-  const endedAt = span.endedAt ?? span.startedAt;
-  return {
-    traceId,
-    spanId: padSpanId(span.spanId),
-    parentSpanId: span.parentSpanId ? padSpanId(span.parentSpanId) : void 0,
-    name: span.name,
-    kind: 1,
-    // SPAN_KIND_INTERNAL
-    startTimeUnixNano: msToNs(span.startedAt),
-    endTimeUnixNano: msToNs(endedAt),
-    attributes: toAttributes(flattenSpanAttributes(span)),
-    events: events.map((e) => ({
-      timeUnixNano: msToNs(e.timestamp),
-      name: e.kind,
-      attributes: toAttributes(flattenPayload(e.payload))
-    })),
-    status: span.status === "error" ? { code: 2, message: span.error } : { code: 1 }
-  };
-}
-function flattenSpanAttributes(span) {
-  const base = {
-    "span.kind": span.kind
-  };
-  if (span.kind === "llm") {
-    base["llm.model"] = span.model;
-    if (span.inputTokens !== void 0) base["llm.input_tokens"] = span.inputTokens;
-    if (span.outputTokens !== void 0) base["llm.output_tokens"] = span.outputTokens;
-    if (span.costUsd !== void 0) base["llm.cost_usd"] = span.costUsd;
-    if (span.finishReason) base["llm.finish_reason"] = span.finishReason;
-  } else if (span.kind === "tool") {
-    base["tool.name"] = span.toolName;
-    if (span.latencyMs !== void 0) base["tool.latency_ms"] = span.latencyMs;
-  } else if (span.kind === "retrieval") {
-    base["retrieval.query"] = span.query;
-    base["retrieval.hits"] = span.hits.length;
-  } else if (span.kind === "judge") {
-    base["judge.id"] = span.judgeId;
-    base["judge.dimension"] = span.dimension;
-    base["judge.score"] = span.score;
-    base["judge.target_span_id"] = span.targetSpanId;
-  } else if (span.kind === "sandbox") {
-    if (span.image) base["sandbox.image"] = span.image;
-    if (span.exitCode !== void 0) base["sandbox.exit_code"] = span.exitCode;
-    if (span.testsPassed !== void 0) base["sandbox.tests_passed"] = span.testsPassed;
-    if (span.testsTotal !== void 0) base["sandbox.tests_total"] = span.testsTotal;
-  }
-  if (span.attributes) {
-    for (const [k, v] of Object.entries(span.attributes)) {
-      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") base[k] = v;
-    }
-  }
-  return base;
-}
-function flattenPayload(payload) {
-  const out = {};
-  for (const [k, v] of Object.entries(payload)) {
-    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") out[k] = v;
-    else out[k] = JSON.stringify(v);
-  }
-  return out;
-}
-function toAttributes(record) {
-  return Object.entries(record).map(([key, value]) => ({
-    key,
-    value: typeof value === "number" ? Number.isInteger(value) ? { intValue: value.toString() } : { doubleValue: value } : typeof value === "boolean" ? { boolValue: value } : { stringValue: value }
-  }));
-}
-function msToNs(ms) {
-  return (BigInt(Math.floor(ms)) * 1000000n).toString();
-}
-function padSpanId(id) {
-  const cleaned = id.replace(/-/g, "");
-  return cleaned.slice(0, 16).padEnd(16, "0");
-}
-function runToTraceId(run) {
-  const cleaned = run.runId.replace(/-/g, "");
-  return cleaned.slice(0, 32).padEnd(32, "0");
-}
-
-// src/trace/otel-bridge.ts
-function otelRunCompleteHook(exporter) {
-  return async (ctx) => {
-    const spans = await ctx.store.spans({ runId: ctx.runId });
-    for (const span of spans) {
-      if (span.endedAt) {
-        exporter.exportSpan(storeSpanToExportable(span, ctx.runId));
-      }
-    }
-    await exporter.flush();
-  };
-}
-function createOtelTracingStore(inner, exporter, traceId) {
-  return {
-    async appendRun(run) {
-      return inner.appendRun(run);
-    },
-    async updateRun(runId, patch) {
-      return inner.updateRun(runId, patch);
-    },
-    async appendSpan(span) {
-      if (span.endedAt) {
-        exporter.exportSpan(storeSpanToExportable(span, traceId));
-      }
-      return inner.appendSpan(span);
-    },
-    async updateSpan(spanId, patch) {
-      await inner.updateSpan(spanId, patch);
-      if (patch.endedAt) {
-        const spans = await inner.spans({ runId: traceId });
-        const found = spans.find((s) => s.spanId === spanId);
-        if (found) {
-          exporter.exportSpan(storeSpanToExportable(found, traceId));
-        }
-      }
-    },
-    async appendEvent(event) {
-      return inner.appendEvent(event);
-    },
-    async appendBudgetEntry(entry) {
-      return inner.appendBudgetEntry(entry);
-    },
-    async appendArtifact(artifact) {
-      return inner.appendArtifact(artifact);
-    },
-    getRun: inner.getRun.bind(inner),
-    listRuns: inner.listRuns.bind(inner),
-    spans: inner.spans.bind(inner),
-    events: inner.events.bind(inner),
-    budget: inner.budget.bind(inner),
-    artifacts: inner.artifacts.bind(inner)
-  };
-}
-function storeSpanToExportable(span, traceId) {
-  const llm = span.kind === "llm" ? span : void 0;
-  return {
-    traceId,
-    spanId: span.spanId,
-    parentSpanId: span.parentSpanId,
-    name: span.name,
-    kind: span.kind,
-    startedAt: span.startedAt,
-    endedAt: span.endedAt,
-    status: span.status,
-    error: span.error,
-    model: llm?.model,
-    inputTokens: llm?.inputTokens,
-    outputTokens: llm?.outputTokens,
-    costUsd: llm?.costUsd,
-    attributes: span.attributes
-  };
-}
-
-// src/trace/otel-export.ts
-function createOtelExporter(config) {
-  const resolvedEndpoint = config?.endpoint ?? (typeof process !== "undefined" ? process.env.OTEL_EXPORTER_OTLP_ENDPOINT : void 0);
-  if (!resolvedEndpoint) return void 0;
-  const endpoint = resolvedEndpoint;
-  const headers = config?.headers ?? parseHeadersFromEnv();
-  const batchSize = config?.batchSize ?? 64;
-  const flushIntervalMs = config?.flushIntervalMs ?? 5e3;
-  const serviceName = config?.serviceName ?? "agent-eval";
-  const resourceAttrs = config?.resourceAttributes ?? {};
-  const pending = [];
-  let timer;
-  let stopped = false;
-  const exporter = {
-    exportSpan(span) {
-      if (stopped) return;
-      pending.push(toOtlpSpan(span));
-      if (pending.length >= batchSize) {
-        void doFlush();
-      }
-    },
-    async flush() {
-      await doFlush();
-    },
-    async shutdown() {
-      stopped = true;
-      if (timer !== void 0) {
-        clearInterval(timer);
-        timer = void 0;
-      }
-      await doFlush();
-    }
-  };
-  timer = setInterval(() => {
-    if (pending.length > 0) void doFlush();
-  }, flushIntervalMs);
-  if (typeof timer === "object" && "unref" in timer) {
-    ;
-    timer.unref();
-  }
-  async function doFlush() {
-    if (pending.length === 0) return;
-    const batch = pending.splice(0);
-    const body = {
-      resourceSpans: [
-        {
-          resource: {
-            attributes: toAttributes2({
-              "service.name": serviceName,
-              ...resourceAttrs
-            })
-          },
-          scopeSpans: [{ scope: OTEL_AGENT_EVAL_SCOPE, spans: batch }]
-        }
-      ]
-    };
-    const url = `${endpoint.replace(/\/+$/, "")}/v1/traces`;
-    try {
-      await fetch(url, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          ...headers
-        },
-        body: JSON.stringify(body)
-      });
-    } catch {
-    }
-  }
-  return exporter;
-}
-function parseHeadersFromEnv() {
-  if (typeof process === "undefined") return {};
-  const raw = process.env.OTEL_EXPORTER_OTLP_HEADERS;
-  if (!raw) return {};
-  const out = {};
-  for (const pair of raw.split(",")) {
-    const eq = pair.indexOf("=");
-    if (eq < 0) continue;
-    const key = pair.slice(0, eq).trim();
-    const value = pair.slice(eq + 1).trim();
-    if (key) out[key] = value;
-  }
-  return out;
-}
-function toOtlpSpan(span) {
-  const endedAt = span.endedAt ?? span.startedAt;
-  const attrs = {
-    "span.kind": span.kind
-  };
-  if (span.model) attrs["llm.model"] = span.model;
-  if (span.inputTokens !== void 0) attrs["llm.input_tokens"] = span.inputTokens;
-  if (span.outputTokens !== void 0) attrs["llm.output_tokens"] = span.outputTokens;
-  if (span.costUsd !== void 0) attrs["llm.cost_usd"] = span.costUsd;
-  if (span.attributes) {
-    for (const [k, v] of Object.entries(span.attributes)) {
-      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") attrs[k] = v;
-    }
-  }
-  return {
-    traceId: padTraceId(span.traceId),
-    spanId: padSpanId2(span.spanId),
-    parentSpanId: span.parentSpanId ? padSpanId2(span.parentSpanId) : void 0,
-    name: span.name,
-    kind: 1,
-    // SPAN_KIND_INTERNAL
-    startTimeUnixNano: msToNs2(span.startedAt),
-    endTimeUnixNano: msToNs2(endedAt),
-    attributes: toAttributes2(attrs),
-    status: span.status === "error" ? { code: 2, message: span.error } : { code: 1 }
-  };
-}
-function toAttributes2(record) {
-  return Object.entries(record).map(([key, value]) => ({
-    key,
-    value: typeof value === "number" ? Number.isInteger(value) ? { intValue: value.toString() } : { doubleValue: value } : typeof value === "boolean" ? { boolValue: value } : { stringValue: value }
-  }));
-}
-function msToNs2(ms) {
-  return (BigInt(Math.floor(ms)) * 1000000n).toString();
-}
-function padSpanId2(id) {
-  const cleaned = id.replace(/-/g, "");
-  return cleaned.slice(0, 16).padEnd(16, "0");
-}
-function padTraceId(id) {
-  const cleaned = id.replace(/-/g, "");
-  return cleaned.slice(0, 32).padEnd(32, "0");
-}
-
-// src/replay.ts
-var ReplayCacheMissError = class extends ReplayError {
-  constructor(url, requestKey2, message) {
-    super(message ?? `replay cache miss for ${url} (key=${requestKey2})`);
-    this.url = url;
-    this.requestKey = requestKey2;
-  }
-  url;
-  requestKey;
-};
-var ReplayCache = class _ReplayCache {
-  byKey = /* @__PURE__ */ new Map();
-  orphans = 0;
-  byProvider = {};
-  byModel = {};
-  /**
-   * Build a cache from a sink's events. The sink must implement `list()`.
-   * Filter by `runId` / `spanId` to scope to a specific replay.
-   */
-  static async fromSink(sink, filter = {}) {
-    if (!sink.list) {
-      throw new ReplayError("ReplayCache.fromSink: sink must implement list() to be replayable.");
-    }
-    const events = await sink.list(filter);
-    return _ReplayCache.fromEvents(events);
-  }
-  /** Build a cache from an in-memory event list. */
-  static async fromEvents(events) {
-    const cache = new _ReplayCache();
-    const groups = /* @__PURE__ */ new Map();
-    for (const e of events) {
-      const k = `${e.runId ?? ""}::${e.spanId ?? ""}::${e.attemptIndex}`;
-      const g = groups.get(k) ?? {};
-      if (e.direction === "request") g.req = e;
-      else g.res = e;
-      groups.set(k, g);
-    }
-    for (const g of groups.values()) {
-      if (!g.req) continue;
-      if (!g.res) {
-        cache.orphans += 1;
-        continue;
-      }
-      const key = await requestKey(g.req);
-      cache.byKey.set(key, { request: g.req, response: g.res });
-      cache.byProvider[g.req.provider] = (cache.byProvider[g.req.provider] ?? 0) + 1;
-      cache.byModel[g.req.model] = (cache.byModel[g.req.model] ?? 0) + 1;
-    }
-    return cache;
-  }
-  /** Number of cacheable (request, response) pairs in the cache. */
-  size() {
-    return this.byKey.size;
-  }
-  stats() {
-    return {
-      total: this.byKey.size,
-      byProvider: { ...this.byProvider },
-      byModel: { ...this.byModel },
-      orphanRequests: this.orphans
-    };
-  }
-  /** Iterate every cached `(request, response)` pair in insertion order. */
-  *entries() {
-    for (const entry of this.byKey.values()) yield entry;
-  }
-  /**
-   * Look up a cached response by hashing the (model, messages, temperature,
-   * maxTokens, response_format) shape. Returns `undefined` on miss; the
-   * caller decides whether to throw, fall back to the network, or skip.
-   */
-  async lookup(requestBody) {
-    const key = await keyFromBody(requestBody);
-    return this.byKey.get(key);
-  }
-};
-function createReplayFetch(cache, opts = {}) {
-  const onMiss = opts.onMiss ?? "throw";
-  const fallback = opts.fallbackFetch ?? globalThis.fetch?.bind(globalThis);
-  return (async (input, init) => {
-    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-    if (!/\/chat\/completions(?:[?#].*)?$/.test(url)) {
-      if (!fallback)
-        throw new ReplayError(
-          `replay fetch: non-completions URL ${url} but no fallbackFetch configured`
-        );
-      return fallback(input, init);
-    }
-    let bodyParsed;
-    if (init?.body && typeof init.body === "string") {
-      try {
-        bodyParsed = JSON.parse(init.body);
-      } catch {
-      }
-    }
-    const hit = bodyParsed === void 0 ? void 0 : await cache.lookup(bodyParsed);
-    if (hit) {
-      opts.onHit?.({ url, provider: hit.request.provider, model: hit.request.model });
-      const status = hit.response.statusCode ?? 200;
-      const headers = new Headers(
-        Object.entries(hit.response.responseHeaders ?? { "Content-Type": "application/json" })
-      );
-      const bodyText = typeof hit.response.responseBody === "string" ? hit.response.responseBody : JSON.stringify(hit.response.responseBody ?? {});
-      return new Response(bodyText, { status, headers });
-    }
-    opts.onMissNotify?.({ url, requestBody: bodyParsed });
-    if (onMiss === "throw") {
-      const key = bodyParsed === void 0 ? "<unparseable>" : await keyFromBody(bodyParsed);
-      throw new ReplayCacheMissError(url, key);
-    }
-    if (onMiss === "fail-closed") {
-      return new Response(JSON.stringify({ error: "replay_cache_miss" }), { status: 599 });
-    }
-    if (!fallback)
-      throw new ReplayError("replay fetch: onMiss=fallback but no fallbackFetch configured");
-    return fallback(input, init);
-  });
-}
-async function* iterateRawCalls(sink, filter = {}) {
-  if (!sink.list) {
-    throw new ReplayError("iterateRawCalls: sink must implement list().");
-  }
-  const events = await sink.list(filter);
-  const cache = await ReplayCache.fromEvents(events);
-  for (const entry of cache.entries()) yield entry;
-}
-async function requestKey(event) {
-  return keyFromBody(event.requestBody);
-}
-async function keyFromBody(body) {
-  if (body == null || typeof body !== "object") return hashJson({ raw: String(body) });
-  const b = body;
-  const reduced = canonicalize({
-    model: b.model ?? null,
-    messages: b.messages ?? null,
-    temperature: b.temperature ?? null,
-    max_tokens: b.max_tokens ?? null,
-    max_completion_tokens: b.max_completion_tokens ?? null,
-    response_format: b.response_format ?? null
-  });
-  return hashJson(reduced);
-}
-
 export {
-  TRACE_ANALYST_ACTOR_DESCRIPTION,
-  TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION,
-  TRACE_ANALYST_SUBAGENT_DESCRIPTION,
+  projectOtlpFlatLine,
+  readOtlpStatus,
+  inferOtlpKind,
+  extractOtlpAttributes,
+  stringField,
+  asString,
+  asNumber,
+  firstNumberAttr,
+  firstStringAttr,
   DEFAULT_TRACE_ANALYST_BUDGETS,
   TRACE_ANALYST_TRUNCATION_MARKER_PREFIX,
   OtlpFileTraceStore,
@@ -2259,29 +1098,9 @@ export {
   SpanNotFoundError,
   buildTraceAnalystTools,
   traceAnalystFunctionGroup,
-  analyzeTraces,
-  traceAnalystOnRunComplete,
-  tokenizeDomainWords,
-  inferDomainKeywords,
-  domainEvidencePattern,
-  describeTraceInsightScope,
-  planTraceInsightQuestions,
-  buildTraceInsightContext,
-  scoreTraceInsightReadiness,
-  defaultTraceInsightPanel,
-  buildTraceInsightPrompt,
-  flattenOtlpExportToNdjson,
-  InMemoryTraceStore,
-  FileSystemTraceStore,
-  captureFetchToRawSink,
-  OTEL_AGENT_EVAL_SCOPE,
-  exportRunAsOtlp,
-  otelRunCompleteHook,
-  createOtelTracingStore,
-  createOtelExporter,
-  ReplayCacheMissError,
-  ReplayCache,
-  createReplayFetch,
-  iterateRawCalls
+  TRACE_ANALYST_ACTOR_DESCRIPTION,
+  TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION,
+  TRACE_ANALYST_SUBAGENT_DESCRIPTION,
+  analyzeTraces
 };
-//# sourceMappingURL=chunk-ODGETRTM.js.map
+//# sourceMappingURL=chunk-VUINJM5M.js.map