@tangle-network/agent-eval 0.27.2 → 0.29.0

package/dist/index.js

@@ -169,12 +169,15 @@ import {
   REDACTION_VERSION,
   ReplayCache,
   ReplayCacheMissError,
+  TraceFileMissingError,
+  analyzeTraces,
+  buildTraceAnalystTools,
   createReplayFetch,
   exportRunAsOtlp,
   iterateRawCalls,
   redactString,
   redactValue
-} from "./chunk-4U4BKCXK.js";
+} from "./chunk-UW4NOOZI.js";
 import {
   aggregateLlm,
   argHash,
@@ -229,6 +232,1492 @@ import {
 } from "./chunk-NG236HPC.js";
 import "./chunk-PZ5AY32C.js";
 
+// src/run-score.ts
+var DEFAULT_RUN_SCORE_WEIGHTS = {
+  success: 4,
+  goalProgress: 2,
+  repoGroundedness: 1.5,
+  driftPenalty: -1.5,
+  toolUseQuality: 1,
+  patchQuality: 1.25,
+  testReality: 1.5,
+  finalGate: 3,
+  reviewerBlockers: -2,
+  costUsd: -0.2,
+  wallSeconds: -0.1
+};
+function aggregateRunScore(score, weights = {}) {
+  const w = { ...DEFAULT_RUN_SCORE_WEIGHTS, ...weights };
+  return w.success * clamp01(score.success) + w.goalProgress * clamp01(score.goalProgress) + w.repoGroundedness * clamp01(score.repoGroundedness) + w.driftPenalty * clamp01(score.driftPenalty) + w.toolUseQuality * clamp01(score.toolUseQuality) + w.patchQuality * clamp01(score.patchQuality) + w.testReality * clamp01(score.testReality) + w.finalGate * clamp01(score.finalGate) + w.reviewerBlockers * clamp01(score.reviewerBlockers) + w.costUsd * Math.max(0, finiteOrZero(score.costUsd)) + w.wallSeconds * Math.max(0, finiteOrZero(score.wallSeconds) / 60);
+}
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function finiteOrZero(value) {
+  return Number.isFinite(value) ? value : 0;
+}
+
+// src/run-critic.ts
+var DEFAULT_DRIFT_PATTERNS = [
+  /https?:\/\//i,
+  /\btitle:\s/i,
+  /\bsummary:\s/i,
+  /\burl:\s/i,
+  /\bnpm package usage\b/i,
+  /\bnews\b/i
+];
+var RunCritic = class {
+  weights;
+  driftPatterns;
+  constructor(options = {}) {
+    this.weights = options.weights;
+    this.driftPatterns = options.driftPatterns ?? DEFAULT_DRIFT_PATTERNS;
+  }
+  async score(store, runId) {
+    const run = await store.getRun(runId);
+    if (!run) throw new NotFoundError(`run ${runId} not found`);
+    const [spans, events, artifacts, budget] = await Promise.all([
+      store.spans({ runId }),
+      store.events({ runId }),
+      store.artifacts(runId),
+      store.budget(runId)
+    ]);
+    return this.scoreTrace({ run, spans, events, artifacts, budget });
+  }
+  scoreTrace(trace) {
+    const notes = [];
+    const llmSpans2 = trace.spans.filter(
+      (s) => s.kind === "llm"
+    );
+    const toolSpans2 = trace.spans.filter(
+      (s) => s.kind === "tool"
+    );
+    const judgeSpans2 = trace.spans.filter(
+      (s) => s.kind === "judge"
+    );
+    const sandboxSpans = trace.spans.filter(
+      (s) => s.kind === "sandbox"
+    );
+    const finalGateSpans = judgeSpans2.filter(
+      (span) => span.dimension === "final_gate" || span.attributes?.finalGate === true
+    );
+    const success = trace.run.outcome?.pass === true ? 1 : trace.run.status === "completed" ? 0.5 : 0;
+    if (!success) notes.push("run did not complete with pass=true");
+    const judgeAverage = judgeSpans2.length ? judgeSpans2.reduce((sum2, span) => sum2 + normalizeJudgeScore(span.score), 0) / judgeSpans2.length : void 0;
+    const outcomeScore = typeof trace.run.outcome?.score === "number" ? clamp01(
+      trace.run.outcome.score > 1 ? trace.run.outcome.score / 100 : trace.run.outcome.score
+    ) : void 0;
+    const goalProgress = outcomeScore ?? judgeAverage ?? success;
+    const successfulTools = toolSpans2.filter((span) => span.status !== "error").length;
+    const toolUseQuality = toolSpans2.length === 0 ? 0 : successfulTools / toolSpans2.length;
+    if (toolSpans2.length === 0) notes.push("no tool spans recorded");
+    const patchEvidence = trace.artifacts.length + toolSpans2.filter((span) => /write|edit|patch|apply/i.test(span.toolName)).length;
+    const patchQuality = patchEvidence > 0 ? clamp01(patchEvidence / 4) : 0;
+    if (!patchQuality) notes.push("no artifact or edit evidence recorded");
+    const sandboxTests = sandboxSpans.filter(
+      (span) => typeof span.testsTotal === "number" && span.testsTotal > 0
+    );
+    const testReality = sandboxTests.length ? sandboxTests.reduce(
+      (sum2, span) => sum2 + (span.testsPassed ?? 0) / Math.max(1, span.testsTotal ?? 1),
+      0
+    ) / sandboxTests.length : toolSpans2.some(
+      (span) => /\btest|vitest|pytest|jest|build|tsc\b/i.test(JSON.stringify(span.args))
+    ) ? 0.4 : 0;
+    if (!testReality) notes.push("no real test/build evidence recorded");
+    const blockerSpans = judgeSpans2.filter((span) => isBlockingJudge(span));
+    const finalGateBlockers = finalGateSpans.filter((span) => isBlockingJudge(span));
+    const finalGate = finalGateSpans.length ? finalGateBlockers.length ? 0 : 1 : success;
+    if (finalGateBlockers.length)
+      notes.push(`final gate blocked by ${finalGateBlockers.length} reviewer(s)`);
+    else if (!finalGateSpans.length) notes.push("no final gate judgment recorded");
+    const reviewerBlockers = judgeSpans2.length ? blockerSpans.length / judgeSpans2.length : 0;
+    if (reviewerBlockers) notes.push(`detected ${blockerSpans.length} blocking reviewer signal(s)`);
+    const positiveGroundingSignals = patchEvidence + sandboxSpans.length + llmSpans2.filter((span) => looksRepoGrounded(span.output ?? "")).length;
+    const driftSignals = llmSpans2.filter((span) => this.isDrift(span.output ?? "")).length + trace.events.filter((event) => this.isDrift(JSON.stringify(event.payload))).length;
+    const repoGroundedness = positiveGroundingSignals + driftSignals === 0 ? 0 : positiveGroundingSignals / (positiveGroundingSignals + driftSignals);
+    const driftPenalty = positiveGroundingSignals + driftSignals === 0 ? 0 : driftSignals / (positiveGroundingSignals + driftSignals);
+    if (driftSignals > 0) notes.push(`detected ${driftSignals} drift signal(s)`);
+    const costUsd = trace.budget.length ? Math.max(
+      ...trace.budget.filter((entry) => entry.dimension === "usd").map((entry) => entry.consumed),
+      0
+    ) : llmSpans2.reduce((sum2, span) => sum2 + (span.costUsd ?? 0), 0);
+    const wallSeconds = trace.run.endedAt && trace.run.startedAt ? Math.max(0, (trace.run.endedAt - trace.run.startedAt) / 1e3) : 0;
+    return {
+      success,
+      goalProgress,
+      repoGroundedness,
+      driftPenalty,
+      toolUseQuality,
+      patchQuality,
+      testReality,
+      finalGate,
+      reviewerBlockers,
+      costUsd,
+      wallSeconds,
+      notes
+    };
+  }
+  rank(score) {
+    return aggregateRunScore(score, this.weights);
+  }
+  isDrift(text) {
+    return this.driftPatterns.some((pattern) => pattern.test(text));
+  }
+};
+function normalizeJudgeScore(score) {
+  return score > 1 ? clamp01(score / 10) : clamp01(score);
+}
+function looksRepoGrounded(text) {
+  return /(?:src\/|tests?\/|package\.json|tsconfig|\.ts\b|\.tsx\b|git status|pnpm |npm |vitest|pytest|jest)/i.test(
+    text
+  );
+}
+function isBlockingJudge(span) {
+  return span.attributes?.blocking === true || span.attributes?.verdict === "BLOCKING" || positiveNumber(span.attributes?.blockingFindings) || positiveNumber(span.attributes?.highFindings) || span.score <= 2;
+}
+function positiveNumber(value) {
+  return typeof value === "number" && value > 0;
+}
+
+// src/semantic-concept-judge.ts
+var DEFAULT_COMPLEXITY_WEIGHTS = {
+  render: 1,
+  integrate: 2,
+  compute: 2.5
+};
+var SEMANTIC_CONCEPT_JUDGE_VERSION = "semantic-concept-judge-v1-2026-04-24";
+var DEFAULT_MAX_SOURCE = 45e3;
+var DEFAULT_MAX_HTML = 3e4;
+var DEFAULT_MAX_PER_FILE = 2e4;
+var DEFAULT_TIMEOUT = 18e4;
+var DEFAULT_MODEL = "claude-sonnet-4-6";
+var SEMANTIC_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["summary", "concepts"],
+  properties: {
+    summary: { type: "string", minLength: 20, maxLength: 600 },
+    concepts: {
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["concept", "present", "score", "evidence", "severity"],
+        properties: {
+          concept: { type: "string", minLength: 1, maxLength: 120 },
+          present: { type: "boolean" },
+          score: { type: "number", minimum: 0, maximum: 10 },
+          evidence: { type: "string", minLength: 5, maxLength: 400 },
+          severity: { type: "string", enum: ["critical", "major", "minor", "info"] }
+        }
+      }
+    }
+  }
+};
+function truncate(body, cap, label) {
+  if (body.length <= cap) return body;
+  return `${body.slice(0, cap)}
+\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 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.
+
+You MUST distinguish:
+  (a) WORKING code that implements the concept (rendered UI, wired handler, real API call),
+  (b) KEYWORD-PRESENT stub (comments mentioning the concept, variable names, TODOs),
+  (c) ABSENT (concept nowhere).
+
+A comment like "// TODO: add mint button" is NOT present \u2014 score 2-3. Only count a concept as present if there is real functional code: a rendered component, a call handler wired to state or a network call, a computed value actually used.
+
+USER REQUEST (what the agent was asked to build):
+${input.userRequest}
+
+${input.artifactLabel ? `ARTIFACT METADATA:
+  name: ${input.artifactLabel}
+  description: ${input.artifactDescription ?? ""}
+
+` : ""}EXPECTED CONCEPTS (each must be graded independently):
+${input.expectedConcepts.map(
+    (c, i) => `  ${i + 1}. "${c.name}"${c.keywords?.length ? ` \u2014 hints: [${c.keywords.slice(0, 6).join(" | ")}]` : ""}`
+  ).join("\n")}
+
+${html ? `SERVED HTML (what the preview returns when hit):
+${truncate(html, opts.maxHtmlChars, "HTML")}
+
+` : ""}SOURCE FILES (the agent's workdir):
+${truncate(sourceBlob, opts.maxSourceChars, "source")}
+
+For EACH concept, return:
+  - concept: the concept name as given (match exactly)
+  - present: boolean \u2014 does a working implementation exist?
+  - score: 0-10 \u2014 10 = production-ready; 7 = functional but thin; 4 = partial/stubbed; 2 = keyword-only comment; 0 = absent
+  - evidence: cite "<file>:<line>" or "served-html:<selector>" pointing at the strongest supporting code. If the concept is absent or stubbed, explain what's missing.
+  - severity:
+      "info" when present: true AND score >= 7
+      "minor" when present: true AND 4 <= score < 7
+      "major" when present: false OR score < 4
+      "critical" when the concept is not only absent but a core user flow depends on it
+
+Also produce a "summary" (one sentence, 20-600 chars): overall verdict on whether this is a shippable implementation of the user request vs a keyword-dense placeholder.
+
+BE SKEPTICAL. Keyword matching already passed \u2014 your job is to catch what keyword matching misses. If the agent shipped a working build, say so. If it shipped a stub, say so. Don't grade on effort.
+
+Return STRICT JSON. No prose outside the JSON.`;
+}
+async function runSemanticConceptJudge(input, options = {}) {
+  const start = Date.now();
+  const totalCount = input.expectedConcepts.length;
+  if (totalCount === 0) {
+    return {
+      kind: "semantic-concept",
+      version: SEMANTIC_CONCEPT_JUDGE_VERSION,
+      score: 0,
+      presentCount: 0,
+      totalCount: 0,
+      findings: [],
+      summary: "no expected concepts declared",
+      durationMs: 0,
+      costUsd: null,
+      available: false,
+      error: "no expected concepts declared"
+    };
+  }
+  const opts = {
+    model: options.model ?? DEFAULT_MODEL,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT,
+    maxSourceChars: options.maxSourceChars ?? DEFAULT_MAX_SOURCE,
+    maxPerFileChars: options.maxPerFileChars ?? DEFAULT_MAX_PER_FILE,
+    maxHtmlChars: options.maxHtmlChars ?? DEFAULT_MAX_HTML,
+    llm: options.llm ?? {},
+    weightConcepts: options.weightConcepts ?? "mean",
+    complexityWeights: { ...DEFAULT_COMPLEXITY_WEIGHTS, ...options.complexityWeights ?? {} }
+  };
+  const weightForConcept = (spec) => {
+    if (opts.weightConcepts === "mean") return 1;
+    if (spec.weight != null) return spec.weight;
+    if (opts.weightConcepts === "complexity") {
+      return opts.complexityWeights[spec.complexity ?? "render"] ?? 1;
+    }
+    return 1;
+  };
+  const weightByName = new Map(
+    input.expectedConcepts.map((c) => [c.name, weightForConcept(c)])
+  );
+  try {
+    const { value, result } = await callLlmJson(
+      {
+        model: opts.model,
+        messages: [
+          {
+            role: "system",
+            content: "You are a strict code-review judge. Return strict JSON only. No prose outside the JSON. A keyword in a comment is NOT a working implementation."
+          },
+          { role: "user", content: buildPrompt(input, opts) }
+        ],
+        jsonSchema: { name: "semantic_concept_judge", schema: SEMANTIC_SCHEMA },
+        temperature: 0,
+        timeoutMs: opts.timeoutMs
+      },
+      opts.llm
+    );
+    if (!value?.concepts || !Array.isArray(value.concepts)) {
+      throw new Error('judge returned malformed response \u2014 expected array under "concepts"');
+    }
+    const findings = value.concepts.map((c) => ({
+      concept: String(c.concept),
+      present: Boolean(c.present),
+      score: Math.max(0, Math.min(10, Number(c.score ?? 0))),
+      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;
+    let weightSum = 0;
+    let weightedScoreSum = 0;
+    for (const f of findings) {
+      const w = weightByName.get(f.concept) ?? 1;
+      weightSum += w;
+      weightedScoreSum += w * f.score;
+    }
+    const scoreAvg = weightSum > 0 ? weightedScoreSum / weightSum : findings.reduce((a, f) => a + f.score, 0) / Math.max(1, findings.length);
+    return {
+      kind: "semantic-concept",
+      version: SEMANTIC_CONCEPT_JUDGE_VERSION,
+      score: Number((scoreAvg / 10).toFixed(3)),
+      presentCount,
+      totalCount,
+      findings,
+      summary: String(value.summary ?? ""),
+      durationMs: Date.now() - start,
+      costUsd: result.costUsd ?? null,
+      available: true
+    };
+  } catch (err) {
+    return {
+      kind: "semantic-concept",
+      version: SEMANTIC_CONCEPT_JUDGE_VERSION,
+      score: 0,
+      presentCount: 0,
+      totalCount,
+      findings: [],
+      summary: "",
+      durationMs: Date.now() - start,
+      costUsd: null,
+      available: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function createSemanticConceptJudge(options = {}) {
+  return (input) => runSemanticConceptJudge(input, options);
+}
+
+// src/analyst/types.ts
+import { createHash } from "crypto";
+function computeFindingId(input) {
+  const basis = JSON.stringify({
+    a: input.analyst_id,
+    r: input.area,
+    s: input.subject ?? "",
+    c: normalizeClaim(input.id_basis ?? input.claim)
+  });
+  return `f_${createHash("sha256").update(basis).digest("hex").slice(0, 20)}`;
+}
+function normalizeClaim(c) {
+  return c.toLowerCase().replace(/\s+/g, " ").replace(/[.!?;:,]+$/g, "").trim();
+}
+function makeFinding(init) {
+  const { id_basis, produced_at, ...rest } = init;
+  return {
+    schema_version: "1.0.0",
+    finding_id: computeFindingId({
+      analyst_id: rest.analyst_id,
+      area: rest.area,
+      subject: rest.subject,
+      claim: rest.claim,
+      id_basis
+    }),
+    produced_at: produced_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+    ...rest
+  };
+}
+
+// src/analyst/adapters.ts
+var ADAPTER_REV = "1";
+function liftSeverity(s) {
+  switch (s) {
+    case "critical":
+      return "critical";
+    case "major":
+      return "high";
+    case "minor":
+      return "medium";
+    case "info":
+      return "info";
+  }
+}
+function createTraceAnalystAdapter(opts) {
+  const id = opts.id ?? "trace-analyst";
+  const area = opts.area ?? "agent-reasoning";
+  return {
+    id,
+    description: "Runs the agent-eval trace analyst over an OTLP trace store and lifts its bulleted findings.",
+    inputKind: "trace-store",
+    cost: { kind: "llm", models: opts.model ? [opts.model] : void 0 },
+    version: `trace-analyst-${ADAPTER_REV}`,
+    async analyze(store, ctx) {
+      const out = [];
+      for (const question of opts.questions) {
+        if (ctx.signal?.aborted) break;
+        const result = await analyzeTraces(
+          { question },
+          { source: store, ai: opts.ai, model: opts.model, ...opts.extra }
+        );
+        const subject = ctx.tags?.subject ?? question.slice(0, 60);
+        if (result.findings.length === 0) {
+          out.push(
+            makeFinding({
+              analyst_id: id,
+              area,
+              subject,
+              claim: result.answer.slice(0, 200),
+              rationale: result.answer,
+              severity: "info",
+              confidence: 0.5,
+              evidence_refs: [],
+              metadata: {
+                actor_prompt_version: result.actorPromptVersion,
+                turns: result.turnCount
+              }
+            })
+          );
+          continue;
+        }
+        result.findings.forEach((claim, i) => {
+          out.push(
+            makeFinding({
+              analyst_id: id,
+              area,
+              subject,
+              claim,
+              rationale: i === 0 ? result.answer : void 0,
+              severity: "medium",
+              confidence: 0.6,
+              evidence_refs: [],
+              metadata: { question, turns: result.turnCount, finding_index: i }
+            })
+          );
+        });
+      }
+      return out;
+    }
+  };
+}
+function createVerifierAdapter(opts) {
+  const id = opts.id ?? "multi-layer-verifier";
+  const area = opts.area ?? "verification";
+  return {
+    id,
+    description: "Runs a MultiLayerVerifier and lifts each layer's findings into the analyst envelope.",
+    inputKind: "custom",
+    cost: { kind: "deterministic" },
+    version: `verifier-${ADAPTER_REV}`,
+    async analyze(env, ctx) {
+      const report = await opts.verifier.run({ env, ...opts.options });
+      const out = [];
+      for (const layer of report.layers) {
+        for (const finding of layer.findings) {
+          out.push(liftLayerFinding(id, area, layer.layer, finding));
+        }
+        if (layer.status === "fail" || layer.status === "error" || layer.status === "timeout") {
+          out.push(
+            makeFinding({
+              analyst_id: id,
+              area,
+              subject: layer.layer,
+              claim: `layer "${layer.layer}" ${layer.status}: ${layer.reason ?? "no reason given"}`,
+              severity: layer.status === "error" ? "high" : layer.status === "timeout" ? "medium" : "high",
+              confidence: 1,
+              evidence_refs: [],
+              metadata: {
+                layer_status: layer.status,
+                duration_ms: layer.durationMs,
+                score: layer.score,
+                diagnostics: layer.diagnostics
+              }
+            })
+          );
+        }
+      }
+      ctx.log?.("verifier complete", {
+        layers: report.layers.length,
+        blended: report.blendedScore,
+        all_pass: report.allPass
+      });
+      return out;
+    }
+  };
+}
+function liftLayerFinding(analyst_id, area, layer, f) {
+  return makeFinding({
+    analyst_id,
+    area,
+    subject: f.layer ?? layer,
+    claim: f.message,
+    severity: liftSeverity(f.severity),
+    confidence: 0.85,
+    evidence_refs: f.evidence ? [{ kind: "artifact", uri: "inline:evidence", excerpt: f.evidence }] : [],
+    metadata: f.detail
+  });
+}
+function createRunCriticAdapter(opts = {}) {
+  const id = opts.id ?? "run-critic";
+  const area = opts.area ?? "run-quality";
+  const critic = opts.critic ?? new RunCritic();
+  const threshold = opts.threshold ?? 0.5;
+  return {
+    id,
+    description: "Scores a single run across success / grounding / drift / tool-quality and surfaces below-threshold dimensions.",
+    inputKind: "custom",
+    cost: { kind: "deterministic" },
+    version: `run-critic-${ADAPTER_REV}`,
+    async analyze(trace) {
+      const score = critic.scoreTrace(trace);
+      const out = [];
+      const dims = [
+        ["success", "critical", "run did not complete successfully"],
+        ["goalProgress", "high", "goal progress is low"],
+        ["repoGroundedness", "high", "output is poorly grounded in the repository"],
+        ["toolUseQuality", "medium", "tool use quality is low"],
+        ["patchQuality", "medium", "no real patch/edit evidence"],
+        ["testReality", "high", "no real test/build evidence"],
+        ["finalGate", "critical", "final gate is blocking"]
+      ];
+      for (const [dim, sev, msg] of dims) {
+        const value = score[dim];
+        if (typeof value === "number" && value < threshold) {
+          out.push(
+            makeFinding({
+              analyst_id: id,
+              area,
+              subject: dim,
+              claim: msg,
+              rationale: `${dim}=${value.toFixed(2)} below threshold ${threshold}`,
+              severity: sev,
+              confidence: 1,
+              evidence_refs: [],
+              metadata: { dimension: dim, value, threshold, run_id: trace.run.runId }
+            })
+          );
+        }
+      }
+      if (score.driftPenalty > 1 - threshold) {
+        out.push(
+          makeFinding({
+            analyst_id: id,
+            area,
+            subject: "drift",
+            claim: "agent output drifted from repository signal",
+            rationale: `driftPenalty=${score.driftPenalty.toFixed(2)}`,
+            severity: "medium",
+            confidence: 0.9,
+            evidence_refs: [],
+            metadata: { drift_penalty: score.driftPenalty, notes: score.notes }
+          })
+        );
+      }
+      return out;
+    }
+  };
+}
+function createJudgeAdapter(opts) {
+  const id = opts.id ?? "judge";
+  const area = opts.area ?? "judge";
+  const threshold = opts.threshold ?? 6;
+  return {
+    id,
+    description: "Wraps an agent-eval JudgeFn into an analyst; below-threshold dimensions surface as findings.",
+    inputKind: "judge-input",
+    cost: opts.cost ?? { kind: "llm" },
+    version: `judge-${ADAPTER_REV}`,
+    async analyze(input) {
+      const scores = await opts.judge(opts.tcloud, input);
+      return scores.filter((s) => normalize10(s.score) < threshold).map((s) => liftJudgeScore(id, area, s));
+    }
+  };
+}
+function normalize10(s) {
+  return s <= 1 ? s * 10 : s;
+}
+function liftJudgeScore(analyst_id, area, s) {
+  const score10 = normalize10(s.score);
+  const severity = score10 < 3 ? "critical" : score10 < 5 ? "high" : score10 < 7 ? "medium" : "low";
+  return makeFinding({
+    analyst_id,
+    area,
+    subject: s.dimension,
+    claim: `${s.judgeName}/${s.dimension} scored ${score10.toFixed(1)}/10`,
+    rationale: s.reasoning,
+    severity,
+    confidence: 0.8,
+    evidence_refs: s.evidence ? [{ kind: "artifact", uri: "inline:evidence", excerpt: s.evidence }] : [],
+    metadata: { judge_name: s.judgeName, dimension: s.dimension, score_10: score10 }
+  });
+}
+function createSemanticConceptJudgeAdapter(opts = {}) {
+  const id = opts.id ?? "semantic-concept-judge";
+  const area = opts.area ?? "concept-coverage";
+  return {
+    id,
+    description: "Runs the semantic-concept judge and surfaces missing / weak concepts as findings.",
+    inputKind: "custom",
+    cost: { kind: "llm", models: opts.options?.model ? [opts.options.model] : void 0 },
+    version: `${SEMANTIC_CONCEPT_JUDGE_VERSION}-adapter-${ADAPTER_REV}`,
+    async analyze(input) {
+      const result = await runSemanticConceptJudge(input, opts.options);
+      if (!result.available) {
+        return [
+          makeFinding({
+            analyst_id: id,
+            area,
+            claim: "semantic-concept judge unavailable",
+            rationale: result.error,
+            severity: "info",
+            confidence: 1,
+            evidence_refs: [],
+            metadata: { reason: result.error }
+          })
+        ];
+      }
+      const out = [];
+      for (const f of result.findings) {
+        if (f.present && f.score >= 7) continue;
+        out.push(
+          makeFinding({
+            analyst_id: id,
+            area,
+            subject: f.concept,
+            claim: f.present ? `concept "${f.concept}" is weak (${f.score}/10)` : `concept "${f.concept}" is missing`,
+            rationale: f.evidence,
+            severity: liftSeverity(f.severity),
+            confidence: 0.85,
+            evidence_refs: [{ kind: "artifact", uri: "inline:evidence", excerpt: f.evidence }],
+            metadata: {
+              concept: f.concept,
+              present: f.present,
+              score_10: f.score,
+              cost_usd: result.costUsd ?? void 0
+            }
+          })
+        );
+      }
+      return out;
+    }
+  };
+}
+
+// src/analyst/chat-client.ts
+function createChatClient(opts) {
+  switch (opts.transport) {
+    case "router":
+      return wrapLlmClient(
+        opts.transport,
+        opts.defaultModel,
+        new LlmClient({
+          baseUrl: opts.baseUrl ?? "https://router.tangle.tools/v1",
+          apiKey: opts.apiKey
+        })
+      );
+    case "cli-bridge":
+      return wrapLlmClient(
+        opts.transport,
+        opts.defaultModel,
+        new LlmClient({
+          baseUrl: opts.baseUrl ?? "http://127.0.0.1:3344/v1",
+          apiKey: opts.bearer ?? ""
+        })
+      );
+    case "direct-provider":
+      return wrapLlmClient(
+        opts.transport,
+        opts.defaultModel,
+        new LlmClient({
+          baseUrl: opts.baseUrl,
+          apiKey: opts.apiKey
+        })
+      );
+    case "sandbox-sdk":
+      return {
+        transport: "sandbox-sdk",
+        defaultModel: opts.defaultModel,
+        chat: async (req, callOpts) => opts.chat(resolveModel(req, opts.defaultModel), callOpts)
+      };
+    case "mock":
+      return {
+        transport: "mock",
+        defaultModel: opts.defaultModel,
+        chat: async (req, callOpts) => opts.handler(resolveModel(req, opts.defaultModel), callOpts)
+      };
+  }
+}
+function wrapLlmClient(transport, defaultModel, inner) {
+  return {
+    transport,
+    defaultModel,
+    chat: async (req, callOpts) => {
+      const resolved = resolveModel(req, defaultModel);
+      const call = inner.call({
+        model: resolved.model,
+        messages: req.messages,
+        jsonMode: req.jsonMode,
+        jsonSchema: req.jsonSchema,
+        temperature: req.temperature,
+        maxTokens: req.maxTokens,
+        timeoutMs: req.timeoutMs
+      });
+      if (!callOpts?.signal) return await call;
+      return await Promise.race([call, abortAsRejection(callOpts.signal)]);
+    }
+  };
+}
+function abortAsRejection(signal) {
+  if (signal.aborted) return Promise.reject(toAbortError(signal));
+  return new Promise((_, reject) => {
+    signal.addEventListener("abort", () => reject(toAbortError(signal)), { once: true });
+  });
+}
+function toAbortError(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error) return reason;
+  const e = new Error("ChatClient.chat: aborted");
+  e.name = "AbortError";
+  return e;
+}
+function resolveModel(req, defaultModel) {
+  if (req.model) return req;
+  if (!defaultModel) {
+    throw new Error(
+      "ChatClient.chat: no model on request and no defaultModel on the client. Either pass req.model or bind defaultModel at createChatClient()."
+    );
+  }
+  return { ...req, model: defaultModel };
+}
+
+// src/analyst/finding-signature.ts
+import { z } from "zod";
+var ANALYST_SEVERITIES = ["critical", "high", "medium", "low", "info"];
+var RawAnalystFindingSchema = z.object({
+  severity: z.enum(ANALYST_SEVERITIES),
+  claim: z.string().min(1).max(2e3),
+  subject: z.string().max(400).optional(),
+  evidence_uri: z.string().min(1).max(2e3),
+  evidence_excerpt: z.string().max(2e3).optional(),
+  confidence: z.number().min(0).max(1),
+  rationale: z.string().max(4e3).optional(),
+  recommended_action: z.string().max(2e3).optional()
+}).strict();
+var RAW_FINDING_SCHEMA_PROMPT = `Each finding MUST be a JSON object with these fields:
+  - severity: one of "critical" | "high" | "medium" | "low" | "info"
+  - claim: one-sentence statement (max 2000 chars)
+  - subject?: the leaf id, agent id, span id, tool name, or noun phrase the finding is about
+  - evidence_uri: "span://<trace_id>/<span_id>" for trace evidence, "artifact://<relative-path>" for files, "metric://<name>" for named scalars \u2014 ALWAYS cite a real id surfaced by the tools
+  - evidence_excerpt?: short quote (<=2000 chars) from the cited span/artifact
+  - confidence: number 0..1 \u2014 0.9+ when backed by exact quotes, 0.6-0.8 for inferred patterns, <0.5 for speculative
+  - rationale?: one or two sentences explaining the reasoning
+  - recommended_action?: concrete change phrased as an imperative ("Add ...", "Replace ...", "Stop ...") \u2014 omit when the finding is purely descriptive
+
+Emit an empty array when the question has no findings to report. Do not fabricate evidence.`;
+function parseRawFinding(row, log) {
+  const result = RawAnalystFindingSchema.safeParse(row);
+  if (!result.success) {
+    log?.("finding rejected: schema failure", {
+      issues: result.error.issues.map((i) => ({
+        path: i.path.join("."),
+        code: i.code,
+        message: i.message
+      }))
+    });
+    return null;
+  }
+  return result.data;
+}
+
+// src/analyst/findings-store.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+
+// src/locked-jsonl-appender.ts
+import { appendFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+
+// src/concurrency.ts
+var Mutex = class {
+  locked = false;
+  waiters = [];
+  async acquire() {
+    if (!this.locked) {
+      this.locked = true;
+      return () => this.release();
+    }
+    return new Promise((resolve) => {
+      this.waiters.push(() => {
+        resolve(() => this.release());
+      });
+    });
+  }
+  release() {
+    const next = this.waiters.shift();
+    if (next) {
+      next();
+    } else {
+      this.locked = false;
+    }
+  }
+  async runExclusive(fn) {
+    const release = await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+  /** True iff someone holds the lock right now. Diagnostics only. */
+  get isLocked() {
+    return this.locked;
+  }
+  /** Pending waiter count. Diagnostics only. */
+  get pending() {
+    return this.waiters.length;
+  }
+};
+
+// src/locked-jsonl-appender.ts
+var mutexes = /* @__PURE__ */ new Map();
+function getMutex(path) {
+  let m = mutexes.get(path);
+  if (!m) {
+    m = new Mutex();
+    mutexes.set(path, m);
+  }
+  return m;
+}
+var LockedJsonlAppender = class {
+  constructor(path) {
+    this.path = path;
+    this.mutex = getMutex(path);
+    if (!existsSync(dirname(path))) {
+      mkdirSync(dirname(path), { recursive: true });
+    }
+  }
+  path;
+  mutex;
+  async append(entry) {
+    const line = `${JSON.stringify(entry)}
+`;
+    await this.mutex.runExclusive(() => {
+      appendFileSync(this.path, line);
+    });
+  }
+};
+function resetLockedAppendersForTesting() {
+  mutexes.clear();
+}
+
+// src/analyst/findings-store.ts
+var FindingsStore = class {
+  constructor(path) {
+    this.path = path;
+    this.appender = new LockedJsonlAppender(path);
+  }
+  path;
+  appender;
+  async append(runId, findings) {
+    for (const f of findings) {
+      const row = { ...f, run_id: runId };
+      await this.appender.append(row);
+    }
+  }
+  /** Load every persisted finding. Discards malformed trailing lines silently. */
+  loadAll() {
+    if (!existsSync2(this.path)) return [];
+    const raw = readFileSync(this.path, "utf8");
+    if (!raw) return [];
+    const out = [];
+    for (const line of raw.split("\n")) {
+      if (!line) continue;
+      try {
+        out.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return out;
+  }
+  /** Filter to a single run. */
+  loadRun(runId) {
+    return this.loadAll().filter((r) => r.run_id === runId);
+  }
+};
+function defaultIsMaterial(a, b) {
+  if (a.severity !== b.severity) return true;
+  if (Math.abs((a.confidence ?? 0) - (b.confidence ?? 0)) > 0.05) return true;
+  if (a.evidence_refs.length !== b.evidence_refs.length) return true;
+  return false;
+}
+function diffFindings(previous, current, policy = {}) {
+  const isMaterial = policy.isMaterial ?? defaultIsMaterial;
+  const prevById = new Map(previous.map((f) => [f.finding_id, f]));
+  const curById = new Map(current.map((f) => [f.finding_id, f]));
+  const appeared = [];
+  const disappeared = [];
+  const persisted = [];
+  const changed = [];
+  for (const [id, cur] of curById) {
+    const prev = prevById.get(id);
+    if (!prev) {
+      appeared.push(cur);
+      continue;
+    }
+    if (isMaterial(prev, cur)) {
+      changed.push({ previous: prev, current: cur });
+    } else {
+      persisted.push(cur);
+    }
+  }
+  for (const [id, prev] of prevById) {
+    if (!curById.has(id)) disappeared.push(prev);
+  }
+  return { appeared, disappeared, persisted, changed };
+}
+
+// src/analyst/kind-factory.ts
+import { AxJSRuntime, agent } from "@ax-llm/ax";
+function createTraceAnalystKind(spec, opts) {
+  const version = opts.versionSuffix ? `${spec.version}+${opts.versionSuffix}` : spec.version;
+  return {
+    id: spec.id,
+    description: spec.description,
+    inputKind: "trace-store",
+    cost: spec.cost,
+    version,
+    async analyze(store, ctx) {
+      const tools = spec.buildTools(store);
+      const maxDepth = spec.recursion?.maxDepth ?? 0;
+      const maxParallel = spec.recursion?.maxParallelSubagents ?? 2;
+      const priorContext = renderPriorFindings(ctx.priorFindings);
+      const actorDescription = spec.actorDescription.trim() + priorContext + "\n\n" + RAW_FINDING_SCHEMA_PROMPT + "\n\nReturn the array in the `findings` output field. Use `final(...)` with the structured `{ findings }` payload when you are done.";
+      const ax = agent(
+        "question:string -> findings:json[]",
+        {
+          agentIdentity: {
+            name: spec.id,
+            description: spec.description
+          },
+          contextFields: ["question"],
+          runtime: new AxJSRuntime({
+            permissions: [],
+            blockDynamicImport: true,
+            allowedModules: [],
+            freezeIntrinsics: true,
+            blockShadowRealm: true,
+            preventGlobalThisExtensions: false
+          }),
+          mode: maxDepth > 0 ? "advanced" : "simple",
+          recursionOptions: maxDepth > 0 ? { maxDepth } : void 0,
+          maxTurns: spec.maxTurns ?? 12,
+          maxRuntimeChars: spec.maxRuntimeChars ?? 6e3,
+          maxBatchedLlmQueryConcurrency: maxParallel,
+          promptLevel: "detailed",
+          contextPolicy: { preset: "full", budget: "balanced" },
+          functions: { local: tools },
+          actorOptions: {
+            description: actorDescription,
+            ...opts.model ? { model: opts.model } : {},
+            showThoughts: false,
+            thinkingTokenBudget: "none"
+          },
+          responderOptions: {
+            description: spec.responderDescription ?? "Format the structured `findings` array exactly as the actor produced it. Do not add, drop, or summarize entries.",
+            ...opts.model ? { model: opts.model } : {},
+            showThoughts: false
+          },
+          bubbleErrors: [TraceFileMissingError]
+        }
+      );
+      ctx.log?.(`analyst.kind ${spec.id} forward`, {
+        max_depth: maxDepth,
+        tool_count: tools.length,
+        tags: ctx.tags
+      });
+      const result = await ax.forward(opts.ai, { question: deriveQuestion(ctx, spec) });
+      const out = [];
+      const rawRows = Array.isArray(result.findings) ? result.findings : [];
+      for (const row of rawRows) {
+        const parsed = parseRawFinding(row, ctx.log);
+        if (!parsed) continue;
+        const postProcessed = spec.postProcess?.(parsed, ctx) ?? parsed;
+        if (!postProcessed) continue;
+        out.push(toAnalystFinding(spec, postProcessed));
+      }
+      ctx.log?.(`analyst.kind ${spec.id} done`, {
+        emitted: rawRows.length,
+        accepted: out.length
+      });
+      return out;
+    }
+  };
+}
+function deriveQuestion(ctx, spec) {
+  const focus = ctx.tags?.focus?.trim();
+  if (focus) return `${spec.id}: ${focus}`;
+  return spec.id;
+}
+function toAnalystFinding(spec, raw) {
+  return makeFinding({
+    analyst_id: spec.id,
+    area: spec.area,
+    subject: raw.subject,
+    claim: raw.claim,
+    rationale: raw.rationale,
+    severity: raw.severity,
+    confidence: raw.confidence,
+    evidence_refs: [
+      {
+        kind: evidenceKindFromUri(raw.evidence_uri),
+        uri: raw.evidence_uri,
+        excerpt: raw.evidence_excerpt
+      }
+    ],
+    recommended_action: raw.recommended_action,
+    metadata: { kind_version: spec.version }
+  });
+}
+function evidenceKindFromUri(uri) {
+  if (uri.startsWith("span://")) return "span";
+  if (uri.startsWith("artifact://")) return "artifact";
+  if (uri.startsWith("metric://")) return "metric";
+  if (uri.startsWith("event://")) return "event";
+  if (uri.startsWith("finding://")) return "finding";
+  return "artifact";
+}
+function renderPriorFindings(prior) {
+  if (!prior || prior.length === 0) return "";
+  const MAX_ROWS = 40;
+  const rows = prior.slice(0, MAX_ROWS).map((f) => {
+    const subject = f.subject ? ` [${f.subject}]` : "";
+    return `  - id=${f.finding_id} ${f.severity}${subject} ${truncateForContext(f.claim, 160)}`;
+  });
+  const overflow = prior.length > MAX_ROWS ? `
+  ... +${prior.length - MAX_ROWS} more prior findings (older history truncated)` : "";
+  return [
+    "",
+    "",
+    "PRIOR FINDINGS (from a previous run on related data):",
+    "When the work you do now matches a row below, REUSE the `finding_id` (pass it as `id_basis`) so the cross-run diff stays stable.",
+    "A finding that reappears with no remediation evidence SHOULD raise its `confidence` and may justify a higher `severity`.",
+    ...rows,
+    overflow
+  ].filter(Boolean).join("\n");
+}
+function truncateForContext(s, max) {
+  if (s.length <= max) return s;
+  return `${s.slice(0, max - 1).trimEnd()}\u2026`;
+}
+
+// src/analyst/tool-groups.ts
+var TOOL_NAMES_BY_GROUP = {
+  all: /* @__PURE__ */ new Set(),
+  discovery: /* @__PURE__ */ new Set(["getDatasetOverview", "queryTraces", "countTraces"]),
+  discoveryAndRead: /* @__PURE__ */ new Set([
+    "getDatasetOverview",
+    "queryTraces",
+    "countTraces",
+    "viewTrace",
+    "viewSpans"
+  ]),
+  discoveryAndSearch: /* @__PURE__ */ new Set([
+    "getDatasetOverview",
+    "queryTraces",
+    "countTraces",
+    "searchTrace",
+    "searchSpan"
+  ]),
+  targeted: /* @__PURE__ */ new Set(["getDatasetOverview", "queryTraces", "viewSpans", "searchSpan"])
+};
+function buildTraceToolsForGroup(group, store) {
+  const all = buildTraceAnalystTools({ store });
+  if (group === "all") return all;
+  const allow = TOOL_NAMES_BY_GROUP[group];
+  if (!allow) throw new Error(`unknown trace tool group: ${group}`);
+  return all.filter((tool) => allow.has(tool.name));
+}
+
+// src/analyst/kinds/failure-mode.ts
+var ACTOR_PROMPT = `You are a failure-mode classifier for an OTLP trace dataset. Your job is to identify the **distinct ways agents failed** in this dataset, not to grade individual runs.
+
+DISCOVERY \u2192 CLUSTER \u2192 CITE protocol:
+
+1. Call \`traces.getDatasetOverview({})\` first. Use \`has_errors\`, \`models\`, \`agent_names\`, \`tools\`, and \`sample_trace_ids\` to size the failure surface.
+2. Use \`traces.queryTraces({ filters: { has_errors: true }, limit })\` to pull error-bearing traces. Combine with \`traces.countTraces\` to see what fraction of the dataset failed.
+3. For each candidate failure cluster, use \`traces.searchTrace\` with regex like \`STATUS_CODE_ERROR\`, \`MaxTurnsExceeded\`, \`assertion\`, \`unauthorized\`, \`timeout\`, \`429\`, \`5\\d\\d\`, the agent's specific error strings, or the names of its tools. Pull one or two representative traces per cluster, **not all** of them.
+4. **Cluster, do not enumerate.** Two failures with the same root cause should be ONE finding citing both traces, not two findings. The point of this analyst is to compress N runs into K modes.
+5. For each cluster you can defend with evidence, emit ONE finding with:
+   - \`area\` = "failure-mode"
+   - \`subject\` = a short label for the cluster ("tool-call-loop", "auth-revoked-mid-run", "agent-asked-clarification-too-late", ...)
+   - \`claim\` = one sentence stating the mode
+   - \`severity\` = "critical" when it blocks the run, "high" when the run finished degraded, "medium" when it slowed convergence
+   - \`evidence_uri\` = \`span://<trace_id>/<span_id>\` of the most representative span
+   - \`evidence_excerpt\` = the exact quote (e.g. error message, stuck tool call payload, contradictory turn output)
+   - \`confidence\` = 0.85+ when multiple traces show the same shape; 0.6-0.8 for a single-trace inference; <0.5 for speculative.
+   - \`recommended_action\` = imperative-phrased fix idea (kept short \u2014 the improvement-analyst will expand on these)
+
+If the dataset has no failures, return an empty findings array \u2014 do NOT pad with low-confidence speculation.
+
+**Delegate aggressively.** The recursion budget is there to be used:
+- After your first \`getDatasetOverview\` + \`queryTraces\` calls, you should have 3-6 candidate failure clusters in mind. Spawn one \`llmQuery\` per cluster in a single batch \u2014 they investigate in parallel.
+- A sub-investigator that finds its cluster is actually two distinct modes should split again at its own level. Recursion is meant to discover sub-modes, not to do trivial drilling that the parent could do in-line.
+- Pass narrow context to each subagent: { question: 'investigate the auth-revoked-mid-run cluster', context: { trace_ids: ['abc', 'def'], suspected_root_cause: 'token refresh skipped on idle sessions' } }. Subagents need enough context to skip re-discovery but not the whole conversation.
+- Each subagent returns its findings as JSON; the parent merges them. Do NOT have subagents call \`final()\` \u2014 they return their findings list to you, and you call \`final()\` once at the top.
+
+OBSERVABILITY rules:
+- Each non-final turn must emit at least one \`console.log\` for evidence.
+- Reuse runtime variables across turns; don't recompute.
+- Call \`final({ findings: [...] })\` exactly once, after you've gathered evidence for every cluster you intend to report.`;
+var FAILURE_MODE_KIND_SPEC = {
+  id: "failure-mode",
+  description: "Clusters trace-dataset failures into distinct failure modes with cited evidence and a short recommended action.",
+  area: "failure-mode",
+  version: "1.0.0",
+  actorDescription: ACTOR_PROMPT,
+  buildTools: (store) => buildTraceToolsForGroup("all", store),
+  recursion: { maxDepth: 3, maxParallelSubagents: 4 },
+  maxTurns: 24,
+  cost: { kind: "llm" }
+};
+
+// src/analyst/kinds/improvement.ts
+var ACTOR_PROMPT2 = `You are a recursive-self-improvement analyst. Your job is to propose **concrete, locus-named edits** the agent's runtime should adopt to fix the failure modes, knowledge gaps, and poisonings present in this dataset.
+
+Upstream analysts have already classified the problems. Your job is to convert each problem into a *change to make* and grade its expected leverage. Each finding is one proposed edit.
+
+DISCOVERY \u2192 CANDIDATE-FIXES \u2192 COMPETE \u2192 CITE protocol:
+
+1. \`traces.getDatasetOverview({})\` first. Note the agents, tools, and any system-prompt fingerprints (look for the prompt text echoed in early spans).
+2. For each high-severity failure pattern, generate 2-3 candidate fixes. Real candidate axes:
+   - **System-prompt edit** \u2014 add an instruction, remove a misleading one, restructure precedence
+   - **Tool description edit** \u2014 rewrite a tool's description so the agent picks it correctly / passes valid args
+   - **New tool** \u2014 add a tool the agent kept emulating in code
+   - **RAG ingestion** \u2014 add a document or correct a stale one
+   - **Memory invalidation** \u2014 clear cached prior-run decisions that no longer apply
+   - **Scaffolding** \u2014 add a precondition check, a retry policy, a turn budget, a verification step
+   - **Output schema** \u2014 narrow the agent's output to forbid the failure shape
+3. **Compete candidate fixes via subagents.** For each failure cluster, spawn one \`llmQuery\` per candidate-fix axis you want to evaluate. Each subagent's job: simulate the fix on the cited traces and report (i) likely effect, (ii) side effects, (iii) implementation cost as small/medium/large. Pass the cluster's failing trace_ids and the candidate axis as context.
+4. After subagents return, **pick the winning candidate per cluster** based on (effect / cost) and emit ONE finding. Discard the losing candidates \u2014 the output is the recommendation, not the candidate set.
+5. **Cross-reference upstream findings.** If a finding cites a prior failure-mode or knowledge-gap finding, use \`evidence_uri = "finding://<prior-finding-id>"\` (the registry supports this kind). This builds the dependency graph that lets the dashboard show "fix #X resolves failure modes A, B, C."
+
+For each winning recommendation, emit ONE finding with:
+- \`area\` = "improvement"
+- \`subject\` = the locus to edit: \`system-prompt:<section>\`, \`tool-doc:<tool-name>\`, \`new-tool:<proposed-name>\`, \`rag:<corpus>:<doc-id>\`, \`memory:<key>\`, \`scaffolding:<concern>\`, \`output-schema:<field>\`
+- \`claim\` = one sentence stating the edit ("Add a precondition check to refuse tool X calls without arg Y")
+- \`severity\` = leverage rating: "critical" when fix resolves a critical failure mode; "high" when it resolves a high; "medium" when it's a quality-of-life win; "info" when it's a cleanup with no behavioral effect
+- \`evidence_uri\` = the failure-mode finding id this fix targets (\`finding://<id>\`) when it exists; else the most representative span
+- \`evidence_excerpt\` = a fragment showing the problem the fix targets
+- \`confidence\` = 0.85+ when the fix is mechanical and the failure mode is well-evidenced; 0.6-0.8 when the fix requires judgment; <0.5 for speculative
+- \`rationale\` = why this candidate beat its alternatives (2 sentences max)
+- \`recommended_action\` = the **literal edit**, phrased as a diff or a quoted replacement: "Replace section X with: '...'" or "Add tool with description: '...'" or "Set retry policy to max_attempts=3 with exponential backoff"
+
+If no upstream failure findings exist in this run, derive your own from the trace dataset using the failure-mode protocol inline (\`searchTrace\` for STATUS_CODE_ERROR / MaxTurnsExceeded / etc.). But prefer to consume upstream findings when present \u2014 the kinds are designed to chain.
+
+Do NOT propose a fix you cannot defend with evidence. "Tighten the prompt" is not a finding; "Add 'When the user asks for X, always Y' to the system prompt section "request-classification"" is.
+
+OBSERVABILITY rules:
+- Each non-final turn must emit at least one \`console.log\` for evidence.
+- Call \`final({ findings: [...] })\` exactly once at the top level.`;
+var IMPROVEMENT_KIND_SPEC = {
+  id: "improvement",
+  description: "Converts upstream failure / gap / poisoning findings into concrete locus-named edits (prompt, tool-doc, RAG, scaffolding) with leverage grades.",
+  area: "improvement",
+  version: "1.0.0",
+  actorDescription: ACTOR_PROMPT2,
+  buildTools: (store) => buildTraceToolsForGroup("all", store),
+  recursion: { maxDepth: 3, maxParallelSubagents: 4 },
+  maxTurns: 30,
+  maxRuntimeChars: 12e3,
+  cost: { kind: "llm" }
+};
+
+// src/analyst/kinds/knowledge-gap.ts
+var ACTOR_PROMPT3 = `You are a knowledge-gap analyst for an OTLP trace dataset. Your job is to identify the **specific pieces of information the agent lacked, or that were stale**, that caused poor decisions.
+
+The agent under analysis maintains a curated knowledge base via \`@tangle-network/agent-knowledge\` \u2014 a wiki of \`KnowledgePage\`s with raw source anchors, claims, and relations. The primary expected store of agent-knowable facts IS that wiki. A "knowledge gap" is anything the agent had to discover or guess at run-time that the wiki should have held \u2014 or an outdated/contradictory fact the agent picked up from a non-wiki source.
+
+DISCOVERY \u2192 ATTRIBUTE-TO-LAYER \u2192 CITE protocol:
+
+1. \`traces.getDatasetOverview({})\` first. Note which agents, tools, and models appear.
+2. Pull traces where the agent shows gap signals. The strongest signals are:
+   - Self-correction turns ("I assumed X but\u2026", "let me re-check", "actually,")
+   - Clarifying-question turns where the agent asked the user something the runtime should have surfaced
+   - Repeated retrieval / lookup calls for the same artifact with slightly varied queries
+   - Tool errors that name a missing argument or unknown resource
+   - Web-search calls returning pages dated before a known cutoff for content that changes (versioned APIs, schemas, policies)
+   - Agent quoting a tool's docs / system prompt incorrectly because the actual text was insufficient
+   - Fabricated identifiers that don't appear in dataset \`sample_trace_ids\`
+   Use \`traces.searchTrace\` with patterns like \`I (don.?t|do not) know\`, \`assumed\`, \`unclear\`, \`could you (clarify|tell me|provide)\`, \`not found\`, \`undefined\`, \`unknown\`, \`null\`, dates older than the analysis window, or the agent's specific clarification phrases.
+3. For each gap, identify the **layer of the runtime that should have prevented it**. The locus is the value of \`subject\` on the finding. Use one of:
+   - \`agent-knowledge:wiki:<page-slug>\` \u2014 the wiki page that should exist but doesn't, or exists but lacks the claim
+   - \`agent-knowledge:wiki:<page-slug>#<heading>\` \u2014 wiki page exists but a specific section is missing
+   - \`agent-knowledge:claim:<topic>\` \u2014 a specific claim/relation triple that should be in the wiki
+   - \`agent-knowledge:raw:<source-id>\` \u2014 raw source captured but never lifted into a curated page
+   - \`agent-knowledge:stale:<page-slug>\` \u2014 wiki page exists but contradicts ground-truth evidence in this trace (the wiki itself drifted)
+   - \`websearch:outdated:<topic>\` \u2014 agent relied on a web result that was stale; wiki should have superseded it
+   - \`tool-doc:<tool-name>:<aspect>\` \u2014 tool description missed a behavior aspect (return shape, failure modes, side effects)
+   - \`system-prompt:<section>\` \u2014 system prompt should have stated the rule directly
+   - \`memory:<key>\` \u2014 prior-run memory should have surfaced an earlier decision
+4. For each gap you can defend with evidence, emit ONE finding with:
+   - \`area\` = "knowledge-gap"
+   - \`subject\` = the locus string from the list above
+   - \`claim\` = a sentence naming the missing or stale knowledge ("wiki has no page on invoice line-item shape, agent had to re-derive it from raw spans")
+   - \`severity\` = "high" when the gap caused a failure or a clarifying question; "medium" when it caused unnecessary turns; "low" when it caused minor inefficiency
+   - \`evidence_uri\` = \`span://<trace_id>/<span_id>\` of the moment the gap surfaced (the question, the self-correction, the retrieval miss, the stale web result)
+   - \`evidence_excerpt\` = exact quote where the agent showed the gap
+   - \`confidence\` = 0.85+ when the agent itself articulated the gap; 0.6-0.8 when inferred from behavior
+   - \`recommended_action\` = phrased as a wiki edit when the locus is \`agent-knowledge:*\` ("Create wiki page \`invoice-line-items\` with claims: ..."), or as a prompt/tool-doc edit otherwise
+
+**Delegate per layer.** After your first scan, you should have candidates spread across \`agent-knowledge:*\`, \`websearch:outdated\`, \`tool-doc:*\`, \`system-prompt:*\`, and \`memory:*\`. Spawn one \`llmQuery\` per layer in parallel \u2014 each subagent runs a focused detection (e.g. the \`agent-knowledge\` subagent looks for both missing-pages AND stale-pages; the \`websearch\` subagent looks specifically for date staleness signals; the \`tool-doc\` subagent looks for tool-call argument errors a fuller description would have prevented). Subagents return findings; you merge and emit one \`final({ findings })\` at the top.
+
+Do NOT report a gap that the agent later recovered from cleanly within the same turn \u2014 that's resilience, not a gap. Cite the *non-recovery* version when both exist.
+
+OBSERVABILITY rules:
+- Each non-final turn must emit at least one \`console.log\` for evidence.
+- Call \`final({ findings: [...] })\` exactly once at the top level.`;
+var KNOWLEDGE_GAP_KIND_SPEC = {
+  id: "knowledge-gap",
+  description: "Identifies missing or stale pieces of knowledge \u2014 primarily against the agent-knowledge wiki \u2014 and attributes each to the runtime layer (wiki page, claim, raw source, websearch, tool-doc, system-prompt, memory) that should have held it.",
+  area: "knowledge-gap",
+  version: "1.0.0",
+  actorDescription: ACTOR_PROMPT3,
+  buildTools: (store) => buildTraceToolsForGroup("discoveryAndSearch", store),
+  recursion: { maxDepth: 2, maxParallelSubagents: 4 },
+  maxTurns: 18,
+  cost: { kind: "llm" }
+};
+
+// src/analyst/kinds/knowledge-poisoning.ts
+var ACTOR_PROMPT4 = `You are a knowledge-poisoning analyst for an OTLP trace dataset. Your job is to identify cases where the agent **confidently used wrong information** \u2014 not where it lacked information (that's the knowledge-gap analyst).
+
+DISCOVERY \u2192 DUAL-VERIFY \u2192 CITE protocol:
+
+1. \`traces.getDatasetOverview({})\` first. Identify the agents, models, and tools.
+2. Pull traces where the agent's confident action was later contradicted. Strongest signals:
+   - Agent stated a fact in one span; a later span surfaced contradictory evidence; the agent then proceeded anyway or fabricated reconciliation.
+   - Tool call with stale arguments (an id that no longer exists, an API shape that changed).
+   - Agent cited an \`agent-knowledge\` wiki page or claim whose content contradicts the trace's own evidence \u2014 the wiki itself drifted.
+   - Web-search result the agent cited that returned an outdated page; agent treated it as canonical.
+   - System-prompt instruction the agent followed that ground-truth evidence in the trace contradicts (e.g. prompt says "use endpoint A"; tool reply says "endpoint A deprecated, use B").
+   - Repeated wrong-shape parsing despite the tool's actual output proving the shape.
+3. Use \`traces.searchTrace\` with regex on phrases like \`actually\`, \`turns out\`, \`previously assumed\`, \`old version\`, \`deprecated\`, \`updated to\`, \`now uses\`, or specific entity names you suspect have changed.
+4. For each candidate poisoning, **DUAL-VERIFY**:
+   - Confirm the agent actually acted on the false belief (cite the span where it did)
+   - Confirm the belief is actually false in this trace's own evidence (cite the span that contradicts it)
+   Only emit a finding when both halves are nailed down. If you can only nail one, drop it \u2014 single-evidence poisoning findings are too speculative to be useful.
+
+**Delegate the dual-verify.** Use the recursion budget so each candidate poisoning gets one subagent investigating "did the agent act?" and one investigating "is the belief false?". After your first scan, fire off N parallel \`llmQuery\` pairs (one cluster per pair). Subagents return their findings; you accept only the ones where BOTH halves of the pair were confirmed.
+
+For each confirmed poisoning, emit ONE finding with:
+- \`area\` = "knowledge-poisoning"
+- \`subject\` = the source of the false belief, one of: \`agent-knowledge:wiki:<page-slug>\` (wiki page contradicts current ground truth), \`agent-knowledge:claim:<topic>\` (a specific claim/relation went stale), \`agent-knowledge:raw:<source-id>\` (the raw source is outdated and the wiki inherited the drift), \`websearch:outdated:<url-or-topic>\`, \`tool-doc:<tool>\`, \`system-prompt:<section>\`, \`memory:<key>\`, \`prior-run-summary:<topic>\`
+- \`claim\` = one sentence: "agent believed X (from source S); evidence in trace shows X is false"
+- \`severity\` = "critical" when poisoning caused a wrong user-visible action; "high" when caught internally but wasted significant work; "medium" for inefficiency only
+- \`evidence_uri\` = \`span://<trace_id>/<span_id>\` of the action span (the moment the agent acted on the false belief)
+- \`evidence_excerpt\` = exact quote of the confident-but-wrong claim or action
+- \`confidence\` = 0.85+ when both halves are exact-quote backed; 0.6-0.8 when one half is inferred
+- \`recommended_action\` = where the source should be updated and how ("Update wiki page \`X\` claim \`Y\` to '...'", "Invalidate raw source \`Z\` and re-curate", "Replace system-prompt section X with 'tool foo now returns Y'")
+
+Do NOT report a finding if the agent caught and corrected the false belief in the same turn \u2014 that's the system working. Reserve poisoning for cases where the false belief shaped downstream action.
+
+OBSERVABILITY rules:
+- Each non-final turn must emit at least one \`console.log\` for evidence.
+- Call \`final({ findings: [...] })\` exactly once at the top level.`;
+var KNOWLEDGE_POISONING_KIND_SPEC = {
+  id: "knowledge-poisoning",
+  description: "Identifies confident-but-wrong actions caused by stale memory, contradicting RAG, deprecated tool docs, or outdated system-prompt instructions.",
+  area: "knowledge-poisoning",
+  version: "1.0.0",
+  actorDescription: ACTOR_PROMPT4,
+  buildTools: (store) => buildTraceToolsForGroup("all", store),
+  recursion: { maxDepth: 2, maxParallelSubagents: 4 },
+  maxTurns: 20,
+  cost: { kind: "llm" }
+};
+
+// src/analyst/kinds/index.ts
+var DEFAULT_TRACE_ANALYST_KINDS = [
+  FAILURE_MODE_KIND_SPEC,
+  KNOWLEDGE_GAP_KIND_SPEC,
+  KNOWLEDGE_POISONING_KIND_SPEC,
+  IMPROVEMENT_KIND_SPEC
+];
+
+// src/analyst/registry.ts
+import { randomUUID } from "crypto";
+var AnalystRegistry = class {
+  analysts = /* @__PURE__ */ new Map();
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  register(analyst) {
+    if (!analyst.id) throw new Error("AnalystRegistry.register: analyst.id is required");
+    if (this.analysts.has(analyst.id)) {
+      throw new Error(`AnalystRegistry.register: duplicate analyst id "${analyst.id}"`);
+    }
+    if (!analyst.version) {
+      throw new Error(`AnalystRegistry.register: analyst "${analyst.id}" must declare a version`);
+    }
+    this.analysts.set(analyst.id, analyst);
+  }
+  list() {
+    return Array.from(this.analysts.values()).map((a) => ({
+      id: a.id,
+      description: a.description,
+      version: a.version,
+      cost: a.cost
+    }));
+  }
+  async run(runId, inputs, runOpts = {}) {
+    const correlationId = `ar_${randomUUID().slice(0, 12)}`;
+    const log = this.options.log ?? (() => {
+    });
+    const hooks = this.options.hooks ?? {};
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const started = Date.now();
+    const deadlineMs = runOpts.timeoutMs ? started + runOpts.timeoutMs : void 0;
+    const selected = this.selectAnalysts(runOpts);
+    const budget = runOpts.budget ?? this.options.defaultBudget;
+    const summaries = [];
+    const allFindings = [];
+    let totalCost = 0;
+    let remainingUsd = budget?.totalUsd;
+    for (const analyst of selected) {
+      const t0 = Date.now();
+      const input = this.routeInput(analyst, inputs);
+      if (input.kind === "missing") {
+        const summary = {
+          analyst_id: analyst.id,
+          status: "skipped",
+          reason: `missing input of kind '${analyst.inputKind}'`,
+          findings_count: 0,
+          latency_ms: 0,
+          cost_usd: 0
+        };
+        summaries.push(summary);
+        log(`[analyst] skip ${analyst.id} \u2014 missing input`, { runId, kind: analyst.inputKind });
+        await hooks.onAfterAnalyze?.({ analyst, summary, findings: [], runId });
+        continue;
+      }
+      const perBudget = allocateBudget(budget, {
+        analyst,
+        remainingUsd,
+        runningCount: selected.length
+      });
+      const ctx = {
+        runId,
+        correlationId,
+        deadlineMs,
+        budgetUsd: perBudget,
+        chat: this.options.chat,
+        tags: runOpts.tags,
+        log: (msg, fields) => log(`[${analyst.id}] ${msg}`, { runId, correlationId, ...fields }),
+        signal: runOpts.signal,
+        priorFindings: selectPriorFindings(runOpts.priorFindings, analyst.id)
+      };
+      await hooks.onBeforeAnalyze?.({ analyst, ctx, runId });
+      try {
+        const findings = await analyst.analyze(input.value, ctx);
+        const latency = Date.now() - t0;
+        const cost = sumFindingCost(findings);
+        totalCost += cost;
+        if (typeof remainingUsd === "number") remainingUsd = Math.max(0, remainingUsd - cost);
+        allFindings.push(...findings);
+        const summary = {
+          analyst_id: analyst.id,
+          status: "ok",
+          findings_count: findings.length,
+          latency_ms: latency,
+          cost_usd: cost
+        };
+        summaries.push(summary);
+        log(`[analyst] ok ${analyst.id}`, {
+          runId,
+          findings: findings.length,
+          latency_ms: latency,
+          cost_usd: cost
+        });
+        await hooks.onAfterAnalyze?.({ analyst, summary, findings, runId });
+      } catch (err) {
+        const latency = Date.now() - t0;
+        const e = err instanceof Error ? err : new Error(String(err));
+        const hookFindings = await hooks.onError?.({ analyst, error: e, runId }) ?? [];
+        if (hookFindings.length) allFindings.push(...hookFindings);
+        const summary = {
+          analyst_id: analyst.id,
+          status: "failed",
+          findings_count: hookFindings.length,
+          latency_ms: latency,
+          cost_usd: 0,
+          error: { class: e.constructor.name, message: e.message }
+        };
+        summaries.push(summary);
+        log(`[analyst] FAIL ${analyst.id}`, {
+          runId,
+          error_class: e.constructor.name,
+          error: e.message
+        });
+        await hooks.onAfterAnalyze?.({ analyst, summary, findings: hookFindings, runId });
+      }
+    }
+    const result = {
+      run_id: runId,
+      correlation_id: correlationId,
+      started_at: startedAt,
+      ended_at: (/* @__PURE__ */ new Date()).toISOString(),
+      findings: allFindings,
+      per_analyst: summaries,
+      total_cost_usd: totalCost
+    };
+    await hooks.onComplete?.({ result });
+    return result;
+  }
+  selectAnalysts(opts) {
+    let candidates = Array.from(this.analysts.values());
+    if (opts.only?.length) {
+      const only = new Set(opts.only);
+      candidates = candidates.filter((a) => only.has(a.id));
+    }
+    if (opts.skip?.length) {
+      const skip = new Set(opts.skip);
+      candidates = candidates.filter((a) => !skip.has(a.id));
+    }
+    return candidates;
+  }
+  routeInput(analyst, inputs) {
+    switch (analyst.inputKind) {
+      case "trace-store":
+        return inputs.traceStore ? { kind: "present", value: inputs.traceStore } : { kind: "missing" };
+      case "artifact-dir":
+        return inputs.artifactDir ? { kind: "present", value: inputs.artifactDir } : { kind: "missing" };
+      case "run-record":
+        return inputs.runRecord ? { kind: "present", value: inputs.runRecord } : { kind: "missing" };
+      case "judge-input":
+        return inputs.judgeInput ? { kind: "present", value: inputs.judgeInput } : { kind: "missing" };
+      case "custom": {
+        const v = inputs.custom?.[analyst.id];
+        return v !== void 0 ? { kind: "present", value: v } : { kind: "missing" };
+      }
+    }
+  }
+};
+function allocateBudget(policy, args) {
+  if (!policy) return void 0;
+  if (policy.allocate) {
+    return policy.allocate({
+      analyst: args.analyst,
+      totalUsd: policy.totalUsd,
+      remainingUsd: args.remainingUsd,
+      runningCount: args.runningCount
+    });
+  }
+  if (policy.totalUsd == null) return void 0;
+  if (policy.weights) {
+    const w = policy.weights[args.analyst.id] ?? 1;
+    const totalWeight = Math.max(1, args.runningCount);
+    return policy.totalUsd * w / totalWeight;
+  }
+  return policy.totalUsd / Math.max(1, args.runningCount);
+}
+function sumFindingCost(findings) {
+  let sum2 = 0;
+  for (const f of findings) {
+    const c = f.metadata?.cost_usd;
+    if (typeof c === "number" && Number.isFinite(c)) sum2 += c;
+  }
+  return sum2;
+}
+function selectPriorFindings(source, analystId) {
+  if (!source) return void 0;
+  if (Array.isArray(source)) {
+    const own2 = source.filter((f) => f.analyst_id === analystId);
+    return own2.length > 0 ? own2 : void 0;
+  }
+  const record = source;
+  const own = record[analystId] ?? [];
+  const wildcard = record["*"] ?? [];
+  const merged = [...own, ...wildcard];
+  return merged.length > 0 ? merged : void 0;
+}
+
 // src/auto-pr.ts
 async function proposeAutomatedPullRequest(client, input) {
   validate(input);
@@ -3135,154 +4624,6 @@ var FileSystemExperimentStore = class {
   }
 };
 
-// src/run-score.ts
-var DEFAULT_RUN_SCORE_WEIGHTS = {
-  success: 4,
-  goalProgress: 2,
-  repoGroundedness: 1.5,
-  driftPenalty: -1.5,
-  toolUseQuality: 1,
-  patchQuality: 1.25,
-  testReality: 1.5,
-  finalGate: 3,
-  reviewerBlockers: -2,
-  costUsd: -0.2,
-  wallSeconds: -0.1
-};
-function aggregateRunScore(score, weights = {}) {
-  const w = { ...DEFAULT_RUN_SCORE_WEIGHTS, ...weights };
-  return w.success * clamp01(score.success) + w.goalProgress * clamp01(score.goalProgress) + w.repoGroundedness * clamp01(score.repoGroundedness) + w.driftPenalty * clamp01(score.driftPenalty) + w.toolUseQuality * clamp01(score.toolUseQuality) + w.patchQuality * clamp01(score.patchQuality) + w.testReality * clamp01(score.testReality) + w.finalGate * clamp01(score.finalGate) + w.reviewerBlockers * clamp01(score.reviewerBlockers) + w.costUsd * Math.max(0, finiteOrZero(score.costUsd)) + w.wallSeconds * Math.max(0, finiteOrZero(score.wallSeconds) / 60);
-}
-function clamp01(value) {
-  if (!Number.isFinite(value)) return 0;
-  return Math.max(0, Math.min(1, value));
-}
-function finiteOrZero(value) {
-  return Number.isFinite(value) ? value : 0;
-}
-
-// src/run-critic.ts
-var DEFAULT_DRIFT_PATTERNS = [
-  /https?:\/\//i,
-  /\btitle:\s/i,
-  /\bsummary:\s/i,
-  /\burl:\s/i,
-  /\bnpm package usage\b/i,
-  /\bnews\b/i
-];
-var RunCritic = class {
-  weights;
-  driftPatterns;
-  constructor(options = {}) {
-    this.weights = options.weights;
-    this.driftPatterns = options.driftPatterns ?? DEFAULT_DRIFT_PATTERNS;
-  }
-  async score(store, runId) {
-    const run = await store.getRun(runId);
-    if (!run) throw new NotFoundError(`run ${runId} not found`);
-    const [spans, events, artifacts, budget] = await Promise.all([
-      store.spans({ runId }),
-      store.events({ runId }),
-      store.artifacts(runId),
-      store.budget(runId)
-    ]);
-    return this.scoreTrace({ run, spans, events, artifacts, budget });
-  }
-  scoreTrace(trace) {
-    const notes = [];
-    const llmSpans2 = trace.spans.filter(
-      (s) => s.kind === "llm"
-    );
-    const toolSpans2 = trace.spans.filter(
-      (s) => s.kind === "tool"
-    );
-    const judgeSpans2 = trace.spans.filter(
-      (s) => s.kind === "judge"
-    );
-    const sandboxSpans = trace.spans.filter(
-      (s) => s.kind === "sandbox"
-    );
-    const finalGateSpans = judgeSpans2.filter(
-      (span) => span.dimension === "final_gate" || span.attributes?.finalGate === true
-    );
-    const success = trace.run.outcome?.pass === true ? 1 : trace.run.status === "completed" ? 0.5 : 0;
-    if (!success) notes.push("run did not complete with pass=true");
-    const judgeAverage = judgeSpans2.length ? judgeSpans2.reduce((sum2, span) => sum2 + normalizeJudgeScore(span.score), 0) / judgeSpans2.length : void 0;
-    const outcomeScore = typeof trace.run.outcome?.score === "number" ? clamp01(
-      trace.run.outcome.score > 1 ? trace.run.outcome.score / 100 : trace.run.outcome.score
-    ) : void 0;
-    const goalProgress = outcomeScore ?? judgeAverage ?? success;
-    const successfulTools = toolSpans2.filter((span) => span.status !== "error").length;
-    const toolUseQuality = toolSpans2.length === 0 ? 0 : successfulTools / toolSpans2.length;
-    if (toolSpans2.length === 0) notes.push("no tool spans recorded");
-    const patchEvidence = trace.artifacts.length + toolSpans2.filter((span) => /write|edit|patch|apply/i.test(span.toolName)).length;
-    const patchQuality = patchEvidence > 0 ? clamp01(patchEvidence / 4) : 0;
-    if (!patchQuality) notes.push("no artifact or edit evidence recorded");
-    const sandboxTests = sandboxSpans.filter(
-      (span) => typeof span.testsTotal === "number" && span.testsTotal > 0
-    );
-    const testReality = sandboxTests.length ? sandboxTests.reduce(
-      (sum2, span) => sum2 + (span.testsPassed ?? 0) / Math.max(1, span.testsTotal ?? 1),
-      0
-    ) / sandboxTests.length : toolSpans2.some(
-      (span) => /\btest|vitest|pytest|jest|build|tsc\b/i.test(JSON.stringify(span.args))
-    ) ? 0.4 : 0;
-    if (!testReality) notes.push("no real test/build evidence recorded");
-    const blockerSpans = judgeSpans2.filter((span) => isBlockingJudge(span));
-    const finalGateBlockers = finalGateSpans.filter((span) => isBlockingJudge(span));
-    const finalGate = finalGateSpans.length ? finalGateBlockers.length ? 0 : 1 : success;
-    if (finalGateBlockers.length)
-      notes.push(`final gate blocked by ${finalGateBlockers.length} reviewer(s)`);
-    else if (!finalGateSpans.length) notes.push("no final gate judgment recorded");
-    const reviewerBlockers = judgeSpans2.length ? blockerSpans.length / judgeSpans2.length : 0;
-    if (reviewerBlockers) notes.push(`detected ${blockerSpans.length} blocking reviewer signal(s)`);
-    const positiveGroundingSignals = patchEvidence + sandboxSpans.length + llmSpans2.filter((span) => looksRepoGrounded(span.output ?? "")).length;
-    const driftSignals = llmSpans2.filter((span) => this.isDrift(span.output ?? "")).length + trace.events.filter((event) => this.isDrift(JSON.stringify(event.payload))).length;
-    const repoGroundedness = positiveGroundingSignals + driftSignals === 0 ? 0 : positiveGroundingSignals / (positiveGroundingSignals + driftSignals);
-    const driftPenalty = positiveGroundingSignals + driftSignals === 0 ? 0 : driftSignals / (positiveGroundingSignals + driftSignals);
-    if (driftSignals > 0) notes.push(`detected ${driftSignals} drift signal(s)`);
-    const costUsd = trace.budget.length ? Math.max(
-      ...trace.budget.filter((entry) => entry.dimension === "usd").map((entry) => entry.consumed),
-      0
-    ) : llmSpans2.reduce((sum2, span) => sum2 + (span.costUsd ?? 0), 0);
-    const wallSeconds = trace.run.endedAt && trace.run.startedAt ? Math.max(0, (trace.run.endedAt - trace.run.startedAt) / 1e3) : 0;
-    return {
-      success,
-      goalProgress,
-      repoGroundedness,
-      driftPenalty,
-      toolUseQuality,
-      patchQuality,
-      testReality,
-      finalGate,
-      reviewerBlockers,
-      costUsd,
-      wallSeconds,
-      notes
-    };
-  }
-  rank(score) {
-    return aggregateRunScore(score, this.weights);
-  }
-  isDrift(text) {
-    return this.driftPatterns.some((pattern) => pattern.test(text));
-  }
-};
-function normalizeJudgeScore(score) {
-  return score > 1 ? clamp01(score / 10) : clamp01(score);
-}
-function looksRepoGrounded(text) {
-  return /(?:src\/|tests?\/|package\.json|tsconfig|\.ts\b|\.tsx\b|git status|pnpm |npm |vitest|pytest|jest)/i.test(
-    text
-  );
-}
-function isBlockingJudge(span) {
-  return span.attributes?.blocking === true || span.attributes?.verdict === "BLOCKING" || positiveNumber(span.attributes?.blockingFindings) || positiveNumber(span.attributes?.highFindings) || span.score <= 2;
-}
-function positiveNumber(value) {
-  return typeof value === "number" && value > 0;
-}
-
 // src/harness-optimizer.ts
 var DEFAULT_HARNESS_OBJECTIVES = [
   { name: "aggregate", direction: "maximize", value: (r) => r.aggregateMean },
@@ -3952,7 +5293,7 @@ function assertNonNegative(n, name) {
 }
 
 // src/muffled-gate-scanner.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
 import { join } from "path";
 function codeOf(line) {
   return line.replace(/\/\/.*$/, "").replace(/^\s*\*.*$/, "");
@@ -4066,7 +5407,7 @@ function autoDeriveImporters(repoRoot, roots, extensions, importsContain) {
   const matches = [];
   const walk = (rel) => {
     const abs = join(repoRoot, rel);
-    if (!existsSync(abs)) return;
+    if (!existsSync3(abs)) return;
     for (const entry of readdirSync(abs)) {
       const sub = join(rel, entry);
       const subAbs = join(repoRoot, sub);
@@ -4085,7 +5426,7 @@ function autoDeriveImporters(repoRoot, roots, extensions, importsContain) {
           continue;
         let text;
         try {
-          text = readFileSync(subAbs, "utf8");
+          text = readFileSync2(subAbs, "utf8");
         } catch {
           continue;
         }
@@ -4101,8 +5442,8 @@ function scanForMuffledGates(opts) {
   const scanned = /* @__PURE__ */ new Set();
   for (const file of opts.scanFiles) {
     const abs = join(opts.repoRoot, file);
-    if (!existsSync(abs)) continue;
-    const text = readFileSync(abs, "utf8");
+    if (!existsSync3(abs)) continue;
+    const text = readFileSync2(abs, "utf8");
     for (const find of opts.finders) findings.push(...find(file, text));
     scanned.add(file);
   }
@@ -4116,8 +5457,8 @@ function scanForMuffledGates(opts) {
     for (const file of importers) {
       if (scanned.has(file)) continue;
       const abs = join(opts.repoRoot, file);
-      if (!existsSync(abs)) continue;
-      const text = readFileSync(abs, "utf8");
+      if (!existsSync3(abs)) continue;
+      const text = readFileSync2(abs, "utf8");
       for (const find of opts.autoDerive.universalFinders) findings.push(...find(file, text));
     }
   }
@@ -6014,7 +7355,7 @@ async function runSelfPlay(proposer, scorer, targets, options = {}) {
 
 // src/command-runner.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
 import { join as join2 } from "path";
 var localCommandRunner = {
   name: "local",
@@ -6043,11 +7384,11 @@ var localCommandRunner = {
     return r.status === 0 && (r.stdout ?? "").trim().length > 0;
   },
   async fileExists(path) {
-    return existsSync2(path);
+    return existsSync4(path);
   },
   async readFile(path) {
     try {
-      return readFileSync2(path, "utf8");
+      return readFileSync3(path, "utf8");
     } catch {
       return null;
     }
@@ -6401,11 +7742,11 @@ function flowLayer(input) {
 
 // src/intent-match-judge.ts
 var INTENT_MATCH_JUDGE_VERSION = "intent-match-judge-v1-2026-04-24";
-var DEFAULT_MODEL = "claude-sonnet-4-6";
-var DEFAULT_TIMEOUT = 9e4;
-var DEFAULT_MAX_SOURCE = 25e3;
-var DEFAULT_MAX_PER_FILE = 12e3;
-var DEFAULT_MAX_HTML = 2e4;
+var DEFAULT_MODEL2 = "claude-sonnet-4-6";
+var DEFAULT_TIMEOUT2 = 9e4;
+var DEFAULT_MAX_SOURCE2 = 25e3;
+var DEFAULT_MAX_PER_FILE2 = 12e3;
+var DEFAULT_MAX_HTML2 = 2e4;
 var INTENT_SCHEMA = {
   type: "object",
   additionalProperties: false,
@@ -6415,12 +7756,12 @@ var INTENT_SCHEMA = {
     evidence: { type: "string", minLength: 10, maxLength: 400 }
   }
 };
-function truncate(body, cap, label) {
+function truncate2(body, cap, label) {
   if (body.length <= cap) return body;
   return `${body.slice(0, cap)}
 \u2026 [truncated ${body.length - cap} chars of ${label}]`;
 }
-function buildPrompt(input, opts) {
+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 html = input.servedHtml ?? "";
@@ -6439,10 +7780,10 @@ ${input.artifactLabel ? `ARTIFACT METADATA:
   description: ${input.artifactDescription ?? ""}
 
 ` : ""}${html ? `SERVED HTML (what the preview returns):
-${truncate(html, opts.maxHtmlChars, "HTML")}
+${truncate2(html, opts.maxHtmlChars, "HTML")}
 
 ` : ""}SOURCE FILES (the agent's workdir):
-${truncate(sourceBlob, opts.maxSourceChars, "source")}
+${truncate2(sourceBlob, opts.maxSourceChars, "source")}
 
 Score 0\u20131:
   1.0 \u2014 unmistakably the right app. Even with bugs, gaps, or missing
@@ -6470,11 +7811,11 @@ Return STRICT JSON. No prose outside.`;
 async function runIntentMatchJudge(input, options = {}) {
   const start = Date.now();
   const opts = {
-    model: options.model ?? DEFAULT_MODEL,
-    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT,
-    maxSourceChars: options.maxSourceChars ?? DEFAULT_MAX_SOURCE,
-    maxPerFileChars: options.maxPerFileChars ?? DEFAULT_MAX_PER_FILE,
-    maxHtmlChars: options.maxHtmlChars ?? DEFAULT_MAX_HTML,
+    model: options.model ?? DEFAULT_MODEL2,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT2,
+    maxSourceChars: options.maxSourceChars ?? DEFAULT_MAX_SOURCE2,
+    maxPerFileChars: options.maxPerFileChars ?? DEFAULT_MAX_PER_FILE2,
+    maxHtmlChars: options.maxHtmlChars ?? DEFAULT_MAX_HTML2,
     llm: options.llm ?? {}
   };
   if (input.sourceFiles.length === 0 && !input.servedHtml) {
@@ -6498,7 +7839,7 @@ async function runIntentMatchJudge(input, options = {}) {
             role: "system",
             content: "You are a holistic code reviewer answering one question: did the agent build the right app for the user. Return strict JSON. No prose outside."
           },
-          { role: "user", content: buildPrompt(input, opts) }
+          { role: "user", content: buildPrompt2(input, opts) }
         ],
         jsonSchema: { name: "intent_match_judge", schema: INTENT_SCHEMA },
         temperature: 0,
@@ -6958,72 +8299,29 @@ function multiToolchainLayer(config) {
                 {
                   severity: "major",
                   layer: config.name,
-                  message: err instanceof Error ? err.message : String(err),
-                  detail: { adapter: adapterName }
-                }
-              ],
-              reason: err instanceof Error ? err.message : String(err)
-            }
-          };
-        }
-      };
-      const results = [];
-      for (let i = 0; i < config.adapters.length; i += maxParallel) {
-        const chunk = config.adapters.slice(i, i + maxParallel);
-        const chunkResults = await Promise.all(chunk.map(runOne));
-        results.push(...chunkResults);
-      }
-      return mergeLayerResults(config.name, results);
-    }
-  };
-}
-
-// src/reference-replay.ts
-import { appendFileSync, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3 } from "fs";
-import { dirname } from "path";
-
-// src/concurrency.ts
-var Mutex = class {
-  locked = false;
-  waiters = [];
-  async acquire() {
-    if (!this.locked) {
-      this.locked = true;
-      return () => this.release();
-    }
-    return new Promise((resolve) => {
-      this.waiters.push(() => {
-        resolve(() => this.release());
-      });
-    });
-  }
-  release() {
-    const next = this.waiters.shift();
-    if (next) {
-      next();
-    } else {
-      this.locked = false;
-    }
-  }
-  async runExclusive(fn) {
-    const release = await this.acquire();
-    try {
-      return await fn();
-    } finally {
-      release();
+                  message: err instanceof Error ? err.message : String(err),
+                  detail: { adapter: adapterName }
+                }
+              ],
+              reason: err instanceof Error ? err.message : String(err)
+            }
+          };
+        }
+      };
+      const results = [];
+      for (let i = 0; i < config.adapters.length; i += maxParallel) {
+        const chunk = config.adapters.slice(i, i + maxParallel);
+        const chunkResults = await Promise.all(chunk.map(runOne));
+        results.push(...chunkResults);
+      }
+      return mergeLayerResults(config.name, results);
     }
-  }
-  /** True iff someone holds the lock right now. Diagnostics only. */
-  get isLocked() {
-    return this.locked;
-  }
-  /** Pending waiter count. Diagnostics only. */
-  get pending() {
-    return this.waiters.length;
-  }
-};
+  };
+}
 
 // src/reference-replay.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2 } from "path";
 var DEFAULT_MATCH_THRESHOLD = 0.55;
 var ALL_SPLITS = ["train", "dev", "test", "holdout"];
 async function runReferenceReplay(cases, options) {
@@ -7141,14 +8439,14 @@ function jsonlReferenceReplayStore(path) {
   return {
     async save(run) {
       await lock.runExclusive(() => {
-        mkdirSync(dirname(path), { recursive: true });
-        appendFileSync(path, `${JSON.stringify(run)}
+        mkdirSync2(dirname2(path), { recursive: true });
+        appendFileSync2(path, `${JSON.stringify(run)}
 `);
       });
     },
     async list() {
       return lock.runExclusive(() => {
-        if (!existsSync3(path)) return [];
+        if (!existsSync5(path)) return [];
         return readJsonl(path);
       });
     }
@@ -7491,7 +8789,7 @@ function throwIfAborted(signal) {
   throw new Error(signal.reason ? String(signal.reason) : "reference replay aborted");
 }
 function readJsonl(path) {
-  const raw = readFileSync3(path, "utf8");
+  const raw = readFileSync4(path, "utf8");
   const out = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
@@ -7646,202 +8944,6 @@ function createDefaultReviewer(options) {
   };
 }
 
-// src/semantic-concept-judge.ts
-var DEFAULT_COMPLEXITY_WEIGHTS = {
-  render: 1,
-  integrate: 2,
-  compute: 2.5
-};
-var SEMANTIC_CONCEPT_JUDGE_VERSION = "semantic-concept-judge-v1-2026-04-24";
-var DEFAULT_MAX_SOURCE2 = 45e3;
-var DEFAULT_MAX_HTML2 = 3e4;
-var DEFAULT_MAX_PER_FILE2 = 2e4;
-var DEFAULT_TIMEOUT2 = 18e4;
-var DEFAULT_MODEL2 = "claude-sonnet-4-6";
-var SEMANTIC_SCHEMA = {
-  type: "object",
-  additionalProperties: false,
-  required: ["summary", "concepts"],
-  properties: {
-    summary: { type: "string", minLength: 20, maxLength: 600 },
-    concepts: {
-      type: "array",
-      minItems: 1,
-      items: {
-        type: "object",
-        additionalProperties: false,
-        required: ["concept", "present", "score", "evidence", "severity"],
-        properties: {
-          concept: { type: "string", minLength: 1, maxLength: 120 },
-          present: { type: "boolean" },
-          score: { type: "number", minimum: 0, maximum: 10 },
-          evidence: { type: "string", minLength: 5, maxLength: 400 },
-          severity: { type: "string", enum: ["critical", "major", "minor", "info"] }
-        }
-      }
-    }
-  }
-};
-function truncate2(body, cap, label) {
-  if (body.length <= cap) return body;
-  return `${body.slice(0, cap)}
-\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 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.
-
-You MUST distinguish:
-  (a) WORKING code that implements the concept (rendered UI, wired handler, real API call),
-  (b) KEYWORD-PRESENT stub (comments mentioning the concept, variable names, TODOs),
-  (c) ABSENT (concept nowhere).
-
-A comment like "// TODO: add mint button" is NOT present \u2014 score 2-3. Only count a concept as present if there is real functional code: a rendered component, a call handler wired to state or a network call, a computed value actually used.
-
-USER REQUEST (what the agent was asked to build):
-${input.userRequest}
-
-${input.artifactLabel ? `ARTIFACT METADATA:
-  name: ${input.artifactLabel}
-  description: ${input.artifactDescription ?? ""}
-
-` : ""}EXPECTED CONCEPTS (each must be graded independently):
-${input.expectedConcepts.map(
-    (c, i) => `  ${i + 1}. "${c.name}"${c.keywords?.length ? ` \u2014 hints: [${c.keywords.slice(0, 6).join(" | ")}]` : ""}`
-  ).join("\n")}
-
-${html ? `SERVED HTML (what the preview returns when hit):
-${truncate2(html, opts.maxHtmlChars, "HTML")}
-
-` : ""}SOURCE FILES (the agent's workdir):
-${truncate2(sourceBlob, opts.maxSourceChars, "source")}
-
-For EACH concept, return:
-  - concept: the concept name as given (match exactly)
-  - present: boolean \u2014 does a working implementation exist?
-  - score: 0-10 \u2014 10 = production-ready; 7 = functional but thin; 4 = partial/stubbed; 2 = keyword-only comment; 0 = absent
-  - evidence: cite "<file>:<line>" or "served-html:<selector>" pointing at the strongest supporting code. If the concept is absent or stubbed, explain what's missing.
-  - severity:
-      "info" when present: true AND score >= 7
-      "minor" when present: true AND 4 <= score < 7
-      "major" when present: false OR score < 4
-      "critical" when the concept is not only absent but a core user flow depends on it
-
-Also produce a "summary" (one sentence, 20-600 chars): overall verdict on whether this is a shippable implementation of the user request vs a keyword-dense placeholder.
-
-BE SKEPTICAL. Keyword matching already passed \u2014 your job is to catch what keyword matching misses. If the agent shipped a working build, say so. If it shipped a stub, say so. Don't grade on effort.
-
-Return STRICT JSON. No prose outside the JSON.`;
-}
-async function runSemanticConceptJudge(input, options = {}) {
-  const start = Date.now();
-  const totalCount = input.expectedConcepts.length;
-  if (totalCount === 0) {
-    return {
-      kind: "semantic-concept",
-      version: SEMANTIC_CONCEPT_JUDGE_VERSION,
-      score: 0,
-      presentCount: 0,
-      totalCount: 0,
-      findings: [],
-      summary: "no expected concepts declared",
-      durationMs: 0,
-      costUsd: null,
-      available: false,
-      error: "no expected concepts declared"
-    };
-  }
-  const opts = {
-    model: options.model ?? DEFAULT_MODEL2,
-    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT2,
-    maxSourceChars: options.maxSourceChars ?? DEFAULT_MAX_SOURCE2,
-    maxPerFileChars: options.maxPerFileChars ?? DEFAULT_MAX_PER_FILE2,
-    maxHtmlChars: options.maxHtmlChars ?? DEFAULT_MAX_HTML2,
-    llm: options.llm ?? {},
-    weightConcepts: options.weightConcepts ?? "mean",
-    complexityWeights: { ...DEFAULT_COMPLEXITY_WEIGHTS, ...options.complexityWeights ?? {} }
-  };
-  const weightForConcept = (spec) => {
-    if (opts.weightConcepts === "mean") return 1;
-    if (spec.weight != null) return spec.weight;
-    if (opts.weightConcepts === "complexity") {
-      return opts.complexityWeights[spec.complexity ?? "render"] ?? 1;
-    }
-    return 1;
-  };
-  const weightByName = new Map(
-    input.expectedConcepts.map((c) => [c.name, weightForConcept(c)])
-  );
-  try {
-    const { value, result } = await callLlmJson(
-      {
-        model: opts.model,
-        messages: [
-          {
-            role: "system",
-            content: "You are a strict code-review judge. Return strict JSON only. No prose outside the JSON. A keyword in a comment is NOT a working implementation."
-          },
-          { role: "user", content: buildPrompt2(input, opts) }
-        ],
-        jsonSchema: { name: "semantic_concept_judge", schema: SEMANTIC_SCHEMA },
-        temperature: 0,
-        timeoutMs: opts.timeoutMs
-      },
-      opts.llm
-    );
-    if (!value?.concepts || !Array.isArray(value.concepts)) {
-      throw new Error('judge returned malformed response \u2014 expected array under "concepts"');
-    }
-    const findings = value.concepts.map((c) => ({
-      concept: String(c.concept),
-      present: Boolean(c.present),
-      score: Math.max(0, Math.min(10, Number(c.score ?? 0))),
-      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;
-    let weightSum = 0;
-    let weightedScoreSum = 0;
-    for (const f of findings) {
-      const w = weightByName.get(f.concept) ?? 1;
-      weightSum += w;
-      weightedScoreSum += w * f.score;
-    }
-    const scoreAvg = weightSum > 0 ? weightedScoreSum / weightSum : findings.reduce((a, f) => a + f.score, 0) / Math.max(1, findings.length);
-    return {
-      kind: "semantic-concept",
-      version: SEMANTIC_CONCEPT_JUDGE_VERSION,
-      score: Number((scoreAvg / 10).toFixed(3)),
-      presentCount,
-      totalCount,
-      findings,
-      summary: String(value.summary ?? ""),
-      durationMs: Date.now() - start,
-      costUsd: result.costUsd ?? null,
-      available: true
-    };
-  } catch (err) {
-    return {
-      kind: "semantic-concept",
-      version: SEMANTIC_CONCEPT_JUDGE_VERSION,
-      score: 0,
-      presentCount: 0,
-      totalCount,
-      findings: [],
-      summary: "",
-      durationMs: Date.now() - start,
-      costUsd: null,
-      available: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
-}
-function createSemanticConceptJudge(options = {}) {
-  return (input) => runSemanticConceptJudge(input, options);
-}
-
 // src/canary.ts
 function runCanaries(runs, opts = {}) {
   const alerts = [
@@ -8040,8 +9142,8 @@ function chiSquareCritical(df, alpha) {
   if (TABLE[df]) return TABLE[df][idx];
   if (df > 30) {
     const zMap = { 0: 1.282, 1: 1.645, 2: 1.96, 3: 2.326 };
-    const z = zMap[idx] ?? 1.96;
-    const term = 1 - 2 / (9 * df) + z * Math.sqrt(2 / (9 * df));
+    const z2 = zMap[idx] ?? 1.96;
+    const term = 1 - 2 / (9 * df) + z2 * Math.sqrt(2 / (9 * df));
     return df * term ** 3;
   }
   const keys = Object.keys(TABLE).map((k) => Number(k)).sort((a, b) => a - b);
@@ -8255,44 +9357,8 @@ async function discoverPersonas(dir, opts = {}) {
 }
 
 // src/evolution-telemetry.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync } from "fs";
 import { dirname as dirname3 } from "path";
-
-// src/locked-jsonl-appender.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
-var mutexes = /* @__PURE__ */ new Map();
-function getMutex(path) {
-  let m = mutexes.get(path);
-  if (!m) {
-    m = new Mutex();
-    mutexes.set(path, m);
-  }
-  return m;
-}
-var LockedJsonlAppender = class {
-  constructor(path) {
-    this.path = path;
-    this.mutex = getMutex(path);
-    if (!existsSync4(dirname2(path))) {
-      mkdirSync2(dirname2(path), { recursive: true });
-    }
-  }
-  path;
-  mutex;
-  async append(entry) {
-    const line = `${JSON.stringify(entry)}
-`;
-    await this.mutex.runExclusive(() => {
-      appendFileSync2(this.path, line);
-    });
-  }
-};
-function resetLockedAppendersForTesting() {
-  mutexes.clear();
-}
-
-// src/evolution-telemetry.ts
 var MutationTelemetry = class {
   appender;
   constructor(path) {
@@ -8322,16 +9388,16 @@ var LineageRecorder = class {
     this.snapshotPath = `${path}.snapshot`;
     this.kindOf = kindOf ?? defaultKindOf;
     mkdirSync3(dirname3(path), { recursive: true });
-    if (existsSync5(this.snapshotPath)) {
+    if (existsSync6(this.snapshotPath)) {
       try {
-        const parsed = JSON.parse(readFileSync4(this.snapshotPath, "utf-8"));
+        const parsed = JSON.parse(readFileSync5(this.snapshotPath, "utf-8"));
         for (const n of parsed) this.nodes.set(n.id, n);
       } catch {
       }
     }
-    if (existsSync5(path)) {
+    if (existsSync6(path)) {
       try {
-        for (const line of readFileSync4(path, "utf-8").split("\n")) {
+        for (const line of readFileSync5(path, "utf-8").split("\n")) {
           if (!line.trim()) continue;
           try {
             const entry = JSON.parse(line);
@@ -8343,9 +9409,9 @@ var LineageRecorder = class {
       } catch {
       }
     }
-    if (existsSync5(path) && this.nodes.size === 0) {
+    if (existsSync6(path) && this.nodes.size === 0) {
       try {
-        const raw = readFileSync4(path, "utf-8").trim();
+        const raw = readFileSync5(path, "utf-8").trim();
         if (raw.startsWith("[")) {
           const parsed = JSON.parse(raw);
           for (const n of parsed) this.nodes.set(n.id, n);
@@ -8359,8 +9425,8 @@ var LineageRecorder = class {
       const prev = this.nodes.get(node.id);
       this.nodes.set(node.id, { ...prev, ...node });
       try {
-        if (existsSync5(this.path)) {
-          const head = readFileSync4(this.path, { encoding: "utf-8", flag: "r" }).slice(0, 1);
+        if (existsSync6(this.path)) {
+          const head = readFileSync5(this.path, { encoding: "utf-8", flag: "r" }).slice(0, 1);
           if (head === "[") {
             writeFileSync(this.path, "");
           }
@@ -8426,9 +9492,9 @@ var CostLedger = class {
   mutex = new Mutex();
   constructor(path) {
     this.path = path;
-    if (existsSync5(path)) {
+    if (existsSync6(path)) {
       try {
-        const loaded = JSON.parse(readFileSync4(path, "utf-8"));
+        const loaded = JSON.parse(readFileSync5(path, "utf-8"));
         for (const k of Object.keys(this.totals)) {
           if (k === "byGeneration") {
             if (loaded.byGeneration && typeof loaded.byGeneration === "object") {
@@ -8597,7 +9663,7 @@ function precision(goldens, candidates, options = {}) {
 }
 
 // src/jsonl-trial-cache.ts
-import { appendFileSync as appendFileSync4, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5 } from "fs";
+import { appendFileSync as appendFileSync4, existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6 } from "fs";
 import { dirname as dirname4 } from "path";
 var JsonlTrialCache = class {
   map = /* @__PURE__ */ new Map();
@@ -8605,8 +9671,8 @@ var JsonlTrialCache = class {
   appender;
   constructor(path) {
     this.path = path;
-    if (existsSync6(path)) {
-      for (const line of readFileSync5(path, "utf-8").split("\n")) {
+    if (existsSync7(path)) {
+      for (const line of readFileSync6(path, "utf-8").split("\n")) {
         if (!line.trim()) continue;
         try {
           const entry = JSON.parse(line);
@@ -8994,8 +10060,10 @@ function aggregateTrialsByMode(trials, opts) {
   };
 }
 export {
+  ANALYST_SEVERITIES,
   AgentDriver,
   AgentEvalError,
+  AnalystRegistry,
   AxGepaSteeringOptimizer,
   BENCHMARK_SPLIT_SEED,
   BenchmarkRunner,
@@ -9019,19 +10087,23 @@ export {
   DEFAULT_RED_TEAM_CORPUS,
   DEFAULT_RUN_SCORE_WEIGHTS,
   DEFAULT_SEVERITY_WEIGHTS,
+  DEFAULT_TRACE_ANALYST_KINDS,
   Dataset,
   DockerSandboxDriver,
   DualAgentBench,
   ERROR_COUNT_PATTERNS,
   ExperimentTracker,
   FAILURE_CLASSES,
+  FAILURE_MODE_KIND_SPEC,
   FileSystemExperimentStore,
   FileSystemFeedbackTrajectoryStore,
   FileSystemRawProviderSink,
   FileSystemTraceStore,
+  FindingsStore,
   HeldOutGate,
   HoldoutAuditor,
   HoldoutLockedError,
+  IMPROVEMENT_KIND_SPEC,
   INTENT_MATCH_JUDGE_VERSION,
   InMemoryExperimentStore,
   InMemoryFeedbackTrajectoryStore,
@@ -9042,6 +10114,8 @@ export {
   JsonlTrialCache,
   JudgeError,
   JudgeRunner,
+  KNOWLEDGE_GAP_KIND_SPEC,
+  KNOWLEDGE_POISONING_KIND_SPEC,
   LineageRecorder,
   LlmCallError,
   LlmClient,
@@ -9059,8 +10133,10 @@ export {
   PairwiseSteeringOptimizer,
   ProductClient,
   PromptRegistry,
+  RAW_FINDING_SCHEMA_PROMPT,
   REDACTION_VERSION,
   RESEARCH_REPORT_HARD_PAIR_FLOOR,
+  RawAnalystFindingSchema,
   ReplayCache,
   ReplayCacheMissError,
   ReplayError,
@@ -9102,6 +10178,7 @@ export {
   bootstrapCi,
   buildReflectionPrompt,
   buildReviewerPrompt,
+  buildTraceToolsForGroup,
   buildTrajectory,
   byteLengthRange,
   calibrateJudge,
@@ -9127,6 +10204,7 @@ export {
   compilerJudge,
   composeParsers,
   composeValidators,
+  computeFindingId,
   computeToolUseMetrics,
   confidenceInterval,
   containsAll,
@@ -9137,26 +10215,35 @@ export {
   corpusInterRaterAgreement,
   corpusInterRaterAgreementFromJudgeScores,
   createAntiSlopJudge,
+  createChatClient,
   createCompositeMutator,
   createCustomJudge,
   createDefaultReviewer,
   createDomainExpertJudge,
   createFeedbackTrajectory,
   createIntentMatchJudge,
+  createJudgeAdapter,
   createLlmReviewer,
   createReplayFetch,
+  createRunCriticAdapter,
   createSandboxCodeMutator,
   createSandboxPool,
   createSemanticConceptJudge,
+  createSemanticConceptJudgeAdapter,
+  createTraceAnalystAdapter,
+  createTraceAnalystKind,
+  createVerifierAdapter,
   crossTraceDiff,
   crowdingDistance,
   decideReferenceReplayPromotion,
   decideReferenceReplayRunPromotion,
+  defaultIsMaterial,
   defaultJudges,
   defaultMultiShotObjectives,
   defaultProviderRedactor,
   defaultReferenceReplayMatcher,
   deployGateLayer,
+  diffFindings,
   discoverPersonas,
   distillPlaybook,
   dominates,
@@ -9225,12 +10312,14 @@ export {
   judgeSpans,
   keyPreserved,
   knowledgeReadinessTracePayload,
+  liftSeverity,
   linterJudge,
   llmSpanFromProvider,
   llmSpans,
   loadScorerFromGrader,
   localCommandRunner,
   lowercaseMutator,
+  makeFinding,
   mannWhitneyU,
   matchGoldens,
   mergeLayerResults,
@@ -9250,6 +10339,7 @@ export {
   paretoFrontier,
   paretoFrontierWithCrowding,
   parseFeedbackTrajectoriesJsonl,
+  parseRawFinding,
   parseReflectionResponse,
   parseRunRecordSafe,
   partialCredit,
@@ -9277,6 +10367,7 @@ export {
   renderMarkdownReport,
   renderPlaybookMarkdown,
   renderPreferenceMemoryMarkdown,
+  renderPriorFindings,
   renderReleaseReport,
   renderSteeringText,
   replayFeedbackTrajectories,