@tangle-network/agent-eval 0.71.0 → 0.72.3

package/dist/index.js

@@ -1,6 +1,17 @@
 import {
-  agentProfileHash
-} from "./chunk-PQV2TKC3.js";
+  MODEL_PRICING,
+  MetricsCollector,
+  TokenCounter,
+  agentProfileHash,
+  createLlmCorrectnessChecker,
+  estimateCost,
+  estimateTokens,
+  extractProducedState,
+  isModelPriced,
+  parseCorrectnessResponse,
+  resolveModelPricing,
+  verifyCompletion
+} from "./chunk-LB2UOI5F.js";
 import {
   HoldoutAuditor,
   canaryLeakView,
@@ -31,12 +42,12 @@ import {
   scoreRedTeamOutput,
   surfaceContentHash,
   toolNamesForRun
-} from "./chunk-VMAYE3LM.js";
+} from "./chunk-JYE3WOTE.js";
 import {
   BackendIntegrityError,
   assertRealBackend,
   summarizeBackendIntegrity
-} from "./chunk-6XQIEUQ2.js";
+} from "./chunk-ZPSKPT3V.js";
 import {
   BENCHMARK_SPLIT_SEED,
   benchmarks_exports,
@@ -82,6 +93,40 @@ import {
   scoreKnowledgeReadiness,
   userQuestionsForKnowledgeGaps
 } from "./chunk-3CKU6VGU.js";
+import {
+  DEFAULT_COMPLEXITY_WEIGHTS,
+  DEFAULT_RUN_SCORE_WEIGHTS,
+  FindingsStore,
+  LockedJsonlAppender,
+  Mutex,
+  RunCritic,
+  SEMANTIC_CONCEPT_JUDGE_VERSION,
+  SKILL_USAGE_ANALYST,
+  SkillUsageAnalyst,
+  aggregateRunScore,
+  buildDefaultAnalystRegistry,
+  clamp01,
+  computeTraceMetrics,
+  createAnalystAi,
+  createChatClient,
+  createSemanticConceptJudge,
+  defaultIsMaterial,
+  diffFindings,
+  resetLockedAppendersForTesting,
+  runSemanticConceptJudge
+} from "./chunk-7W4SM7FD.js";
+import {
+  AnalystRegistry,
+  DEFAULT_TRACE_ANALYST_KINDS,
+  FAILURE_MODE_KIND_SPEC,
+  IMPROVEMENT_KIND_SPEC,
+  KNOWLEDGE_GAP_KIND_SPEC,
+  KNOWLEDGE_POISONING_KIND_SPEC,
+  computeFindingId,
+  createTraceAnalystKind,
+  makeFinding,
+  renderPriorFindings
+} from "./chunk-WYIHD6EB.js";
 import {
   controlFailureClassFromVerification,
   controlRunToRunRecord,
@@ -110,26 +155,19 @@ import {
 } from "./chunk-B26KI423.js";
 import {
   runEvalCampaign
-} from "./chunk-AIWHLG7J.js";
+} from "./chunk-GJJNJVIR.js";
 import {
-  AGENT_PROFILE_KINDS,
-  AgentProfileCellValidationError,
-  RunRecordValidationError,
-  agentProfileCellHashMaterial,
-  agentProfileCellKey,
-  assertRunAgentProfileCell,
-  buildAgentProfileCell,
-  buildSandboxAgentProfileCell,
-  groupRunsByAgentProfileCell,
-  isRunRecord,
-  parseRunRecordSafe,
-  requireAgentProfileCell,
-  roundTripRunRecord,
-  toAgentProfileJson,
-  validateAgentProfileCell,
-  validateRunRecord,
-  verifyAgentProfileCell
-} from "./chunk-F3SRAAZO.js";
+  LlmCallError,
+  LlmClient,
+  LlmRouteAssertionError,
+  assertLlmRoute,
+  backoffMs,
+  callLlm,
+  callLlmJson,
+  isTransientLlmError,
+  probeLlm,
+  stripFencedJson
+} from "./chunk-IHDHUN2X.js";
 import {
   evaluateInterimReleaseConfidence,
   pairedEvalueSequence
@@ -165,2113 +203,139 @@ import {
   selfPreference,
   verbosityBias,
   weightedComposite,
-  weightedMean,
-  wilcoxonSignedRank
-} from "./chunk-ITBRCT73.js";
-import {
-  DEFAULT_TRACE_ANALYST_BUDGETS,
-  FileSystemTraceStore,
-  InMemoryTraceStore,
-  OTEL_AGENT_EVAL_SCOPE,
-  OtlpFileTraceStore,
-  ReplayCache,
-  ReplayCacheMissError,
-  SpanNotFoundError,
-  TRACE_ANALYST_ACTOR_DESCRIPTION,
-  TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION,
-  TRACE_ANALYST_SUBAGENT_DESCRIPTION,
-  TRACE_ANALYST_TRUNCATION_MARKER_PREFIX,
-  TraceFileMissingError,
-  TraceNotFoundError,
-  analyzeTraces,
-  buildTraceAnalystTools,
-  buildTraceInsightContext,
-  buildTraceInsightPrompt,
-  captureFetchToRawSink,
-  createOtelExporter,
-  createOtelTracingStore,
-  createReplayFetch,
-  defaultTraceInsightPanel,
-  describeTraceInsightScope,
-  domainEvidencePattern,
-  exportRunAsOtlp,
-  flattenOtlpExportToNdjson,
-  inferDomainKeywords,
-  iterateRawCalls,
-  otelRunCompleteHook,
-  planTraceInsightQuestions,
-  scoreTraceInsightReadiness,
-  tokenizeDomainWords,
-  traceAnalystFunctionGroup,
-  traceAnalystOnRunComplete
-} from "./chunk-ODGETRTM.js";
-import {
-  DEFAULT_REDACTION_RULES,
-  REDACTION_VERSION,
-  redactString,
-  redactValue
-} from "./chunk-GGE4NNQT.js";
-import {
-  aggregateLlm,
-  argHash,
-  groupBy,
-  judgeSpans,
-  llmSpans,
-  runFailureClass,
-  runsForScenario,
-  toolSpans
-} from "./chunk-47X6LRCE.js";
-import {
-  FAILURE_CLASSES,
-  TRACE_SCHEMA_VERSION,
-  isJudgeSpan,
-  isLlmSpan,
-  isRetrievalSpan,
-  isSandboxSpan,
-  isToolSpan
-} from "./chunk-5BKGXME7.js";
-import {
-  RunIntegrityError,
-  assertRunCaptured,
-  throwIfRunIncomplete
-} from "./chunk-SBCB6VZY.js";
-import {
-  TraceEmitter,
-  llmSpanFromProvider
-} from "./chunk-TVVP3ZZQ.js";
-import {
-  canonicalize,
-  evaluateHypothesis,
-  hashJson,
-  signManifest,
-  verifyManifest
-} from "./chunk-VSMTAMNK.js";
-import {
-  LlmCallError,
-  LlmClient,
-  LlmRouteAssertionError,
-  assertLlmRoute,
-  backoffMs,
-  callLlm,
-  callLlmJson,
-  isTransientLlmError,
-  probeLlm,
-  stripFencedJson
-} from "./chunk-IHDHUN2X.js";
-import {
-  FileSystemRawProviderSink,
-  InMemoryRawProviderSink,
-  NoopRawProviderSink,
-  defaultProviderRedactor,
-  providerFromBaseUrl
-} from "./chunk-PC4UYEBM.js";
-import {
-  AgentEvalError,
-  CaptureIntegrityError,
-  ConfigError,
-  JudgeError,
-  NotFoundError,
-  ReplayError,
-  ValidationError,
-  VerificationError
-} from "./chunk-3BFEG2F6.js";
-import {
-  __export
-} from "./chunk-PZ5AY32C.js";
-
-// src/run-score.ts
-var DEFAULT_RUN_SCORE_WEIGHTS = {
-  success: 4,
-  goalProgress: 2,
-  repoGroundedness: 1.5,
-  driftPenalty: -1.5,
-  toolUseQuality: 1,
-  patchQuality: 1.25,
-  testReality: 1.5,
-  finalGate: 3,
-  reviewerBlockers: -2,
-  costUsd: -0.2,
-  wallSeconds: -0.1
-};
-function aggregateRunScore(score, weights = {}) {
-  const w = { ...DEFAULT_RUN_SCORE_WEIGHTS, ...weights };
-  return w.success * clamp01(score.success) + w.goalProgress * clamp01(score.goalProgress) + w.repoGroundedness * clamp01(score.repoGroundedness) + w.driftPenalty * clamp01(score.driftPenalty) + w.toolUseQuality * clamp01(score.toolUseQuality) + w.patchQuality * clamp01(score.patchQuality) + w.testReality * clamp01(score.testReality) + w.finalGate * clamp01(score.finalGate) + w.reviewerBlockers * clamp01(score.reviewerBlockers) + w.costUsd * Math.max(0, finiteOrZero(score.costUsd)) + w.wallSeconds * Math.max(0, finiteOrZero(score.wallSeconds) / 60);
-}
-function clamp01(value) {
-  if (!Number.isFinite(value)) return 0;
-  return Math.max(0, Math.min(1, value));
-}
-function finiteOrZero(value) {
-  return Number.isFinite(value) ? value : 0;
-}
-
-// src/run-critic.ts
-var DEFAULT_DRIFT_PATTERNS = [
-  /https?:\/\//i,
-  /\btitle:\s/i,
-  /\bsummary:\s/i,
-  /\burl:\s/i,
-  /\bnpm package usage\b/i,
-  /\bnews\b/i
-];
-var RunCritic = class {
-  weights;
-  driftPatterns;
-  constructor(options = {}) {
-    this.weights = options.weights;
-    this.driftPatterns = options.driftPatterns ?? DEFAULT_DRIFT_PATTERNS;
-  }
-  async score(store, runId) {
-    const run = await store.getRun(runId);
-    if (!run) throw new NotFoundError(`run ${runId} not found`);
-    const [spans, events, artifacts, budget] = await Promise.all([
-      store.spans({ runId }),
-      store.events({ runId }),
-      store.artifacts(runId),
-      store.budget(runId)
-    ]);
-    return this.scoreTrace({ run, spans, events, artifacts, budget });
-  }
-  scoreTrace(trace) {
-    const notes = [];
-    const llmSpans2 = trace.spans.filter(
-      (s) => s.kind === "llm"
-    );
-    const toolSpans2 = trace.spans.filter(
-      (s) => s.kind === "tool"
-    );
-    const judgeSpans2 = trace.spans.filter(
-      (s) => s.kind === "judge"
-    );
-    const sandboxSpans = trace.spans.filter(
-      (s) => s.kind === "sandbox"
-    );
-    const finalGateSpans = judgeSpans2.filter(
-      (span) => span.dimension === "final_gate" || span.attributes?.finalGate === true
-    );
-    const success = trace.run.outcome?.pass === true ? 1 : trace.run.status === "completed" ? 0.5 : 0;
-    if (!success) notes.push("run did not complete with pass=true");
-    const judgeAverage = judgeSpans2.length ? judgeSpans2.reduce((sum3, span) => sum3 + 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(
-      (sum3, span) => sum3 + (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((sum3, span) => sum3 + (span.costUsd ?? 0), 0);
-    const wallSeconds = trace.run.endedAt && trace.run.startedAt ? Math.max(0, (trace.run.endedAt - trace.run.startedAt) / 1e3) : 0;
-    return {
-      success,
-      goalProgress,
-      repoGroundedness,
-      driftPenalty,
-      toolUseQuality,
-      patchQuality,
-      testReality,
-      finalGate,
-      reviewerBlockers,
-      costUsd,
-      wallSeconds,
-      notes
-    };
-  }
-  rank(score) {
-    return aggregateRunScore(score, this.weights);
-  }
-  isDrift(text) {
-    return this.driftPatterns.some((pattern) => pattern.test(text));
-  }
-};
-function normalizeJudgeScore(score) {
-  return score > 1 ? clamp01(score / 10) : clamp01(score);
-}
-function looksRepoGrounded(text) {
-  return /(?:src\/|tests?\/|package\.json|tsconfig|\.ts\b|\.tsx\b|git status|pnpm |npm |vitest|pytest|jest)/i.test(
-    text
-  );
-}
-function isBlockingJudge(span) {
-  return span.attributes?.blocking === true || span.attributes?.verdict === "BLOCKING" || positiveNumber(span.attributes?.blockingFindings) || positiveNumber(span.attributes?.highFindings) || span.score <= 2;
-}
-function positiveNumber(value) {
-  return typeof value === "number" && value > 0;
-}
-
-// src/semantic-concept-judge.ts
-var DEFAULT_COMPLEXITY_WEIGHTS = {
-  render: 1,
-  integrate: 2,
-  compute: 2.5
-};
-var SEMANTIC_CONCEPT_JUDGE_VERSION = "semantic-concept-judge-v1-2026-04-24";
-var DEFAULT_MAX_SOURCE = 45e3;
-var DEFAULT_MAX_HTML = 3e4;
-var DEFAULT_MAX_PER_FILE = 2e4;
-var DEFAULT_TIMEOUT = 18e4;
-var DEFAULT_MODEL = "claude-sonnet-4-6";
-var SEMANTIC_SCHEMA = {
-  type: "object",
-  additionalProperties: false,
-  required: ["summary", "concepts"],
-  properties: {
-    summary: { type: "string", minLength: 20, maxLength: 600 },
-    concepts: {
-      type: "array",
-      minItems: 1,
-      items: {
-        type: "object",
-        additionalProperties: false,
-        required: ["concept", "present", "score", "evidence", "severity"],
-        properties: {
-          concept: { type: "string", minLength: 1, maxLength: 120 },
-          present: { type: "boolean" },
-          score: { type: "number", minimum: 0, maximum: 10 },
-          evidence: { type: "string", minLength: 5, maxLength: 400 },
-          severity: { type: "string", enum: ["critical", "major", "minor", "info"] }
-        }
-      }
-    }
-  }
-};
-function truncate(body, cap, label) {
-  if (body.length <= cap) return body;
-  return `${body.slice(0, cap)}
-\u2026 [truncated ${body.length - cap} chars of ${label}]`;
-}
-function buildPrompt(input, opts) {
-  const sourceBlob = input.sourceFiles.filter((f) => f.content.length <= opts.maxPerFileChars).map((f) => `--- FILE: ${f.path} ---
-${f.content}`).join("\n\n");
-  const html = input.servedHtml ?? "";
-  return `You are a strict code-review judge evaluating whether an agent's 0-to-1 build actually implements the features the user asked for.
-
-You MUST distinguish:
-  (a) WORKING code that implements the concept (rendered UI, wired handler, real API call),
-  (b) KEYWORD-PRESENT stub (comments mentioning the concept, variable names, TODOs),
-  (c) ABSENT (concept nowhere).
-
-A comment like "// TODO: add mint button" is NOT present \u2014 score 2-3. Only count a concept as present if there is real functional code: a rendered component, a call handler wired to state or a network call, a computed value actually used.
-
-USER REQUEST (what the agent was asked to build):
-${input.userRequest}
-
-${input.artifactLabel ? `ARTIFACT METADATA:
-  name: ${input.artifactLabel}
-  description: ${input.artifactDescription ?? ""}
-
-` : ""}EXPECTED CONCEPTS (each must be graded independently):
-${input.expectedConcepts.map(
-    (c, i) => `  ${i + 1}. "${c.name}"${c.keywords?.length ? ` \u2014 hints: [${c.keywords.slice(0, 6).join(" | ")}]` : ""}`
-  ).join("\n")}
-
-${html ? `SERVED HTML (what the preview returns when hit):
-${truncate(html, opts.maxHtmlChars, "HTML")}
-
-` : ""}SOURCE FILES (the agent's workdir):
-${truncate(sourceBlob, opts.maxSourceChars, "source")}
-
-For EACH concept, return:
-  - concept: the concept name as given (match exactly)
-  - present: boolean \u2014 does a working implementation exist?
-  - score: 0-10 \u2014 10 = production-ready; 7 = functional but thin; 4 = partial/stubbed; 2 = keyword-only comment; 0 = absent
-  - evidence: cite "<file>:<line>" or "served-html:<selector>" pointing at the strongest supporting code. If the concept is absent or stubbed, explain what's missing.
-  - severity:
-      "info" when present: true AND score >= 7
-      "minor" when present: true AND 4 <= score < 7
-      "major" when present: false OR score < 4
-      "critical" when the concept is not only absent but a core user flow depends on it
-
-Also produce a "summary" (one sentence, 20-600 chars): overall verdict on whether this is a shippable implementation of the user request vs a keyword-dense placeholder.
-
-BE SKEPTICAL. Keyword matching already passed \u2014 your job is to catch what keyword matching misses. If the agent shipped a working build, say so. If it shipped a stub, say so. Don't grade on effort.
-
-Return STRICT JSON. No prose outside the JSON.`;
-}
-async function runSemanticConceptJudge(input, options = {}) {
-  const start = Date.now();
-  const totalCount = input.expectedConcepts.length;
-  if (totalCount === 0) {
-    return {
-      kind: "semantic-concept",
-      version: SEMANTIC_CONCEPT_JUDGE_VERSION,
-      score: 0,
-      presentCount: 0,
-      totalCount: 0,
-      findings: [],
-      summary: "no expected concepts declared",
-      durationMs: 0,
-      costUsd: null,
-      available: false,
-      error: "no expected concepts declared"
-    };
-  }
-  const opts = {
-    model: options.model ?? DEFAULT_MODEL,
-    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT,
-    maxSourceChars: options.maxSourceChars ?? DEFAULT_MAX_SOURCE,
-    maxPerFileChars: options.maxPerFileChars ?? DEFAULT_MAX_PER_FILE,
-    maxHtmlChars: options.maxHtmlChars ?? DEFAULT_MAX_HTML,
-    llm: options.llm ?? {},
-    weightConcepts: options.weightConcepts ?? "mean",
-    complexityWeights: { ...DEFAULT_COMPLEXITY_WEIGHTS, ...options.complexityWeights ?? {} }
-  };
-  const weightForConcept = (spec) => {
-    if (opts.weightConcepts === "mean") return 1;
-    if (spec.weight != null) return spec.weight;
-    if (opts.weightConcepts === "complexity") {
-      return opts.complexityWeights[spec.complexity ?? "render"] ?? 1;
-    }
-    return 1;
-  };
-  const weightByName = new Map(
-    input.expectedConcepts.map((c) => [c.name, weightForConcept(c)])
-  );
-  try {
-    const { value, result } = await callLlmJson(
-      {
-        model: opts.model,
-        messages: [
-          {
-            role: "system",
-            content: "You are a strict code-review judge. Return strict JSON only. No prose outside the JSON. A keyword in a comment is NOT a working implementation."
-          },
-          { role: "user", content: buildPrompt(input, opts) }
-        ],
-        jsonSchema: { name: "semantic_concept_judge", schema: SEMANTIC_SCHEMA },
-        temperature: 0,
-        timeoutMs: opts.timeoutMs
-      },
-      opts.llm
-    );
-    if (!value?.concepts || !Array.isArray(value.concepts)) {
-      throw new Error('judge returned malformed response \u2014 expected array under "concepts"');
-    }
-    const findings = value.concepts.map((c) => ({
-      concept: String(c.concept),
-      present: Boolean(c.present),
-      score: Math.max(0, Math.min(10, Number(c.score ?? 0))),
-      evidence: String(c.evidence ?? ""),
-      severity: ["critical", "major", "minor", "info"].includes(c.severity) ? c.severity : "info"
-    }));
-    const presentCount = findings.filter((f) => f.present && f.score >= 7).length;
-    let weightSum = 0;
-    let weightedScoreSum = 0;
-    for (const f of findings) {
-      const w = weightByName.get(f.concept) ?? 1;
-      weightSum += w;
-      weightedScoreSum += w * f.score;
-    }
-    const scoreAvg = weightSum > 0 ? weightedScoreSum / weightSum : findings.reduce((a, f) => a + f.score, 0) / Math.max(1, findings.length);
-    return {
-      kind: "semantic-concept",
-      version: SEMANTIC_CONCEPT_JUDGE_VERSION,
-      score: Number((scoreAvg / 10).toFixed(3)),
-      presentCount,
-      totalCount,
-      findings,
-      summary: String(value.summary ?? ""),
-      durationMs: Date.now() - start,
-      costUsd: result.costUsd ?? null,
-      available: true
-    };
-  } catch (err) {
-    return {
-      kind: "semantic-concept",
-      version: SEMANTIC_CONCEPT_JUDGE_VERSION,
-      score: 0,
-      presentCount: 0,
-      totalCount,
-      findings: [],
-      summary: "",
-      durationMs: Date.now() - start,
-      costUsd: null,
-      available: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
-}
-function createSemanticConceptJudge(options = {}) {
-  return (input) => runSemanticConceptJudge(input, options);
-}
-
-// src/analyst/types.ts
-import { createHash } from "crypto";
-function computeFindingId(input) {
-  const basis = JSON.stringify({
-    a: input.analyst_id,
-    r: input.area,
-    s: input.subject ?? "",
-    c: normalizeClaim(input.id_basis ?? input.claim)
-  });
-  return `f_${createHash("sha256").update(basis).digest("hex").slice(0, 20)}`;
-}
-function normalizeClaim(c) {
-  return c.toLowerCase().replace(/\s+/g, " ").replace(/[.!?;:,]+$/g, "").trim();
-}
-function makeFinding(init) {
-  const { id_basis, produced_at, ...rest } = init;
-  return {
-    schema_version: "1.0.0",
-    finding_id: computeFindingId({
-      analyst_id: rest.analyst_id,
-      area: rest.area,
-      subject: rest.subject,
-      claim: rest.claim,
-      id_basis
-    }),
-    produced_at: produced_at ?? (/* @__PURE__ */ new Date()).toISOString(),
-    ...rest
-  };
-}
-
-// src/analyst/adapters.ts
-var ADAPTER_REV = "1";
-function liftSeverity(s) {
-  switch (s) {
-    case "critical":
-      return "critical";
-    case "major":
-      return "high";
-    case "minor":
-      return "medium";
-    case "info":
-      return "info";
-  }
-}
-function createTraceAnalystAdapter(opts) {
-  const id = opts.id ?? "trace-analyst";
-  const area = opts.area ?? "agent-reasoning";
-  return {
-    id,
-    description: "Runs the agent-eval trace analyst over an OTLP trace store and lifts its bulleted findings.",
-    inputKind: "trace-store",
-    cost: { kind: "llm", models: opts.model ? [opts.model] : void 0 },
-    version: `trace-analyst-${ADAPTER_REV}`,
-    async analyze(store, ctx) {
-      const out = [];
-      for (const question of opts.questions) {
-        if (ctx.signal?.aborted) break;
-        const result = await analyzeTraces(
-          { question },
-          { source: store, ai: opts.ai, model: opts.model, ...opts.extra }
-        );
-        const subject = ctx.tags?.subject ?? question.slice(0, 60);
-        if (result.findings.length === 0) {
-          out.push(
-            makeFinding({
-              analyst_id: id,
-              area,
-              subject,
-              claim: result.answer.slice(0, 200),
-              rationale: result.answer,
-              severity: "info",
-              confidence: 0.5,
-              evidence_refs: [],
-              metadata: {
-                actor_prompt_version: result.actorPromptVersion,
-                turns: result.turnCount
-              }
-            })
-          );
-          continue;
-        }
-        result.findings.forEach((claim, i) => {
-          out.push(
-            makeFinding({
-              analyst_id: id,
-              area,
-              subject,
-              claim,
-              rationale: i === 0 ? result.answer : void 0,
-              severity: "medium",
-              confidence: 0.6,
-              evidence_refs: [],
-              metadata: { question, turns: result.turnCount, finding_index: i }
-            })
-          );
-        });
-      }
-      return out;
-    }
-  };
-}
-function createVerifierAdapter(opts) {
-  const id = opts.id ?? "multi-layer-verifier";
-  const area = opts.area ?? "verification";
-  return {
-    id,
-    description: "Runs a MultiLayerVerifier and lifts each layer's findings into the analyst envelope.",
-    inputKind: "custom",
-    cost: { kind: "deterministic" },
-    version: `verifier-${ADAPTER_REV}`,
-    async analyze(env, ctx) {
-      const report = await opts.verifier.run({ env, ...opts.options });
-      const out = [];
-      for (const layer of report.layers) {
-        for (const finding2 of layer.findings) {
-          out.push(liftLayerFinding(id, area, layer.layer, finding2));
-        }
-        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 scores2 = await opts.judge(opts.tcloud, input);
-      return scores2.filter((s) => normalize10(s.score) < threshold).map((s) => liftJudgeScore(id, area, s));
-    }
-  };
-}
-function normalize10(s) {
-  return s <= 1 ? s * 10 : s;
-}
-function liftJudgeScore(analyst_id, area, s) {
-  const score10 = normalize10(s.score);
-  const severity = score10 < 3 ? "critical" : score10 < 5 ? "high" : score10 < 7 ? "medium" : "low";
-  return makeFinding({
-    analyst_id,
-    area,
-    subject: s.dimension,
-    claim: `${s.judgeName}/${s.dimension} scored ${score10.toFixed(1)}/10`,
-    rationale: s.reasoning,
-    severity,
-    confidence: 0.8,
-    evidence_refs: s.evidence ? [{ kind: "artifact", uri: "inline:evidence", excerpt: s.evidence }] : [],
-    metadata: { judge_name: s.judgeName, dimension: s.dimension, score_10: score10 }
-  });
-}
-function createSemanticConceptJudgeAdapter(opts = {}) {
-  const id = opts.id ?? "semantic-concept-judge";
-  const area = opts.area ?? "concept-coverage";
-  return {
-    id,
-    description: "Runs the semantic-concept judge and surfaces missing / weak concepts as findings.",
-    inputKind: "custom",
-    cost: { kind: "llm", models: opts.options?.model ? [opts.options.model] : void 0 },
-    version: `${SEMANTIC_CONCEPT_JUDGE_VERSION}-adapter-${ADAPTER_REV}`,
-    async analyze(input) {
-      const result = await runSemanticConceptJudge(input, opts.options);
-      if (!result.available) {
-        return [
-          makeFinding({
-            analyst_id: id,
-            area,
-            claim: "semantic-concept judge unavailable",
-            rationale: result.error,
-            severity: "info",
-            confidence: 1,
-            evidence_refs: [],
-            metadata: { reason: result.error }
-          })
-        ];
-      }
-      const out = [];
-      for (const f of result.findings) {
-        if (f.present && f.score >= 7) continue;
-        out.push(
-          makeFinding({
-            analyst_id: id,
-            area,
-            subject: f.concept,
-            claim: f.present ? `concept "${f.concept}" is weak (${f.score}/10)` : `concept "${f.concept}" is missing`,
-            rationale: f.evidence,
-            severity: liftSeverity(f.severity),
-            confidence: 0.85,
-            evidence_refs: [{ kind: "artifact", uri: "inline:evidence", excerpt: f.evidence }],
-            metadata: {
-              concept: f.concept,
-              present: f.present,
-              score_10: f.score,
-              cost_usd: result.costUsd ?? void 0
-            }
-          })
-        );
-      }
-      return out;
-    }
-  };
-}
-
-// src/analyst/chat-client.ts
-function createChatClient(opts) {
-  switch (opts.transport) {
-    case "router":
-      return wrapLlmClient(
-        opts.transport,
-        opts.defaultModel,
-        new LlmClient({
-          baseUrl: opts.baseUrl ?? "https://router.tangle.tools/v1",
-          apiKey: opts.apiKey
-        })
-      );
-    case "cli-bridge":
-      return wrapLlmClient(
-        opts.transport,
-        opts.defaultModel,
-        new LlmClient({
-          baseUrl: opts.baseUrl ?? "http://127.0.0.1:3344/v1",
-          apiKey: opts.bearer ?? ""
-        })
-      );
-    case "direct-provider":
-      return wrapLlmClient(
-        opts.transport,
-        opts.defaultModel,
-        new LlmClient({
-          baseUrl: opts.baseUrl,
-          apiKey: opts.apiKey
-        })
-      );
-    case "sandbox-sdk":
-      return {
-        transport: "sandbox-sdk",
-        defaultModel: opts.defaultModel,
-        chat: async (req, callOpts) => opts.chat(resolveModel(req, opts.defaultModel), callOpts)
-      };
-    case "mock":
-      return {
-        transport: "mock",
-        defaultModel: opts.defaultModel,
-        chat: async (req, callOpts) => opts.handler(resolveModel(req, opts.defaultModel), callOpts)
-      };
-  }
-}
-function wrapLlmClient(transport, defaultModel, inner) {
-  return {
-    transport,
-    defaultModel,
-    chat: async (req, callOpts) => {
-      const resolved = resolveModel(req, defaultModel);
-      const call = inner.call({
-        model: resolved.model,
-        messages: req.messages,
-        jsonMode: req.jsonMode,
-        jsonSchema: req.jsonSchema,
-        temperature: req.temperature,
-        maxTokens: req.maxTokens,
-        timeoutMs: req.timeoutMs
-      });
-      if (!callOpts?.signal) return await call;
-      return await Promise.race([call, abortAsRejection(callOpts.signal)]);
-    }
-  };
-}
-function abortAsRejection(signal) {
-  if (signal.aborted) return Promise.reject(toAbortError(signal));
-  return new Promise((_, reject) => {
-    signal.addEventListener("abort", () => reject(toAbortError(signal)), { once: true });
-  });
-}
-function toAbortError(signal) {
-  const reason = signal.reason;
-  if (reason instanceof Error) return reason;
-  const e = new Error("ChatClient.chat: aborted");
-  e.name = "AbortError";
-  return e;
-}
-function resolveModel(req, defaultModel) {
-  if (req.model) return req;
-  if (!defaultModel) {
-    throw new Error(
-      "ChatClient.chat: no model on request and no defaultModel on the client. Either pass req.model or bind defaultModel at createChatClient()."
-    );
-  }
-  return { ...req, model: defaultModel };
-}
-
-// src/analyst/finding-signature.ts
-import { z as z2 } from "zod";
-
-// src/analyst/finding-subject.ts
-import { z } from "zod";
-var FINDING_SUBJECT_KINDS = [
-  "knowledge.wiki",
-  "knowledge.claim",
-  "knowledge.raw",
-  "knowledge.stale",
-  "system-prompt",
-  "tool-doc",
-  "new-tool",
-  "rag",
-  "memory",
-  "scaffolding",
-  "output-schema",
-  "websearch.outdated",
-  "prior-run-summary",
-  "cluster"
-];
-function parseFindingSubject(raw) {
-  if (raw === null || raw === void 0) return null;
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) return null;
-  const wiki = trimmed.match(
-    /^agent-knowledge:wiki:([a-z0-9][a-z0-9-]*)(?:#([a-z0-9][a-z0-9-]*))?$/
-  );
-  if (wiki)
-    return { kind: "knowledge.wiki", slug: wiki[1], ...wiki[2] ? { heading: wiki[2] } : {} };
-  const claim = trimmed.match(/^agent-knowledge:claim:(.+)$/);
-  if (claim && claim[1].trim().length > 0)
-    return { kind: "knowledge.claim", topic: claim[1].trim() };
-  const raw_ = trimmed.match(/^agent-knowledge:raw:(.+)$/);
-  if (raw_ && raw_[1].trim().length > 0)
-    return { kind: "knowledge.raw", sourceId: raw_[1].trim() };
-  const stale = trimmed.match(/^agent-knowledge:stale:([a-z0-9][a-z0-9-]*)$/);
-  if (stale) return { kind: "knowledge.stale", slug: stale[1] };
-  const sp = trimmed.match(/^system-prompt:(.+)$/);
-  if (sp && sp[1].trim().length > 0) return { kind: "system-prompt", section: sp[1].trim() };
-  const tdAspect = trimmed.match(/^tool-doc:([a-z0-9][a-z0-9_-]*):(.+)$/);
-  if (tdAspect && tdAspect[2].trim().length > 0) {
-    return { kind: "tool-doc", tool: tdAspect[1], aspect: tdAspect[2].trim() };
-  }
-  const td = trimmed.match(/^tool-doc:([a-z0-9][a-z0-9_-]*)$/);
-  if (td) return { kind: "tool-doc", tool: td[1] };
-  const nt = trimmed.match(/^new-tool:([a-z0-9][a-z0-9_-]*)$/);
-  if (nt) return { kind: "new-tool", name: nt[1] };
-  const rag = trimmed.match(/^rag:([a-z0-9][a-z0-9_-]*):(.+)$/);
-  if (rag && rag[2].trim().length > 0) {
-    return { kind: "rag", corpus: rag[1], docId: rag[2].trim() };
-  }
-  const mem = trimmed.match(/^memory:(.+)$/);
-  if (mem && mem[1].trim().length > 0) return { kind: "memory", key: mem[1].trim() };
-  const sc = trimmed.match(/^scaffolding:(.+)$/);
-  if (sc && sc[1].trim().length > 0) return { kind: "scaffolding", concern: sc[1].trim() };
-  const os = trimmed.match(/^output-schema:(.+)$/);
-  if (os && os[1].trim().length > 0) return { kind: "output-schema", field: os[1].trim() };
-  const ws = trimmed.match(/^websearch:outdated:(.+)$/);
-  if (ws && ws[1].trim().length > 0) return { kind: "websearch.outdated", topic: ws[1].trim() };
-  const prs = trimmed.match(/^prior-run-summary:(.+)$/);
-  if (prs && prs[1].trim().length > 0) return { kind: "prior-run-summary", topic: prs[1].trim() };
-  if (/^[a-z0-9][a-z0-9-]*$/.test(trimmed) && trimmed.length <= 80) {
-    return { kind: "cluster", label: trimmed };
-  }
-  return null;
-}
-function renderFindingSubject(s) {
-  switch (s.kind) {
-    case "knowledge.wiki":
-      return s.heading ? `agent-knowledge:wiki:${s.slug}#${s.heading}` : `agent-knowledge:wiki:${s.slug}`;
-    case "knowledge.claim":
-      return `agent-knowledge:claim:${s.topic}`;
-    case "knowledge.raw":
-      return `agent-knowledge:raw:${s.sourceId}`;
-    case "knowledge.stale":
-      return `agent-knowledge:stale:${s.slug}`;
-    case "system-prompt":
-      return `system-prompt:${s.section}`;
-    case "tool-doc":
-      return s.aspect ? `tool-doc:${s.tool}:${s.aspect}` : `tool-doc:${s.tool}`;
-    case "new-tool":
-      return `new-tool:${s.name}`;
-    case "rag":
-      return `rag:${s.corpus}:${s.docId}`;
-    case "memory":
-      return `memory:${s.key}`;
-    case "scaffolding":
-      return `scaffolding:${s.concern}`;
-    case "output-schema":
-      return `output-schema:${s.field}`;
-    case "websearch.outdated":
-      return `websearch:outdated:${s.topic}`;
-    case "prior-run-summary":
-      return `prior-run-summary:${s.topic}`;
-    case "cluster":
-      return s.label;
-  }
-}
-var FINDING_SUBJECT_GRAMMAR_PROMPT = [
-  "Subjects MUST match this grammar \u2014 anything else is rejected at parse time and your work is wasted:",
-  "",
-  "  Knowledge loci (write to the agent-knowledge base):",
-  "    agent-knowledge:wiki:<slug>[#<heading>]   create / update a wiki page",
-  "    agent-knowledge:claim:<topic>             draft a claim / relation triple",
-  "    agent-knowledge:raw:<source-id>           lift a raw source into a curated page",
-  "    agent-knowledge:stale:<slug>              mark a page superseded",
-  "",
-  "  Runtime mutable surfaces (write to prompts / tools / scaffolding):",
-  "    system-prompt:<section>                   add / replace a system-prompt section",
-  "    tool-doc:<tool>[:<aspect>]                rewrite a tool description",
-  "    new-tool:<name>                           propose a new tool surface",
-  "    rag:<corpus>:<doc-id>                     ingest / correct a RAG document",
-  "    memory:<key>                              invalidate / set a memory entry",
-  "    scaffolding:<concern>                     change a precondition / retry / verifier",
-  "    output-schema:<field>                     constrain the agent output shape",
-  "",
-  "  Stale signals (knowledge-poisoning only):",
-  "    websearch:outdated:<topic>                stale web result",
-  "    prior-run-summary:<topic>                 stale prior-run summary",
-  "",
-  "  Cluster label (failure-mode only):",
-  '    <kebab-case-label>                        short cluster id, e.g. "tool-call-loop"',
-  "",
-  "Slugs / tool ids: [a-z0-9-]+ (lowercase kebab). Topics / keys / sections: free-form, trimmed."
-].join("\n");
-var KIND_EXPECTED_SUBJECTS = {
-  "failure-mode": ["cluster"],
-  "knowledge-gap": [
-    "knowledge.wiki",
-    "knowledge.claim",
-    "knowledge.raw",
-    "knowledge.stale",
-    "tool-doc",
-    "system-prompt",
-    "memory",
-    "websearch.outdated",
-    "prior-run-summary"
-  ],
-  "knowledge-poisoning": [
-    "knowledge.wiki",
-    "knowledge.claim",
-    "knowledge.raw",
-    "tool-doc",
-    "system-prompt",
-    "memory",
-    "websearch.outdated",
-    "prior-run-summary"
-  ],
-  improvement: [
-    "system-prompt",
-    "tool-doc",
-    "new-tool",
-    "rag",
-    "memory",
-    "scaffolding",
-    "output-schema",
-    "knowledge.wiki",
-    "knowledge.claim"
-  ]
-};
-var FindingSubjectStringSchema = z.string().refine((s) => parseFindingSubject(s) !== null, {
-  message: "subject does not match the finding-subject grammar"
-});
-
-// src/analyst/finding-signature.ts
-var ANALYST_SEVERITIES = ["critical", "high", "medium", "low", "info"];
-var RawAnalystFindingSchema = z2.object({
-  severity: z2.enum(ANALYST_SEVERITIES),
-  claim: z2.string().min(1).max(2e3),
-  /**
-   * Subject locus the finding is about. Validated at parse time
-   * against the documented grammar (`finding-subject.ts`). Findings
-   * with a malformed subject are rejected — they would have been
-   * silently skipped by every downstream adapter, so failing loud at
-   * parse time turns a hidden no-op into a kind-prompt audit signal.
-   *
-   * Optional because purely descriptive findings (no actionable
-   * locus) are legitimate; they just don't route through the
-   * KnowledgeAdapter / ImprovementAdapter.
-   */
-  subject: z2.string().max(400).refine((s) => parseFindingSubject(s) !== null, {
-    message: "subject does not match the finding-subject grammar"
-  }).optional(),
-  evidence_uri: z2.string().min(1).max(2e3),
-  evidence_excerpt: z2.string().max(2e3).optional(),
-  confidence: z2.number().min(0).max(1),
-  rationale: z2.string().max(4e3).optional(),
-  recommended_action: z2.string().max(2e3).optional()
-}).strict();
-var RAW_FINDING_SCHEMA_PROMPT = `Each finding MUST be a JSON object with these fields:
-  - severity: one of "critical" | "high" | "medium" | "low" | "info"
-  - claim: one-sentence statement (max 2000 chars)
-  - subject?: the leaf id, agent id, span id, tool name, or noun phrase the finding is about
-  - evidence_uri: "span://<trace_id>/<span_id>" for trace evidence, "artifact://<relative-path>" for files, "metric://<name>" for named scalars \u2014 ALWAYS cite a real id surfaced by the tools
-  - evidence_excerpt?: short quote (<=2000 chars) from the cited span/artifact
-  - confidence: number 0..1 \u2014 0.9+ when backed by exact quotes, 0.6-0.8 for inferred patterns, <0.5 for speculative
-  - rationale?: one or two sentences explaining the reasoning
-  - recommended_action?: concrete change phrased as an imperative ("Add ...", "Replace ...", "Stop ...") \u2014 omit when the finding is purely descriptive
-
-Emit an empty array when the question has no findings to report. Do not fabricate evidence.`;
-function parseRawFinding(row, log) {
-  const result = RawAnalystFindingSchema.safeParse(row);
-  if (!result.success) {
-    log?.("finding rejected: schema failure", {
-      issues: result.error.issues.map((i) => ({
-        path: i.path.join("."),
-        code: i.code,
-        message: i.message
-      }))
-    });
-    return null;
-  }
-  return result.data;
-}
-
-// src/analyst/findings-store.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-
-// src/locked-jsonl-appender.ts
-import { appendFileSync, existsSync, mkdirSync } from "fs";
-import { dirname } from "path";
-
-// src/concurrency.ts
-var Mutex = class {
-  locked = false;
-  waiters = [];
-  async acquire() {
-    if (!this.locked) {
-      this.locked = true;
-      return () => this.release();
-    }
-    return new Promise((resolve) => {
-      this.waiters.push(() => {
-        resolve(() => this.release());
-      });
-    });
-  }
-  release() {
-    const next = this.waiters.shift();
-    if (next) {
-      next();
-    } else {
-      this.locked = false;
-    }
-  }
-  async runExclusive(fn) {
-    const release = await this.acquire();
-    try {
-      return await fn();
-    } finally {
-      release();
-    }
-  }
-  /** True iff someone holds the lock right now. Diagnostics only. */
-  get isLocked() {
-    return this.locked;
-  }
-  /** Pending waiter count. Diagnostics only. */
-  get pending() {
-    return this.waiters.length;
-  }
-};
-
-// src/locked-jsonl-appender.ts
-var mutexes = /* @__PURE__ */ new Map();
-function getMutex(path) {
-  let m = mutexes.get(path);
-  if (!m) {
-    m = new Mutex();
-    mutexes.set(path, m);
-  }
-  return m;
-}
-var LockedJsonlAppender = class {
-  constructor(path) {
-    this.path = path;
-    this.mutex = getMutex(path);
-    if (!existsSync(dirname(path))) {
-      mkdirSync(dirname(path), { recursive: true });
-    }
-  }
-  path;
-  mutex;
-  async append(entry) {
-    const line = `${JSON.stringify(entry)}
-`;
-    await this.mutex.runExclusive(() => {
-      appendFileSync(this.path, line);
-    });
-  }
-};
-function resetLockedAppendersForTesting() {
-  mutexes.clear();
-}
-
-// src/analyst/findings-store.ts
-var FindingsStore = class {
-  constructor(path) {
-    this.path = path;
-    this.appender = new LockedJsonlAppender(path);
-  }
-  path;
-  appender;
-  async append(runId, findings) {
-    for (const f of findings) {
-      const row = { ...f, run_id: runId };
-      await this.appender.append(row);
-    }
-  }
-  /** Load every persisted finding. Discards malformed trailing lines silently. */
-  loadAll() {
-    if (!existsSync2(this.path)) return [];
-    const raw = readFileSync(this.path, "utf8");
-    if (!raw) return [];
-    const out = [];
-    for (const line of raw.split("\n")) {
-      if (!line) continue;
-      try {
-        out.push(JSON.parse(line));
-      } catch {
-      }
-    }
-    return out;
-  }
-  /** Filter to a single run. */
-  loadRun(runId) {
-    return this.loadAll().filter((r) => r.run_id === runId);
-  }
-};
-function defaultIsMaterial(a, b) {
-  if (a.severity !== b.severity) return true;
-  if (Math.abs((a.confidence ?? 0) - (b.confidence ?? 0)) > 0.05) return true;
-  if (a.evidence_refs.length !== b.evidence_refs.length) return true;
-  return false;
-}
-function diffFindings(previous, current, policy = {}) {
-  const isMaterial = policy.isMaterial ?? defaultIsMaterial;
-  const prevById = new Map(previous.map((f) => [f.finding_id, f]));
-  const curById = new Map(current.map((f) => [f.finding_id, f]));
-  const appeared = [];
-  const disappeared = [];
-  const persisted = [];
-  const changed = [];
-  for (const [id, cur] of curById) {
-    const prev = prevById.get(id);
-    if (!prev) {
-      appeared.push(cur);
-      continue;
-    }
-    if (isMaterial(prev, cur)) {
-      changed.push({ previous: prev, current: cur });
-    } else {
-      persisted.push(cur);
-    }
-  }
-  for (const [id, prev] of prevById) {
-    if (!curById.has(id)) disappeared.push(prev);
-  }
-  return { appeared, disappeared, persisted, changed };
-}
-
-// src/analyst/kind-factory.ts
-import { AxJSRuntime, agent } from "@ax-llm/ax";
-function createTraceAnalystKind(spec, opts) {
-  const version = opts.versionSuffix ? `${spec.version}+${opts.versionSuffix}` : spec.version;
-  return {
-    id: spec.id,
-    description: spec.description,
-    inputKind: "trace-store",
-    cost: spec.cost,
-    version,
-    async analyze(store, ctx) {
-      const tools = spec.buildTools(store);
-      const maxDepth = spec.recursion?.maxDepth ?? 0;
-      const maxParallel = spec.recursion?.maxParallelSubagents ?? 2;
-      const priorContext = renderPriorFindings(ctx.priorFindings);
-      const actorDescription = spec.actorDescription.trim() + priorContext + "\n\n" + RAW_FINDING_SCHEMA_PROMPT + "\n\nReturn the array in the `findings` output field. Use `final(...)` with the structured `{ findings }` payload when you are done.";
-      const ax = agent(
-        "question:string -> findings:json[]",
-        {
-          agentIdentity: {
-            name: spec.id,
-            description: spec.description
-          },
-          contextFields: ["question"],
-          runtime: new AxJSRuntime({
-            permissions: [],
-            blockDynamicImport: true,
-            allowedModules: [],
-            freezeIntrinsics: true,
-            blockShadowRealm: true,
-            preventGlobalThisExtensions: false
-          }),
-          mode: maxDepth > 0 ? "advanced" : "simple",
-          recursionOptions: maxDepth > 0 ? { maxDepth } : void 0,
-          maxTurns: spec.maxTurns ?? 12,
-          maxRuntimeChars: spec.maxRuntimeChars ?? 6e3,
-          maxBatchedLlmQueryConcurrency: maxParallel,
-          promptLevel: "detailed",
-          contextPolicy: { preset: "full", budget: "balanced" },
-          functions: { local: tools },
-          actorOptions: {
-            description: actorDescription,
-            ...opts.model ? { model: opts.model } : {},
-            showThoughts: false,
-            thinkingTokenBudget: "none"
-          },
-          responderOptions: {
-            description: spec.responderDescription ?? "Format the structured `findings` array exactly as the actor produced it. Do not add, drop, or summarize entries.",
-            ...opts.model ? { model: opts.model } : {},
-            showThoughts: false
-          },
-          bubbleErrors: [TraceFileMissingError]
-        }
-      );
-      ctx.log?.(`analyst.kind ${spec.id} forward`, {
-        max_depth: maxDepth,
-        tool_count: tools.length,
-        tags: ctx.tags
-      });
-      const result = await ax.forward(opts.ai, { question: deriveQuestion(ctx, spec) });
-      const expectedSubjects = KIND_EXPECTED_SUBJECTS[spec.id];
-      const out = [];
-      const rawRows = Array.isArray(result.findings) ? result.findings : [];
-      let rejectedWrongKind = 0;
-      for (const row of rawRows) {
-        const parsed = parseRawFinding(row, ctx.log);
-        if (!parsed) continue;
-        if (expectedSubjects && parsed.subject !== void 0) {
-          const parsedSubject = parseFindingSubject(parsed.subject);
-          if (parsedSubject === null) {
-            ctx.log?.("finding rejected: subject failed to parse", {
-              kind: spec.id,
-              subject: parsed.subject
-            });
-            rejectedWrongKind += 1;
-            continue;
-          }
-          if (!expectedSubjects.includes(parsedSubject.kind)) {
-            ctx.log?.("finding rejected: subject variant not allowed for this kind", {
-              kind: spec.id,
-              subject_kind: parsedSubject.kind,
-              subject: parsed.subject,
-              allowed: expectedSubjects
-            });
-            rejectedWrongKind += 1;
-            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,
-        rejected_wrong_subject: rejectedWrongKind
-      });
-      return out;
-    }
-  };
-}
-function deriveQuestion(ctx, spec) {
-  const focus = ctx.tags?.focus?.trim();
-  if (focus) return `${spec.id}: ${focus}`;
-  return spec.id;
-}
-function toAnalystFinding(spec, raw) {
-  return makeFinding({
-    analyst_id: spec.id,
-    area: spec.area,
-    subject: raw.subject,
-    claim: raw.claim,
-    rationale: raw.rationale,
-    severity: raw.severity,
-    confidence: raw.confidence,
-    evidence_refs: [
-      {
-        kind: evidenceKindFromUri(raw.evidence_uri),
-        uri: raw.evidence_uri,
-        excerpt: raw.evidence_excerpt
-      }
-    ],
-    recommended_action: raw.recommended_action,
-    metadata: { kind_version: spec.version }
-  });
-}
-function evidenceKindFromUri(uri) {
-  if (uri.startsWith("span://")) return "span";
-  if (uri.startsWith("artifact://")) return "artifact";
-  if (uri.startsWith("metric://")) return "metric";
-  if (uri.startsWith("event://")) return "event";
-  if (uri.startsWith("finding://")) return "finding";
-  return "artifact";
-}
-function renderPriorFindings(prior) {
-  if (!prior || prior.length === 0) return "";
-  const MAX_ROWS = 40;
-  const rows = prior.slice(0, MAX_ROWS).map((f) => {
-    const subject = f.subject ? ` [${f.subject}]` : "";
-    return `  - id=${f.finding_id} ${f.severity}${subject} ${truncateForContext(f.claim, 160)}`;
-  });
-  const overflow = prior.length > MAX_ROWS ? `
-  ... +${prior.length - MAX_ROWS} more prior findings (older history truncated)` : "";
-  return [
-    "",
-    "",
-    "PRIOR FINDINGS (from a previous run on related data):",
-    "When the work you do now matches a row below, REUSE the `finding_id` (pass it as `id_basis`) so the cross-run diff stays stable.",
-    "A finding that reappears with no remediation evidence SHOULD raise its `confidence` and may justify a higher `severity`.",
-    ...rows,
-    overflow
-  ].filter(Boolean).join("\n");
-}
-function truncateForContext(s, max) {
-  if (s.length <= max) return s;
-  return `${s.slice(0, max - 1).trimEnd()}\u2026`;
-}
-
-// src/analyst/tool-groups.ts
-var TOOL_NAMES_BY_GROUP = {
-  all: /* @__PURE__ */ new Set(),
-  discovery: /* @__PURE__ */ new Set(["getDatasetOverview", "queryTraces", "countTraces"]),
-  discoveryAndRead: /* @__PURE__ */ new Set([
-    "getDatasetOverview",
-    "queryTraces",
-    "countTraces",
-    "viewTrace",
-    "viewSpans"
-  ]),
-  discoveryAndSearch: /* @__PURE__ */ new Set([
-    "getDatasetOverview",
-    "queryTraces",
-    "countTraces",
-    "searchTrace",
-    "searchSpan"
-  ]),
-  targeted: /* @__PURE__ */ new Set(["getDatasetOverview", "queryTraces", "viewSpans", "searchSpan"])
-};
-function buildTraceToolsForGroup(group, store) {
-  const all = buildTraceAnalystTools({ store });
-  if (group === "all") return all;
-  const allow = TOOL_NAMES_BY_GROUP[group];
-  if (!allow) throw new Error(`unknown trace tool group: ${group}`);
-  return all.filter((tool) => allow.has(tool.name));
-}
-
-// src/analyst/kinds/failure-mode.ts
-var ACTOR_PROMPT = `You are a failure-mode classifier for an OTLP trace dataset. Your job is to identify the **distinct ways agents failed** in this dataset, not to grade individual runs.
-
-DISCOVERY \u2192 CLUSTER \u2192 CITE protocol:
-
-1. Call \`traces.getDatasetOverview({})\` first. Use \`has_errors\`, \`models\`, \`agent_names\`, \`tools\`, and \`sample_trace_ids\` to size the failure surface.
-2. Use \`traces.queryTraces({ filters: { has_errors: true }, limit })\` to pull error-bearing traces. Combine with \`traces.countTraces\` to see what fraction of the dataset failed.
-3. For each candidate failure cluster, use \`traces.searchTrace\` with regex like \`STATUS_CODE_ERROR\`, \`MaxTurnsExceeded\`, \`assertion\`, \`unauthorized\`, \`timeout\`, \`429\`, \`5\\d\\d\`, the agent's specific error strings, or the names of its tools. Pull one or two representative traces per cluster, **not all** of them.
-4. **Cluster, do not enumerate.** Two failures with the same root cause should be ONE finding citing both traces, not two findings. The point of this analyst is to compress N runs into K modes.
-5. For each cluster you can defend with evidence, emit ONE finding with:
-   - \`area\` = "failure-mode"
-   - \`subject\` = a short label for the cluster ("tool-call-loop", "auth-revoked-mid-run", "agent-asked-clarification-too-late", ...)
-   - \`claim\` = one sentence stating the mode
-   - \`severity\` = "critical" when it blocks the run, "high" when the run finished degraded, "medium" when it slowed convergence
-   - \`evidence_uri\` = \`span://<trace_id>/<span_id>\` of the most representative span
-   - \`evidence_excerpt\` = the exact quote (e.g. error message, stuck tool call payload, contradictory turn output)
-   - \`confidence\` = 0.85+ when multiple traces show the same shape; 0.6-0.8 for a single-trace inference; <0.5 for speculative.
-   - \`recommended_action\` = imperative-phrased fix idea (kept short \u2014 the improvement-analyst will expand on these)
-
-If the dataset has no failures, return an empty findings array \u2014 do NOT pad with low-confidence speculation.
-
-**Delegate aggressively.** The recursion budget is there to be used:
-- After your first \`getDatasetOverview\` + \`queryTraces\` calls, you should have 3-6 candidate failure clusters in mind. Spawn one \`llmQuery\` per cluster in a single batch \u2014 they investigate in parallel.
-- A sub-investigator that finds its cluster is actually two distinct modes should split again at its own level. Recursion is meant to discover sub-modes, not to do trivial drilling that the parent could do in-line.
-- Pass narrow context to each subagent: { question: 'investigate the auth-revoked-mid-run cluster', context: { trace_ids: ['abc', 'def'], suspected_root_cause: 'token refresh skipped on idle sessions' } }. Subagents need enough context to skip re-discovery but not the whole conversation.
-- Each subagent returns its findings as JSON; the parent merges them. Do NOT have subagents call \`final()\` \u2014 they return their findings list to you, and you call \`final()\` once at the top.
-
-OBSERVABILITY rules:
-- Each non-final turn must emit at least one \`console.log\` for evidence.
-- Reuse runtime variables across turns; don't recompute.
-- Call \`final({ findings: [...] })\` exactly once, after you've gathered evidence for every cluster you intend to report.`;
-var FAILURE_MODE_KIND_SPEC = {
-  id: "failure-mode",
-  description: "Clusters trace-dataset failures into distinct failure modes with cited evidence and a short recommended action.",
-  area: "failure-mode",
-  version: "1.0.0",
-  actorDescription: ACTOR_PROMPT,
-  buildTools: (store) => buildTraceToolsForGroup("all", store),
-  recursion: { maxDepth: 3, maxParallelSubagents: 4 },
-  maxTurns: 24,
-  cost: { kind: "llm" }
-};
-
-// src/analyst/kinds/improvement.ts
-var ACTOR_PROMPT2 = `You are a recursive-self-improvement analyst. Your job is to propose **concrete, locus-named edits** the agent's runtime should adopt to fix the failure modes, knowledge gaps, and poisonings present in this dataset.
-
-Upstream analysts have already classified the problems. Your job is to convert each problem into a *change to make* and grade its expected leverage. Each finding is one proposed edit.
-
-DISCOVERY \u2192 CANDIDATE-FIXES \u2192 COMPETE \u2192 CITE protocol:
-
-1. \`traces.getDatasetOverview({})\` first. Note the agents, tools, and any system-prompt fingerprints (look for the prompt text echoed in early spans).
-2. For each high-severity failure pattern, generate 2-3 candidate fixes. Real candidate axes:
-   - **System-prompt edit** \u2014 add an instruction, remove a misleading one, restructure precedence
-   - **Tool description edit** \u2014 rewrite a tool's description so the agent picks it correctly / passes valid args
-   - **New tool** \u2014 add a tool the agent kept emulating in code
-   - **RAG ingestion** \u2014 add a document or correct a stale one
-   - **Memory invalidation** \u2014 clear cached prior-run decisions that no longer apply
-   - **Scaffolding** \u2014 add a precondition check, a retry policy, a turn budget, a verification step
-   - **Output schema** \u2014 narrow the agent's output to forbid the failure shape
-3. **Compete candidate fixes via subagents.** For each failure cluster, spawn one \`llmQuery\` per candidate-fix axis you want to evaluate. Each subagent's job: simulate the fix on the cited traces and report (i) likely effect, (ii) side effects, (iii) implementation cost as small/medium/large. Pass the cluster's failing trace_ids and the candidate axis as context.
-4. After subagents return, **pick the winning candidate per cluster** based on (effect / cost) and emit ONE finding. Discard the losing candidates \u2014 the output is the recommendation, not the candidate set.
-5. **Cross-reference upstream findings.** If a finding cites a prior failure-mode or knowledge-gap finding, use \`evidence_uri = "finding://<prior-finding-id>"\` (the registry supports this kind). This builds the dependency graph that lets the dashboard show "fix #X resolves failure modes A, B, C."
-
-For each winning recommendation, emit ONE finding with:
-- \`area\` = "improvement"
-- \`subject\` = the locus to edit: \`system-prompt:<section>\`, \`tool-doc:<tool-name>\`, \`new-tool:<proposed-name>\`, \`rag:<corpus>:<doc-id>\`, \`memory:<key>\`, \`scaffolding:<concern>\`, \`output-schema:<field>\`
-- \`claim\` = one sentence stating the edit ("Add a precondition check to refuse tool X calls without arg Y")
-- \`severity\` = leverage rating: "critical" when fix resolves a critical failure mode; "high" when it resolves a high; "medium" when it's a quality-of-life win; "info" when it's a cleanup with no behavioral effect
-- \`evidence_uri\` = the failure-mode finding id this fix targets (\`finding://<id>\`) when it exists; else the most representative span
-- \`evidence_excerpt\` = a fragment showing the problem the fix targets
-- \`confidence\` = 0.85+ when the fix is mechanical and the failure mode is well-evidenced; 0.6-0.8 when the fix requires judgment; <0.5 for speculative
-- \`rationale\` = why this candidate beat its alternatives (2 sentences max)
-- \`recommended_action\` = the **literal edit**, phrased as a diff or a quoted replacement: "Replace section X with: '...'" or "Add tool with description: '...'" or "Set retry policy to max_attempts=3 with exponential backoff"
-
-If no upstream failure findings exist in this run, derive your own from the trace dataset using the failure-mode protocol inline (\`searchTrace\` for STATUS_CODE_ERROR / MaxTurnsExceeded / etc.). But prefer to consume upstream findings when present \u2014 the kinds are designed to chain.
-
-Do NOT propose a fix you cannot defend with evidence. "Tighten the prompt" is not a finding; "Add 'When the user asks for X, always Y' to the system prompt section "request-classification"" is.
-
-OBSERVABILITY rules:
-- Each non-final turn must emit at least one \`console.log\` for evidence.
-- Call \`final({ findings: [...] })\` exactly once at the top level.`;
-var IMPROVEMENT_KIND_SPEC = {
-  id: "improvement",
-  description: "Converts upstream failure / gap / poisoning findings into concrete locus-named edits (prompt, tool-doc, RAG, scaffolding) with leverage grades.",
-  area: "improvement",
-  version: "1.0.0",
-  actorDescription: ACTOR_PROMPT2,
-  buildTools: (store) => buildTraceToolsForGroup("all", store),
-  recursion: { maxDepth: 3, maxParallelSubagents: 4 },
-  maxTurns: 30,
-  maxRuntimeChars: 12e3,
-  cost: { kind: "llm" }
-};
-
-// src/analyst/kinds/knowledge-gap.ts
-var ACTOR_PROMPT3 = `You are a knowledge-gap analyst for an OTLP trace dataset. Your job is to identify the **specific pieces of information the agent lacked, or that were stale**, that caused poor decisions.
-
-The agent under analysis maintains a curated knowledge base via \`@tangle-network/agent-knowledge\` \u2014 a wiki of \`KnowledgePage\`s with raw source anchors, claims, and relations. The primary expected store of agent-knowable facts IS that wiki. A "knowledge gap" is anything the agent had to discover or guess at run-time that the wiki should have held \u2014 or an outdated/contradictory fact the agent picked up from a non-wiki source.
-
-DISCOVERY \u2192 ATTRIBUTE-TO-LAYER \u2192 CITE protocol:
-
-1. \`traces.getDatasetOverview({})\` first. Note which agents, tools, and models appear.
-2. Pull traces where the agent shows gap signals. The strongest signals are:
-   - Self-correction turns ("I assumed X but\u2026", "let me re-check", "actually,")
-   - Clarifying-question turns where the agent asked the user something the runtime should have surfaced
-   - Repeated retrieval / lookup calls for the same artifact with slightly varied queries
-   - Tool errors that name a missing argument or unknown resource
-   - Web-search calls returning pages dated before a known cutoff for content that changes (versioned APIs, schemas, policies)
-   - Agent quoting a tool's docs / system prompt incorrectly because the actual text was insufficient
-   - Fabricated identifiers that don't appear in dataset \`sample_trace_ids\`
-   Use \`traces.searchTrace\` with patterns like \`I (don.?t|do not) know\`, \`assumed\`, \`unclear\`, \`could you (clarify|tell me|provide)\`, \`not found\`, \`undefined\`, \`unknown\`, \`null\`, dates older than the analysis window, or the agent's specific clarification phrases.
-3. For each gap, identify the **layer of the runtime that should have prevented it**. The locus is the value of \`subject\` on the finding. Use one of:
-   - \`agent-knowledge:wiki:<page-slug>\` \u2014 the wiki page that should exist but doesn't, or exists but lacks the claim
-   - \`agent-knowledge:wiki:<page-slug>#<heading>\` \u2014 wiki page exists but a specific section is missing
-   - \`agent-knowledge:claim:<topic>\` \u2014 a specific claim/relation triple that should be in the wiki
-   - \`agent-knowledge:raw:<source-id>\` \u2014 raw source captured but never lifted into a curated page
-   - \`agent-knowledge:stale:<page-slug>\` \u2014 wiki page exists but contradicts ground-truth evidence in this trace (the wiki itself drifted)
-   - \`websearch:outdated:<topic>\` \u2014 agent relied on a web result that was stale; wiki should have superseded it
-   - \`tool-doc:<tool-name>:<aspect>\` \u2014 tool description missed a behavior aspect (return shape, failure modes, side effects)
-   - \`system-prompt:<section>\` \u2014 system prompt should have stated the rule directly
-   - \`memory:<key>\` \u2014 prior-run memory should have surfaced an earlier decision
-4. For each gap you can defend with evidence, emit ONE finding with:
-   - \`area\` = "knowledge-gap"
-   - \`subject\` = the locus string from the list above
-   - \`claim\` = a sentence naming the missing or stale knowledge ("wiki has no page on invoice line-item shape, agent had to re-derive it from raw spans")
-   - \`severity\` = "high" when the gap caused a failure or a clarifying question; "medium" when it caused unnecessary turns; "low" when it caused minor inefficiency
-   - \`evidence_uri\` = \`span://<trace_id>/<span_id>\` of the moment the gap surfaced (the question, the self-correction, the retrieval miss, the stale web result)
-   - \`evidence_excerpt\` = exact quote where the agent showed the gap
-   - \`confidence\` = 0.85+ when the agent itself articulated the gap; 0.6-0.8 when inferred from behavior
-   - \`recommended_action\` = phrased as a wiki edit when the locus is \`agent-knowledge:*\` ("Create wiki page \`invoice-line-items\` with claims: ..."), or as a prompt/tool-doc edit otherwise
-
-**Delegate per layer.** After your first scan, you should have candidates spread across \`agent-knowledge:*\`, \`websearch:outdated\`, \`tool-doc:*\`, \`system-prompt:*\`, and \`memory:*\`. Spawn one \`llmQuery\` per layer in parallel \u2014 each subagent runs a focused detection (e.g. the \`agent-knowledge\` subagent looks for both missing-pages AND stale-pages; the \`websearch\` subagent looks specifically for date staleness signals; the \`tool-doc\` subagent looks for tool-call argument errors a fuller description would have prevented). Subagents return findings; you merge and emit one \`final({ findings })\` at the top.
-
-Do NOT report a gap that the agent later recovered from cleanly within the same turn \u2014 that's resilience, not a gap. Cite the *non-recovery* version when both exist.
-
-OBSERVABILITY rules:
-- Each non-final turn must emit at least one \`console.log\` for evidence.
-- Call \`final({ findings: [...] })\` exactly once at the top level.`;
-var KNOWLEDGE_GAP_KIND_SPEC = {
-  id: "knowledge-gap",
-  description: "Identifies missing or stale pieces of knowledge \u2014 primarily against the agent-knowledge wiki \u2014 and attributes each to the runtime layer (wiki page, claim, raw source, websearch, tool-doc, system-prompt, memory) that should have held it.",
-  area: "knowledge-gap",
-  version: "1.0.0",
-  actorDescription: ACTOR_PROMPT3,
-  buildTools: (store) => buildTraceToolsForGroup("discoveryAndSearch", store),
-  recursion: { maxDepth: 2, maxParallelSubagents: 4 },
-  maxTurns: 18,
-  cost: { kind: "llm" }
-};
-
-// src/analyst/kinds/knowledge-poisoning.ts
-var ACTOR_PROMPT4 = `You are a knowledge-poisoning analyst for an OTLP trace dataset. Your job is to identify cases where the agent **confidently used wrong information** \u2014 not where it lacked information (that's the knowledge-gap analyst).
-
-DISCOVERY \u2192 DUAL-VERIFY \u2192 CITE protocol:
-
-1. \`traces.getDatasetOverview({})\` first. Identify the agents, models, and tools.
-2. Pull traces where the agent's confident action was later contradicted. Strongest signals:
-   - Agent stated a fact in one span; a later span surfaced contradictory evidence; the agent then proceeded anyway or fabricated reconciliation.
-   - Tool call with stale arguments (an id that no longer exists, an API shape that changed).
-   - Agent cited an \`agent-knowledge\` wiki page or claim whose content contradicts the trace's own evidence \u2014 the wiki itself drifted.
-   - Web-search result the agent cited that returned an outdated page; agent treated it as canonical.
-   - System-prompt instruction the agent followed that ground-truth evidence in the trace contradicts (e.g. prompt says "use endpoint A"; tool reply says "endpoint A deprecated, use B").
-   - Repeated wrong-shape parsing despite the tool's actual output proving the shape.
-3. Use \`traces.searchTrace\` with regex on phrases like \`actually\`, \`turns out\`, \`previously assumed\`, \`old version\`, \`deprecated\`, \`updated to\`, \`now uses\`, or specific entity names you suspect have changed.
-4. For each candidate poisoning, **DUAL-VERIFY**:
-   - Confirm the agent actually acted on the false belief (cite the span where it did)
-   - Confirm the belief is actually false in this trace's own evidence (cite the span that contradicts it)
-   Only emit a finding when both halves are nailed down. If you can only nail one, drop it \u2014 single-evidence poisoning findings are too speculative to be useful.
-
-**Delegate the dual-verify.** Use the recursion budget so each candidate poisoning gets one subagent investigating "did the agent act?" and one investigating "is the belief false?". After your first scan, fire off N parallel \`llmQuery\` pairs (one cluster per pair). Subagents return their findings; you accept only the ones where BOTH halves of the pair were confirmed.
-
-For each confirmed poisoning, emit ONE finding with:
-- \`area\` = "knowledge-poisoning"
-- \`subject\` = the source of the false belief, one of: \`agent-knowledge:wiki:<page-slug>\` (wiki page contradicts current ground truth), \`agent-knowledge:claim:<topic>\` (a specific claim/relation went stale), \`agent-knowledge:raw:<source-id>\` (the raw source is outdated and the wiki inherited the drift), \`websearch:outdated:<url-or-topic>\`, \`tool-doc:<tool>\`, \`system-prompt:<section>\`, \`memory:<key>\`, \`prior-run-summary:<topic>\`
-- \`claim\` = one sentence: "agent believed X (from source S); evidence in trace shows X is false"
-- \`severity\` = "critical" when poisoning caused a wrong user-visible action; "high" when caught internally but wasted significant work; "medium" for inefficiency only
-- \`evidence_uri\` = \`span://<trace_id>/<span_id>\` of the action span (the moment the agent acted on the false belief)
-- \`evidence_excerpt\` = exact quote of the confident-but-wrong claim or action
-- \`confidence\` = 0.85+ when both halves are exact-quote backed; 0.6-0.8 when one half is inferred
-- \`recommended_action\` = where the source should be updated and how ("Update wiki page \`X\` claim \`Y\` to '...'", "Invalidate raw source \`Z\` and re-curate", "Replace system-prompt section X with 'tool foo now returns Y'")
-
-Do NOT report a finding if the agent caught and corrected the false belief in the same turn \u2014 that's the system working. Reserve poisoning for cases where the false belief shaped downstream action.
-
-OBSERVABILITY rules:
-- Each non-final turn must emit at least one \`console.log\` for evidence.
-- Call \`final({ findings: [...] })\` exactly once at the top level.`;
-var KNOWLEDGE_POISONING_KIND_SPEC = {
-  id: "knowledge-poisoning",
-  description: "Identifies confident-but-wrong actions caused by stale memory, contradicting RAG, deprecated tool docs, or outdated system-prompt instructions.",
-  area: "knowledge-poisoning",
-  version: "1.0.0",
-  actorDescription: ACTOR_PROMPT4,
-  buildTools: (store) => buildTraceToolsForGroup("all", store),
-  recursion: { maxDepth: 2, maxParallelSubagents: 4 },
-  maxTurns: 20,
-  cost: { kind: "llm" }
-};
-
-// src/analyst/kinds/index.ts
-var DEFAULT_TRACE_ANALYST_KINDS = [
-  FAILURE_MODE_KIND_SPEC,
-  KNOWLEDGE_GAP_KIND_SPEC,
-  KNOWLEDGE_POISONING_KIND_SPEC,
-  IMPROVEMENT_KIND_SPEC
-];
-
-// src/analyst/kinds/skill-usage.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
-import { join } from "path";
-var BLOAT_LINE_THRESHOLD = 300;
-var TANGLE_PRIVATE_RE = /\b(cli-bridge|tangletools|ops-board|drew-gtr-pro|@tangle-network\/|~\/company|tangle\.tools|gtm-agent)\b|\bkimi\b|\btcloud\b/gi;
-var TRIGGER_RE = /triggers?\s*[:-]/i;
-function listSkillDirs(root) {
-  if (!existsSync3(root)) return [];
-  const out = [];
-  for (const entry of readdirSync(root, { withFileTypes: true })) {
-    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const skillMd = join(root, entry.name, "SKILL.md");
-    if (existsSync3(skillMd)) out.push({ name: entry.name, path: skillMd });
-  }
-  return out;
-}
-function walkJsonl(dir, cap) {
-  if (!existsSync3(dir)) return [];
-  const files = [];
-  const stack = [dir];
-  while (stack.length) {
-    const cur = stack.pop();
-    let entries;
-    try {
-      entries = readdirSync(cur, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const e of entries) {
-      const full = join(cur, e.name);
-      if (e.isDirectory()) stack.push(full);
-      else if (e.name.endsWith(".jsonl")) {
-        files.push(full);
-        if (cap > 0 && files.length >= cap) return files;
-      }
-    }
-  }
-  return files;
-}
-function frontmatterDescription(body) {
-  const fm = /^---\n([\s\S]*?)\n---/.exec(body);
-  const block = fm?.[1] ?? "";
-  const m = /description:\s*(.+)/i.exec(block);
-  return m?.[1] ?? "";
-}
-function countArtifacts(roots, name, aliases) {
-  let n = 0;
-  for (const root of roots) {
-    const candidates = [join(root, ".evolve", name), ...aliases.map((a) => join(root, a))];
-    for (const dir of candidates) {
-      if (!existsSync3(dir)) continue;
-      try {
-        if (statSync(dir).isDirectory()) n += readdirSync(dir).length;
-        else n += 1;
-      } catch {
-      }
-    }
-  }
-  return n;
-}
-function buildSkillUsageReport(config) {
-  const skills = config.skillRoots.flatMap(
-    ({ root, kind }) => listSkillDirs(root).map((s) => ({ ...s, kind }))
-  );
-  const names = skills.map((s) => s.name);
-  const direct = new Map(names.map((n) => [n, 0]));
-  const slash = new Map(names.map((n) => [n, 0]));
-  const skillRe = /"skill"\s*:\s*"([a-z0-9_:-]+)"/g;
-  const cmdRe = /<command-name>\/?([a-z0-9_:-]+)<\/command-name>/g;
-  let transcripts = 0;
-  for (const dir of config.transcriptDirs) {
-    for (const file of walkJsonl(dir, config.maxTranscriptsPerDir ?? 0)) {
-      transcripts += 1;
-      let data;
-      try {
-        data = readFileSync2(file, "utf8");
-      } catch {
-        continue;
-      }
-      for (const m of data.matchAll(skillRe)) {
-        const g = m[1];
-        if (!g) continue;
-        const n = g.split(":").pop() ?? g;
-        const prev = direct.get(n);
-        if (prev !== void 0) direct.set(n, prev + 1);
-      }
-      for (const m of data.matchAll(cmdRe)) {
-        const g = m[1];
-        if (g === void 0) continue;
-        const prev = slash.get(g);
-        if (prev !== void 0) slash.set(g, prev + 1);
-      }
-    }
-  }
-  const bodies = /* @__PURE__ */ new Map();
-  for (const s of skills) {
-    try {
-      bodies.set(s.name, readFileSync2(s.path, "utf8"));
-    } catch {
-      bodies.set(s.name, "");
-    }
-  }
-  const inbound = new Map(names.map((n) => [n, 0]));
-  for (const target of names) {
-    const ref = new RegExp(`/${target}\\b|\\[\\[${target}\\]\\]`);
-    for (const s of skills) {
-      if (s.name === target) continue;
-      if (ref.test(bodies.get(s.name) ?? "")) inbound.set(target, inbound.get(target) + 1);
-    }
-  }
-  const records = skills.map((s) => {
-    const body = bodies.get(s.name) ?? "";
-    const dir = s.path.replace(/\/SKILL\.md$/, "");
-    return {
-      name: s.name,
-      kind: s.kind,
-      path: s.path,
-      lines: body ? body.split("\n").length : 0,
-      directInvocations: direct.get(s.name) ?? 0,
-      slashInvocations: slash.get(s.name) ?? 0,
-      inboundRefs: inbound.get(s.name) ?? 0,
-      artifactCount: countArtifacts(
-        config.artifactRoots ?? [],
-        s.name,
-        config.artifactAliases?.[s.name] ?? []
-      ),
-      tanglePrivateRefs: (body.match(TANGLE_PRIVATE_RE) ?? []).length,
-      hasReferencesDir: existsSync3(join(dir, "references")),
-      hasEvalsDir: existsSync3(join(dir, "evals")),
-      logsRuns: body.includes("skill-runs.jsonl"),
-      hasTriggerPhrases: TRIGGER_RE.test(frontmatterDescription(body) || body.slice(0, 600))
-    };
-  });
-  return { generatedFromTraces: transcripts, records };
-}
-var ANALYST_ID = "skill-usage";
-function finding(area, subject, claim, severity, confidence, producedAt, recommended, evidenceUri, rationale) {
-  return {
-    schema_version: "1.0.0",
-    finding_id: computeFindingId({ analyst_id: ANALYST_ID, area, subject, claim }),
-    analyst_id: ANALYST_ID,
-    produced_at: producedAt,
-    severity,
-    area,
-    claim,
-    rationale,
-    evidence_refs: [{ kind: "artifact", uri: evidenceUri }],
-    recommended_action: recommended,
-    confidence,
-    subject
-  };
-}
-function emitSkillUsageFindings(report, producedAt) {
-  const out = [];
-  for (const r of report.records) {
-    const directTotal = r.directInvocations + r.slashInvocations;
-    const trueUsage = directTotal + r.inboundRefs + r.artifactCount;
-    if (trueUsage === 0) {
-      out.push(
-        finding(
-          "skill-usage",
-          r.name,
-          `Skill '${r.name}' has zero usage across all signals (direct, slash, inbound-refs, artifacts)`,
-          "high",
-          0.6,
-          producedAt,
-          "Confirm the skill covers a real recurring job; if not, deprecate. Zero true usage is the only deterministic deprecation candidate.",
-          r.path,
-          "No Skill-tool call, no slash invocation, no sibling dispatches to it, and no on-disk artifacts."
-        )
-      );
-    } else if (directTotal === 0 && r.inboundRefs + r.artifactCount > 0) {
-      out.push(
-        finding(
-          "skill-usage",
-          r.name,
-          `Skill '${r.name}' shows 0 direct invocations but is used via orchestration/artifacts (inbound=${r.inboundRefs}, artifacts=${r.artifactCount})`,
-          "info",
-          0.8,
-          producedAt,
-          "Do NOT treat as unused \u2014 usage is real but logged under parent skills or on disk. Strengthen direct-invocation discovery only if direct use is desired.",
-          r.path,
-          "The Skill-tool counter undercounts orchestrated/chained leaf skills."
-        )
-      );
-    }
-    if (directTotal <= 2 && !r.hasTriggerPhrases) {
-      out.push(
-        finding(
-          "discoverability",
-          r.name,
-          `Skill '${r.name}' is rarely invoked directly and its description has no explicit trigger phrases`,
-          "medium",
-          0.7,
-          producedAt,
-          "Add a `Triggers:` clause with verbatim user phrases to the frontmatter description so the model auto-invokes it.",
-          r.path
-        )
-      );
-    }
-    if (r.kind === "public" && r.tanglePrivateRefs > 0) {
-      out.push(
-        finding(
-          "safety",
-          r.name,
-          `Public skill '${r.name}' carries ${r.tanglePrivateRefs} Tangle-private reference(s)`,
-          "high",
-          0.75,
-          producedAt,
-          "Sanitize incidental internal refs (cli-bridge/kimi/tcloud/~company/private repos) or relocate to a private repo. Verify @tangle-network/* refs are to PUBLISHED packages before treating as a leak.",
-          r.path
-        )
-      );
-    }
-    if (r.lines > BLOAT_LINE_THRESHOLD && !r.hasReferencesDir) {
-      out.push(
-        finding(
-          "maintainability",
-          r.name,
-          `Skill '${r.name}' is ${r.lines} lines with no references/ split (progressive disclosure)`,
-          "medium",
-          0.8,
-          producedAt,
-          `Split detail into references/ loaded on demand; keep SKILL.md a short overview. ${r.lines} lines load into every session's context budget.`,
-          r.path
-        )
-      );
-    }
-    if (!r.hasEvalsDir) {
-      out.push(
-        finding(
-          "data-quality",
-          r.name,
-          `Skill '${r.name}' ships no evals/`,
-          "low",
-          0.6,
-          producedAt,
-          "Add evals/evals.json with >=3 scenarios proving the skill beats baseline; gives regression coverage.",
-          r.path
-        )
-      );
-    }
-    if (!r.logsRuns) {
-      out.push(
-        finding(
-          "observability",
-          r.name,
-          `Skill '${r.name}' never appends to .evolve/skill-runs.jsonl`,
-          "low",
-          0.55,
-          producedAt,
-          "Append one run line to .evolve/skill-runs.jsonl on completion, or declare it a non-logging leaf, so the self-improvement loop can see it ran.",
-          r.path
-        )
-      );
-    }
-  }
-  return out;
-}
-var SkillUsageAnalyst = class {
-  id = ANALYST_ID;
-  description = "Deterministic multi-signal skill-usage analysis: flags dead skills, measurement-invisible (orchestrated) usage, discovery gaps, public-repo leaks, bloat, missing evals, and missing run-logging.";
-  inputKind = "custom";
-  cost = { kind: "deterministic", est_usd_per_run: 0 };
-  version = "1.0.0";
-  async analyze(input, ctx) {
-    const producedAt = ctx.tags?.producedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-    ctx.log?.(
-      `skill-usage: ${input.records.length} skills over ${input.generatedFromTraces} transcripts`
-    );
-    return emitSkillUsageFindings(input, producedAt);
-  }
-};
-var SKILL_USAGE_ANALYST = new SkillUsageAnalyst();
-
-// 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 = {}) {
-    for await (const ev of this.runStream(runId, inputs, runOpts)) {
-      if (ev.type === "run-completed") return ev.result;
-    }
-    throw new Error("AnalystRegistry.run: stream completed without run-completed event");
-  }
-  /**
-   * Streaming counterpart to `run()`. Emits `AnalystRunEvent` values
-   * in real time — `run-started`, then per-analyst `skipped` /
-   * `started` / `completed`, then a terminal `run-completed` whose
-   * payload is the full `AnalystRunResult`. UIs use this to render
-   * progress; persistence consumers use `run()` and read the result.
-   *
-   * Hooks (`onBeforeAnalyze` / `onAfterAnalyze` / `onError` /
-   * `onComplete`) fire as before — streaming is additive, not a hook
-   * replacement.
-   */
-  async *runStream(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;
-    yield {
-      type: "run-started",
-      run_id: runId,
-      correlation_id: correlationId,
-      started_at: startedAt,
-      analyst_ids: selected.map((a) => a.id)
-    };
-    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 });
-        yield { type: "analyst-skipped", summary };
-        continue;
-      }
-      const perBudget = allocateBudget(budget, {
-        analyst,
-        remainingUsd,
-        runningCount: selected.length
-      });
-      const ctx = {
-        runId,
-        correlationId,
-        deadlineMs,
-        budgetUsd: perBudget,
-        chat: this.options.chat,
-        tags: runOpts.tags,
-        log: (msg, fields) => log(`[${analyst.id}] ${msg}`, { runId, correlationId, ...fields }),
-        signal: runOpts.signal,
-        priorFindings: selectPriorFindings(runOpts.priorFindings, analyst.id)
-      };
-      await hooks.onBeforeAnalyze?.({ analyst, ctx, runId });
-      yield {
-        type: "analyst-started",
-        analyst_id: analyst.id,
-        started_at: new Date(t0).toISOString()
-      };
-      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 });
-        yield { type: "analyst-completed", summary, findings };
-      } 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 });
-        yield { type: "analyst-completed", summary, findings: hookFindings };
-      }
-    }
-    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 });
-    yield { type: "run-completed", 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 sum3 = 0;
-  for (const f of findings) {
-    const c = f.metadata?.cost_usd;
-    if (typeof c === "number" && Number.isFinite(c)) sum3 += c;
-  }
-  return sum3;
-}
-function selectPriorFindings(source, analystId) {
-  if (!source) return void 0;
-  if (Array.isArray(source)) {
-    const own2 = source.filter((f) => f.analyst_id === analystId);
-    return own2.length > 0 ? own2 : void 0;
-  }
-  const record = source;
-  const own = record[analystId] ?? [];
-  const wildcard = record["*"] ?? [];
-  const merged = [...own, ...wildcard];
-  return merged.length > 0 ? merged : void 0;
-}
+  weightedMean,
+  wilcoxonSignedRank
+} from "./chunk-ITBRCT73.js";
+import {
+  FileSystemTraceStore,
+  InMemoryTraceStore,
+  OTEL_AGENT_EVAL_SCOPE,
+  ReplayCache,
+  ReplayCacheMissError,
+  buildTraceInsightContext,
+  buildTraceInsightPrompt,
+  captureFetchToRawSink,
+  createOtelExporter,
+  createOtelTracingStore,
+  createReplayFetch,
+  defaultTraceInsightPanel,
+  describeTraceInsightScope,
+  domainEvidencePattern,
+  exportRunAsOtlp,
+  flattenOtlpExportToNdjson,
+  inferDomainKeywords,
+  iterateRawCalls,
+  otelRunCompleteHook,
+  otlpToRunRecords,
+  otlpToTraceRunRecords,
+  planTraceInsightQuestions,
+  scoreTraceInsightReadiness,
+  tokenizeDomainWords,
+  traceAnalystOnRunComplete
+} from "./chunk-JHA3ZGSO.js";
+import {
+  DEFAULT_REDACTION_RULES,
+  REDACTION_VERSION,
+  redactString,
+  redactValue
+} from "./chunk-GGE4NNQT.js";
+import {
+  aggregateLlm,
+  argHash,
+  groupBy,
+  judgeSpans,
+  llmSpans,
+  runFailureClass,
+  runsForScenario,
+  toolSpans
+} from "./chunk-47X6LRCE.js";
+import {
+  FAILURE_CLASSES,
+  TRACE_SCHEMA_VERSION,
+  isJudgeSpan,
+  isLlmSpan,
+  isRetrievalSpan,
+  isSandboxSpan,
+  isToolSpan
+} from "./chunk-5BKGXME7.js";
+import {
+  DEFAULT_TRACE_ANALYST_BUDGETS,
+  OtlpFileTraceStore,
+  SpanNotFoundError,
+  TRACE_ANALYST_ACTOR_DESCRIPTION,
+  TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION,
+  TRACE_ANALYST_SUBAGENT_DESCRIPTION,
+  TRACE_ANALYST_TRUNCATION_MARKER_PREFIX,
+  TraceFileMissingError,
+  TraceNotFoundError,
+  analyzeTraces,
+  asNumber,
+  asString,
+  buildTraceAnalystTools,
+  extractOtlpAttributes,
+  firstNumberAttr,
+  firstStringAttr,
+  inferOtlpKind,
+  projectOtlpFlatLine,
+  readOtlpStatus,
+  stringField,
+  traceAnalystFunctionGroup
+} from "./chunk-VUINJM5M.js";
+import {
+  RunIntegrityError,
+  assertRunCaptured,
+  throwIfRunIncomplete
+} from "./chunk-SBCB6VZY.js";
+import {
+  FileSystemRawProviderSink,
+  InMemoryRawProviderSink,
+  NoopRawProviderSink,
+  defaultProviderRedactor,
+  providerFromBaseUrl
+} from "./chunk-PC4UYEBM.js";
+import {
+  AGENT_PROFILE_KINDS,
+  AgentProfileCellValidationError,
+  RunRecordValidationError,
+  agentProfileCellHashMaterial,
+  agentProfileCellKey,
+  assertRunAgentProfileCell,
+  buildAgentProfileCell,
+  buildSandboxAgentProfileCell,
+  groupRunsByAgentProfileCell,
+  isRunRecord,
+  parseRunRecordSafe,
+  requireAgentProfileCell,
+  roundTripRunRecord,
+  toAgentProfileJson,
+  validateAgentProfileCell,
+  validateRunRecord,
+  verifyAgentProfileCell
+} from "./chunk-F3SRAAZO.js";
+import {
+  TraceEmitter,
+  llmSpanFromProvider
+} from "./chunk-TVVP3ZZQ.js";
+import {
+  canonicalize,
+  evaluateHypothesis,
+  hashJson,
+  signManifest,
+  verifyManifest
+} from "./chunk-VSMTAMNK.js";
+import {
+  AgentEvalError,
+  CaptureIntegrityError,
+  ConfigError,
+  JudgeError,
+  NotFoundError,
+  ReplayError,
+  ValidationError,
+  VerificationError
+} from "./chunk-3BFEG2F6.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
 
 // src/auto-pr.ts
 async function proposeAutomatedPullRequest(client, input) {
@@ -2477,12 +541,12 @@ function ghCliClient(opts = {}) {
       await exec("git", ["branch", "-D", input.branchName], { cwd });
       await run("git", ["checkout", "-b", input.branchName]);
       const { mkdir, writeFile } = await import("fs/promises");
-      const { dirname: dirname4, join: join5, resolve } = await import("path");
+      const { dirname: dirname3, join: join4, resolve } = await import("path");
       for (const change of input.fileChanges) {
         const abs = resolve(cwd, change.path);
-        await mkdir(dirname4(abs), { recursive: true });
+        await mkdir(dirname3(abs), { recursive: true });
         await writeFile(abs, change.contents, "utf8");
-        await run("git", ["add", join5(change.path)]);
+        await run("git", ["add", join4(change.path)]);
       }
       const env = {};
       if (input.authorName) env.GIT_AUTHOR_NAME = input.authorName;
@@ -3093,158 +1157,6 @@ var ConvergenceTracker = class {
   }
 };
 
-// src/metrics.ts
-var MODEL_PRICING = {
-  "gpt-4o": { input: 25e-4, output: 0.01 },
-  "gpt-4o-mini": { input: 15e-5, output: 6e-4 },
-  "gpt-4-turbo": { input: 0.01, output: 0.03 },
-  "claude-sonnet-4-20250514": { input: 3e-3, output: 0.015 },
-  "claude-opus-4-20250514": { input: 0.015, output: 0.075 },
-  "claude-3-haiku-20240307": { input: 25e-5, output: 125e-5 }
-};
-var FAMILY_PRICING = [
-  [/claude.*opus/, { input: 0.015, output: 0.075 }],
-  [/claude.*haiku/, { input: 8e-4, output: 4e-3 }],
-  [/claude.*sonnet|claude-code|claude-sonnet/, { input: 3e-3, output: 0.015 }],
-  [/gpt-4o-mini/, { input: 15e-5, output: 6e-4 }],
-  [/gpt-5|gpt-4\.1|o[134]\b/, { input: 125e-5, output: 0.01 }],
-  [/gpt-4o|gpt-4/, { input: 25e-4, output: 0.01 }],
-  [/deepseek/, { input: 3e-4, output: 11e-4 }],
-  [/glm|zhipu|zai/, { input: 6e-4, output: 22e-4 }],
-  [/kimi|moonshot/, { input: 6e-4, output: 25e-4 }],
-  [/qwen/, { input: 4e-4, output: 12e-4 }],
-  [/gemini.*flash/, { input: 1e-4, output: 4e-4 }],
-  [/gemini/, { input: 125e-5, output: 5e-3 }],
-  [/llama/, { input: 2e-4, output: 6e-4 }]
-];
-function normalizeModelId(model) {
-  return (model.split("@")[0] ?? model).trim().toLowerCase();
-}
-function resolveModelPricing(model) {
-  if (MODEL_PRICING[model]) return MODEL_PRICING[model];
-  const id = normalizeModelId(model);
-  if (MODEL_PRICING[id]) return MODEL_PRICING[id];
-  for (const [pattern, price] of FAMILY_PRICING) {
-    if (pattern.test(id)) return price;
-  }
-  return null;
-}
-function isModelPriced(model) {
-  return resolveModelPricing(model) !== null;
-}
-var warnedUnpricedModels = /* @__PURE__ */ new Set();
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function estimateCost(inputTokens, outputTokens, model) {
-  const pricing = resolveModelPricing(model);
-  if (!pricing) {
-    if (!warnedUnpricedModels.has(model)) {
-      warnedUnpricedModels.add(model);
-      console.warn(
-        `estimateCost: no pricing for model "${model}" \u2014 returning 0; add it to MODEL_PRICING/FAMILY_PRICING (cost/Pareto axes will be blank until then)`
-      );
-    }
-    return 0;
-  }
-  return inputTokens / 1e3 * pricing.input + outputTokens / 1e3 * pricing.output;
-}
-var TokenCounter = class {
-  totalInput = 0;
-  totalOutput = 0;
-  totalCost = 0;
-  model;
-  constructor(model = "gpt-4o") {
-    this.model = model;
-  }
-  /** Record tokens for a turn, returns per-turn cost */
-  record(inputTokens, outputTokens) {
-    this.totalInput += inputTokens;
-    this.totalOutput += outputTokens;
-    const cost = estimateCost(inputTokens, outputTokens, this.model);
-    this.totalCost += cost;
-    return cost;
-  }
-  /** Estimate and record from raw text */
-  recordFromText(inputText, outputText) {
-    const inputTokens = estimateTokens(inputText);
-    const outputTokens = estimateTokens(outputText);
-    const cost = this.record(inputTokens, outputTokens);
-    return { inputTokens, outputTokens, cost };
-  }
-  getTotalInput() {
-    return this.totalInput;
-  }
-  getTotalOutput() {
-    return this.totalOutput;
-  }
-  getTotalCost() {
-    return this.totalCost;
-  }
-};
-var MetricsCollector = class {
-  client;
-  workspaceId;
-  metrics = [];
-  constructor(client, workspaceId) {
-    this.client = client;
-    this.workspaceId = workspaceId;
-  }
-  /** Collect metrics after a turn completes */
-  async collect(turn, responseLatencyMs, responseChars, codeBlocksProduced, blocksExtracted, completionCriteriaMet, completionCriteriaTotal, qualityScore, inputTokens = 0, outputTokens = 0, estimatedCostUsd = 0) {
-    const state = await this.getState();
-    const m = {
-      turn,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      tasks: state.tasks,
-      events: state.events,
-      proposals: state.proposals,
-      vaultFiles: state.vaultFiles.length,
-      responseLatencyMs,
-      responseChars,
-      codeBlocksProduced,
-      blocksExtracted,
-      qualityScore,
-      inputTokens,
-      outputTokens,
-      estimatedCostUsd,
-      totalCostUsd: estimatedCostUsd,
-      completionPercent: completionCriteriaTotal > 0 ? completionCriteriaMet / completionCriteriaTotal * 100 : 0
-    };
-    this.metrics.push(m);
-    return m;
-  }
-  /** Get current product state */
-  async getState() {
-    const [tasks, events, approvals, vaultFiles] = await Promise.all([
-      this.client.getTasks(this.workspaceId),
-      this.client.getEvents(this.workspaceId),
-      this.client.getApprovals(this.workspaceId),
-      this.client.getVaultTree(this.workspaceId)
-    ]);
-    return {
-      tasks: tasks.length,
-      events: events.length,
-      proposals: {
-        pending: approvals.filter((a) => a.status === "pending").length,
-        approved: approvals.filter((a) => a.status === "approved").length,
-        rejected: approvals.filter((a) => a.status === "rejected").length
-      },
-      vaultFiles,
-      codeBlocks: 0,
-      generations: 0
-    };
-  }
-  /** Get all collected metrics */
-  getMetrics() {
-    return [...this.metrics];
-  }
-  /** Get convergence curve (completion% over turns) */
-  getConvergenceCurve() {
-    return this.metrics.map((m) => m.completionPercent);
-  }
-};
-
 // src/driver.ts
 var RIGOR_STANCE = {
   cooperative: "Your stance: a pragmatic early adopter. You accept reasonable answers and only push back on clear gaps or outright errors.",
@@ -3517,10 +1429,10 @@ var FileSystemFeedbackTrajectoryStore = class {
   }
   async append(record) {
     const { appendFile, mkdir } = await import("fs/promises");
-    const { join: join5 } = await import("path");
+    const { join: join4 } = await import("path");
     await mkdir(this.dir, { recursive: true });
     await appendFile(
-      join5(this.dir, "feedback-trajectories.ndjson"),
+      join4(this.dir, "feedback-trajectories.ndjson"),
       `${JSON.stringify(record)}
 `,
       "utf8"
@@ -3529,8 +1441,8 @@ var FileSystemFeedbackTrajectoryStore = class {
   async load() {
     if (this.loaded) return;
     const { readFile } = await import("fs/promises");
-    const { join: join5 } = await import("path");
-    const file = join5(this.dir, "feedback-trajectories.ndjson");
+    const { join: join4 } = await import("path");
+    const file = join4(this.dir, "feedback-trajectories.ndjson");
     try {
       const raw = await readFile(file, "utf8");
       for (const line of raw.split("\n")) {
@@ -3843,21 +1755,21 @@ var SingleBackendError = class extends AgentEvalError {
 function stripSlash(url) {
   return url.replace(/\/+$/, "");
 }
-function assertSingleBackend(agent2, judge, opts = {}) {
+function assertSingleBackend(agent, judge, opts = {}) {
   const divergences = [];
-  if (agent2.kind !== judge.kind) {
-    divergences.push({ field: "kind", agent: agent2.kind, judge: judge.kind });
+  if (agent.kind !== judge.kind) {
+    divergences.push({ field: "kind", agent: agent.kind, judge: judge.kind });
   }
-  if (stripSlash(agent2.baseUrl) !== stripSlash(judge.baseUrl)) {
-    divergences.push({ field: "baseUrl", agent: agent2.baseUrl, judge: judge.baseUrl });
+  if (stripSlash(agent.baseUrl) !== stripSlash(judge.baseUrl)) {
+    divergences.push({ field: "baseUrl", agent: agent.baseUrl, judge: judge.baseUrl });
   }
-  if (agent2.model !== judge.model) {
-    divergences.push({ field: "model", agent: agent2.model, judge: judge.model });
+  if (agent.model !== judge.model) {
+    divergences.push({ field: "model", agent: agent.model, judge: judge.model });
   }
-  if (agent2.provider !== judge.provider) {
-    divergences.push({ field: "provider", agent: agent2.provider, judge: judge.provider });
+  if (agent.provider !== judge.provider) {
+    divergences.push({ field: "provider", agent: agent.provider, judge: judge.provider });
   }
-  const agentHasKey = Boolean(agent2.apiKey);
+  const agentHasKey = Boolean(agent.apiKey);
   const judgeHasKey = Boolean(judge.apiKey);
   if (agentHasKey !== judgeHasKey) {
     divergences.push({
@@ -4910,194 +2822,6 @@ function pathExists(obj, path) {
   return true;
 }
 
-// src/completion-verifier.ts
-var STOPWORDS = /* @__PURE__ */ new Set([
-  "the",
-  "a",
-  "an",
-  "of",
-  "for",
-  "and",
-  "or",
-  "to",
-  "in",
-  "on",
-  "with",
-  "by"
-]);
-var MATCH_THRESHOLD = 0.5;
-var MIN_CONTENT_CHARS = 50;
-function tokens(s) {
-  return new Set(
-    s.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 1 && !STOPWORDS.has(t))
-  );
-}
-function tokenRecall(requirementText, candidateText) {
-  const req = tokens(requirementText);
-  if (req.size === 0) return 0;
-  const cand = tokens(candidateText);
-  let hit = 0;
-  for (const t of req) if (cand.has(t)) hit++;
-  return hit / req.size;
-}
-function artifactCandidates(req, reqIndex, artifacts) {
-  const reqText = `${req.title} ${req.category ?? ""}`;
-  const out = [];
-  artifacts.forEach((a, i) => {
-    if ((a.content ?? "").trim().length < MIN_CONTENT_CHARS) return;
-    let score = tokenRecall(reqText, `${a.path ?? ""} ${a.kind}`);
-    if (req.category && a.kind && req.category.toLowerCase() === a.kind.toLowerCase()) {
-      score = Math.max(score, 1);
-    }
-    if (score < MATCH_THRESHOLD) return;
-    out.push({
-      reqIndex,
-      itemKey: `artifact:${i}`,
-      score,
-      evidence: `artifact '${a.path ?? a.kind}' matched (token recall ${score.toFixed(2)})`,
-      content: a.content ?? null
-    });
-  });
-  return out;
-}
-function proposalCandidates(req, reqIndex, proposals) {
-  const reqText = `${req.title} ${req.category ?? ""}`;
-  const out = [];
-  for (const p of proposals) {
-    if (p.status !== "approved") continue;
-    const score = tokenRecall(reqText, p.title);
-    if (score < MATCH_THRESHOLD) continue;
-    const body = p.content ?? "";
-    out.push({
-      reqIndex,
-      itemKey: `proposal:${p.id}`,
-      score,
-      evidence: `approved proposal '${p.title}' matched (token recall ${score.toFixed(2)})`,
-      content: body.trim().length >= MIN_CONTENT_CHARS ? body : null
-    });
-  }
-  return out;
-}
-function toolCallCandidates(req, reqIndex, toolCalls) {
-  const out = [];
-  toolCalls.forEach((name, i) => {
-    const score = tokenRecall(req.title, name);
-    if (score < MATCH_THRESHOLD) return;
-    out.push({
-      reqIndex,
-      itemKey: `tool:${i}`,
-      score,
-      evidence: `tool call '${name}' matched (token recall ${score.toFixed(2)})`,
-      content: null
-    });
-  });
-  return out;
-}
-async function verifyCompletion(gold, state, checkCorrectness) {
-  if (gold.requirements.length === 0) {
-    throw new Error(
-      `verifyCompletion: task '${gold.taskId}' has no requirements \u2014 malformed gold spec`
-    );
-  }
-  const candidates = [];
-  gold.requirements.forEach((req, i) => {
-    const by = req.satisfiedBy ?? "any";
-    if (by === "artifact" || by === "any") {
-      candidates.push(...artifactCandidates(req, i, state.artifacts));
-    }
-    if (by === "proposal" || by === "any") {
-      candidates.push(...proposalCandidates(req, i, state.proposals));
-    }
-    if (by === "tool-call" || by === "any") {
-      candidates.push(...toolCallCandidates(req, i, state.toolCalls));
-    }
-  });
-  candidates.sort((a, b) => b.score - a.score);
-  const assigned = /* @__PURE__ */ new Map();
-  const itemTaken = /* @__PURE__ */ new Set();
-  for (const c of candidates) {
-    if (assigned.has(c.reqIndex) || itemTaken.has(c.itemKey)) continue;
-    assigned.set(c.reqIndex, c);
-    itemTaken.add(c.itemKey);
-  }
-  const requirements = [];
-  for (let i = 0; i < gold.requirements.length; i++) {
-    const req = gold.requirements[i];
-    const match = assigned.get(i);
-    const evidence = [];
-    let correct = null;
-    if (match) {
-      evidence.push(match.evidence);
-      if (match.content !== null) {
-        const r = await checkCorrectness(req, match.content);
-        correct = r.correct;
-        evidence.push(`correctness: ${r.correct ? "pass" : "fail"} \u2014 ${r.reason}`);
-      } else {
-        evidence.push("correctness: not assessed \u2014 matched item carries no content");
-      }
-    } else {
-      const by = req.satisfiedBy ?? "any";
-      const kind = by === "any" ? "artifact/proposal/tool-call" : by;
-      evidence.push(`no produced ${kind} matched this requirement`);
-    }
-    const structurallyPresent = match !== void 0;
-    const satisfied = structurallyPresent && correct !== false;
-    requirements.push({
-      reqId: req.reqId,
-      title: req.title,
-      structurallyPresent,
-      correct,
-      satisfied,
-      evidence
-    });
-  }
-  const satisfiedCount = requirements.filter((r) => r.satisfied).length;
-  return {
-    taskId: gold.taskId,
-    requirements,
-    completionRate: satisfiedCount / requirements.length,
-    fullyComplete: satisfiedCount === requirements.length
-  };
-}
-function parseCorrectnessResponse(raw) {
-  const match = raw.match(/\{[\s\S]*\}/);
-  if (!match) {
-    throw new Error(`correctness checker: no JSON object in model response: ${raw.slice(0, 200)}`);
-  }
-  const parsed = JSON.parse(match[0]);
-  if (typeof parsed.correct !== "boolean") {
-    throw new Error(`correctness checker: 'correct' is not a boolean in: ${match[0].slice(0, 200)}`);
-  }
-  return { correct: parsed.correct, reason: typeof parsed.reason === "string" ? parsed.reason : "" };
-}
-function createLlmCorrectnessChecker(tc, opts = {}) {
-  const model = opts.model ?? "claude-sonnet-4-6";
-  const maxContentChars = opts.maxContentChars ?? 8e3;
-  return async (requirement, content) => {
-    const resp = await tc.chat({
-      model,
-      messages: [
-        {
-          role: "system",
-          content: 'You verify whether a produced work artifact actually fulfils a stated requirement. Judge fulfilment only \u2014 is the deliverable substantively present and on-point \u2014 not polish. A plan to do it later, a vague gesture, or a description of what should be done does NOT fulfil a requirement; the artifact must BE the deliverable. Respond with a single JSON object: {"correct": boolean, "reason": string (<= 30 words)}.'
-        },
-        {
-          role: "user",
-          content: `Requirement: ${requirement.title}
-${requirement.category ? `Category: ${requirement.category}
-` : ""}
-Produced artifact:
-${content.slice(0, maxContentChars)}`
-        }
-      ],
-      temperature: 0,
-      maxTokens: 200
-    });
-    const raw = resp.choices?.[0]?.message?.content ?? "";
-    return parseCorrectnessResponse(raw);
-  };
-}
-
 // src/dual-agent-bench.ts
 var DualAgentBench = class {
   async run(config) {
@@ -5752,40 +3476,6 @@ function canonicalInstruction(value) {
   return normalized.length === 0 ? normalized : normalized[0].toUpperCase() + normalized.slice(1);
 }
 
-// src/produced-state.ts
-function artifactKind(mimeType) {
-  if (!mimeType) return "file";
-  if (mimeType.includes("json")) return "json";
-  if (mimeType.startsWith("text/")) return "text";
-  return "file";
-}
-function extractProducedState(events) {
-  const artifacts = [];
-  const proposals = [];
-  const toolCalls = [];
-  const seenTools = /* @__PURE__ */ new Set();
-  for (const ev of events) {
-    if (ev.type === "tool_call") {
-      const name = ev.toolName;
-      if (name && !seenTools.has(name)) {
-        seenTools.add(name);
-        toolCalls.push(name);
-      }
-    } else if (ev.type === "artifact") {
-      const a = ev;
-      artifacts.push({
-        kind: artifactKind(a.mimeType),
-        path: a.name ?? a.uri ?? a.artifactId,
-        content: a.content ?? ""
-      });
-    } else if (ev.type === "proposal_created") {
-      const p = ev;
-      proposals.push({ id: p.proposalId, title: p.title, status: p.status ?? "pending" });
-    }
-  }
-  return { artifacts, proposals, toolCalls };
-}
-
 // src/prompt-registry.ts
 var PromptRegistry = class {
   entries = /* @__PURE__ */ new Map();
@@ -5885,12 +3575,17 @@ function renderSteeringText(bundle) {
     ([a], [b]) => a.localeCompare(b)
   );
   for (const [name, prompt] of reviewers) lines.push(`reviewer:${name}:${prompt}`);
+  const roles = Object.entries(bundle.rolePrompts ?? {}).sort(([a], [b]) => a.localeCompare(b));
+  for (const [name, role] of roles) {
+    lines.push(`role:${name}:system:${role.system ?? ""}:append:${role.append ?? ""}`);
+  }
   const skills = [...bundle.skills ?? []].sort();
   if (skills.length) lines.push(`skills:${skills.join(",")}`);
   return lines.join("\n");
 }
 
 // src/steering-optimizer.ts
+import { AxGEPA, ai, ax } from "@ax-llm/ax";
 var PairwiseSteeringOptimizer = class {
   optimize(rows, config = {}) {
     const ranked = rankRows(rows, config.weights);
@@ -5910,36 +3605,25 @@ var AxGepaSteeringOptimizer = class {
   config;
   async optimize(rows) {
     const fallback = new PairwiseSteeringOptimizer().optimize(rows, this.config);
-    const minRows = this.config.minRows ?? 6;
+    const minScenarioWinners = this.config.minScenarioWinners ?? 6;
     const variantIds = [...new Set(rows.map((row) => row.variantId))];
     const byScenario = collapseScenarioWinners(rows, this.config.weights);
-    if (variantIds.length < 2 || byScenario.length < minRows) {
-      return {
-        ...fallback,
-        backend: "ax-gepa",
-        skipped: true,
-        rationale: `AxGEPA skipped: need >=2 variants and >=${minRows} scenario winners, got ${variantIds.length} variant(s) and ${byScenario.length} scenario winner(s).`
-      };
-    }
-    let axLib;
-    try {
-      axLib = await import("@ax-llm/ax");
-    } catch {
+    if (variantIds.length < 2 || byScenario.length < minScenarioWinners) {
       return {
         ...fallback,
         backend: "ax-gepa",
         skipped: true,
-        rationale: "AxGEPA unavailable: install @ax-llm/ax to enable selector optimization."
+        rationale: `AxGEPA skipped: need >=2 variants and >=${minScenarioWinners} scenario winners, got ${variantIds.length} variant(s) and ${byScenario.length} scenario winner(s).`
       };
     }
-    const { ai, ax, AxGEPA } = axLib;
     const signature = `task:string, split:string, seedPreview:string -> variantId:class "${variantIds.join(", ")}", rationale:string`;
     const selector = ax(signature, {
       description: "Choose the best steering bundle variant for an autopilot task."
     });
-    const splitIndex = Math.max(1, Math.floor(byScenario.length * 0.8));
-    const train = byScenario.slice(0, splitIndex);
-    const validation = byScenario.slice(splitIndex);
+    const shuffled = seededShuffle(byScenario, signature);
+    const splitIndex = Math.max(1, Math.floor(shuffled.length * 0.8));
+    const train = shuffled.slice(0, splitIndex);
+    const validation = shuffled.slice(splitIndex);
     if (!validation.length) {
       return {
         ...fallback,
@@ -5948,10 +3632,10 @@ var AxGepaSteeringOptimizer = class {
         rationale: "AxGEPA skipped: no validation examples after split."
       };
     }
+    const studentAI = createAxService(this.config.provider, this.config.apiKey, this.config.model);
     const optimizer = new AxGEPA({
-      studentAI: createAxService(ai, this.config.provider, this.config.apiKey, this.config.model),
+      studentAI,
       teacherAI: createAxService(
-        ai,
         this.config.provider,
         this.config.apiKey,
         this.config.teacherModel ?? this.config.model
@@ -5965,7 +3649,7 @@ var AxGepaSteeringOptimizer = class {
     const compiled = await optimizer.compile(
       selector,
       train,
-      ({ prediction, example }) => prediction?.variantId === example?.variantId ? 1 : 0,
+      (input) => input.prediction?.variantId === input.example?.variantId ? 1 : 0,
       {
         validationExamples: validation,
         maxMetricCalls: 64
@@ -5974,6 +3658,13 @@ var AxGepaSteeringOptimizer = class {
     if (compiled.optimizedProgram !== void 0) {
       selector.applyOptimization(compiled.optimizedProgram);
     }
+    const selectVariant = async (row) => {
+      const prediction = await selector.forward(studentAI, row);
+      return {
+        variantId: String(prediction.variantId),
+        rationale: String(prediction.rationale ?? "")
+      };
+    };
     return {
       ...fallback,
       backend: "ax-gepa",
@@ -5983,7 +3674,8 @@ var AxGepaSteeringOptimizer = class {
         signature,
         labels: variantIds,
         rationale: compiled.bestScore !== void 0 ? `bestScore=${compiled.bestScore}` : void 0
-      }
+      },
+      selectVariant
     };
   }
 };
@@ -6017,13 +3709,39 @@ function collapseScenarioWinners(rows, weights) {
     };
   });
 }
-function createAxService(aiFactory, provider, apiKey, model) {
-  return aiFactory({
+function createAxService(provider, apiKey, model) {
+  return ai({
     name: provider,
     apiKey,
     config: { model }
   });
 }
+function seededShuffle(items, seed) {
+  const rng = mulberry32(hashString(seed));
+  const out = [...items];
+  for (let i = out.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1));
+    [out[i], out[j]] = [out[j], out[i]];
+  }
+  return out;
+}
+function hashString(value) {
+  let h = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    h ^= value.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
 
 // src/workspace-inspector.ts
 var InMemoryWorkspaceInspector = class {
@@ -6258,8 +3976,8 @@ function assertNonNegative(n, name) {
 }
 
 // src/muffled-gate-scanner.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { join } from "path";
 function codeOf(line) {
   return line.replace(/\/\/.*$/, "").replace(/^\s*\*.*$/, "");
 }
@@ -6371,14 +4089,14 @@ var UNIVERSAL_FINDERS = [findConstructorCwdDropped];
 function autoDeriveImporters(repoRoot, roots, extensions, importsContain) {
   const matches = [];
   const walk = (rel) => {
-    const abs = join2(repoRoot, rel);
-    if (!existsSync4(abs)) return;
-    for (const entry of readdirSync2(abs)) {
-      const sub = join2(rel, entry);
-      const subAbs = join2(repoRoot, sub);
+    const abs = join(repoRoot, rel);
+    if (!existsSync(abs)) return;
+    for (const entry of readdirSync(abs)) {
+      const sub = join(rel, entry);
+      const subAbs = join(repoRoot, sub);
       let st;
       try {
-        st = statSync2(subAbs);
+        st = statSync(subAbs);
       } catch {
         continue;
       }
@@ -6391,7 +4109,7 @@ function autoDeriveImporters(repoRoot, roots, extensions, importsContain) {
           continue;
         let text;
         try {
-          text = readFileSync3(subAbs, "utf8");
+          text = readFileSync(subAbs, "utf8");
         } catch {
           continue;
         }
@@ -6406,9 +4124,9 @@ function scanForMuffledGates(opts) {
   const findings = [];
   const scanned = /* @__PURE__ */ new Set();
   for (const file of opts.scanFiles) {
-    const abs = join2(opts.repoRoot, file);
-    if (!existsSync4(abs)) continue;
-    const text = readFileSync3(abs, "utf8");
+    const abs = join(opts.repoRoot, file);
+    if (!existsSync(abs)) continue;
+    const text = readFileSync(abs, "utf8");
     for (const find of opts.finders) findings.push(...find(file, text));
     scanned.add(file);
   }
@@ -6421,9 +4139,9 @@ function scanForMuffledGates(opts) {
     );
     for (const file of importers) {
       if (scanned.has(file)) continue;
-      const abs = join2(opts.repoRoot, file);
-      if (!existsSync4(abs)) continue;
-      const text = readFileSync3(abs, "utf8");
+      const abs = join(opts.repoRoot, file);
+      if (!existsSync(abs)) continue;
+      const text = readFileSync(abs, "utf8");
       for (const find of opts.autoDerive.universalFinders) findings.push(...find(file, text));
     }
   }
@@ -6573,8 +4291,8 @@ function isObject(v) {
 }
 
 // src/scorecard.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname2 } from "path";
+import { appendFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2 } from "fs";
+import { dirname } from "path";
 function median(xs) {
   if (xs.length === 0) return 0;
   const sorted = [...xs].sort((a, b) => a - b);
@@ -6639,8 +4357,8 @@ function recordRuns(runs, opts) {
 }
 function appendScorecard(logPath, lines) {
   if (lines.length === 0) return;
-  mkdirSync2(dirname2(logPath), { recursive: true });
-  appendFileSync2(logPath, `${lines.map((line) => JSON.stringify(line)).join("\n")}
+  mkdirSync(dirname(logPath), { recursive: true });
+  appendFileSync(logPath, `${lines.map((line) => JSON.stringify(line)).join("\n")}
 `);
 }
 function recordRunsToScorecard(logPath, runs, opts) {
@@ -6649,10 +4367,10 @@ function recordRunsToScorecard(logPath, runs, opts) {
   return lines;
 }
 function loadScorecard(logPath) {
-  if (!existsSync5(logPath)) return { cells: [], profiles: {} };
+  if (!existsSync2(logPath)) return { cells: [], profiles: {} };
   const cells = /* @__PURE__ */ new Map();
   const profiles = {};
-  for (const raw of readFileSync4(logPath, "utf8").split("\n")) {
+  for (const raw of readFileSync2(logPath, "utf8").split("\n")) {
     const line = raw.trim();
     if (!line) continue;
     let parsed;
@@ -6917,9 +4635,9 @@ function statusAdvanced(key, progression) {
     description: `"${key}" progressed along ${progression.join("\u2192")}`,
     score: ({ before, after }) => {
       const bi = progression.indexOf(String(before[key]));
-      const ai = progression.indexOf(String(after[key]));
-      if (bi === -1 || ai === -1) return 0;
-      return ai >= bi ? 1 : 0;
+      const ai2 = progression.indexOf(String(after[key]));
+      if (bi === -1 || ai2 === -1) return 0;
+      return ai2 >= bi ? 1 : 0;
     }
   };
 }
@@ -7529,7 +5247,7 @@ async function commitBisect(options) {
 }
 async function promptBisect(options) {
   const split = options.paragraphSplitter ?? ((p) => p.split(/\n\s*\n/));
-  const join5 = (paragraphs) => paragraphs.join("\n\n");
+  const join4 = (paragraphs) => paragraphs.join("\n\n");
   const goodParas = split(options.good);
   const badParas = split(options.bad);
   if (goodParas.length !== badParas.length) {
@@ -7549,7 +5267,7 @@ async function promptBisect(options) {
   const result = await bisect({
     good: goodMask,
     bad: badMask,
-    runEval: (mask) => options.runEval(join5(paragraphsFor(mask))),
+    runEval: (mask) => options.runEval(join4(paragraphsFor(mask))),
     maxIterations: options.maxIterations ?? n + 5,
     halfway: (g, b) => {
       for (let i = 0; i < g.length; i++) {
@@ -7580,12 +5298,12 @@ async function promptBisect(options) {
     }
   }
   const materializedPath = result.path.map((s) => ({
-    state: join5(paragraphsFor(s.state)),
+    state: join4(paragraphsFor(s.state)),
     score: s.score,
     pass: s.pass
   }));
   return {
-    culprit: join5(paragraphsFor(culprit)),
+    culprit: join4(paragraphsFor(culprit)),
     path: materializedPath,
     converged: result.converged,
     inputInconsistent: result.inputInconsistent,
@@ -8079,8 +5797,8 @@ async function runSelfPlay(proposer, scorer, targets, options = {}) {
 
 // src/command-runner.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { join as join2 } from "path";
 var localCommandRunner = {
   name: "local",
   async run(input) {
@@ -8108,11 +5826,11 @@ var localCommandRunner = {
     return r.status === 0 && (r.stdout ?? "").trim().length > 0;
   },
   async fileExists(path) {
-    return existsSync6(path);
+    return existsSync3(path);
   },
   async readFile(path) {
     try {
-      return readFileSync5(path, "utf8");
+      return readFileSync3(path, "utf8");
     } catch {
       return null;
     }
@@ -8120,14 +5838,14 @@ var localCommandRunner = {
   async readDir(path) {
     let entries;
     try {
-      entries = readdirSync3(path);
+      entries = readdirSync2(path);
     } catch {
       return [];
     }
     const out = [];
     for (const name of entries) {
       try {
-        const st = statSync3(join3(path, name));
+        const st = statSync2(join2(path, name));
         out.push({
           name,
           isDirectory: st.isDirectory(),
@@ -8466,11 +6184,11 @@ function flowLayer(input) {
 
 // src/intent-match-judge.ts
 var INTENT_MATCH_JUDGE_VERSION = "intent-match-judge-v1-2026-04-24";
-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 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 INTENT_SCHEMA = {
   type: "object",
   additionalProperties: false,
@@ -8480,12 +6198,12 @@ var INTENT_SCHEMA = {
     evidence: { type: "string", minLength: 10, maxLength: 400 }
   }
 };
-function truncate2(body, cap, label) {
+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 buildPrompt2(input, opts) {
+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 ?? "";
@@ -8504,10 +6222,10 @@ ${input.artifactLabel ? `ARTIFACT METADATA:
   description: ${input.artifactDescription ?? ""}
 
 ` : ""}${html ? `SERVED HTML (what the preview returns):
-${truncate2(html, opts.maxHtmlChars, "HTML")}
+${truncate(html, opts.maxHtmlChars, "HTML")}
 
 ` : ""}SOURCE FILES (the agent's workdir):
-${truncate2(sourceBlob, opts.maxSourceChars, "source")}
+${truncate(sourceBlob, opts.maxSourceChars, "source")}
 
 Score 0\u20131:
   1.0 \u2014 unmistakably the right app. Even with bugs, gaps, or missing
@@ -8535,11 +6253,11 @@ Return STRICT JSON. No prose outside.`;
 async function runIntentMatchJudge(input, options = {}) {
   const start = Date.now();
   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,
+    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 ?? {}
   };
   if (input.sourceFiles.length === 0 && !input.servedHtml) {
@@ -8563,7 +6281,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: buildPrompt2(input, opts) }
+          { role: "user", content: buildPrompt(input, opts) }
         ],
         jsonSchema: { name: "intent_match_judge", schema: INTENT_SCHEMA },
         temperature: 0,
@@ -9045,8 +6763,8 @@ function multiToolchainLayer(config) {
 }
 
 // src/reference-replay.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname3 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync4, 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) {
@@ -9164,14 +6882,14 @@ function jsonlReferenceReplayStore(path) {
   return {
     async save(run) {
       await lock.runExclusive(() => {
-        mkdirSync3(dirname3(path), { recursive: true });
-        appendFileSync3(path, `${JSON.stringify(run)}
+        mkdirSync2(dirname2(path), { recursive: true });
+        appendFileSync2(path, `${JSON.stringify(run)}
 `);
       });
     },
     async list() {
       return lock.runExclusive(() => {
-        if (!existsSync7(path)) return [];
+        if (!existsSync4(path)) return [];
         return readJsonl(path);
       });
     }
@@ -9464,8 +7182,8 @@ function ratio(numerator, denominator) {
   return denominator > 0 ? numerator / denominator : 0;
 }
 function tokenJaccard(a, b) {
-  const left = new Set(tokens2(a));
-  const right = new Set(tokens2(b));
+  const left = new Set(tokens(a));
+  const right = new Set(tokens(b));
   if (left.size === 0 || right.size === 0) return 0;
   let intersection = 0;
   for (const token of left) {
@@ -9483,7 +7201,7 @@ function tagOverlap(a, b) {
   }
   return intersection / Math.max(left.size, right.size);
 }
-function tokens2(text) {
+function tokens(text) {
   return normalize(text).split(/\s+/).filter((token) => token.length >= 3 && !STOP_WORDS.has(token));
 }
 function normalize(text) {
@@ -9514,7 +7232,7 @@ function throwIfAborted(signal) {
   throw new Error(signal.reason ? String(signal.reason) : "reference replay aborted");
 }
 function readJsonl(path) {
-  const raw = readFileSync6(path, "utf8");
+  const raw = readFileSync4(path, "utf8");
   const out = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
@@ -9671,7 +7389,7 @@ function createDefaultReviewer(options) {
 
 // src/discover-personas.ts
 import { promises as fs } from "fs";
-import { basename, extname, join as join4 } from "path";
+import { basename, extname, join as join3 } from "path";
 var DEFAULT_PATTERN = /^\d{2}-.+\.(yaml|yml|json|md)$/;
 async function discoverPersonas(dir, opts = {}) {
   const pattern = opts.pattern ?? DEFAULT_PATTERN;
@@ -9689,7 +7407,7 @@ async function discoverPersonas(dir, opts = {}) {
     }
     const out = [];
     for (const entry of entries) {
-      const full = join4(d, entry.name);
+      const full = join3(d, entry.name);
       if (entry.isDir) {
         if (opts.recursive) out.push(...await walk(full));
         continue;
@@ -10516,9 +8234,9 @@ function jaccard(a, b) {
 }
 
 // src/campaign/distillation/gold-scenarios.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 function loadGoldScenarios(jsonlPath) {
-  const text = readFileSync7(jsonlPath, "utf8");
+  const text = readFileSync5(jsonlPath, "utf8");
   return parseGoldJsonl(text, jsonlPath);
 }
 function parseGoldJsonl(text, sourceLabel = "<inline>") {
@@ -10863,7 +8581,6 @@ function sectionHash(section) {
 }
 export {
   AGENT_PROFILE_KINDS,
-  ANALYST_SEVERITIES,
   AgentDriver,
   AgentEvalError,
   AgentProfileCellValidationError,
@@ -10902,13 +8619,10 @@ export {
   ExperimentTracker,
   FAILURE_CLASSES,
   FAILURE_MODE_KIND_SPEC,
-  FINDING_SUBJECT_GRAMMAR_PROMPT,
-  FINDING_SUBJECT_KINDS,
   FileSystemExperimentStore,
   FileSystemFeedbackTrajectoryStore,
   FileSystemRawProviderSink,
   FileSystemTraceStore,
-  FindingSubjectStringSchema,
   FindingsStore,
   HeldOutGate,
   HoldoutAuditor,
@@ -10922,7 +8636,6 @@ export {
   InMemoryWorkspaceInspector,
   JudgeError,
   JudgeRunner,
-  KIND_EXPECTED_SUBJECTS,
   KNOWLEDGE_GAP_KIND_SPEC,
   KNOWLEDGE_POISONING_KIND_SPEC,
   LlmCallError,
@@ -10941,10 +8654,8 @@ export {
   PairwiseSteeringOptimizer,
   ProductClient,
   PromptRegistry,
-  RAW_FINDING_SCHEMA_PROMPT,
   REDACTION_VERSION,
   RESEARCH_REPORT_HARD_PAIR_FLOOR,
-  RawAnalystFindingSchema,
   ReplayCache,
   ReplayCacheMissError,
   ReplayError,
@@ -10985,6 +8696,8 @@ export {
   analyzeTraces,
   appendScorecard,
   argHash,
+  asNumber,
+  asString,
   assertCrossFamily,
   assertLlmRoute,
   assertRealBackend,
@@ -11004,15 +8717,14 @@ export {
   bootstrapCi,
   buildAgentProfileCell,
   buildAgreementJudge,
+  buildDefaultAnalystRegistry,
   buildDriverSystemPrompt,
   buildReflectionPrompt,
   buildReviewerPrompt,
   buildSandboxAgentProfileCell,
-  buildSkillUsageReport,
   buildTraceAnalystTools,
   buildTraceInsightContext,
   buildTraceInsightPrompt,
-  buildTraceToolsForGroup,
   buildTrajectory,
   byteLengthRange,
   calibrateJudge,
@@ -11043,6 +8755,7 @@ export {
   composeValidators,
   computeFindingId,
   computeToolUseMetrics,
+  computeTraceMetrics,
   confidenceInterval,
   containsAll,
   continuousAgreement,
@@ -11051,26 +8764,21 @@ export {
   controlRunToRunRecord,
   corpusInterRaterAgreement,
   corpusInterRaterAgreementFromJudgeScores,
+  createAnalystAi,
   createAntiSlopJudge,
-  createChatClient,
   createCustomJudge,
   createDefaultReviewer,
   createDomainExpertJudge,
   createFeedbackTrajectory,
   createIntentMatchJudge,
-  createJudgeAdapter,
   createLlmCorrectnessChecker,
   createLlmReviewer,
   createOtelExporter,
   createOtelTracingStore,
   createReplayFetch,
-  createRunCriticAdapter,
   createSandboxPool,
   createSemanticConceptJudge,
-  createSemanticConceptJudgeAdapter,
-  createTraceAnalystAdapter,
   createTraceAnalystKind,
-  createVerifierAdapter,
   crossTraceDiff,
   crowdingDistance,
   decideNextUserTurn,
@@ -11091,7 +8799,6 @@ export {
   distillPlaybook,
   domainEvidencePattern,
   dominates,
-  emitSkillUsageFindings,
   estimateCost,
   estimateTokens,
   euAiActReport,
@@ -11107,6 +8814,7 @@ export {
   exportRunAsOtlp,
   extractAssetUrls,
   extractErrorCount,
+  extractOtlpAttributes,
   extractProducedState,
   feedbackTrajectoriesToDatasetScenarios,
   feedbackTrajectoriesToOptimizerRows,
@@ -11120,6 +8828,8 @@ export {
   findFallbackToPass,
   findLiteralTruePass,
   findSkipCountsAsPass,
+  firstNumberAttr,
+  firstStringAttr,
   flattenOtlpExportToNdjson,
   flowLayer,
   formatBenchmarkReport,
@@ -11140,6 +8850,7 @@ export {
   inMemoryReferenceReplayStore,
   inMemoryReviewStore,
   inferDomainKeywords,
+  inferOtlpKind,
   interRaterReliability,
   interpretCliffs,
   iqr,
@@ -11163,7 +8874,6 @@ export {
   judgeSpans,
   keyPreserved,
   knowledgeReadinessTracePayload,
-  liftSeverity,
   linterJudge,
   llmSpanFromProvider,
   llmSpans,
@@ -11183,6 +8893,8 @@ export {
   notBlocked,
   objectiveEval,
   otelRunCompleteHook,
+  otlpToRunRecords,
+  otlpToTraceRunRecords,
   pairedBootstrap,
   pairedEvalueSequence,
   pairedMde,
@@ -11194,9 +8906,7 @@ export {
   paretoFrontierWithCrowding,
   parseCorrectnessResponse,
   parseFeedbackTrajectoriesJsonl,
-  parseFindingSubject,
   parseGoldJsonl,
-  parseRawFinding,
   parseReflectionResponse,
   parseRunRecordSafe,
   partialCredit,
@@ -11208,11 +8918,13 @@ export {
   printDriverSummary,
   probeLlm,
   profile_exports as profile,
+  projectOtlpFlatLine,
   promptBisect,
   proposeAutomatedPullRequest,
   proposeSynthesisTargets,
   providerFromBaseUrl,
   pytestTestParser,
+  readOtlpStatus,
   recordRuns,
   recordRunsToScorecard,
   redTeamDataset,
@@ -11223,7 +8935,6 @@ export {
   referenceReplayScenarioToRunScore,
   regexMatch,
   regexMatches,
-  renderFindingSubject,
   renderMarkdown,
   renderMarkdownReport,
   renderPlaybookMarkdown,
@@ -11287,6 +8998,7 @@ export {
   statusAdvanced,
   stopOnNoProgress,
   stopOnRepeatedAction,
+  stringField,
   stripFencedJson,
   subjectiveEval,
   summarize,