@tangle-network/agent-eval 0.20.3 → 0.20.5

package/dist/index.js

@@ -560,11 +560,11 @@ var FileSystemFeedbackTrajectoryStore = class {
   }
   async load() {
     if (this.loaded) return;
-    const { readFile } = await import("fs/promises");
+    const { readFile: readFile2 } = await import("fs/promises");
     const { join: join3 } = await import("path");
     const file = join3(this.dir, "feedback-trajectories.ndjson");
     try {
-      const raw = await readFile(file, "utf8");
+      const raw = await readFile2(file, "utf8");
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
         try {
@@ -1358,7 +1358,7 @@ function incompleteBeta(x, a, b) {
   let d = 1 - (a + b) * x / (a + 1);
   if (Math.abs(d) < 1e-30) d = 1e-30;
   d = 1 / d;
-  let f = d;
+  let f2 = d;
   for (let m = 1; m <= maxIter; m++) {
     const m2 = 2 * m;
     let num = m * (b - m) * x / ((a + m2 - 1) * (a + m2));
@@ -1367,7 +1367,7 @@ function incompleteBeta(x, a, b) {
     c = 1 + num / c;
     if (Math.abs(c) < 1e-30) c = 1e-30;
     d = 1 / d;
-    f *= d * c;
+    f2 *= d * c;
     num = -((a + m) * (a + b + m) * x) / ((a + m2) * (a + m2 + 1));
     d = 1 + num * d;
     if (Math.abs(d) < 1e-30) d = 1e-30;
@@ -1375,10 +1375,10 @@ function incompleteBeta(x, a, b) {
     if (Math.abs(c) < 1e-30) c = 1e-30;
     d = 1 / d;
     const delta = d * c;
-    f *= delta;
+    f2 *= delta;
     if (Math.abs(delta - 1) < eps) break;
   }
-  return front * f;
+  return front * f2;
 }
 function lnGamma(z) {
   const g = 7;
@@ -2305,10 +2305,10 @@ var TraceEmitter = class {
    * Runs `fn` inside a span; auto-ends on success, auto-fails on throw.
    * Returns the fn's return value. Use this for the 95% case.
    */
-  async within(init, fn) {
+  async within(init, fn2) {
     const handle = await this.span(init);
     try {
-      const result = await fn(handle);
+      const result = await fn2(handle);
       await handle.end();
       return result;
     } catch (err) {
@@ -3834,8 +3834,8 @@ var FileSystemExperimentStore = class {
     const path = await import("path");
     const active = path.join(this.dir, `${name}.ndjson`);
     try {
-      const stat = await fs.stat(active);
-      if (stat.size >= this.maxBytes) {
+      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);
       }
@@ -3850,7 +3850,7 @@ var FileSystemExperimentStore = class {
     const store = new InMemoryExperimentStore();
     try {
       const entries = await fs.readdir(this.dir);
-      const sorted = entries.filter((f) => f.endsWith(".ndjson")).sort((a, b) => a.localeCompare(b));
+      const sorted = entries.filter((f2) => f2.endsWith(".ndjson")).sort((a, b) => a.localeCompare(b));
       for (const file of sorted) {
         const full = path.join(this.dir, file);
         const content = await fs.readFile(full, "utf8");
@@ -4498,7 +4498,7 @@ function buildJobs(config) {
   }
   return jobs;
 }
-async function mapLimit(items, limit, fn) {
+async function mapLimit(items, limit, fn2) {
   const results = new Array(items.length);
   let next = 0;
   const workerCount = Math.max(1, Math.min(Math.floor(limit), items.length));
@@ -4507,7 +4507,7 @@ async function mapLimit(items, limit, fn) {
       const index = next++;
       const item = items[index];
       if (item === void 0) continue;
-      results[index] = await fn(item);
+      results[index] = await fn2(item);
     }
   }));
   return results;
@@ -4585,36 +4585,36 @@ var InMemoryTraceStore = class {
     return this.allArtifacts.filter((a) => a.runId === runId).map((a) => ({ ...a }));
   }
 };
-function matchesRun(r, f) {
-  if (f.scenarioId && r.scenarioId !== f.scenarioId) return false;
-  if (f.variantId && r.variantId !== f.variantId) return false;
-  if (f.status && r.status !== f.status) return false;
-  if (f.since !== void 0 && r.startedAt < f.since) return false;
-  if (f.until !== void 0 && r.startedAt > f.until) return false;
-  if (f.tag && r.tags?.[f.tag.key] !== f.tag.value) return false;
-  if (f.parentRunId && r.parentRunId !== f.parentRunId) return false;
-  if (f.projectId && r.projectId !== f.projectId) return false;
-  if (f.chatId && r.chatId !== f.chatId) return false;
-  if (f.layer && r.layer !== f.layer) return false;
+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, f) {
-  if (f.runId && s.runId !== f.runId) return false;
-  if (f.parentSpanId && s.parentSpanId !== f.parentSpanId) return false;
-  if (f.kind && s.kind !== f.kind) return false;
-  if (f.name && s.name !== f.name) return false;
-  if (f.toolName && (s.kind !== "tool" || s.toolName !== f.toolName)) return false;
-  if (f.judgeId && (s.kind !== "judge" || s.judgeId !== f.judgeId)) return false;
-  if (f.since !== void 0 && s.startedAt < f.since) return false;
-  if (f.until !== void 0 && s.startedAt > f.until) return false;
+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, f) {
-  if (f.runId && e.runId !== f.runId) return false;
-  if (f.spanId && e.spanId !== f.spanId) return false;
-  if (f.kind && e.kind !== f.kind) return false;
-  if (f.since !== void 0 && e.timestamp < f.since) return false;
-  if (f.until !== void 0 && e.timestamp > f.until) return false;
+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 {
@@ -4637,8 +4637,8 @@ var FileSystemTraceStore = class {
     const path = await import("path");
     let active = path.join(this.dir, `${name}.ndjson`);
     try {
-      const stat = await fs.stat(active);
-      if (stat.size >= this.maxBytes) {
+      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);
       }
@@ -6106,22 +6106,22 @@ async function computeToolUseMetrics(store, runId, options = {}) {
   const sortedTools = [...tools].sort((a, b) => a.startedAt - b.startedAt);
   const seenSignatures = /* @__PURE__ */ new Set();
   for (const t of sortedTools) {
-    const stat = byTool[t.toolName] ??= { calls: 0, errors: 0, avgLatencyMs: 0, duplicates: 0 };
-    stat.calls += 1;
+    const stat2 = byTool[t.toolName] ??= { calls: 0, errors: 0, avgLatencyMs: 0, duplicates: 0 };
+    stat2.calls += 1;
     if (t.status === "error") {
-      stat.errors += 1;
+      stat2.errors += 1;
       totalErrors += 1;
     }
-    if (typeof t.latencyMs === "number") stat.avgLatencyMs += t.latencyMs;
+    if (typeof t.latencyMs === "number") stat2.avgLatencyMs += t.latencyMs;
     const sig = `${t.toolName}|${argHash(t.args)}`;
     if (seenSignatures.has(sig)) {
-      stat.duplicates += 1;
+      stat2.duplicates += 1;
       totalDuplicates += 1;
     }
     seenSignatures.add(sig);
   }
-  for (const stat of Object.values(byTool)) {
-    stat.avgLatencyMs = stat.calls > 0 ? stat.avgLatencyMs / stat.calls : 0;
+  for (const stat2 of Object.values(byTool)) {
+    stat2.avgLatencyMs = stat2.calls > 0 ? stat2.avgLatencyMs / stat2.calls : 0;
   }
   let retryOpportunities = 0;
   let retriesFollowed = 0;
@@ -6181,7 +6181,7 @@ async function stuckLoopView(store, options = {}) {
       });
     }
   }
-  const affectedRuns = new Set(findings.map((f) => f.runId));
+  const affectedRuns = new Set(findings.map((f2) => f2.runId));
   return {
     findings,
     affectedRunRatio: runs.length > 0 ? affectedRuns.size / runs.length : 0,
@@ -6261,7 +6261,7 @@ async function budgetBreachView(store, options = {}) {
       if (run.variantId) byVariant[run.variantId] = (byVariant[run.variantId] ?? 0) + 1;
     }
   }
-  const breachedRuns = new Set(findings.map((f) => f.runId));
+  const breachedRuns = new Set(findings.map((f2) => f2.runId));
   return {
     findings,
     byDimension,
@@ -6552,7 +6552,7 @@ function incompleteBeta2(x, a, b) {
   let d = 1 - (a + b) * x / (a + 1);
   if (Math.abs(d) < 1e-30) d = 1e-30;
   d = 1 / d;
-  let f = d;
+  let f2 = d;
   for (let m = 1; m <= 200; m++) {
     const m2 = 2 * m;
     let num = m * (b - m) * x / ((a + m2 - 1) * (a + m2));
@@ -6561,7 +6561,7 @@ function incompleteBeta2(x, a, b) {
     c = 1 + num / c;
     if (Math.abs(c) < 1e-30) c = 1e-30;
     d = 1 / d;
-    f *= d * c;
+    f2 *= d * c;
     num = -((a + m) * (a + b + m) * x) / ((a + m2) * (a + m2 + 1));
     d = 1 + num * d;
     if (Math.abs(d) < 1e-30) d = 1e-30;
@@ -6569,10 +6569,10 @@ function incompleteBeta2(x, a, b) {
     if (Math.abs(c) < 1e-30) c = 1e-30;
     d = 1 / d;
     const delta = d * c;
-    f *= delta;
+    f2 *= delta;
     if (Math.abs(delta - 1) < 3e-7) break;
   }
-  return front * f;
+  return front * f2;
 }
 function lnGamma2(z) {
   const coefs = [
@@ -7071,8 +7071,8 @@ function formatFindings(findings) {
     `Found ${findings.length} muffled-gate pattern(s).`,
     `Fix each or annotate the line with "// muffle-ok: <reason>".`,
     "",
-    ...findings.map((f) => `  ${f.file}:${f.line} \u2014 ${f.pattern}
-    ${f.lineText}`)
+    ...findings.map((f2) => `  ${f2.file}:${f2.line} \u2014 ${f2.pattern}
+    ${f2.lineText}`)
   ].join("\n");
 }
 
@@ -7554,17 +7554,17 @@ function scoreRedTeamOutput(output, toolCalls, rtCase) {
 }
 function redTeamReport(findings) {
   const byCat = {};
-  for (const f of findings) {
-    const bucket = byCat[f.category] ?? { passed: 0, total: 0 };
+  for (const f2 of findings) {
+    const bucket = byCat[f2.category] ?? { passed: 0, total: 0 };
     bucket.total++;
-    if (f.passed) bucket.passed++;
-    byCat[f.category] = bucket;
+    if (f2.passed) bucket.passed++;
+    byCat[f2.category] = bucket;
   }
   const passRateByCategory = {};
   for (const [cat, { passed, total }] of Object.entries(byCat)) {
     passRateByCategory[cat] = total > 0 ? passed / total : 0;
   }
-  const overallPassRate = findings.length > 0 ? findings.filter((f) => f.passed).length / findings.length : 0;
+  const overallPassRate = findings.length > 0 ? findings.filter((f2) => f2.passed).length / findings.length : 0;
   return { findings, passRateByCategory, overallPassRate };
 }
 async function toolNamesForRun(store, runId) {
@@ -7744,7 +7744,7 @@ var CallExpectation = class {
   }
   async check() {
     const calls = await toolSpans(this.store, this.runId, this.toolName);
-    const matching = calls.filter((c) => this.argMatchers.every((fn) => fn(c.args)));
+    const matching = calls.filter((c) => this.argMatchers.every((fn2) => fn2(c.args)));
     const count = matching.length;
     if (count < this.minCount) return { ok: false, detail: `expected \u2265 ${this.minCount} matching "${this.toolName}" calls, got ${count}` };
     if (count > this.maxCount) return { ok: false, detail: `expected \u2264 ${this.maxCount} matching "${this.toolName}" calls, got ${count}` };
@@ -8132,8 +8132,8 @@ async function paraphraseRobustness(prompt, mutators, scoreFn, options = {}) {
   const originalScore = await scoreFn(prompt);
   const variantScores = [];
   const all = [originalScore];
-  for (const { id, fn } of mutators) {
-    const mutated = fn(prompt, seed);
+  for (const { id, fn: fn2 } of mutators) {
+    const mutated = fn2(prompt, seed);
     const score = await scoreFn(mutated);
     variantScores.push({ mutator: id, score, mutated });
     all.push(score);
@@ -8626,8 +8626,8 @@ var FileSystemOutcomeStore = class {
     const path = await import("path");
     const active = path.join(this.dir, "outcomes.ndjson");
     try {
-      const stat = await fs.stat(active);
-      if (stat.size >= this.maxBytes) {
+      const stat2 = await fs.stat(active);
+      if (stat2.size >= this.maxBytes) {
         await fs.rename(active, path.join(this.dir, `outcomes.${Date.now()}.ndjson`));
       }
     } catch {
@@ -8663,12 +8663,12 @@ var FileSystemOutcomeStore = class {
     return (await this.load()).list(filter);
   }
 };
-function matches(o, f) {
-  if (f.runIds && !f.runIds.includes(o.runId)) return false;
-  if (f.since !== void 0 && o.capturedAt < f.since) return false;
-  if (f.until !== void 0 && o.capturedAt > f.until) return false;
-  if (f.source && o.source !== f.source) return false;
-  if (f.label && o.labels?.[f.label.key] !== f.label.value) return false;
+function matches(o, f2) {
+  if (f2.runIds && !f2.runIds.includes(o.runId)) return false;
+  if (f2.since !== void 0 && o.capturedAt < f2.since) return false;
+  if (f2.until !== void 0 && o.capturedAt > f2.until) return false;
+  if (f2.source && o.source !== f2.source) return false;
+  if (f2.label && o.labels?.[f2.label.key] !== f2.label.value) return false;
   return true;
 }
 
@@ -9210,7 +9210,7 @@ async function promptBisect(options) {
           if (differing.length === 1) return null;
           const flip = differing.slice(0, Math.ceil(differing.length / 2));
           const chars = g.split("");
-          for (const f of flip) chars[f] = b[f];
+          for (const f2 of flip) chars[f2] = b[f2];
           return chars.join("");
         }
       }
@@ -9560,17 +9560,17 @@ function causalAttribution(cells) {
   const grandMean = allScores.reduce((a, b) => a + b, 0) / allScores.length;
   const totalVariance = allScores.reduce((acc, s) => acc + (s - grandMean) ** 2, 0) / allScores.length;
   if (totalVariance === 0) {
-    return { totalVariance: 0, mainEffects: factors.map((f) => ({ factor: f, shareOfVariance: 0, range: 0 })), interactions: [], residualShare: 1, sharesSum: 1 };
+    return { totalVariance: 0, mainEffects: factors.map((f2) => ({ factor: f2, shareOfVariance: 0, range: 0 })), interactions: [], residualShare: 1, sharesSum: 1 };
   }
-  const mainEffects = factors.map((f) => {
-    const byLevel = groupBy2(cells, (c) => c.levels[f]);
+  const mainEffects = factors.map((f2) => {
+    const byLevel = groupBy2(cells, (c) => c.levels[f2]);
     const means = [];
     for (const arr of byLevel.values()) {
       means.push(arr.reduce((a, c) => a + c.score, 0) / arr.length);
     }
     const mainVariance = means.reduce((acc, m) => acc + (m - grandMean) ** 2, 0) / means.length;
     return {
-      factor: f,
+      factor: f2,
       shareOfVariance: mainVariance / totalVariance,
       range: Math.max(...means) - Math.min(...means)
     };
@@ -9768,17 +9768,17 @@ function renderMarkdown(report) {
   lines.push("");
   lines.push("## Findings");
   lines.push("");
-  for (const f of report.findings) {
-    lines.push(`### ${sevEmoji[f.severity]} ${f.id} \u2014 ${f.control}`);
+  for (const f2 of report.findings) {
+    lines.push(`### ${sevEmoji[f2.severity]} ${f2.id} \u2014 ${f2.control}`);
     lines.push("");
-    lines.push(f.summary);
-    if (f.evidence) {
+    lines.push(f2.summary);
+    if (f2.evidence) {
       lines.push("");
-      lines.push("**Evidence:** " + f.evidence);
+      lines.push("**Evidence:** " + f2.evidence);
     }
-    if (f.remediation) {
+    if (f2.remediation) {
       lines.push("");
-      lines.push("**Remediation:** " + f.remediation);
+      lines.push("**Remediation:** " + f2.remediation);
     }
     lines.push("");
   }
@@ -9792,7 +9792,7 @@ function summarize(findings) {
     high: 0,
     critical: 0
   };
-  for (const f of findings) byeverity[f.severity]++;
+  for (const f2 of findings) byeverity[f2.severity]++;
   const overall = byeverity.critical + byeverity.high > 0 ? "non-compliant" : byeverity.medium + byeverity.low > 0 ? "compliant-with-findings" : "compliant";
   return { findings: findings.length, byeverity, overall };
 }
@@ -10140,7 +10140,7 @@ function gradeSemanticStatus(input) {
   if (!input.available) return "error";
   const threshold = input.threshold ?? 0.7;
   const criticalGaps = input.findings.filter(
-    (f) => f.severity === "critical" && (f.present === false || (f.score ?? 0) < 7)
+    (f2) => f2.severity === "critical" && (f2.present === false || (f2.score ?? 0) < 7)
   );
   return input.score >= threshold && criticalGaps.length === 0 ? "pass" : "fail";
 }
@@ -10212,7 +10212,7 @@ var MultiLayerVerifier = class {
         } finally {
           if (layerTimer) clearTimeout(layerTimer);
         }
-        result.findings = result.findings.map((f) => ({ ...f, layer: f.layer ?? layer.name }));
+        result.findings = result.findings.map((f2) => ({ ...f2, layer: f2.layer ?? layer.name }));
         results.push(result);
         byName[layer.name] = result;
         opts.onLayer?.(result);
@@ -10371,8 +10371,8 @@ var SEVERITY_RANK = {
 };
 function maxSeverity(findings) {
   let best = "info";
-  for (const f of findings) {
-    if (SEVERITY_RANK[f.severity] > SEVERITY_RANK[best]) best = f.severity;
+  for (const f2 of findings) {
+    if (SEVERITY_RANK[f2.severity] > SEVERITY_RANK[best]) best = f2.severity;
   }
   return best;
 }
@@ -10394,11 +10394,11 @@ function mergeLayerResults(name, perAdapter, options = {}) {
     return {
       ...only.result,
       layer: name,
-      findings: only.result.findings.map((f) => ({
-        ...f,
+      findings: only.result.findings.map((f2) => ({
+        ...f2,
         layer: name,
-        message: prefix ? `${prefix(only.adapter)} ${f.message}` : f.message,
-        detail: { ...f.detail ?? {}, adapter: only.adapter }
+        message: prefix ? `${prefix(only.adapter)} ${f2.message}` : f2.message,
+        detail: { ...f2.detail ?? {}, adapter: only.adapter }
       })),
       reason: only.result.reason ?? `${only.adapter}: ${only.result.status}`
     };
@@ -10418,12 +10418,12 @@ function mergeLayerResults(name, perAdapter, options = {}) {
     }
     durationMs = mergeDuration === "sum" ? durationMs + result.durationMs : Math.max(durationMs, result.durationMs);
     reasonParts.push(`${adapter2}: ${result.status}`);
-    for (const f of result.findings) {
+    for (const f2 of result.findings) {
       findings.push({
-        ...f,
+        ...f2,
         layer: name,
-        message: prefix ? `${prefix(adapter2)} ${f.message}` : f.message,
-        detail: { ...f.detail ?? {}, adapter: adapter2 }
+        message: prefix ? `${prefix(adapter2)} ${f2.message}` : f2.message,
+        detail: { ...f2.detail ?? {}, adapter: adapter2 }
       });
     }
     for (const [k, v] of Object.entries(result.diagnostics ?? {})) {
@@ -10672,8 +10672,8 @@ function truncate(body, cap, label) {
 \u2026 [truncated ${body.length - cap} chars of ${label}]`;
 }
 function buildPrompt(input, opts) {
-  const sourceBlob = input.sourceFiles.filter((f) => f.content.length <= opts.maxPerFileChars).map((f) => `--- FILE: ${f.path} ---
-${f.content}`).join("\n\n");
+  const sourceBlob = input.sourceFiles.filter((f2) => f2.content.length <= opts.maxPerFileChars).map((f2) => `--- FILE: ${f2.path} ---
+${f2.content}`).join("\n\n");
   const html = input.servedHtml ?? "";
   return `You are a strict code-review judge evaluating whether an agent's 0-to-1 build actually implements the features the user asked for.
 
@@ -10783,15 +10783,15 @@ async function runSemanticConceptJudge(input, options = {}) {
       evidence: String(c.evidence ?? ""),
       severity: ["critical", "major", "minor", "info"].includes(c.severity) ? c.severity : "info"
     }));
-    const presentCount = findings.filter((f) => f.present && f.score >= 7).length;
+    const presentCount = findings.filter((f2) => f2.present && f2.score >= 7).length;
     let weightSum = 0;
     let weightedScoreSum = 0;
-    for (const f of findings) {
-      const w = weightByName.get(f.concept) ?? 1;
+    for (const f2 of findings) {
+      const w = weightByName.get(f2.concept) ?? 1;
       weightSum += w;
-      weightedScoreSum += w * f.score;
+      weightedScoreSum += w * f2.score;
     }
-    const scoreAvg = weightSum > 0 ? weightedScoreSum / weightSum : findings.reduce((a, f) => a + f.score, 0) / Math.max(1, findings.length);
+    const scoreAvg = weightSum > 0 ? weightedScoreSum / weightSum : findings.reduce((a, f2) => a + f2.score, 0) / Math.max(1, findings.length);
     return {
       kind: "semantic-concept",
       version: SEMANTIC_CONCEPT_JUDGE_VERSION,
@@ -10846,8 +10846,8 @@ function truncate2(body, cap, label) {
 \u2026 [truncated ${body.length - cap} chars of ${label}]`;
 }
 function buildPrompt2(input, opts) {
-  const sourceBlob = input.sourceFiles.filter((f) => f.content.length <= opts.maxPerFileChars).map((f) => `--- FILE: ${f.path} ---
-${f.content}`).join("\n\n");
+  const sourceBlob = input.sourceFiles.filter((f2) => f2.content.length <= opts.maxPerFileChars).map((f2) => `--- FILE: ${f2.path} ---
+${f2.content}`).join("\n\n");
   const html = input.servedHtml ?? "";
   return `You are evaluating whether an agent built THE RIGHT APP for a user request.
 
@@ -11290,7 +11290,7 @@ function runKeywordCoverageJudge(html, expectedConcepts, assets = []) {
     const found = matchedKeywords.length > 0 && passesElementGate;
     return { concept: concept.name, found, matchedKeywords, requiredElementPresent };
   });
-  const presentCount = findings.filter((f) => f.found).length;
+  const presentCount = findings.filter((f2) => f2.found).length;
   return {
     score: presentCount / expectedConcepts.length,
     presentCount,
@@ -11443,10 +11443,10 @@ var Mutex = class {
       this.locked = false;
     }
   }
-  async runExclusive(fn) {
+  async runExclusive(fn2) {
     const release = await this.acquire();
     try {
-      return await fn();
+      return await fn2();
     } finally {
       release();
     }
@@ -13955,10 +13955,10 @@ function createSandboxPool(opts) {
       }
     };
   }
-  async function withSlot(fn) {
+  async function withSlot(fn2) {
     const { slot, release } = await checkout();
     try {
-      return await fn(slot);
+      return await fn2(slot);
     } finally {
       release();
     }
@@ -14496,6 +14496,1103 @@ function parseReflectionResponse(raw, maxProposals) {
   }
   return out;
 }
+
+// src/trace-analyst/analyst.ts
+import {
+  AxJSRuntime,
+  agent
+} from "@ax-llm/ax";
+
+// src/trace-analyst/store-otlp.ts
+import { readFile, stat } from "fs/promises";
+
+// src/trace-analyst/types.ts
+var DEFAULT_TRACE_ANALYST_BUDGETS = {
+  perCallByteCeiling: 15e4,
+  perAttributeViewBudget: 4096,
+  perAttributeSpanBudget: 16384,
+  perMatchTextBudget: 1024
+};
+var TRACE_ANALYST_TRUNCATION_MARKER_PREFIX = "[trace-analyst truncated:";
+
+// src/trace-analyst/store.ts
+function compileSearchRegex(pattern) {
+  return new RegExp(pattern, "m");
+}
+function truncateForBudget(value, byteCap) {
+  const original = Buffer.byteLength(value, "utf8");
+  if (original <= byteCap) return value;
+  const ratio2 = byteCap / original;
+  let cut = Math.max(0, Math.floor(value.length * ratio2));
+  while (cut > 0 && Buffer.byteLength(value.slice(0, cut), "utf8") > byteCap) {
+    cut -= 1;
+  }
+  return `${value.slice(0, cut)}
+[trace-analyst truncated: original ${original} bytes]`;
+}
+
+// src/trace-analyst/store-otlp.ts
+var OtlpFileTraceStore = class {
+  path;
+  perAttributeViewBudget;
+  perAttributeSpanBudget;
+  perCallByteCeiling;
+  perMatchTextBudget;
+  indexPromise;
+  /** Cached UTF-8 buffer of the file. We pin it once because every
+   *  read needs slice access and re-reading on each call balloons the
+   *  syscall count. */
+  bufferPromise;
+  constructor(opts) {
+    this.path = opts.path;
+    this.perAttributeViewBudget = opts.perAttributeViewBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perAttributeViewBudget;
+    this.perAttributeSpanBudget = opts.perAttributeSpanBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perAttributeSpanBudget;
+    this.perCallByteCeiling = opts.perCallByteCeiling ?? DEFAULT_TRACE_ANALYST_BUDGETS.perCallByteCeiling;
+    this.perMatchTextBudget = opts.perMatchTextBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perMatchTextBudget;
+  }
+  // ─── Public API ────────────────────────────────────────────────────
+  async getOverview(filters) {
+    const idx = await this.index();
+    const matched = await this.matchedTraces(idx, filters);
+    const services = /* @__PURE__ */ new Set();
+    const agents = /* @__PURE__ */ new Set();
+    const models = /* @__PURE__ */ new Set();
+    const tools = /* @__PURE__ */ new Set();
+    let rawBytes = 0;
+    let earliest = null;
+    let latest = null;
+    let errorTraceCount = 0;
+    let errorSpanCount = 0;
+    for (const t of matched) {
+      if (t.service_name) services.add(t.service_name);
+      if (t.agent_name) agents.add(t.agent_name);
+      for (const m of t.models) models.add(m);
+      for (const tn of t.tools) tools.add(tn);
+      rawBytes += t.raw_jsonl_bytes;
+      if (!earliest || t.start_time < earliest) earliest = t.start_time;
+      if (!latest || t.end_time > latest) latest = t.end_time;
+      if (t.has_errors) {
+        errorTraceCount += 1;
+        for (const s of t.spans) if (s.status === "ERROR") errorSpanCount += 1;
+      }
+    }
+    const sample_trace_ids = matched.slice(0, 20).map((t) => t.trace_id);
+    return {
+      total_traces: matched.length,
+      raw_jsonl_bytes: rawBytes,
+      services: [...services].sort(),
+      agents: [...agents].sort(),
+      models: [...models].sort(),
+      tool_names: [...tools].sort(),
+      sample_trace_ids,
+      errors: { trace_count: errorTraceCount, span_count: errorSpanCount },
+      time_range: earliest && latest ? { earliest, latest } : null
+    };
+  }
+  async queryTraces(opts) {
+    if (!Number.isInteger(opts.limit) || opts.limit < 1 || opts.limit > 200) {
+      throw new RangeError(`queryTraces.limit must be 1..200, got ${opts.limit}`);
+    }
+    const offset = opts.offset ?? 0;
+    if (!Number.isInteger(offset) || offset < 0) {
+      throw new RangeError(`queryTraces.offset must be >=0, got ${offset}`);
+    }
+    const idx = await this.index();
+    const matched = await this.matchedTraces(idx, opts.filters);
+    const slice = matched.slice(offset, offset + opts.limit);
+    return {
+      traces: slice.map((t) => this.toSummary(t)),
+      total: matched.length,
+      has_more: offset + slice.length < matched.length
+    };
+  }
+  async countTraces(filters) {
+    const idx = await this.index();
+    const matched = await this.matchedTraces(idx, filters);
+    return matched.length;
+  }
+  async viewTrace(opts) {
+    const idx = await this.index();
+    const trace = idx.byTrace.get(opts.trace_id);
+    if (!trace) {
+      throw new TraceNotFoundError(opts.trace_id);
+    }
+    const cap = opts.per_attribute_byte_cap ?? this.perAttributeViewBudget;
+    const buf = await this.buffer();
+    const spans = [];
+    let runningBytes = 0;
+    let span_response_bytes_max = 0;
+    for (const s of trace.spans) {
+      const projected = await this.projectSpan(buf, trace.trace_id, s, cap);
+      const bytes = Buffer.byteLength(JSON.stringify(projected), "utf8");
+      span_response_bytes_max = Math.max(span_response_bytes_max, bytes);
+      runningBytes += bytes;
+      if (runningBytes > this.perCallByteCeiling) {
+        return {
+          trace_id: trace.trace_id,
+          oversized: this.buildOversizedSummary(trace, span_response_bytes_max)
+        };
+      }
+      spans.push(projected);
+    }
+    return { trace_id: trace.trace_id, spans };
+  }
+  async viewSpans(opts) {
+    const idx = await this.index();
+    const trace = idx.byTrace.get(opts.trace_id);
+    if (!trace) throw new TraceNotFoundError(opts.trace_id);
+    if (opts.span_ids.length === 0) {
+      return {
+        trace_id: trace.trace_id,
+        spans: [],
+        missing_span_ids: [],
+        truncated_attribute_count: 0
+      };
+    }
+    if (opts.span_ids.length > 100) {
+      throw new RangeError(`viewSpans.span_ids cap is 100, got ${opts.span_ids.length}`);
+    }
+    const cap = opts.per_attribute_byte_cap ?? this.perAttributeSpanBudget;
+    const wantSet = new Set(opts.span_ids);
+    const found = trace.spans.filter((s) => wantSet.has(s.span_id));
+    const missing = opts.span_ids.filter((id) => !found.some((f2) => f2.span_id === id));
+    const buf = await this.buffer();
+    const spans = [];
+    let truncated = 0;
+    let runningBytes = 0;
+    for (const s of found) {
+      const before = truncationCounter(this);
+      const projected = await this.projectSpan(buf, trace.trace_id, s, cap);
+      truncated += before.delta();
+      const bytes = Buffer.byteLength(JSON.stringify(projected), "utf8");
+      runningBytes += bytes;
+      if (runningBytes > this.perCallByteCeiling) {
+        break;
+      }
+      spans.push(projected);
+    }
+    return {
+      trace_id: trace.trace_id,
+      spans,
+      missing_span_ids: missing,
+      truncated_attribute_count: truncated
+    };
+  }
+  async searchTrace(opts) {
+    const max_matches = opts.max_matches ?? 50;
+    if (!Number.isInteger(max_matches) || max_matches < 1 || max_matches > 500) {
+      throw new RangeError(`searchTrace.max_matches must be 1..500, got ${max_matches}`);
+    }
+    const idx = await this.index();
+    const trace = idx.byTrace.get(opts.trace_id);
+    if (!trace) throw new TraceNotFoundError(opts.trace_id);
+    const re = compileSearchRegex(opts.regex_pattern);
+    const buf = await this.buffer();
+    const hits = [];
+    let total = 0;
+    for (const s of trace.spans) {
+      const localHits = await this.scanSpanForMatches(buf, trace.trace_id, s, re, this.perMatchTextBudget);
+      total += localHits.total;
+      for (const h of localHits.records) {
+        if (hits.length >= max_matches) break;
+        hits.push(h);
+      }
+    }
+    return {
+      trace_id: trace.trace_id,
+      hits,
+      total_matches: total,
+      has_more: total > hits.length
+    };
+  }
+  async searchSpan(opts) {
+    const max_matches = opts.max_matches ?? 50;
+    if (!Number.isInteger(max_matches) || max_matches < 1 || max_matches > 500) {
+      throw new RangeError(`searchSpan.max_matches must be 1..500, got ${max_matches}`);
+    }
+    const idx = await this.index();
+    const trace = idx.byTrace.get(opts.trace_id);
+    if (!trace) throw new TraceNotFoundError(opts.trace_id);
+    const span = trace.spans.find((s) => s.span_id === opts.span_id);
+    if (!span) {
+      throw new SpanNotFoundError(opts.trace_id, opts.span_id);
+    }
+    const re = compileSearchRegex(opts.regex_pattern);
+    const buf = await this.buffer();
+    const localHits = await this.scanSpanForMatches(buf, trace.trace_id, span, re, this.perMatchTextBudget);
+    const truncated = localHits.records.slice(0, max_matches);
+    return {
+      trace_id: trace.trace_id,
+      span_id: span.span_id,
+      hits: truncated,
+      total_matches: localHits.total,
+      has_more: localHits.total > truncated.length
+    };
+  }
+  // ─── Index building ────────────────────────────────────────────────
+  /** Force the index to materialise. Useful to amortise startup cost
+   *  before the first agent call. */
+  async ensureIndexed() {
+    await this.index();
+  }
+  async buffer() {
+    if (!this.bufferPromise) {
+      this.bufferPromise = readFile(this.path);
+    }
+    return this.bufferPromise;
+  }
+  async index() {
+    if (!this.indexPromise) {
+      this.indexPromise = this.buildIndex();
+    }
+    return this.indexPromise;
+  }
+  async buildIndex() {
+    let buf;
+    try {
+      buf = await this.buffer();
+    } catch (err) {
+      const stats = await stat(this.path).catch(() => null);
+      if (!stats) {
+        throw new TraceFileMissingError(this.path);
+      }
+      throw err;
+    }
+    const byTrace = /* @__PURE__ */ new Map();
+    let cursor = 0;
+    while (cursor < buf.length) {
+      const newlineIndex = buf.indexOf(10, cursor);
+      const lineEnd = newlineIndex === -1 ? buf.length : newlineIndex;
+      const lineLength = lineEnd - cursor;
+      if (lineLength === 0) {
+        cursor = lineEnd + 1;
+        continue;
+      }
+      const lineSlice = buf.subarray(cursor, lineEnd).toString("utf8");
+      const lineOffset = cursor;
+      cursor = lineEnd + 1;
+      let parsed;
+      try {
+        parsed = JSON.parse(lineSlice);
+      } catch {
+        continue;
+      }
+      if (!parsed || typeof parsed !== "object") continue;
+      const span = readOtlpSpan(parsed);
+      if (!span) continue;
+      let entry = byTrace.get(span.trace_id);
+      if (!entry) {
+        entry = {
+          trace_id: span.trace_id,
+          service_name: span.service_name,
+          agent_name: span.agent_name,
+          span_count: 0,
+          has_errors: false,
+          start_time: span.start_time,
+          end_time: span.end_time,
+          duration_ms: 0,
+          raw_jsonl_bytes: 0,
+          models: /* @__PURE__ */ new Set(),
+          tools: /* @__PURE__ */ new Set(),
+          spans: []
+        };
+        byTrace.set(span.trace_id, entry);
+      } else {
+        if (!entry.service_name && span.service_name) entry.service_name = span.service_name;
+        if (!entry.agent_name && span.agent_name) entry.agent_name = span.agent_name;
+      }
+      const indexEntry = {
+        span_id: span.span_id,
+        parent_span_id: span.parent_span_id,
+        name: span.name,
+        kind: span.kind,
+        start_time: span.start_time,
+        end_time: span.end_time,
+        duration_ms: span.duration_ms,
+        status: span.status,
+        status_message: span.status_message,
+        service_name: span.service_name,
+        agent_name: span.agent_name,
+        model_name: span.model_name,
+        tool_name: span.tool_name,
+        line_byte_offset: lineOffset,
+        line_byte_length: lineLength
+      };
+      entry.spans.push(indexEntry);
+      entry.span_count += 1;
+      entry.raw_jsonl_bytes += lineLength + 1;
+      if (span.status === "ERROR") entry.has_errors = true;
+      if (span.start_time < entry.start_time) entry.start_time = span.start_time;
+      if (span.end_time > entry.end_time) entry.end_time = span.end_time;
+      if (span.model_name) entry.models.add(span.model_name);
+      if (span.tool_name) entry.tools.add(span.tool_name);
+    }
+    let totalRawBytes = 0;
+    for (const t of byTrace.values()) {
+      totalRawBytes += t.raw_jsonl_bytes;
+      t.spans.sort((a, b) => a.start_time.localeCompare(b.start_time) || a.line_byte_offset - b.line_byte_offset);
+      t.duration_ms = Math.max(
+        0,
+        new Date(t.end_time).getTime() - new Date(t.start_time).getTime()
+      );
+    }
+    const sortedTraceIds = [...byTrace.keys()].sort();
+    return { byTrace, totalRawBytes, sortedTraceIds };
+  }
+  // ─── Filter pipeline ───────────────────────────────────────────────
+  async matchedTraces(idx, filters) {
+    const traces = idx.sortedTraceIds.map((id) => idx.byTrace.get(id)).filter(isPresent);
+    if (!filters) return traces;
+    const indexedFiltered = traces.filter((t) => {
+      if (filters.has_errors !== void 0 && t.has_errors !== filters.has_errors) return false;
+      if (filters.service_names && filters.service_names.length > 0) {
+        if (!t.service_name || !filters.service_names.includes(t.service_name)) return false;
+      }
+      if (filters.agent_names && filters.agent_names.length > 0) {
+        if (!t.agent_name || !filters.agent_names.includes(t.agent_name)) return false;
+      }
+      if (filters.model_names && filters.model_names.length > 0) {
+        if (![...t.models].some((m) => filters.model_names.includes(m))) return false;
+      }
+      if (filters.tool_names && filters.tool_names.length > 0) {
+        if (![...t.tools].some((tn) => filters.tool_names.includes(tn))) return false;
+      }
+      if (filters.start_time_after && t.start_time < filters.start_time_after) return false;
+      if (filters.start_time_before && t.start_time > filters.start_time_before) return false;
+      return true;
+    });
+    if (!filters.regex_pattern) return indexedFiltered;
+    const re = compileSearchRegex(filters.regex_pattern);
+    const buf = await this.buffer();
+    const out = [];
+    for (const t of indexedFiltered) {
+      let matched = false;
+      for (const s of t.spans) {
+        const slice = buf.subarray(
+          s.line_byte_offset,
+          s.line_byte_offset + s.line_byte_length
+        );
+        if (re.test(slice.toString("utf8"))) {
+          matched = true;
+          break;
+        }
+      }
+      if (matched) out.push(t);
+    }
+    return out;
+  }
+  toSummary(t) {
+    return {
+      trace_id: t.trace_id,
+      service_name: t.service_name,
+      agent_name: t.agent_name,
+      span_count: t.span_count,
+      has_errors: t.has_errors,
+      start_time: t.start_time,
+      end_time: t.end_time,
+      duration_ms: t.duration_ms,
+      raw_jsonl_bytes: t.raw_jsonl_bytes,
+      models: [...t.models].sort(),
+      tools: [...t.tools].sort()
+    };
+  }
+  // ─── Span projection (lazy attribute reads) ────────────────────────
+  async projectSpan(buf, trace_id, s, perAttrCap) {
+    const slice = buf.subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length).toString("utf8");
+    let raw = {};
+    try {
+      const parsed = JSON.parse(slice);
+      if (parsed && typeof parsed === "object") raw = parsed;
+    } catch {
+    }
+    const attrs = extractAttributes(raw);
+    const projected = {};
+    for (const [k, v] of Object.entries(attrs)) {
+      if (typeof v === "string") {
+        const trunc = truncateForBudget(v, perAttrCap);
+        if (trunc !== v) trackTruncation(this);
+        projected[k] = trunc;
+      } else if (Array.isArray(v) || v && typeof v === "object") {
+        const json = JSON.stringify(v);
+        const trunc = truncateForBudget(json, perAttrCap);
+        if (trunc !== json) {
+          trackTruncation(this);
+          projected[k] = trunc;
+        } else {
+          projected[k] = v;
+        }
+      } else {
+        projected[k] = v;
+      }
+    }
+    return {
+      trace_id,
+      span_id: s.span_id,
+      parent_span_id: s.parent_span_id,
+      name: s.name,
+      kind: s.kind,
+      start_time: s.start_time,
+      end_time: s.end_time,
+      duration_ms: s.duration_ms,
+      status: s.status,
+      status_message: s.status_message,
+      service_name: s.service_name,
+      agent_name: s.agent_name,
+      model_name: s.model_name,
+      tool_name: s.tool_name,
+      attributes: projected
+    };
+  }
+  buildOversizedSummary(t, span_response_bytes_max) {
+    const counts = /* @__PURE__ */ new Map();
+    let errorCount = 0;
+    for (const s of t.spans) {
+      counts.set(s.name, (counts.get(s.name) ?? 0) + 1);
+      if (s.status === "ERROR") errorCount += 1;
+    }
+    const top = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20);
+    return {
+      span_count: t.span_count,
+      top_span_names: top,
+      span_response_bytes_max,
+      error_span_count: errorCount
+    };
+  }
+  async scanSpanForMatches(buf, trace_id, s, re, textBudget) {
+    const slice = buf.subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length).toString("utf8");
+    const records = [];
+    const globalRe = new RegExp(re.source, re.flags.includes("g") ? re.flags : `${re.flags}g`);
+    let total = 0;
+    let m;
+    while ((m = globalRe.exec(slice)) !== null) {
+      total += 1;
+      if (m.index === globalRe.lastIndex) globalRe.lastIndex += 1;
+      const before = slice.slice(Math.max(0, m.index - textBudget / 2), m.index);
+      const after = slice.slice(
+        m.index + m[0].length,
+        m.index + m[0].length + Math.floor(textBudget / 2)
+      );
+      records.push({
+        trace_id,
+        span_id: s.span_id,
+        span_name: s.name,
+        span_kind: s.kind,
+        attribute_path: bestAttributePathForOffset(slice, m.index) ?? "span.raw",
+        matched_text: truncateForBudget(m[0], textBudget),
+        context_before: truncateForBudget(before, textBudget),
+        context_after: truncateForBudget(after, textBudget),
+        match_offset: m.index
+      });
+    }
+    return { records, total };
+  }
+};
+var TraceFileMissingError = class extends Error {
+  constructor(path) {
+    super(`trace file not found: ${path}`);
+    this.name = "TraceFileMissingError";
+  }
+};
+var TraceNotFoundError = class extends Error {
+  trace_id;
+  constructor(trace_id) {
+    super(`trace not found: ${trace_id}`);
+    this.name = "TraceNotFoundError";
+    this.trace_id = trace_id;
+  }
+};
+var SpanNotFoundError = class extends Error {
+  trace_id;
+  span_id;
+  constructor(trace_id, span_id) {
+    super(`span ${span_id} not found in trace ${trace_id}`);
+    this.name = "SpanNotFoundError";
+    this.trace_id = trace_id;
+    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;
+}
+var truncationCounters = /* @__PURE__ */ new WeakMap();
+function trackTruncation(store) {
+  let c = truncationCounters.get(store);
+  if (!c) {
+    c = { value: 0 };
+    truncationCounters.set(store, c);
+  }
+  c.value += 1;
+}
+function truncationCounter(store) {
+  const before = truncationCounters.get(store)?.value ?? 0;
+  return {
+    delta() {
+      const after = truncationCounters.get(store)?.value ?? 0;
+      return after - before;
+    }
+  };
+}
+function bestAttributePathForOffset(slice, offset) {
+  let i = offset;
+  while (i > 0 && slice[i] !== '"') i -= 1;
+  if (i <= 0) return null;
+  let j = i - 1;
+  while (j > 0 && slice[j] !== ":") j -= 1;
+  if (j <= 0) return null;
+  let k = j - 1;
+  while (k > 0 && slice[k] !== '"') k -= 1;
+  let l = k - 1;
+  while (l > 0 && slice[l] !== '"') l -= 1;
+  if (l <= 0) return null;
+  return slice.slice(l + 1, k);
+}
+
+// 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/tools.ts
+import { f, fn } from "@ax-llm/ax";
+var NAMESPACE = "traces";
+var filtersField = f.json("Filter set. ALL fields are AND-composed. Leave empty to scan everything.").optional();
+function buildTraceAnalystTools(opts) {
+  const { store } = opts;
+  const getDatasetOverview = fn("getDatasetOverview").description(
+    "Dataset rollup: total traces, raw_jsonl_bytes, services, agents, models, tools, and sample_trace_ids (real ids passable to view/search). Always call this FIRST without a regex_pattern."
+  ).namespace(NAMESPACE).arg("filters", filtersField).returns(f.json("DatasetOverview")).handler(async ({ filters }) => store.getOverview(parseFilters(filters))).build();
+  const queryTraces = fn("queryTraces").description(
+    "Paginated trace summaries. Each summary carries raw_jsonl_bytes \u2014 use it to size traces BEFORE calling viewTrace. Narrow with indexed filters before adding regex_pattern."
+  ).namespace(NAMESPACE).arg("filters", filtersField).arg("limit", f.number("Page size, 1..200")).arg("offset", f.number("Page offset; default 0").optional()).returns(f.json("QueryTracesPage")).handler(
+    async ({ filters, limit, offset }) => store.queryTraces({
+      filters: parseFilters(filters),
+      limit: assertPageLimit(limit),
+      offset: assertOffset(offset)
+    })
+  ).build();
+  const countTraces = fn("countTraces").description(
+    "Count traces matching `filters`. Use as a cheap pre-flight before opting into a regex_pattern scan."
+  ).namespace(NAMESPACE).arg("filters", filtersField).returns(f.number("count")).handler(async ({ filters }) => store.countTraces(parseFilters(filters))).build();
+  const viewTrace = fn("viewTrace").description(
+    "Return ALL spans for a single trace, with each attribute capped at ~4KB. If the response would exceed the per-call ceiling the result carries `oversized` instead of `spans` \u2014 DO NOT retry with the same trace_id; switch to searchTrace / viewSpans."
+  ).namespace(NAMESPACE).arg("trace_id", f.string("Real trace id from a prior overview/query")).returns(f.json("ViewTraceResult")).handler(async ({ trace_id }) => store.viewTrace({ trace_id: assertString(trace_id, "trace_id") })).build();
+  const viewSpans = fn("viewSpans").description(
+    "Surgical read of specific spans within a trace, with each attribute capped at ~16KB (4\xD7 the discovery cap). Use after searchTrace narrows to specific span_ids."
+  ).namespace(NAMESPACE).arg("trace_id", f.string("Real trace id")).arg("span_ids", f.string("Span ids to fetch").array()).returns(f.json("ViewSpansResult")).handler(
+    async ({ trace_id, span_ids }) => store.viewSpans({
+      trace_id: assertString(trace_id, "trace_id"),
+      span_ids: assertStringArray(span_ids, "span_ids")
+    })
+  ).build();
+  const searchTrace = fn("searchTrace").description(
+    "Regex search across all spans of one trace. Returns `{trace_id, hits: SpanMatchRecord[], total_matches, has_more}`. **Iterate `result.hits`, NOT `result.matches`** \u2014 the field is `hits`. Each hit has `{span_id, span_name, span_kind, attribute_path, matched_text, context_before, context_after, match_offset}`. Bounded regardless of trace size by max_matches (1..500, default 50). If has_more=true, REFINE the regex rather than blindly raising max_matches."
+  ).namespace(NAMESPACE).arg("trace_id", f.string("Real trace id")).arg("regex_pattern", f.string("JS-compatible regex, multiline")).arg("max_matches", f.number("Max records returned, 1..500; default 50").optional()).returns(f.json("SearchTraceResult")).handler(
+    async ({ trace_id, regex_pattern, max_matches }) => store.searchTrace({
+      trace_id: assertString(trace_id, "trace_id"),
+      regex_pattern: assertRegex(regex_pattern),
+      max_matches: assertMaxMatches(max_matches)
+    })
+  ).build();
+  const searchSpan = fn("searchSpan").description(
+    "Regex search inside a single span. Use when viewSpans returned a 16KB-truncated payload and you need to narrow further. Returns `{trace_id, span_id, hits: SpanMatchRecord[], total_matches, has_more}` \u2014 iterate `result.hits`, NOT `result.matches`."
+  ).namespace(NAMESPACE).arg("trace_id", f.string("Real trace id")).arg("span_id", f.string("Real span id within trace")).arg("regex_pattern", f.string("JS-compatible regex, multiline")).arg("max_matches", f.number("Max records, 1..500; default 50").optional()).returns(f.json("SearchSpanResult")).handler(
+    async ({ trace_id, span_id, regex_pattern, max_matches }) => store.searchSpan({
+      trace_id: assertString(trace_id, "trace_id"),
+      span_id: assertString(span_id, "span_id"),
+      regex_pattern: assertRegex(regex_pattern),
+      max_matches: assertMaxMatches(max_matches)
+    })
+  ).build();
+  return [
+    getDatasetOverview,
+    queryTraces,
+    countTraces,
+    viewTrace,
+    viewSpans,
+    searchTrace,
+    searchSpan
+  ];
+}
+function traceAnalystFunctionGroup(opts) {
+  return {
+    namespace: NAMESPACE,
+    title: "Trace Analysis",
+    selectionCriteria: "Use for any inspection of OTLP-shaped trace data.",
+    description: "Discovery \u2192 narrow \u2192 deep-read tools over a JSONL trace dataset. Always call getDatasetOverview first.",
+    functions: buildTraceAnalystTools(opts)
+  };
+}
+function parseFilters(input) {
+  if (input == null) return void 0;
+  if (typeof input !== "object" || Array.isArray(input)) {
+    throw new TypeError(`filters must be an object, got ${typeof input}`);
+  }
+  const f2 = input;
+  const out = {};
+  if (typeof f2.has_errors === "boolean") out.has_errors = f2.has_errors;
+  out.service_names = stringArrayOrUndefined(f2.service_names, "service_names");
+  out.agent_names = stringArrayOrUndefined(f2.agent_names, "agent_names");
+  out.model_names = stringArrayOrUndefined(f2.model_names, "model_names");
+  out.tool_names = stringArrayOrUndefined(f2.tool_names, "tool_names");
+  if (typeof f2.start_time_after === "string") out.start_time_after = f2.start_time_after;
+  if (typeof f2.start_time_before === "string") out.start_time_before = f2.start_time_before;
+  if (typeof f2.regex_pattern === "string") {
+    if (f2.regex_pattern.length === 0) {
+      throw new TypeError("filters.regex_pattern cannot be empty");
+    }
+    out.regex_pattern = f2.regex_pattern;
+  }
+  return out;
+}
+function stringArrayOrUndefined(v, label) {
+  if (v === void 0 || v === null) return void 0;
+  if (!Array.isArray(v)) throw new TypeError(`${label} must be an array of strings`);
+  if (v.some((x) => typeof x !== "string")) {
+    throw new TypeError(`${label} entries must be strings`);
+  }
+  return v;
+}
+function assertPageLimit(limit) {
+  if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1 || limit > 200) {
+    throw new RangeError(`limit must be an integer 1..200`);
+  }
+  return limit;
+}
+function assertOffset(offset) {
+  if (offset === void 0) return void 0;
+  if (typeof offset !== "number" || !Number.isInteger(offset) || offset < 0) {
+    throw new RangeError(`offset must be a non-negative integer`);
+  }
+  return offset;
+}
+function assertRegex(pattern) {
+  if (typeof pattern !== "string" || pattern.length === 0) {
+    throw new TypeError(`regex_pattern must be a non-empty string`);
+  }
+  new RegExp(pattern, "m");
+  return pattern;
+}
+function assertMaxMatches(n) {
+  if (n === void 0) return void 0;
+  if (typeof n !== "number" || !Number.isInteger(n) || n < 1 || n > 500) {
+    throw new RangeError(`max_matches must be an integer 1..500`);
+  }
+  return n;
+}
+function assertString(v, label) {
+  if (typeof v !== "string" || v.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+  return v;
+}
+function assertStringArray(v, label) {
+  if (!Array.isArray(v)) throw new TypeError(`${label} must be an array of strings`);
+  if (v.some((x) => typeof x !== "string")) {
+    throw new TypeError(`${label} entries must be strings`);
+  }
+  return v;
+}
+
+// src/trace-analyst/analyst.ts
+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: dirname6 } = await import("path");
+    await mkdir(dirname6(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;
+  const maxTurns = options.maxTurns ?? 12;
+  const maxParallelSubagents = options.maxParallelSubagents ?? 2;
+  const maxRuntimeChars = options.maxRuntimeChars ?? 6e3;
+  const analyst = agent(
+    "question:string -> answer:string, findings:string[]",
+    {
+      agentIdentity: {
+        name: "TraceAnalyst",
+        description: "Analyzes OTLP-shaped JSONL traces using bounded discovery tools to identify systemic failure modes."
+      },
+      contextFields: ["question"],
+      runtime: new AxJSRuntime({
+        permissions: [],
+        blockDynamicImport: true,
+        allowedModules: [],
+        freezeIntrinsics: true,
+        blockShadowRealm: true,
+        // RLM stdout mode relies on runtime bindings persisting across turns.
+        preventGlobalThisExtensions: false
+      }),
+      mode: maxDepth > 0 ? "advanced" : "simple",
+      recursionOptions: maxDepth > 0 ? { maxDepth } : void 0,
+      maxTurns,
+      maxRuntimeChars,
+      maxBatchedLlmQueryConcurrency: maxParallelSubagents,
+      promptLevel: "detailed",
+      // Trace analysis depends on exact prior tool results and runtime variables.
+      contextPolicy: { preset: "full", budget: "balanced" },
+      functions: { local: tools },
+      actorOptions: {
+        description: options.actorDescription ?? TRACE_ANALYST_ACTOR_DESCRIPTION,
+        ...options.model ? { model: options.model } : {},
+        // Keep actor messages tool-call/content shaped across reasoning models.
+        showThoughts: false,
+        thinkingTokenBudget: "none"
+      },
+      responderOptions: {
+        ...options.model ? { model: options.model } : {},
+        description: options.subagentDescription ?? TRACE_ANALYST_SUBAGENT_DESCRIPTION,
+        showThoughts: false
+      },
+      actorTurnCallback,
+      bubbleErrors: [TraceFileMissingError]
+    }
+  );
+  let result;
+  try {
+    result = await analyst.forward(options.ai, { question: input.question });
+  } finally {
+    if (progressFs) {
+      await new Promise((resolve) => progressFs.end(() => resolve()));
+    }
+  }
+  return {
+    answer: typeof result.answer === "string" ? result.answer : String(result.answer ?? ""),
+    findings: Array.isArray(result.findings) ? result.findings.filter((s) => typeof s === "string") : [],
+    turns,
+    turnCount: turns.length,
+    usage: analyst.getUsage(),
+    chatLog: analyst.getChatLog(),
+    actorPromptVersion: TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION
+  };
+}
+
+// src/trace-analyst/insights.ts
+var DOMAIN_STOP_WORDS = /* @__PURE__ */ new Set([
+  "and",
+  "app",
+  "build",
+  "create",
+  "for",
+  "from",
+  "implementation",
+  "integrate",
+  "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 buildTraceInsightPrompt(input) {
+  const questions = planTraceInsightQuestions(input);
+  const keywords = inferDomainKeywords(input.suite);
+  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:
+${questions.map((item, index) => `${index + 1}. ${item.question} (${item.why})`).join("\n")}
+
+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: describeTraceInsightScope(input.suite),
+    inferredKeywords: keywords,
+    agent: input.agent ?? null,
+    totals: input.totals ?? null,
+    findings: (input.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.`;
+}
 export {
   AgentDriver,
   AxGepaSteeringOptimizer,
@@ -14519,6 +15616,7 @@ export {
   DEFAULT_RED_TEAM_CORPUS,
   DEFAULT_RUN_SCORE_WEIGHTS,
   DEFAULT_SEVERITY_WEIGHTS,
+  DEFAULT_TRACE_ANALYST_BUDGETS,
   Dataset,
   DockerSandboxDriver,
   DualAgentBench,
@@ -14552,6 +15650,7 @@ export {
   Mutex,
   NoopResearcher,
   OTEL_AGENT_EVAL_SCOPE,
+  OtlpFileTraceStore,
   PairwiseSteeringOptimizer,
   PrmGrader,
   ProductClient,
@@ -14563,10 +15662,17 @@ export {
   SEMANTIC_CONCEPT_JUDGE_VERSION,
   SandboxHarness,
   ScenarioRegistry,
+  SpanNotFoundError,
   SubprocessSandboxDriver,
+  TRACE_ANALYST_ACTOR_DESCRIPTION,
+  TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION,
+  TRACE_ANALYST_SUBAGENT_DESCRIPTION,
+  TRACE_ANALYST_TRUNCATION_MARKER_PREFIX,
   TRACE_SCHEMA_VERSION,
   TokenCounter,
   TraceEmitter,
+  TraceFileMissingError,
+  TraceNotFoundError,
   TrialTelemetry,
   UNIVERSAL_FINDERS,
   acquisitionPlansForKnowledgeGaps,
@@ -14576,6 +15682,7 @@ export {
   allCriticalPassed,
   analyzeAntiSlop,
   analyzeSeries,
+  analyzeTraces,
   argHash,
   assertReleaseConfidence,
   assignFeedbackSplit,
@@ -14591,6 +15698,8 @@ export {
   budgetBreachView,
   buildReflectionPrompt,
   buildReviewerPrompt,
+  buildTraceAnalystTools,
+  buildTraceInsightPrompt,
   buildTrajectory,
   byteLengthRange,
   calibrateJudge,
@@ -14641,7 +15750,9 @@ export {
   defaultMultiShotObjectives,
   defaultReferenceReplayMatcher,
   deployGateLayer,
+  describeTraceInsightScope,
   distillPlaybook,
+  domainEvidencePattern,
   dominates,
   estimateCost,
   estimateTokens,
@@ -14684,6 +15795,7 @@ export {
   htmlContainsElement,
   inMemoryReferenceReplayStore,
   inMemoryReviewStore,
+  inferDomainKeywords,
   interRaterReliability,
   iqr,
   isJudgeSpan,
@@ -14733,6 +15845,7 @@ export {
   partialCredit,
   passOrthogonality,
   pixelDeltaRatio,
+  planTraceInsightQuestions,
   politenessPrefixMutator,
   positionalBias,
   printDriverSummary,
@@ -14820,12 +15933,14 @@ export {
   toLangfuseEnvelope,
   toNdjson,
   toPrometheusText,
+  tokenizeDomainWords,
   toolIntentAlignmentRubric,
   toolNamesForRun,
   toolNonRedundantRubric,
   toolSpans,
   toolSuccessRubric,
   toolWasteView,
+  traceAnalystFunctionGroup,
   trialTraceFromMultiShotTrial,
   typoMutator,
   urlContains,