@tangle-network/agent-eval 0.27.0 → 0.28.0

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   failureClusterView,
   iqr,
   welchsTTest
-} from "./chunk-JLZQWFV3.js";
+} from "./chunk-K33INZHH.js";
 import {
   exportTrainingData,
   toNdjson
@@ -28,7 +28,7 @@ import {
   pytestTestParser,
   runTestGradedScenario,
   vitestTestParser
-} from "./chunk-OWLAAMME.js";
+} from "./chunk-QHF6EQKK.js";
 import {
   classifyEuAiRisk,
   euAiActReport,
@@ -43,7 +43,7 @@ import {
   knowledgeReadinessTracePayload,
   scoreKnowledgeReadiness,
   userQuestionsForKnowledgeGaps
-} from "./chunk-WWYCWKUM.js";
+} from "./chunk-3CKU6VGU.js";
 import {
   controlFailureClassFromVerification,
   controlRunToRunRecord,
@@ -54,7 +54,7 @@ import {
   runProposeReview,
   runProposeReviewAsControlLoop,
   scoreFromEvals
-} from "./chunk-ZN274SWR.js";
+} from "./chunk-PALJO75S.js";
 import {
   allCriticalPassed,
   objectiveEval,
@@ -62,7 +62,7 @@ import {
   stopOnNoProgress,
   stopOnRepeatedAction,
   subjectiveEval
-} from "./chunk-LSH4MMOZ.js";
+} from "./chunk-NCRFYPS3.js";
 import {
   CallbackResearcher,
   DEFAULT_MUTATION_PRIMITIVES,
@@ -96,7 +96,7 @@ import {
   summarizePreferenceMemory,
   trialTraceFromMultiShotTrial,
   withAssignedFeedbackSplit
-} from "./chunk-WHZMVFUV.js";
+} from "./chunk-SZSBQUIJ.js";
 import {
   RunRecordValidationError,
   isRunRecord,
@@ -111,10 +111,10 @@ import {
   judgeReplayGate,
   releaseTraceEvidenceFromMultiShotTrials,
   renderReleaseReport
-} from "./chunk-RAF443UI.js";
+} from "./chunk-DBIGN5MJ.js";
 import {
   runEvalCampaign
-} from "./chunk-SESZDQPX.js";
+} from "./chunk-RUI6SIHY.js";
 import {
   LlmCallError,
   LlmClient,
@@ -128,7 +128,7 @@ import {
 import {
   evaluateInterimReleaseConfidence,
   pairedEvalueSequence
-} from "./chunk-NU65VQ7M.js";
+} from "./chunk-MAZ26DC7.js";
 import {
   RESEARCH_REPORT_HARD_PAIR_FLOOR,
   benjaminiHochberg,
@@ -141,18 +141,26 @@ import {
   requiredSampleSize,
   researchReport,
   summaryTable
-} from "./chunk-2A5XJB43.js";
+} from "./chunk-5AKPEK5L.js";
 import {
+  calibrateJudge,
+  calibrateJudgeContinuous,
   cohensD,
   confidenceInterval,
+  continuousAgreement,
+  corpusInterRaterAgreement,
+  corpusInterRaterAgreementFromJudgeScores,
   interRaterReliability,
   mannWhitneyU,
   normalizeScores,
   pairedTTest,
   partialCredit,
+  positionalBias,
+  selfPreference,
+  verbosityBias,
   weightedMean,
   wilcoxonSignedRank
-} from "./chunk-I4MBDTY5.js";
+} from "./chunk-R5UQJNKC.js";
 import {
   DEFAULT_REDACTION_RULES,
   FileSystemTraceStore,
@@ -161,12 +169,15 @@ import {
   REDACTION_VERSION,
   ReplayCache,
   ReplayCacheMissError,
+  TraceFileMissingError,
+  analyzeTraces,
+  buildTraceAnalystTools,
   createReplayFetch,
   exportRunAsOtlp,
   iterateRawCalls,
   redactString,
   redactValue
-} from "./chunk-K2TPS5LB.js";
+} from "./chunk-UW4NOOZI.js";
 import {
   aggregateLlm,
   argHash,
@@ -208,7 +219,7 @@ import {
   hashJson,
   signManifest,
   verifyManifest
-} from "./chunk-4F5DQN55.js";
+} from "./chunk-VSMTAMNK.js";
 import {
   AgentEvalError,
   CaptureIntegrityError,
@@ -221,95 +232,1534 @@ import {
 } from "./chunk-NG236HPC.js";
 import "./chunk-PZ5AY32C.js";
 
-// src/auto-pr.ts
-async function proposeAutomatedPullRequest(client, input) {
-  validate(input);
-  return client.proposeChange(input);
+// 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 validate(input) {
-  if (!input.repo.owner.trim() || !input.repo.name.trim()) {
-    throw new ValidationError("proposeAutomatedPullRequest: repo.owner and repo.name required");
-  }
-  if (!input.branchName.trim() || /\s/.test(input.branchName)) {
-    throw new ValidationError(
-      "proposeAutomatedPullRequest: branchName must be non-empty and contain no whitespace"
-    );
+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;
   }
-  if (input.branchName === (input.baseBranch ?? "main")) {
-    throw new ValidationError("proposeAutomatedPullRequest: branchName must differ from baseBranch");
+  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 });
   }
-  if (input.fileChanges.length === 0) {
-    throw new ValidationError("proposeAutomatedPullRequest: fileChanges must not be empty");
+  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
+    };
   }
-  const seenPaths = /* @__PURE__ */ new Set();
-  for (const change of input.fileChanges) {
-    if (!change.path.trim() || change.path.includes("..") || change.path.startsWith("/")) {
-      throw new ValidationError(
-        `proposeAutomatedPullRequest: invalid file path "${change.path}" (no '..' or leading '/')`
-      );
-    }
-    if (seenPaths.has(change.path)) {
-      throw new ValidationError(`proposeAutomatedPullRequest: duplicate file path "${change.path}"`);
-    }
-    seenPaths.add(change.path);
+  rank(score) {
+    return aggregateRunScore(score, this.weights);
   }
-  if (!input.title.trim()) {
-    throw new ValidationError("proposeAutomatedPullRequest: title must not be empty");
+  isDrift(text) {
+    return this.driftPatterns.some((pattern) => pattern.test(text));
   }
+};
+function normalizeJudgeScore(score) {
+  return score > 1 ? clamp01(score / 10) : clamp01(score);
 }
-function httpGithubClient(opts) {
-  const fetchImpl = opts.fetchImpl ?? fetch;
-  const apiBase = (opts.apiBase ?? "https://api.github.com").replace(/\/+$/, "");
-  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
-  async function api(method, path, body, accept404 = false) {
-    const res = await fetchImpl(`${apiBase}${path}`, {
-      method,
-      headers: {
-        accept: "application/vnd.github+json",
-        "content-type": "application/json",
-        authorization: `Bearer ${opts.token}`,
-        "x-github-api-version": "2022-11-28"
-      },
-      body: body === void 0 ? void 0 : JSON.stringify(body)
-    });
-    if (accept404 && res.status === 404) return null;
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new ConfigError(
-        `proposeAutomatedPullRequest: GitHub ${method} ${path} \u2192 ${res.status} ${text.slice(0, 400)}`
-      );
+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"] }
+        }
+      }
     }
-    return await res.json();
   }
-  return {
-    async proposeChange(input) {
-      const baseBranch = input.baseBranch ?? "main";
-      const repoPath = `/repos/${input.repo.owner}/${input.repo.name}`;
-      if (input.dryRun) {
-        return {
-          prUrl: `https://github.com/${input.repo.owner}/${input.repo.name}/compare/${baseBranch}...${input.branchName}`,
-          branchName: input.branchName,
-          headSha: "dry-run",
-          dryRun: true
-        };
-      }
-      const baseRef = await api("GET", `${repoPath}/git/ref/heads/${baseBranch}`);
-      if (!baseRef) {
-        throw new ConfigError(`proposeAutomatedPullRequest: base branch "${baseBranch}" not found`);
-      }
-      const baseSha = baseRef.object.sha;
-      const baseCommit = await api("GET", `${repoPath}/git/commits/${baseSha}`);
-      if (!baseCommit) {
-        throw new ConfigError(
-          `proposeAutomatedPullRequest: base commit ${baseSha} not found (race condition?)`
-        );
-      }
-      const treeEntries = [];
-      for (const change of input.fileChanges) {
-        const blob = await api("POST", `${repoPath}/git/blobs`, {
-          content: change.contents,
-          encoding: "utf-8"
-        });
+};
+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/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/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/kind-factory.ts
+import { agent, AxJSRuntime } 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 actorDescription = spec.actorDescription.trim() + "\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";
+}
+
+// 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/knowledge-gap.ts
+var ACTOR_PROMPT2 = `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_PROMPT2,
+  buildTools: (store) => buildTraceToolsForGroup("discoveryAndSearch", store),
+  recursion: { maxDepth: 2, maxParallelSubagents: 4 },
+  maxTurns: 18,
+  cost: { kind: "llm" }
+};
+
+// src/analyst/kinds/knowledge-poisoning.ts
+var ACTOR_PROMPT3 = `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_PROMPT3,
+  buildTools: (store) => buildTraceToolsForGroup("all", store),
+  recursion: { maxDepth: 2, maxParallelSubagents: 4 },
+  maxTurns: 20,
+  cost: { kind: "llm" }
+};
+
+// src/analyst/kinds/improvement.ts
+var ACTOR_PROMPT4 = `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_PROMPT4,
+  buildTools: (store) => buildTraceToolsForGroup("all", store),
+  recursion: { maxDepth: 3, maxParallelSubagents: 4 },
+  maxTurns: 30,
+  maxRuntimeChars: 12e3,
+  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
+      };
+      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;
+}
+
+// src/auto-pr.ts
+async function proposeAutomatedPullRequest(client, input) {
+  validate(input);
+  return client.proposeChange(input);
+}
+function validate(input) {
+  if (!input.repo.owner.trim() || !input.repo.name.trim()) {
+    throw new ValidationError("proposeAutomatedPullRequest: repo.owner and repo.name required");
+  }
+  if (!input.branchName.trim() || /\s/.test(input.branchName)) {
+    throw new ValidationError(
+      "proposeAutomatedPullRequest: branchName must be non-empty and contain no whitespace"
+    );
+  }
+  if (input.branchName === (input.baseBranch ?? "main")) {
+    throw new ValidationError("proposeAutomatedPullRequest: branchName must differ from baseBranch");
+  }
+  if (input.fileChanges.length === 0) {
+    throw new ValidationError("proposeAutomatedPullRequest: fileChanges must not be empty");
+  }
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const change of input.fileChanges) {
+    if (!change.path.trim() || change.path.includes("..") || change.path.startsWith("/")) {
+      throw new ValidationError(
+        `proposeAutomatedPullRequest: invalid file path "${change.path}" (no '..' or leading '/')`
+      );
+    }
+    if (seenPaths.has(change.path)) {
+      throw new ValidationError(`proposeAutomatedPullRequest: duplicate file path "${change.path}"`);
+    }
+    seenPaths.add(change.path);
+  }
+  if (!input.title.trim()) {
+    throw new ValidationError("proposeAutomatedPullRequest: title must not be empty");
+  }
+}
+function httpGithubClient(opts) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const apiBase = (opts.apiBase ?? "https://api.github.com").replace(/\/+$/, "");
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  async function api(method, path, body, accept404 = false) {
+    const res = await fetchImpl(`${apiBase}${path}`, {
+      method,
+      headers: {
+        accept: "application/vnd.github+json",
+        "content-type": "application/json",
+        authorization: `Bearer ${opts.token}`,
+        "x-github-api-version": "2022-11-28"
+      },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    if (accept404 && res.status === 404) return null;
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ConfigError(
+        `proposeAutomatedPullRequest: GitHub ${method} ${path} \u2192 ${res.status} ${text.slice(0, 400)}`
+      );
+    }
+    return await res.json();
+  }
+  return {
+    async proposeChange(input) {
+      const baseBranch = input.baseBranch ?? "main";
+      const repoPath = `/repos/${input.repo.owner}/${input.repo.name}`;
+      if (input.dryRun) {
+        return {
+          prUrl: `https://github.com/${input.repo.owner}/${input.repo.name}/compare/${baseBranch}...${input.branchName}`,
+          branchName: input.branchName,
+          headSha: "dry-run",
+          dryRun: true
+        };
+      }
+      const baseRef = await api("GET", `${repoPath}/git/ref/heads/${baseBranch}`);
+      if (!baseRef) {
+        throw new ConfigError(`proposeAutomatedPullRequest: base branch "${baseBranch}" not found`);
+      }
+      const baseSha = baseRef.object.sha;
+      const baseCommit = await api("GET", `${repoPath}/git/commits/${baseSha}`);
+      if (!baseCommit) {
+        throw new ConfigError(
+          `proposeAutomatedPullRequest: base commit ${baseSha} not found (race condition?)`
+        );
+      }
+      const treeEntries = [];
+      for (const change of input.fileChanges) {
+        const blob = await api("POST", `${repoPath}/git/blobs`, {
+          content: change.contents,
+          encoding: "utf-8"
+        });
         if (!blob) throw new ConfigError("proposeAutomatedPullRequest: blob creation returned null");
         treeEntries.push({
           path: change.path,
@@ -2736,545 +4186,397 @@ var DualAgentBench = class {
     const avgFinalScore = results.length ? results.reduce((acc, r) => acc + r.finalScore, 0) / results.length : 0;
     return {
       scenarios: results,
-      aggregate: { convergenceRate, avgRoundsToConverge, avgFinalScore },
-      config: { maxRounds, convergenceThreshold: threshold }
-    };
-  }
-};
-
-// src/experiment-tracker.ts
-var InMemoryExperimentStore = class {
-  experiments = /* @__PURE__ */ new Map();
-  runs = /* @__PURE__ */ new Map();
-  async saveExperiment(exp) {
-    this.experiments.set(exp.id, { ...exp });
-  }
-  async getExperiment(id) {
-    const e = this.experiments.get(id);
-    return e ? { ...e } : null;
-  }
-  async listExperiments() {
-    return [...this.experiments.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-  }
-  async saveRun(run) {
-    this.runs.set(run.id, structuredClone(run));
-  }
-  async getRun(id) {
-    const r = this.runs.get(id);
-    return r ? structuredClone(r) : null;
-  }
-  async listRuns(experimentId) {
-    return [...this.runs.values()].filter((r) => r.experimentId === experimentId).sort((a, b) => b.startedAt.localeCompare(a.startedAt)).map((r) => structuredClone(r));
-  }
-};
-var ExperimentTracker = class {
-  constructor(store) {
-    this.store = store;
-  }
-  store;
-  async startExperiment(name, metadata) {
-    const exp = {
-      id: `exp_${rand(8)}`,
-      name,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      metadata
-    };
-    await this.store.saveExperiment(exp);
-    return exp;
-  }
-  async startRun(config) {
-    const exp = await this.store.getExperiment(config.experimentId);
-    if (!exp) throw new Error(`Experiment ${config.experimentId} not found`);
-    const run = {
-      id: `run_${rand(10)}`,
-      experimentId: config.experimentId,
-      name: config.name,
-      config,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      status: "running"
-    };
-    await this.store.saveRun(run);
-    return run;
-  }
-  async completeRun(runId, report) {
-    const run = await this.store.getRun(runId);
-    if (!run) throw new Error(`Run ${runId} not found`);
-    run.status = "completed";
-    run.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    run.report = report;
-    await this.store.saveRun(run);
-  }
-  async failRun(runId, error) {
-    const run = await this.store.getRun(runId);
-    if (!run) throw new Error(`Run ${runId} not found`);
-    run.status = "failed";
-    run.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    run.error = error;
-    await this.store.saveRun(run);
-  }
-  /**
-   * Diff two completed runs. Returns per-scenario deltas, aggregate delta,
-   * and config changes that may explain the movement.
-   */
-  async diff(runIdA, runIdB) {
-    const [a, b] = await Promise.all([this.store.getRun(runIdA), this.store.getRun(runIdB)]);
-    if (!a || !b) throw new Error("Both runs must exist");
-    if (!a.report || !b.report) throw new Error("Both runs must be completed with reports");
-    const byScenarioA = new Map(a.report.results.map((r) => [r.scenarioId, r.overallScore]));
-    const byScenarioB = new Map(b.report.results.map((r) => [r.scenarioId, r.overallScore]));
-    const scenarioIds = /* @__PURE__ */ new Set([...byScenarioA.keys(), ...byScenarioB.keys()]);
-    const scenarios = [];
-    for (const id of scenarioIds) {
-      const aScore = byScenarioA.get(id);
-      const bScore = byScenarioB.get(id);
-      if (aScore === void 0) {
-        scenarios.push({
-          scenarioId: id,
-          before: null,
-          after: bScore,
-          delta: null,
-          status: "added"
-        });
-      } else if (bScore === void 0) {
-        scenarios.push({
-          scenarioId: id,
-          before: aScore,
-          after: null,
-          delta: null,
-          status: "removed"
-        });
-      } else {
-        scenarios.push({
-          scenarioId: id,
-          before: aScore,
-          after: bScore,
-          delta: bScore - aScore,
-          status: bScore > aScore ? "improved" : bScore < aScore ? "regressed" : "unchanged"
-        });
-      }
-    }
-    scenarios.sort((x, y) => (y.delta ?? 0) - (x.delta ?? 0));
-    const aggregateDelta = b.report.summary.overallAvg - a.report.summary.overallAvg;
-    const configChanges = {};
-    const keys = /* @__PURE__ */ new Set([...Object.keys(a.config), ...Object.keys(b.config)]);
-    const aCfg = a.config;
-    const bCfg = b.config;
-    for (const k of keys) {
-      if (JSON.stringify(aCfg[k]) !== JSON.stringify(bCfg[k])) {
-        configChanges[k] = { before: aCfg[k], after: bCfg[k] };
-      }
-    }
-    return {
-      before: { runId: runIdA, name: a.name, startedAt: a.startedAt },
-      after: { runId: runIdB, name: b.name, startedAt: b.startedAt },
-      aggregateDelta,
-      scenarios,
-      configChanges
-    };
-  }
-  /** Timeline of aggregate scores for an experiment. */
-  async timeline(experimentId) {
-    const runs = await this.store.listRuns(experimentId);
-    return runs.slice().sort((a, b) => a.startedAt.localeCompare(b.startedAt)).map((r) => ({
-      runId: r.id,
-      startedAt: r.startedAt,
-      overall: r.report?.summary.overallAvg ?? null
-    }));
-  }
-};
-function rand(bytes) {
-  const arr = new Uint8Array(bytes);
-  crypto.getRandomValues(arr);
-  return Array.from(arr).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-
-// src/experiment-tracker-d1.ts
-var SCHEMA_VERSION = 1;
-var D1ExperimentStore = class {
-  db;
-  experimentsTable;
-  runsTable;
-  metaTable;
-  schemaReady = false;
-  constructor(options) {
-    this.db = options.db;
-    const prefix = options.tablePrefix ?? "agent_eval_";
-    this.experimentsTable = `${prefix}experiments`;
-    this.runsTable = `${prefix}runs`;
-    this.metaTable = `${prefix}meta`;
-  }
-  /**
-   * Idempotent schema setup. Safe to call before every operation; the second
-   * call short-circuits via `schemaReady`. Most consumers will call it once
-   * during Worker bootstrap.
-   */
-  async ensureSchema() {
-    if (this.schemaReady) return;
-    const ddl = `
-      CREATE TABLE IF NOT EXISTS ${this.experimentsTable} (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        metadata_json TEXT
-      );
-      CREATE TABLE IF NOT EXISTS ${this.runsTable} (
-        id TEXT PRIMARY KEY,
-        experiment_id TEXT NOT NULL,
-        name TEXT,
-        status TEXT NOT NULL,
-        started_at TEXT NOT NULL,
-        completed_at TEXT,
-        config_json TEXT NOT NULL,
-        report_json TEXT,
-        error TEXT
-      );
-      CREATE INDEX IF NOT EXISTS idx_${this.runsTable}_experiment ON ${this.runsTable}(experiment_id);
-      CREATE INDEX IF NOT EXISTS idx_${this.runsTable}_started ON ${this.runsTable}(started_at);
-      CREATE TABLE IF NOT EXISTS ${this.metaTable} (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-      INSERT OR REPLACE INTO ${this.metaTable}(key, value) VALUES ('schema_version', '${SCHEMA_VERSION}');
-    `;
-    await this.db.exec(ddl.trim().replace(/\s+/g, " "));
-    this.schemaReady = true;
+      aggregate: { convergenceRate, avgRoundsToConverge, avgFinalScore },
+      config: { maxRounds, convergenceThreshold: threshold }
+    };
   }
+};
+
+// src/experiment-tracker.ts
+var InMemoryExperimentStore = class {
+  experiments = /* @__PURE__ */ new Map();
+  runs = /* @__PURE__ */ new Map();
   async saveExperiment(exp) {
-    await this.ensureSchema();
-    await this.db.prepare(
-      `INSERT INTO ${this.experimentsTable}(id, name, created_at, metadata_json)
-         VALUES (?1, ?2, ?3, ?4)
-         ON CONFLICT(id) DO UPDATE SET
-           name = excluded.name,
-           created_at = excluded.created_at,
-           metadata_json = excluded.metadata_json`
-    ).bind(exp.id, exp.name, exp.createdAt, exp.metadata ? JSON.stringify(exp.metadata) : null).run();
+    this.experiments.set(exp.id, { ...exp });
   }
   async getExperiment(id) {
-    await this.ensureSchema();
-    const row = await this.db.prepare(
-      `SELECT id, name, created_at, metadata_json
-         FROM ${this.experimentsTable}
-         WHERE id = ?1`
-    ).bind(id).first();
-    return row ? rowToExperiment(row) : null;
+    const e = this.experiments.get(id);
+    return e ? { ...e } : null;
   }
   async listExperiments() {
-    await this.ensureSchema();
-    const { results } = await this.db.prepare(
-      `SELECT id, name, created_at, metadata_json
-         FROM ${this.experimentsTable}
-         ORDER BY created_at DESC`
-    ).all();
-    return results.map(rowToExperiment);
+    return [...this.experiments.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
   }
   async saveRun(run) {
-    await this.ensureSchema();
-    await this.db.prepare(
-      `INSERT INTO ${this.runsTable}(id, experiment_id, name, status, started_at, completed_at, config_json, report_json, error)
-         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)
-         ON CONFLICT(id) DO UPDATE SET
-           experiment_id = excluded.experiment_id,
-           name = excluded.name,
-           status = excluded.status,
-           started_at = excluded.started_at,
-           completed_at = excluded.completed_at,
-           config_json = excluded.config_json,
-           report_json = excluded.report_json,
-           error = excluded.error`
-    ).bind(
-      run.id,
-      run.experimentId,
-      run.name ?? null,
-      run.status,
-      run.startedAt,
-      run.completedAt ?? null,
-      JSON.stringify(run.config),
-      run.report ? JSON.stringify(run.report) : null,
-      run.error ?? null
-    ).run();
+    this.runs.set(run.id, structuredClone(run));
   }
   async getRun(id) {
-    await this.ensureSchema();
-    const row = await this.db.prepare(
-      `SELECT id, experiment_id, name, status, started_at, completed_at, config_json, report_json, error
-         FROM ${this.runsTable}
-         WHERE id = ?1`
-    ).bind(id).first();
-    return row ? rowToRun(row) : null;
+    const r = this.runs.get(id);
+    return r ? structuredClone(r) : null;
   }
   async listRuns(experimentId) {
-    await this.ensureSchema();
-    const { results } = await this.db.prepare(
-      `SELECT id, experiment_id, name, status, started_at, completed_at, config_json, report_json, error
-         FROM ${this.runsTable}
-         WHERE experiment_id = ?1
-         ORDER BY started_at DESC`
-    ).bind(experimentId).all();
-    return results.map(rowToRun);
+    return [...this.runs.values()].filter((r) => r.experimentId === experimentId).sort((a, b) => b.startedAt.localeCompare(a.startedAt)).map((r) => structuredClone(r));
   }
 };
-function rowToExperiment(row) {
-  return {
-    id: row.id,
-    name: row.name,
-    createdAt: row.created_at,
-    ...row.metadata_json ? { metadata: JSON.parse(row.metadata_json) } : {}
-  };
-}
-function rowToRun(row) {
-  return {
-    id: row.id,
-    experimentId: row.experiment_id,
-    ...row.name ? { name: row.name } : {},
-    status: row.status,
-    startedAt: row.started_at,
-    ...row.completed_at ? { completedAt: row.completed_at } : {},
-    config: JSON.parse(row.config_json),
-    ...row.report_json ? { report: JSON.parse(row.report_json) } : {},
-    ...row.error ? { error: row.error } : {}
-  };
-}
-
-// src/experiment-tracker-fs.ts
-var FileSystemExperimentStore = class {
-  dir;
-  maxBytes;
-  index;
-  loaded = false;
-  constructor(options) {
-    this.dir = options.dir;
-    this.maxBytes = options.maxBytes ?? 32 * 1024 * 1024;
-  }
-  async saveExperiment(exp) {
-    const idx = await this.load();
-    await idx.saveExperiment(exp);
-    await this.append("experiments", exp);
-  }
-  async getExperiment(id) {
-    const idx = await this.load();
-    return idx.getExperiment(id);
-  }
-  async listExperiments() {
-    const idx = await this.load();
-    return idx.listExperiments();
+var ExperimentTracker = class {
+  constructor(store) {
+    this.store = store;
   }
-  async saveRun(run) {
-    const idx = await this.load();
-    await idx.saveRun(run);
-    await this.append("runs", run);
+  store;
+  async startExperiment(name, metadata) {
+    const exp = {
+      id: `exp_${rand(8)}`,
+      name,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata
+    };
+    await this.store.saveExperiment(exp);
+    return exp;
   }
-  async getRun(id) {
-    const idx = await this.load();
-    return idx.getRun(id);
+  async startRun(config) {
+    const exp = await this.store.getExperiment(config.experimentId);
+    if (!exp) throw new Error(`Experiment ${config.experimentId} not found`);
+    const run = {
+      id: `run_${rand(10)}`,
+      experimentId: config.experimentId,
+      name: config.name,
+      config,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "running"
+    };
+    await this.store.saveRun(run);
+    return run;
   }
-  async listRuns(experimentId) {
-    const idx = await this.load();
-    return idx.listRuns(experimentId);
+  async completeRun(runId, report) {
+    const run = await this.store.getRun(runId);
+    if (!run) throw new Error(`Run ${runId} not found`);
+    run.status = "completed";
+    run.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    run.report = report;
+    await this.store.saveRun(run);
   }
-  async ensureDir() {
-    const fs2 = await import("fs/promises");
-    await fs2.mkdir(this.dir, { recursive: true });
+  async failRun(runId, error) {
+    const run = await this.store.getRun(runId);
+    if (!run) throw new Error(`Run ${runId} not found`);
+    run.status = "failed";
+    run.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    run.error = error;
+    await this.store.saveRun(run);
   }
-  async append(name, record) {
-    await this.ensureDir();
-    const fs2 = await import("fs/promises");
-    const path = await import("path");
-    const active = path.join(this.dir, `${name}.ndjson`);
-    try {
-      const stat = await fs2.stat(active);
-      if (stat.size >= this.maxBytes) {
-        const rolled = path.join(this.dir, `${name}.${Date.now()}.ndjson`);
-        await fs2.rename(active, rolled);
+  /**
+   * Diff two completed runs. Returns per-scenario deltas, aggregate delta,
+   * and config changes that may explain the movement.
+   */
+  async diff(runIdA, runIdB) {
+    const [a, b] = await Promise.all([this.store.getRun(runIdA), this.store.getRun(runIdB)]);
+    if (!a || !b) throw new Error("Both runs must exist");
+    if (!a.report || !b.report) throw new Error("Both runs must be completed with reports");
+    const byScenarioA = new Map(a.report.results.map((r) => [r.scenarioId, r.overallScore]));
+    const byScenarioB = new Map(b.report.results.map((r) => [r.scenarioId, r.overallScore]));
+    const scenarioIds = /* @__PURE__ */ new Set([...byScenarioA.keys(), ...byScenarioB.keys()]);
+    const scenarios = [];
+    for (const id of scenarioIds) {
+      const aScore = byScenarioA.get(id);
+      const bScore = byScenarioB.get(id);
+      if (aScore === void 0) {
+        scenarios.push({
+          scenarioId: id,
+          before: null,
+          after: bScore,
+          delta: null,
+          status: "added"
+        });
+      } else if (bScore === void 0) {
+        scenarios.push({
+          scenarioId: id,
+          before: aScore,
+          after: null,
+          delta: null,
+          status: "removed"
+        });
+      } else {
+        scenarios.push({
+          scenarioId: id,
+          before: aScore,
+          after: bScore,
+          delta: bScore - aScore,
+          status: bScore > aScore ? "improved" : bScore < aScore ? "regressed" : "unchanged"
+        });
       }
-    } catch {
-    }
-    await fs2.appendFile(active, `${JSON.stringify(record)}
-`, "utf8");
-  }
-  async load() {
-    if (this.loaded && this.index) return this.index;
-    const fs2 = await import("fs/promises");
-    const path = await import("path");
-    const store = new InMemoryExperimentStore();
-    try {
-      const entries = await fs2.readdir(this.dir);
-      const sorted = entries.filter((f) => f.endsWith(".ndjson")).sort((a, b) => a.localeCompare(b));
-      for (const file of sorted) {
-        const full = path.join(this.dir, file);
-        const content = await fs2.readFile(full, "utf8");
-        const base = file.split(".")[0];
-        for (const line of content.split("\n")) {
-          if (!line.trim()) continue;
-          let record;
-          try {
-            record = JSON.parse(line);
-          } catch {
-            continue;
-          }
-          if (base === "experiments") {
-            await store.saveExperiment(record);
-          } else if (base === "runs") {
-            await store.saveRun(record);
-          }
-        }
+    }
+    scenarios.sort((x, y) => (y.delta ?? 0) - (x.delta ?? 0));
+    const aggregateDelta = b.report.summary.overallAvg - a.report.summary.overallAvg;
+    const configChanges = {};
+    const keys = /* @__PURE__ */ new Set([...Object.keys(a.config), ...Object.keys(b.config)]);
+    const aCfg = a.config;
+    const bCfg = b.config;
+    for (const k of keys) {
+      if (JSON.stringify(aCfg[k]) !== JSON.stringify(bCfg[k])) {
+        configChanges[k] = { before: aCfg[k], after: bCfg[k] };
       }
-    } catch {
     }
-    this.index = store;
-    this.loaded = true;
-    return store;
+    return {
+      before: { runId: runIdA, name: a.name, startedAt: a.startedAt },
+      after: { runId: runIdB, name: b.name, startedAt: b.startedAt },
+      aggregateDelta,
+      scenarios,
+      configChanges
+    };
+  }
+  /** Timeline of aggregate scores for an experiment. */
+  async timeline(experimentId) {
+    const runs = await this.store.listRuns(experimentId);
+    return runs.slice().sort((a, b) => a.startedAt.localeCompare(b.startedAt)).map((r) => ({
+      runId: r.id,
+      startedAt: r.startedAt,
+      overall: r.report?.summary.overallAvg ?? null
+    }));
   }
 };
-
-// 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;
+function rand(bytes) {
+  const arr = new Uint8Array(bytes);
+  crypto.getRandomValues(arr);
+  return Array.from(arr).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 
-// 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;
+// src/experiment-tracker-d1.ts
+var SCHEMA_VERSION = 1;
+var D1ExperimentStore = class {
+  db;
+  experimentsTable;
+  runsTable;
+  metaTable;
+  schemaReady = false;
+  constructor(options) {
+    this.db = options.db;
+    const prefix = options.tablePrefix ?? "agent_eval_";
+    this.experimentsTable = `${prefix}experiments`;
+    this.runsTable = `${prefix}runs`;
+    this.metaTable = `${prefix}meta`;
   }
-  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 });
+  /**
+   * Idempotent schema setup. Safe to call before every operation; the second
+   * call short-circuits via `schemaReady`. Most consumers will call it once
+   * during Worker bootstrap.
+   */
+  async ensureSchema() {
+    if (this.schemaReady) return;
+    const ddl = `
+      CREATE TABLE IF NOT EXISTS ${this.experimentsTable} (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        metadata_json TEXT
+      );
+      CREATE TABLE IF NOT EXISTS ${this.runsTable} (
+        id TEXT PRIMARY KEY,
+        experiment_id TEXT NOT NULL,
+        name TEXT,
+        status TEXT NOT NULL,
+        started_at TEXT NOT NULL,
+        completed_at TEXT,
+        config_json TEXT NOT NULL,
+        report_json TEXT,
+        error TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_${this.runsTable}_experiment ON ${this.runsTable}(experiment_id);
+      CREATE INDEX IF NOT EXISTS idx_${this.runsTable}_started ON ${this.runsTable}(started_at);
+      CREATE TABLE IF NOT EXISTS ${this.metaTable} (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      INSERT OR REPLACE INTO ${this.metaTable}(key, value) VALUES ('schema_version', '${SCHEMA_VERSION}');
+    `;
+    await this.db.exec(ddl.trim().replace(/\s+/g, " "));
+    this.schemaReady = true;
   }
-  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
-    };
+  async saveExperiment(exp) {
+    await this.ensureSchema();
+    await this.db.prepare(
+      `INSERT INTO ${this.experimentsTable}(id, name, created_at, metadata_json)
+         VALUES (?1, ?2, ?3, ?4)
+         ON CONFLICT(id) DO UPDATE SET
+           name = excluded.name,
+           created_at = excluded.created_at,
+           metadata_json = excluded.metadata_json`
+    ).bind(exp.id, exp.name, exp.createdAt, exp.metadata ? JSON.stringify(exp.metadata) : null).run();
+  }
+  async getExperiment(id) {
+    await this.ensureSchema();
+    const row = await this.db.prepare(
+      `SELECT id, name, created_at, metadata_json
+         FROM ${this.experimentsTable}
+         WHERE id = ?1`
+    ).bind(id).first();
+    return row ? rowToExperiment(row) : null;
+  }
+  async listExperiments() {
+    await this.ensureSchema();
+    const { results } = await this.db.prepare(
+      `SELECT id, name, created_at, metadata_json
+         FROM ${this.experimentsTable}
+         ORDER BY created_at DESC`
+    ).all();
+    return results.map(rowToExperiment);
+  }
+  async saveRun(run) {
+    await this.ensureSchema();
+    await this.db.prepare(
+      `INSERT INTO ${this.runsTable}(id, experiment_id, name, status, started_at, completed_at, config_json, report_json, error)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)
+         ON CONFLICT(id) DO UPDATE SET
+           experiment_id = excluded.experiment_id,
+           name = excluded.name,
+           status = excluded.status,
+           started_at = excluded.started_at,
+           completed_at = excluded.completed_at,
+           config_json = excluded.config_json,
+           report_json = excluded.report_json,
+           error = excluded.error`
+    ).bind(
+      run.id,
+      run.experimentId,
+      run.name ?? null,
+      run.status,
+      run.startedAt,
+      run.completedAt ?? null,
+      JSON.stringify(run.config),
+      run.report ? JSON.stringify(run.report) : null,
+      run.error ?? null
+    ).run();
   }
-  rank(score) {
-    return aggregateRunScore(score, this.weights);
+  async getRun(id) {
+    await this.ensureSchema();
+    const row = await this.db.prepare(
+      `SELECT id, experiment_id, name, status, started_at, completed_at, config_json, report_json, error
+         FROM ${this.runsTable}
+         WHERE id = ?1`
+    ).bind(id).first();
+    return row ? rowToRun(row) : null;
   }
-  isDrift(text) {
-    return this.driftPatterns.some((pattern) => pattern.test(text));
+  async listRuns(experimentId) {
+    await this.ensureSchema();
+    const { results } = await this.db.prepare(
+      `SELECT id, experiment_id, name, status, started_at, completed_at, config_json, report_json, error
+         FROM ${this.runsTable}
+         WHERE experiment_id = ?1
+         ORDER BY started_at DESC`
+    ).bind(experimentId).all();
+    return results.map(rowToRun);
   }
 };
-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 rowToExperiment(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    createdAt: row.created_at,
+    ...row.metadata_json ? { metadata: JSON.parse(row.metadata_json) } : {}
+  };
 }
-function positiveNumber(value) {
-  return typeof value === "number" && value > 0;
+function rowToRun(row) {
+  return {
+    id: row.id,
+    experimentId: row.experiment_id,
+    ...row.name ? { name: row.name } : {},
+    status: row.status,
+    startedAt: row.started_at,
+    ...row.completed_at ? { completedAt: row.completed_at } : {},
+    config: JSON.parse(row.config_json),
+    ...row.report_json ? { report: JSON.parse(row.report_json) } : {},
+    ...row.error ? { error: row.error } : {}
+  };
 }
 
+// src/experiment-tracker-fs.ts
+var FileSystemExperimentStore = class {
+  dir;
+  maxBytes;
+  index;
+  loaded = false;
+  constructor(options) {
+    this.dir = options.dir;
+    this.maxBytes = options.maxBytes ?? 32 * 1024 * 1024;
+  }
+  async saveExperiment(exp) {
+    const idx = await this.load();
+    await idx.saveExperiment(exp);
+    await this.append("experiments", exp);
+  }
+  async getExperiment(id) {
+    const idx = await this.load();
+    return idx.getExperiment(id);
+  }
+  async listExperiments() {
+    const idx = await this.load();
+    return idx.listExperiments();
+  }
+  async saveRun(run) {
+    const idx = await this.load();
+    await idx.saveRun(run);
+    await this.append("runs", run);
+  }
+  async getRun(id) {
+    const idx = await this.load();
+    return idx.getRun(id);
+  }
+  async listRuns(experimentId) {
+    const idx = await this.load();
+    return idx.listRuns(experimentId);
+  }
+  async ensureDir() {
+    const fs2 = await import("fs/promises");
+    await fs2.mkdir(this.dir, { recursive: true });
+  }
+  async append(name, record) {
+    await this.ensureDir();
+    const fs2 = await import("fs/promises");
+    const path = await import("path");
+    const active = path.join(this.dir, `${name}.ndjson`);
+    try {
+      const stat = await fs2.stat(active);
+      if (stat.size >= this.maxBytes) {
+        const rolled = path.join(this.dir, `${name}.${Date.now()}.ndjson`);
+        await fs2.rename(active, rolled);
+      }
+    } catch {
+    }
+    await fs2.appendFile(active, `${JSON.stringify(record)}
+`, "utf8");
+  }
+  async load() {
+    if (this.loaded && this.index) return this.index;
+    const fs2 = await import("fs/promises");
+    const path = await import("path");
+    const store = new InMemoryExperimentStore();
+    try {
+      const entries = await fs2.readdir(this.dir);
+      const sorted = entries.filter((f) => f.endsWith(".ndjson")).sort((a, b) => a.localeCompare(b));
+      for (const file of sorted) {
+        const full = path.join(this.dir, file);
+        const content = await fs2.readFile(full, "utf8");
+        const base = file.split(".")[0];
+        for (const line of content.split("\n")) {
+          if (!line.trim()) continue;
+          let record;
+          try {
+            record = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          if (base === "experiments") {
+            await store.saveExperiment(record);
+          } else if (base === "runs") {
+            await store.saveRun(record);
+          }
+        }
+      }
+    } catch {
+    }
+    this.index = store;
+    this.loaded = true;
+    return store;
+  }
+};
+
 // src/harness-optimizer.ts
 var DEFAULT_HARNESS_OBJECTIVES = [
   { name: "aggregate", direction: "maximize", value: (r) => r.aggregateMean },
@@ -3944,7 +5246,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*\*.*$/, "");
@@ -4058,7 +5360,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);
@@ -4077,7 +5379,7 @@ function autoDeriveImporters(repoRoot, roots, extensions, importsContain) {
           continue;
         let text;
         try {
-          text = readFileSync(subAbs, "utf8");
+          text = readFileSync2(subAbs, "utf8");
         } catch {
           continue;
         }
@@ -4093,8 +5395,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);
   }
@@ -4108,8 +5410,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));
     }
   }
@@ -4956,326 +6258,6 @@ function seededShuffle(items, seed) {
   return out;
 }
 
-// src/judge-calibration.ts
-function calibrateJudge(golden, candidate) {
-  const map = /* @__PURE__ */ new Map();
-  for (const g of golden) map.set(g.itemId, { h: g.humanScore, j: NaN });
-  for (const c of candidate) {
-    const entry = map.get(c.itemId);
-    if (entry) entry.j = c.score;
-  }
-  const common = [...map.values()].filter((v) => Number.isFinite(v.j));
-  const n = common.length;
-  if (n < 2) {
-    return { n, pearson: NaN, kappa: NaN, mae: NaN, worstItems: [] };
-  }
-  const humans = common.map((c) => c.h);
-  const judges = common.map((c) => c.j);
-  const pearson = pearsonR(humans, judges);
-  const kappa = weightedKappa(humans.map(Math.round), judges.map(Math.round));
-  const absDiffs = common.map((c) => Math.abs(c.j - c.h));
-  const mae = absDiffs.reduce((a, b) => a + b, 0) / n;
-  const worst2 = [...map.entries()].filter(([, v]) => Number.isFinite(v.j)).map(([itemId, v]) => ({ itemId, judge: v.j, human: v.h, delta: Math.abs(v.j - v.h) })).sort((a, b) => b.delta - a.delta).slice(0, 5);
-  return { n, pearson, kappa, mae, worstItems: worst2 };
-}
-function positionalBias(scores) {
-  const pairs = /* @__PURE__ */ new Map();
-  for (const s of scores) {
-    const slot = pairs.get(s.itemId) ?? {};
-    if (s.positionOfAInput === "first") slot.first = s.score;
-    else if (s.positionOfAInput === "second") slot.second = s.score;
-    pairs.set(s.itemId, slot);
-  }
-  const deltas = [];
-  for (const { first, second } of pairs.values()) {
-    if (first !== void 0 && second !== void 0) deltas.push(first - second);
-  }
-  if (deltas.length === 0) return { avgDelta: 0, n: 0 };
-  return { avgDelta: deltas.reduce((a, b) => a + b, 0) / deltas.length, n: deltas.length };
-}
-function verbosityBias(samples) {
-  const n = samples.length;
-  if (n < 3) return { pearson: NaN, n };
-  return {
-    pearson: pearsonR(
-      samples.map((s) => s.outputLen),
-      samples.map((s) => s.score)
-    ),
-    n
-  };
-}
-function selfPreference(samples) {
-  const inF = samples.filter((s) => s.inFamily).map((s) => s.score);
-  const outF = samples.filter((s) => !s.inFamily).map((s) => s.score);
-  if (inF.length === 0 || outF.length === 0)
-    return { inFamilyMean: 0, outOfFamilyMean: 0, deltaMean: 0, n: 0 };
-  const inMean = inF.reduce((a, b) => a + b, 0) / inF.length;
-  const outMean = outF.reduce((a, b) => a + b, 0) / outF.length;
-  return {
-    inFamilyMean: inMean,
-    outOfFamilyMean: outMean,
-    deltaMean: inMean - outMean,
-    n: samples.length
-  };
-}
-function pearsonR(a, b) {
-  if (a.length !== b.length || a.length < 2) return NaN;
-  const mA = a.reduce((s, v) => s + v, 0) / a.length;
-  const mB = b.reduce((s, v) => s + v, 0) / b.length;
-  let num = 0, dA = 0, dB = 0;
-  for (let i = 0; i < a.length; i++) {
-    const da = a[i] - mA;
-    const db = b[i] - mB;
-    num += da * db;
-    dA += da * da;
-    dB += db * db;
-  }
-  if (dA === 0 || dB === 0) return dA === 0 && dB === 0 ? 1 : 0;
-  return num / Math.sqrt(dA * dB);
-}
-function weightedKappa(a, b) {
-  if (a.length !== b.length || a.length === 0) return NaN;
-  const min = Math.min(...a, ...b);
-  const max = Math.max(...a, ...b);
-  const K = max - min + 1;
-  if (K < 2) return 1;
-  const observed = Array.from({ length: K }, () => new Array(K).fill(0));
-  const rowMarg = new Array(K).fill(0);
-  const colMarg = new Array(K).fill(0);
-  for (let i = 0; i < a.length; i++) {
-    const ai = a[i] - min;
-    const bi = b[i] - min;
-    const row = observed[ai];
-    row[bi] = (row[bi] ?? 0) + 1;
-    rowMarg[ai]++;
-    colMarg[bi]++;
-  }
-  let num = 0;
-  let den = 0;
-  for (let i = 0; i < K; i++) {
-    for (let j = 0; j < K; j++) {
-      const w = (i - j) ** 2 / (K - 1) ** 2;
-      const expected = rowMarg[i] * colMarg[j] / a.length;
-      num += w * observed[i][j];
-      den += w * expected;
-    }
-  }
-  if (den === 0) return 1;
-  return 1 - num / den;
-}
-function continuousAgreement(scores, opts = {}) {
-  const bootstrap = opts.bootstrap ?? 1e3;
-  const weights = opts.weights ?? "quadratic";
-  const seed = opts.seed ?? 12648430;
-  const ciLevel = opts.ciLevel ?? 0.95;
-  const matrix = scores.filter((row) => row.length >= 2 && row.every((v) => Number.isFinite(v)));
-  const raters = matrix[0]?.length ?? 0;
-  const clean = matrix.filter((row) => row.length === raters);
-  const nClean = clean.length;
-  if (nClean < 2 || raters < 2) {
-    return {
-      weightedKappa: NaN,
-      icc: NaN,
-      pearson: NaN,
-      spearman: NaN,
-      ci: { icc: [NaN, NaN], weightedKappa: [NaN, NaN] },
-      n: nClean,
-      raters
-    };
-  }
-  const kappa = continuousWeightedKappa(clean, weights);
-  const icc = icc21(clean);
-  const pearson = avgPairwise(clean, pearsonR);
-  const spearman = avgPairwise(clean, spearmanR);
-  const ciIcc = [NaN, NaN];
-  const ciKappa = [NaN, NaN];
-  if (bootstrap > 0) {
-    const rng = mulberry32(seed);
-    const iccs = [];
-    const kappas = [];
-    for (let b = 0; b < bootstrap; b++) {
-      const sample = new Array(nClean);
-      for (let i = 0; i < nClean; i++) {
-        sample[i] = clean[Math.floor(rng() * nClean)];
-      }
-      const iccB = icc21(sample);
-      const kB = continuousWeightedKappa(sample, weights);
-      if (Number.isFinite(iccB)) iccs.push(iccB);
-      if (Number.isFinite(kB)) kappas.push(kB);
-    }
-    const [lo, hi] = percentileBounds(ciLevel);
-    if (iccs.length > 0) {
-      iccs.sort((a, b) => a - b);
-      ciIcc[0] = quantile(iccs, lo);
-      ciIcc[1] = quantile(iccs, hi);
-    }
-    if (kappas.length > 0) {
-      kappas.sort((a, b) => a - b);
-      ciKappa[0] = quantile(kappas, lo);
-      ciKappa[1] = quantile(kappas, hi);
-    }
-  }
-  return {
-    weightedKappa: kappa,
-    icc,
-    pearson,
-    spearman,
-    ci: { icc: ciIcc, weightedKappa: ciKappa },
-    n: nClean,
-    raters
-  };
-}
-function calibrateJudgeContinuous(golden, candidate, opts = {}) {
-  const base = calibrateJudge(golden, candidate);
-  const map = /* @__PURE__ */ new Map();
-  for (const g of golden) map.set(g.itemId, { h: g.humanScore, j: NaN });
-  for (const c of candidate) {
-    const entry = map.get(c.itemId);
-    if (entry) entry.j = c.score;
-  }
-  const rows = [];
-  for (const v of map.values()) {
-    if (Number.isFinite(v.j)) rows.push([v.h, v.j]);
-  }
-  const agreement = continuousAgreement(rows, opts);
-  return {
-    ...base,
-    weightedKappaContinuous: agreement.weightedKappa,
-    icc: agreement.icc,
-    spearman: agreement.spearman,
-    ci: agreement.ci
-  };
-}
-function continuousWeightedKappa(rows, scheme) {
-  if (rows.length === 0) return NaN;
-  const raters = rows[0].length;
-  if (raters < 2) return NaN;
-  const wFn = scheme === "linear" ? (x, y) => Math.abs(x - y) : (x, y) => (x - y) ** 2;
-  let sum2 = 0;
-  let pairs = 0;
-  for (let r1 = 0; r1 < raters; r1++) {
-    for (let r2 = r1 + 1; r2 < raters; r2++) {
-      const a = rows.map((row) => row[r1]);
-      const b = rows.map((row) => row[r2]);
-      const n = a.length;
-      let obs = 0;
-      for (let i = 0; i < n; i++) obs += wFn(a[i], b[i]);
-      obs /= n;
-      let exp = 0;
-      for (let i = 0; i < n; i++) {
-        for (let j = 0; j < n; j++) exp += wFn(a[i], b[j]);
-      }
-      exp /= n * n;
-      if (exp === 0) {
-        sum2 += obs === 0 ? 1 : 0;
-      } else {
-        sum2 += 1 - obs / exp;
-      }
-      pairs++;
-    }
-  }
-  return pairs === 0 ? NaN : sum2 / pairs;
-}
-function icc21(rows) {
-  const n = rows.length;
-  if (n < 2) return NaN;
-  const k = rows[0].length;
-  if (k < 2) return NaN;
-  const rowMeans = rows.map((row) => row.reduce((s, v) => s + v, 0) / k);
-  const colMeans = new Array(k).fill(0);
-  for (let j = 0; j < k; j++) {
-    let s = 0;
-    for (let i = 0; i < n; i++) s += rows[i][j];
-    colMeans[j] = s / n;
-  }
-  let grand = 0;
-  for (let i = 0; i < n; i++) grand += rowMeans[i];
-  grand /= n;
-  let ssR = 0;
-  for (let i = 0; i < n; i++) ssR += (rowMeans[i] - grand) ** 2;
-  ssR *= k;
-  let ssC = 0;
-  for (let j = 0; j < k; j++) ssC += (colMeans[j] - grand) ** 2;
-  ssC *= n;
-  let ssT = 0;
-  for (let i = 0; i < n; i++) {
-    for (let j = 0; j < k; j++) ssT += (rows[i][j] - grand) ** 2;
-  }
-  const ssE = ssT - ssR - ssC;
-  const dfR = n - 1;
-  const dfC = k - 1;
-  const dfE = (n - 1) * (k - 1);
-  const msR = ssR / dfR;
-  const msC = ssC / dfC;
-  const msE = dfE > 0 ? ssE / dfE : 0;
-  const denom = msR + (k - 1) * msE + k * (msC - msE) / n;
-  if (denom === 0) {
-    return msR === 0 && msE === 0 ? 1 : 0;
-  }
-  return (msR - msE) / denom;
-}
-function avgPairwise(rows, fn) {
-  const k = rows[0]?.length ?? 0;
-  if (k < 2) return NaN;
-  let sum2 = 0;
-  let pairs = 0;
-  for (let i = 0; i < k; i++) {
-    for (let j = i + 1; j < k; j++) {
-      const a = rows.map((row) => row[i]);
-      const b = rows.map((row) => row[j]);
-      const r = fn(a, b);
-      if (Number.isFinite(r)) {
-        sum2 += r;
-        pairs++;
-      }
-    }
-  }
-  return pairs === 0 ? NaN : sum2 / pairs;
-}
-function spearmanR(a, b) {
-  if (a.length !== b.length || a.length < 2) return NaN;
-  return pearsonR(rankWithTies(a), rankWithTies(b));
-}
-function rankWithTies(xs) {
-  const n = xs.length;
-  const indexed = xs.map((v, i2) => ({ v, i: i2 }));
-  indexed.sort((x, y) => x.v - y.v);
-  const ranks = new Array(n).fill(0);
-  let i = 0;
-  while (i < n) {
-    let j = i;
-    while (j + 1 < n && indexed[j + 1].v === indexed[i].v) j++;
-    const avg = (i + j) / 2 + 1;
-    for (let k = i; k <= j; k++) ranks[indexed[k].i] = avg;
-    i = j + 1;
-  }
-  return ranks;
-}
-function mulberry32(seed) {
-  let a = seed >>> 0;
-  return () => {
-    a = a + 1831565813 >>> 0;
-    let t = a;
-    t = Math.imul(t ^ t >>> 15, t | 1);
-    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
-}
-function percentileBounds(ciLevel) {
-  const tail = (1 - ciLevel) / 2;
-  return [tail, 1 - tail];
-}
-function quantile(sorted, q) {
-  if (sorted.length === 0) return NaN;
-  if (sorted.length === 1) return sorted[0];
-  const pos = q * (sorted.length - 1);
-  const lo = Math.floor(pos);
-  const hi = Math.ceil(pos);
-  if (lo === hi) return sorted[lo];
-  const frac = pos - lo;
-  return sorted[lo] * (1 - frac) + sorted[hi] * frac;
-}
-
 // src/observability.ts
 async function toLangfuseEnvelope(store, runId) {
   const run = await store.getRun(runId);
@@ -6077,7 +7059,7 @@ async function proposeSynthesisTargets(dataset, traceStore, options = {}) {
     runCountByScenario.set(r.scenarioId, (runCountByScenario.get(r.scenarioId) ?? 0) + 1);
   }
   const runCounts = [...runCountByScenario.values()];
-  const p25 = runCounts.length > 0 ? quantile2(runCounts, 0.25) : 0;
+  const p25 = runCounts.length > 0 ? quantile(runCounts, 0.25) : 0;
   for (const s of scenarios) {
     const count = runCountByScenario.get(s.id) ?? 0;
     if (count <= p25 && count < 3) {
@@ -6131,7 +7113,7 @@ async function proposeSynthesisTargets(dataset, traceStore, options = {}) {
   }
   return targets.sort((a, b) => b.priority - a.priority).slice(0, topK);
 }
-function quantile2(xs, p) {
+function quantile(xs, p) {
   const sorted = [...xs].sort((a, b) => a - b);
   const idx = p * (sorted.length - 1);
   const lo = Math.floor(idx);
@@ -6326,7 +7308,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",
@@ -6355,11 +7337,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;
     }
@@ -6713,11 +7695,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,
@@ -6727,12 +7709,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 ?? "";
@@ -6751,10 +7733,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
@@ -6782,11 +7764,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) {
@@ -6810,7 +7792,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,
@@ -7270,72 +8252,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) {
@@ -7453,14 +8392,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);
       });
     }
@@ -7803,7 +8742,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();
@@ -7958,202 +8897,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 = [
@@ -8352,8 +9095,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);
@@ -8567,44 +9310,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) {
@@ -8634,16 +9341,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);
@@ -8655,9 +9362,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);
@@ -8671,8 +9378,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, "");
           }
@@ -8738,9 +9445,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") {
@@ -8909,7 +9616,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();
@@ -8917,8 +9624,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);
@@ -9306,8 +10013,10 @@ function aggregateTrialsByMode(trials, opts) {
   };
 }
 export {
+  ANALYST_SEVERITIES,
   AgentDriver,
   AgentEvalError,
+  AnalystRegistry,
   AxGepaSteeringOptimizer,
   BENCHMARK_SPLIT_SEED,
   BenchmarkRunner,
@@ -9331,19 +10040,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,
@@ -9354,6 +10067,8 @@ export {
   JsonlTrialCache,
   JudgeError,
   JudgeRunner,
+  KNOWLEDGE_GAP_KIND_SPEC,
+  KNOWLEDGE_POISONING_KIND_SPEC,
   LineageRecorder,
   LlmCallError,
   LlmClient,
@@ -9371,8 +10086,10 @@ export {
   PairwiseSteeringOptimizer,
   ProductClient,
   PromptRegistry,
+  RAW_FINDING_SCHEMA_PROMPT,
   REDACTION_VERSION,
   RESEARCH_REPORT_HARD_PAIR_FLOOR,
+  RawAnalystFindingSchema,
   ReplayCache,
   ReplayCacheMissError,
   ReplayError,
@@ -9414,6 +10131,7 @@ export {
   bootstrapCi,
   buildReflectionPrompt,
   buildReviewerPrompt,
+  buildTraceToolsForGroup,
   buildTrajectory,
   byteLengthRange,
   calibrateJudge,
@@ -9439,6 +10157,7 @@ export {
   compilerJudge,
   composeParsers,
   composeValidators,
+  computeFindingId,
   computeToolUseMetrics,
   confidenceInterval,
   containsAll,
@@ -9446,27 +10165,38 @@ export {
   controlFailureClassFromVerification,
   controlRunToFeedbackTrajectory,
   controlRunToRunRecord,
+  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,
@@ -9535,12 +10265,14 @@ export {
   judgeSpans,
   keyPreserved,
   knowledgeReadinessTracePayload,
+  liftSeverity,
   linterJudge,
   llmSpanFromProvider,
   llmSpans,
   loadScorerFromGrader,
   localCommandRunner,
   lowercaseMutator,
+  makeFinding,
   mannWhitneyU,
   matchGoldens,
   mergeLayerResults,
@@ -9560,6 +10292,7 @@ export {
   paretoFrontier,
   paretoFrontierWithCrowding,
   parseFeedbackTrajectoriesJsonl,
+  parseRawFinding,
   parseReflectionResponse,
   parseRunRecordSafe,
   partialCredit,