@tangle-network/agent-eval 0.29.1 → 0.31.0

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   failureClusterView,
   iqr,
   welchsTTest
-} from "./chunk-K33INZHH.js";
+} from "./chunk-GVQT44CS.js";
 import {
   exportTrainingData,
   toNdjson
@@ -28,7 +28,7 @@ import {
   pytestTestParser,
   runTestGradedScenario,
   vitestTestParser
-} from "./chunk-QHF6EQKK.js";
+} from "./chunk-YTMXBHFM.js";
 import {
   classifyEuAiRisk,
   euAiActReport,
@@ -54,7 +54,7 @@ import {
   runProposeReview,
   runProposeReviewAsControlLoop,
   scoreFromEvals
-} from "./chunk-PALJO75S.js";
+} from "./chunk-XEL6UP7C.js";
 import {
   allCriticalPassed,
   objectiveEval,
@@ -96,14 +96,14 @@ import {
   summarizePreferenceMemory,
   trialTraceFromMultiShotTrial,
   withAssignedFeedbackSplit
-} from "./chunk-SZSBQUIJ.js";
+} from "./chunk-Y2CPBYKH.js";
 import {
   RunRecordValidationError,
   isRunRecord,
   parseRunRecordSafe,
   roundTripRunRecord,
   validateRunRecord
-} from "./chunk-NLMNWKVM.js";
+} from "./chunk-WSI4K3WB.js";
 import {
   assertReleaseConfidence,
   bootstrapCi,
@@ -111,10 +111,10 @@ import {
   judgeReplayGate,
   releaseTraceEvidenceFromMultiShotTrials,
   renderReleaseReport
-} from "./chunk-DBIGN5MJ.js";
+} from "./chunk-WGXZAQLR.js";
 import {
   runEvalCampaign
-} from "./chunk-RUI6SIHY.js";
+} from "./chunk-75ZREHD7.js";
 import {
   LlmCallError,
   LlmClient,
@@ -124,7 +124,7 @@ import {
   callLlmJson,
   probeLlm,
   stripFencedJson
-} from "./chunk-4S4BM3QQ.js";
+} from "./chunk-M6RZ5LJN.js";
 import {
   evaluateInterimReleaseConfidence,
   pairedEvalueSequence
@@ -141,7 +141,7 @@ import {
   requiredSampleSize,
   researchReport,
   summaryTable
-} from "./chunk-5AKPEK5L.js";
+} from "./chunk-CXJOVDJR.js";
 import {
   calibrateJudge,
   calibrateJudgeContinuous,
@@ -160,24 +160,43 @@ import {
   verbosityBias,
   weightedMean,
   wilcoxonSignedRank
-} from "./chunk-R5UQJNKC.js";
+} from "./chunk-4L3WJXQJ.js";
 import {
   DEFAULT_REDACTION_RULES,
+  DEFAULT_TRACE_ANALYST_BUDGETS,
   FileSystemTraceStore,
   InMemoryTraceStore,
   OTEL_AGENT_EVAL_SCOPE,
+  OtlpFileTraceStore,
   REDACTION_VERSION,
   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,
   createReplayFetch,
+  defaultTraceInsightPanel,
+  describeTraceInsightScope,
+  domainEvidencePattern,
   exportRunAsOtlp,
+  inferDomainKeywords,
   iterateRawCalls,
+  planTraceInsightQuestions,
   redactString,
-  redactValue
-} from "./chunk-UW4NOOZI.js";
+  redactValue,
+  scoreTraceInsightReadiness,
+  tokenizeDomainWords,
+  traceAnalystFunctionGroup,
+  traceAnalystOnRunComplete
+} from "./chunk-HIO4UIS5.js";
 import {
   aggregateLlm,
   argHash,
@@ -201,7 +220,7 @@ import {
   RunIntegrityError,
   assertRunCaptured,
   throwIfRunIncomplete
-} from "./chunk-KTGTIOFD.js";
+} from "./chunk-UBPIXOC4.js";
 import {
   FileSystemRawProviderSink,
   InMemoryRawProviderSink,
@@ -229,7 +248,7 @@ import {
   ReplayError,
   ValidationError,
   VerificationError
-} from "./chunk-NG236HPC.js";
+} from "./chunk-QYJT52YW.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/run-score.ts
@@ -968,17 +987,194 @@ function resolveModel(req, 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 = z.object({
-  severity: z.enum(ANALYST_SEVERITIES),
-  claim: z.string().min(1).max(2e3),
-  subject: z.string().max(400).optional(),
-  evidence_uri: z.string().min(1).max(2e3),
-  evidence_excerpt: z.string().max(2e3).optional(),
-  confidence: z.number().min(0).max(1),
-  rationale: z.string().max(4e3).optional(),
-  recommended_action: z.string().max(2e3).optional()
+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"
@@ -1212,18 +1408,42 @@ function createTraceAnalystKind(spec, opts) {
         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
+        accepted: out.length,
+        rejected_wrong_subject: rejectedWrongKind
       });
       return out;
     }
@@ -3036,6 +3256,107 @@ function suggestionForManifest(input) {
   return "No action required.";
 }
 
+// src/integrity/backend-integrity.ts
+var BackendIntegrityError = class extends AgentEvalError {
+  constructor(message, report) {
+    super("backend_integrity", message);
+    this.report = report;
+  }
+  report;
+};
+function isStubRecord(rec) {
+  return rec.tokenUsage.input === 0 && rec.tokenUsage.output === 0;
+}
+function isUncostedRecord(rec) {
+  return rec.tokenUsage.output > 0 && rec.costUsd === 0;
+}
+function summarizeBackendIntegrity(records) {
+  const totalRecords = records.length;
+  let stubRecords = 0;
+  let realRecords = 0;
+  let uncostedRecords = 0;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCostUsd = 0;
+  for (const rec of records) {
+    totalInputTokens += rec.tokenUsage.input;
+    totalOutputTokens += rec.tokenUsage.output;
+    totalCostUsd += rec.costUsd;
+    if (isStubRecord(rec)) stubRecords++;
+    else realRecords++;
+    if (isUncostedRecord(rec)) uncostedRecords++;
+  }
+  const verdict = totalRecords === 0 ? "stub" : stubRecords === totalRecords ? "stub" : stubRecords === 0 ? "real" : "mixed";
+  const diagnosis = buildDiagnosis({
+    totalRecords,
+    stubRecords,
+    realRecords,
+    uncostedRecords,
+    totalInputTokens,
+    totalOutputTokens,
+    totalCostUsd,
+    verdict
+  });
+  return {
+    totalRecords,
+    stubRecords,
+    realRecords,
+    uncostedRecords,
+    totalInputTokens,
+    totalOutputTokens,
+    totalCostUsd,
+    verdict,
+    diagnosis
+  };
+}
+function buildDiagnosis(r) {
+  if (r.totalRecords === 0) {
+    return "no records \u2014 eval produced zero runs; backend likely failed before first turn";
+  }
+  if (r.verdict === "stub") {
+    return [
+      `all ${r.totalRecords} records have zero token usage \u2014 the LLM backend was never called.`,
+      "common causes: --backend sandbox without a sandbox bridge running; stub model returning hard-coded strings;",
+      "auth misconfigured so requests were silently dropped before the LLM. Re-run with --backend tcloud and TANGLE_API_KEY set,",
+      "or boot the cli-bridge / sandbox before invoking the eval."
+    ].join(" ");
+  }
+  if (r.verdict === "mixed") {
+    const pct = (r.stubRecords / r.totalRecords * 100).toFixed(0);
+    return [
+      `${r.stubRecords}/${r.totalRecords} records (${pct}%) have zero token usage \u2014 the backend partially failed.`,
+      "common causes: rate-limit cascade (429s after the first N personas);",
+      "transient auth expiry mid-run; provider outage. Treat the affected records as missing data, not agent failures."
+    ].join(" ");
+  }
+  if (r.uncostedRecords > 0) {
+    const pct = (r.uncostedRecords / r.totalRecords * 100).toFixed(0);
+    return [
+      `${r.totalRecords} records with real LLM activity (in=${r.totalInputTokens}, out=${r.totalOutputTokens} tokens).`,
+      `${r.uncostedRecords} (${pct}%) have output tokens but costUsd=0 \u2014 cost ledger is mis-wired (no input-token`,
+      "propagation from the runtime stream into RunRecord)."
+    ].join(" ");
+  }
+  return `${r.totalRecords} records with real LLM activity (in=${r.totalInputTokens}, out=${r.totalOutputTokens} tokens, $${r.totalCostUsd.toFixed(4)}).`;
+}
+function assertRealBackend(records, opts = {}) {
+  const report = summarizeBackendIntegrity(records);
+  const allowMixed = opts.allowMixed ?? true;
+  if (report.verdict === "stub") {
+    throw new BackendIntegrityError(
+      `backend-integrity: ran against a stub or unconfigured backend \u2014 ${report.diagnosis}`,
+      report
+    );
+  }
+  if (!allowMixed && report.verdict === "mixed") {
+    throw new BackendIntegrityError(
+      `backend-integrity: partial backend failure rejected \u2014 ${report.diagnosis}`,
+      report
+    );
+  }
+  return report;
+}
+
 // src/judges.ts
 function createDomainExpertJudge(domain) {
   return async (tc, { scenario, turns }) => {
@@ -9174,8 +9495,8 @@ function chiSquareCritical(df, alpha) {
   if (TABLE[df]) return TABLE[df][idx];
   if (df > 30) {
     const zMap = { 0: 1.282, 1: 1.645, 2: 1.96, 3: 2.326 };
-    const z2 = zMap[idx] ?? 1.96;
-    const term = 1 - 2 / (9 * df) + z2 * Math.sqrt(2 / (9 * df));
+    const z3 = zMap[idx] ?? 1.96;
+    const term = 1 - 2 / (9 * df) + z3 * Math.sqrt(2 / (9 * df));
     return df * term ** 3;
   }
   const keys = Object.keys(TABLE).map((k) => Number(k)).sort((a, b) => a - b);
@@ -10098,6 +10419,7 @@ export {
   AnalystRegistry,
   AxGepaSteeringOptimizer,
   BENCHMARK_SPLIT_SEED,
+  BackendIntegrityError,
   BenchmarkRunner,
   BudgetBreachError,
   BudgetGuard,
@@ -10119,6 +10441,7 @@ export {
   DEFAULT_RED_TEAM_CORPUS,
   DEFAULT_RUN_SCORE_WEIGHTS,
   DEFAULT_SEVERITY_WEIGHTS,
+  DEFAULT_TRACE_ANALYST_BUDGETS,
   DEFAULT_TRACE_ANALYST_KINDS,
   Dataset,
   DockerSandboxDriver,
@@ -10127,10 +10450,13 @@ export {
   ExperimentTracker,
   FAILURE_CLASSES,
   FAILURE_MODE_KIND_SPEC,
+  FINDING_SUBJECT_GRAMMAR_PROMPT,
+  FINDING_SUBJECT_KINDS,
   FileSystemExperimentStore,
   FileSystemFeedbackTrajectoryStore,
   FileSystemRawProviderSink,
   FileSystemTraceStore,
+  FindingSubjectStringSchema,
   FindingsStore,
   HeldOutGate,
   HoldoutAuditor,
@@ -10146,6 +10472,7 @@ export {
   JsonlTrialCache,
   JudgeError,
   JudgeRunner,
+  KIND_EXPECTED_SUBJECTS,
   KNOWLEDGE_GAP_KIND_SPEC,
   KNOWLEDGE_POISONING_KIND_SPEC,
   LineageRecorder,
@@ -10162,6 +10489,7 @@ export {
   NoopResearcher,
   NotFoundError,
   OTEL_AGENT_EVAL_SCOPE,
+  OtlpFileTraceStore,
   PairwiseSteeringOptimizer,
   ProductClient,
   PromptRegistry,
@@ -10178,10 +10506,17 @@ export {
   SEMANTIC_CONCEPT_JUDGE_VERSION,
   SandboxHarness,
   ScenarioRegistry,
+  SpanNotFoundError,
   SubprocessSandboxDriver,
+  TRACE_ANALYST_ACTOR_DESCRIPTION,
+  TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION,
+  TRACE_ANALYST_SUBAGENT_DESCRIPTION,
+  TRACE_ANALYST_TRUNCATION_MARKER_PREFIX,
   TRACE_SCHEMA_VERSION,
   TokenCounter,
   TraceEmitter,
+  TraceFileMissingError,
+  TraceNotFoundError,
   TrialTelemetry,
   UNIVERSAL_FINDERS,
   ValidationError,
@@ -10194,8 +10529,10 @@ export {
   allCriticalPassed,
   analyzeAntiSlop,
   analyzeSeries,
+  analyzeTraces,
   argHash,
   assertLlmRoute,
+  assertRealBackend,
   assertReleaseConfidence,
   assertRunCaptured,
   assignFeedbackSplit,
@@ -10210,6 +10547,9 @@ export {
   bootstrapCi,
   buildReflectionPrompt,
   buildReviewerPrompt,
+  buildTraceAnalystTools,
+  buildTraceInsightContext,
+  buildTraceInsightPrompt,
   buildTraceToolsForGroup,
   buildTrajectory,
   byteLengthRange,
@@ -10274,10 +10614,13 @@ export {
   defaultMultiShotObjectives,
   defaultProviderRedactor,
   defaultReferenceReplayMatcher,
+  defaultTraceInsightPanel,
   deployGateLayer,
+  describeTraceInsightScope,
   diffFindings,
   discoverPersonas,
   distillPlaybook,
+  domainEvidencePattern,
   dominates,
   estimateCost,
   estimateTokens,
@@ -10321,6 +10664,7 @@ export {
   httpGithubClient,
   inMemoryReferenceReplayStore,
   inMemoryReviewStore,
+  inferDomainKeywords,
   integrationAsi,
   integrationGateEvals,
   integrationInvokeFailedPayload,
@@ -10371,12 +10715,14 @@ export {
   paretoFrontier,
   paretoFrontierWithCrowding,
   parseFeedbackTrajectoriesJsonl,
+  parseFindingSubject,
   parseRawFinding,
   parseReflectionResponse,
   parseRunRecordSafe,
   partialCredit,
   passOrthogonality,
   pixelDeltaRatio,
+  planTraceInsightQuestions,
   politenessPrefixMutator,
   positionalBias,
   printDriverSummary,
@@ -10395,6 +10741,7 @@ export {
   regexMatch,
   regexMatches,
   releaseTraceEvidenceFromMultiShotTrials,
+  renderFindingSubject,
   renderMarkdown,
   renderMarkdownReport,
   renderPlaybookMarkdown,
@@ -10444,6 +10791,7 @@ export {
   scoreKnowledgeReadiness,
   scoreRedTeamOutput,
   scoreReferenceReplay,
+  scoreTraceInsightReadiness,
   securityJudge,
   selectHarnessVariant,
   selfPreference,
@@ -10457,6 +10805,7 @@ export {
   stripFencedJson,
   subjectiveEval,
   summarize,
+  summarizeBackendIntegrity,
   summarizeHarnessResults,
   summarizePreferenceMemory,
   summaryTable,
@@ -10465,8 +10814,11 @@ export {
   throwIfRunIncomplete,
   toLangfuseEnvelope,
   toPrometheusText,
+  tokenizeDomainWords,
   toolNamesForRun,
   toolSpans,
+  traceAnalystFunctionGroup,
+  traceAnalystOnRunComplete,
   trialTraceFromMultiShotTrial,
   typoMutator,
   urlContains,