@tangle-network/agent-eval 0.128.2 → 0.130.0

package/dist/analyst/index.js

@@ -1,388 +1,343 @@
-import {
-  FindingsStore,
-  RunCritic,
-  SEMANTIC_CONCEPT_JUDGE_VERSION,
-  SKILL_USAGE_ANALYST,
-  SkillUsageAnalyst,
-  buildSkillUsageReport,
-  defaultIsMaterial,
-  diffFindings,
-  emitSkillUsageFindings,
-  runSemanticConceptJudge
-} from "../chunk-ZUUWPZCV.js";
-import {
-  ANALYST_SEVERITIES,
-  AnalystRegistry,
-  CanonicalRawAnalystFindingSchema,
-  DEFAULT_TRACE_ANALYST_KINDS,
-  FAILURE_MODE_KIND_SPEC,
-  FINDING_SUBJECT_GRAMMAR_PROMPT,
-  FINDING_SUBJECT_KINDS,
-  FINDING_SUBJECT_SYNTAX,
-  FindingSubjectStringSchema,
-  IMPROVEMENT_KIND_SPEC,
-  KIND_EXPECTED_SUBJECTS,
-  KNOWLEDGE_GAP_KIND_SPEC,
-  KNOWLEDGE_POISONING_KIND_SPEC,
-  RAW_FINDING_SCHEMA_PROMPT,
-  RawAnalystEvidenceSchema,
-  RawAnalystFindingSchema,
-  behavioralAnalyst,
-  buildDefaultAnalystRegistry,
-  buildTraceToolsForGroup,
-  coerceJson,
-  coerceToFindingRows,
-  computeFindingId,
-  createAnalystAi,
-  createChatClient,
-  createTraceAnalystKind,
-  deriveEfficiencyFindings,
-  evidenceRefsFromRawFinding,
-  findingSubjectGrammarPromptFor,
-  makeFinding,
-  parseCanonicalRawFinding,
-  parseFindingSubject,
-  parseRawFinding,
-  renderFindingSubject,
-  renderPriorFindings,
-  renderUpstreamFindings,
-  settleUsageReceiptFromCostLedger,
-  stripCodeFences,
-  structureFindings,
-  validateUsageSettlementTimeout
-} from "../chunk-DJKY2TSY.js";
-import "../chunk-HHWE3POT.js";
-import "../chunk-WGXIEX7P.js";
-import "../chunk-PBE2LOSS.js";
-import {
-  CostLedger
-} from "../chunk-WS3NZZQQ.js";
-import "../chunk-VI2UW6B6.js";
-import "../chunk-P6FYH6K4.js";
-import "../chunk-PC4UYEBM.js";
-import "../chunk-ONWEPEDO.js";
-import "../chunk-K4DBDHLK.js";
-import "../chunk-PZ5AY32C.js";
-
-// src/analyst/adapters.ts
-var ADAPTER_REV = "1";
+import { A as parseFindingSubject, C as stripCodeFences, D as FindingSubjectStringSchema, E as FINDING_SUBJECT_SYNTAX, F as makeFinding, L as createChatClient, M as behavioralAnalyst, N as deriveEfficiencyFindings, O as KIND_EXPECTED_SUBJECTS, P as computeFindingId, R as createAnalystAi, S as coerceToFindingRows, T as FINDING_SUBJECT_KINDS, _ as RawAnalystEvidenceSchema, a as KNOWLEDGE_GAP_KIND_SPEC, b as parseRawFinding, c as buildTraceToolsForGroup, d as renderUpstreamFindings, f as settleUsageReceiptFromCostLedger, g as RAW_FINDING_SCHEMA_PROMPT, h as ANALYST_SEVERITIES, i as KNOWLEDGE_POISONING_KIND_SPEC, j as renderFindingSubject, k as findingSubjectGrammarPromptFor, l as createTraceAnalystKind, m as structureFindings, n as AnalystRegistry, o as IMPROVEMENT_KIND_SPEC, p as validateUsageSettlementTimeout, r as DEFAULT_TRACE_ANALYST_KINDS, s as FAILURE_MODE_KIND_SPEC, t as buildDefaultAnalystRegistry, u as renderPriorFindings, v as RawAnalystFindingSchema, w as FINDING_SUBJECT_GRAMMAR_PROMPT, x as coerceJson, y as evidenceRefsFromRawFinding } from "../default-registry-C-vFCSEc.js";
+import { i as CostLedger } from "../cost-ledger-DIgQUFZZ.js";
+import { a as RunCritic, c as buildSkillUsageReport, d as defaultIsMaterial, f as diffFindings, i as runSemanticConceptJudge, l as emitSkillUsageFindings, n as SEMANTIC_CONCEPT_JUDGE_VERSION, o as SKILL_USAGE_ANALYST, s as SkillUsageAnalyst, u as FindingsStore } from "../semantic-concept-judge-B6cWNJ2K.js";
+//#region src/analyst/adapters.ts
+/**
+* Adapter factories — lift each existing agent-eval primitive into the
+* Analyst contract without re-implementing it.
+*
+* Five primitives, five factories. Each one:
+*   - Builds an Analyst with a stable id (caller chooses; defaults
+*     given), a sensible default `inputKind`, a version derived from
+*     the wrapped primitive's version + an adapter revision, and an
+*     `analyze()` that calls the primitive and lifts its output to
+*     AnalystFinding[] using `makeFinding()`.
+*   - Maps severities: the existing `Severity` ('critical' | 'major' |
+*     'minor' | 'info') projects onto AnalystSeverity ('critical' |
+*     'high' | 'medium' | 'low' | 'info'); 'major' → 'high', 'minor' →
+*     'medium'. Domain analysts that want finer-grained mapping override.
+*
+* Adapters never own state. Calling the same factory twice with the
+* same primitive instance is safe.
+*/
+const ADAPTER_REV = "1";
 function liftSeverity(s) {
-  switch (s) {
-    case "critical":
-      return "critical";
-    case "major":
-      return "high";
-    case "minor":
-      return "medium";
-    case "info":
-      return "info";
-  }
+	switch (s) {
+		case "critical": return "critical";
+		case "major": return "high";
+		case "minor": return "medium";
+		case "info": return "info";
+	}
 }
 function createVerifierAdapter(opts) {
-  const id = opts.id ?? "multi-layer-verifier";
-  const area = opts.area ?? "verification";
-  return {
-    id,
-    description: "Runs a MultiLayerVerifier and lifts each layer's findings into the analyst envelope.",
-    inputKind: "custom",
-    cost: { kind: "deterministic" },
-    version: `verifier-${ADAPTER_REV}`,
-    async analyze(env, ctx) {
-      const report = await opts.verifier.run({ env, ...opts.options });
-      const out = [];
-      for (const layer of report.layers) {
-        for (const finding of layer.findings) {
-          out.push(liftLayerFinding(id, area, layer.layer, finding));
-        }
-        if (layer.status === "fail" || layer.status === "error" || layer.status === "timeout") {
-          out.push(
-            makeFinding({
-              analyst_id: id,
-              area,
-              subject: layer.layer,
-              claim: `layer "${layer.layer}" ${layer.status}: ${layer.reason ?? "no reason given"}`,
-              severity: layer.status === "error" ? "high" : layer.status === "timeout" ? "medium" : "high",
-              confidence: 1,
-              evidence_refs: [],
-              metadata: {
-                layer_status: layer.status,
-                duration_ms: layer.durationMs,
-                score: layer.score,
-                diagnostics: layer.diagnostics
-              }
-            })
-          );
-        }
-      }
-      ctx.log?.("verifier complete", {
-        layers: report.layers.length,
-        blended: report.blendedScore,
-        all_pass: report.allPass
-      });
-      return out;
-    }
-  };
+	const id = opts.id ?? "multi-layer-verifier";
+	const area = opts.area ?? "verification";
+	return {
+		id,
+		description: "Runs a MultiLayerVerifier and lifts each layer's findings into the analyst envelope.",
+		inputKind: "custom",
+		cost: { kind: "deterministic" },
+		version: `verifier-${ADAPTER_REV}`,
+		async analyze(env, ctx) {
+			const report = await opts.verifier.run({
+				env,
+				...opts.options
+			});
+			const out = [];
+			for (const layer of report.layers) {
+				for (const finding of layer.findings) out.push(liftLayerFinding(id, area, layer.layer, finding));
+				if (layer.status === "fail" || layer.status === "error" || layer.status === "timeout") out.push(makeFinding({
+					analyst_id: id,
+					area,
+					subject: layer.layer,
+					claim: `layer "${layer.layer}" ${layer.status}: ${layer.reason ?? "no reason given"}`,
+					severity: layer.status === "error" ? "high" : layer.status === "timeout" ? "medium" : "high",
+					confidence: 1,
+					evidence_refs: [],
+					metadata: {
+						layer_status: layer.status,
+						duration_ms: layer.durationMs,
+						score: layer.score,
+						diagnostics: layer.diagnostics
+					}
+				}));
+			}
+			ctx.log?.("verifier complete", {
+				layers: report.layers.length,
+				blended: report.blendedScore,
+				all_pass: report.allPass
+			});
+			return out;
+		}
+	};
 }
 function liftLayerFinding(analyst_id, area, layer, f) {
-  return makeFinding({
-    analyst_id,
-    area,
-    subject: f.layer ?? layer,
-    claim: f.message,
-    severity: liftSeverity(f.severity),
-    confidence: 0.85,
-    evidence_refs: f.evidence ? [{ kind: "artifact", uri: "inline:evidence", excerpt: f.evidence }] : [],
-    metadata: f.detail
-  });
+	return makeFinding({
+		analyst_id,
+		area,
+		subject: f.layer ?? layer,
+		claim: f.message,
+		severity: liftSeverity(f.severity),
+		confidence: .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;
-    }
-  };
+	const id = opts.id ?? "run-critic";
+	const area = opts.area ?? "run-quality";
+	const critic = opts.critic ?? new RunCritic();
+	const threshold = opts.threshold ?? .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 = [];
+			for (const [dim, sev, msg] of [
+				[
+					"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"
+				]
+			]) {
+				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: .9,
+				evidence_refs: [],
+				metadata: {
+					drift_penalty: score.driftPenalty,
+					notes: score.notes
+				}
+			}));
+			return out;
+		}
+	};
 }
 function createJudgeAdapter(opts) {
-  const id = opts.id ?? "judge";
-  const area = opts.area ?? "judge";
-  const threshold = opts.threshold ?? 6;
-  return {
-    id,
-    description: "Wraps an agent-eval JudgeFn into an analyst; below-threshold dimensions surface as findings.",
-    inputKind: "judge-input",
-    cost: opts.cost ?? { kind: "llm" },
-    version: `judge-${ADAPTER_REV}`,
-    async analyze(input) {
-      const scores = await opts.judge(opts.tcloud, input);
-      return scores.filter((s) => normalize10(s.score) < threshold).map((s) => liftJudgeScore(id, area, s));
-    }
-  };
+	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) {
+			return (await opts.judge(opts.chat, input)).filter((s) => normalize10(s.score) < threshold).map((s) => liftJudgeScore(id, area, s));
+		}
+	};
 }
 function normalize10(s) {
-  return s <= 1 ? s * 10 : 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 }] : [],
-    // Provenance: this finding IS a judge verdict (an acceptance score), not an
-    // observation of behavior. The steer firewall (assertNoJudgeVerdict) rejects
-    // it from steering — even when it cites an artifact above — because letting a
-    // verdict steer the next attempt is the held-out judge leaking into the loop.
-    derived_from_judge: true,
-    metadata: { judge_name: s.judgeName, dimension: s.dimension, score_10: score10 }
-  });
+	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: .8,
+		evidence_refs: s.evidence ? [{
+			kind: "artifact",
+			uri: "inline:evidence",
+			excerpt: s.evidence
+		}] : [],
+		derived_from_judge: true,
+		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";
-  const settlementTimeoutMs = validateUsageSettlementTimeout(opts.settlementTimeoutMs);
-  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,
-      settlement_timeout_ms: settlementTimeoutMs
-    },
-    version: `${SEMANTIC_CONCEPT_JUDGE_VERSION}-adapter-${ADAPTER_REV}`,
-    async analyze(input, ctx) {
-      const costLedger = new CostLedger(ctx.budgetUsd);
-      let result;
-      try {
-        result = await runSemanticConceptJudge(input, {
-          ...opts.options,
-          costLedger,
-          signal: ctx.signal
-        });
-      } finally {
-        const usage = await settleUsageReceiptFromCostLedger(costLedger, {
-          channel: "judge",
-          timeoutMs: settlementTimeoutMs
-        });
-        if (!usage.settled) {
-          ctx.log?.("semantic-concept judge provider settlement timed out", {
-            pending_calls: usage.pendingCalls,
-            timeout_ms: settlementTimeoutMs
-          });
-        }
-        ctx.recordUsage?.(usage.receipt);
-      }
-      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
-            }
-          })
-        );
-      }
-      return out;
-    }
-  };
+	const id = opts.id ?? "semantic-concept-judge";
+	const area = opts.area ?? "concept-coverage";
+	const settlementTimeoutMs = validateUsageSettlementTimeout(opts.settlementTimeoutMs);
+	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,
+			settlement_timeout_ms: settlementTimeoutMs
+		},
+		version: `${SEMANTIC_CONCEPT_JUDGE_VERSION}-adapter-${ADAPTER_REV}`,
+		async analyze(input, ctx) {
+			const costLedger = new CostLedger(ctx.budgetUsd);
+			let result;
+			try {
+				result = await runSemanticConceptJudge(input, {
+					...opts.options,
+					costLedger,
+					signal: ctx.signal
+				});
+			} finally {
+				const usage = await settleUsageReceiptFromCostLedger(costLedger, {
+					channel: "judge",
+					timeoutMs: settlementTimeoutMs
+				});
+				if (!usage.settled) ctx.log?.("semantic-concept judge provider settlement timed out", {
+					pending_calls: usage.pendingCalls,
+					timeout_ms: settlementTimeoutMs
+				});
+				ctx.recordUsage?.(usage.receipt);
+			}
+			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: .85,
+					evidence_refs: [{
+						kind: "artifact",
+						uri: "inline:evidence",
+						excerpt: f.evidence
+					}],
+					metadata: {
+						concept: f.concept,
+						present: f.present,
+						score_10: f.score
+					}
+				}));
+			}
+			return out;
+		}
+	};
 }
-
-// src/analyst/steer-firewall.ts
-var OBSERVABLE_KINDS = /* @__PURE__ */ new Set([
-  "span",
-  "event",
-  "artifact"
+//#endregion
+//#region src/analyst/steer-firewall.ts
+/** Evidence grounded in the agent's OWN execution: OTLP trace elements
+*  (`span`/`event`) or the artifact it produced (`artifact`). */
+const OBSERVABLE_KINDS = /* @__PURE__ */ new Set([
+	"span",
+	"event",
+	"artifact"
 ]);
+/** DESCRIPTIVE predicate: does the finding cite at least one observable
+*  (span/event/artifact) evidence ref. Useful for ranking evidence quality or
+*  rendering — it is NOT the steer gate. Evidence presence is the WRONG
+*  discriminator for steering: a legitimate trace-analyst observation may cite
+*  nothing (it would be wrongly rejected), and a judge verdict may cite an
+*  artifact (it would be wrongly admitted). Use `assertNoJudgeVerdict` to gate
+*  steering; use this only where "is this grounded in observable evidence" is the
+*  literal question. */
 function isTraceObservable(finding) {
-  return finding.evidence_refs.some((ref) => OBSERVABLE_KINDS.has(ref.kind));
+	return finding.evidence_refs.some((ref) => OBSERVABLE_KINDS.has(ref.kind));
 }
+/** True iff the finding is a JUDGE VERDICT (an acceptance score lifted into a
+*  finding), identified by provenance set at the lift site — independent of
+*  whatever evidence it cites. */
 function isJudgeVerdict(finding) {
-  return finding.derived_from_judge === true;
+	return finding.derived_from_judge === true;
 }
+/**
+* THE steer firewall. Fail-loud guard for any path that admits analyst findings
+* as STEERING input (the `f(trace)` role): rejects — naming the offenders — any
+* finding whose provenance is a judge verdict, rather than let `J` leak into the
+* loop. Returns the findings unchanged for chaining.
+*
+* Call this at the chokepoint where a detector that ALSO scores/gates has its
+* findings turned into a steer (the judge-and-steer dual-role case). It keys on
+* provenance, so it correctly admits evidence-less trace-analyst observations and
+* correctly rejects an artifact-citing judge verdict — the cases an evidence
+* check gets backwards.
+*
+* It is necessary, not sufficient: it stops PROVENANCE-tagged verdicts. A judge
+* whose output is laundered through a hand-built finding with no provenance flag
+* is out of its reach — provenance must be honestly set at every judge→finding
+* lift (today: createJudgeAdapter). That is why the integrity rule lives at the
+* lift site, and why ProposeContext.judgeScores?: never is the complementary
+* compile-time tripwire on the obvious direct channel.
+*/
 function assertNoJudgeVerdict(findings, context = "steer") {
-  const leaks = findings.filter(isJudgeVerdict);
-  if (leaks.length > 0) {
-    throw new Error(
-      `${context}: a judge verdict cannot be admitted as steering input \u2014 that is the held-out judge leaking into the loop. Offending judge-derived findings: [${leaks.map((f) => f.finding_id).join(", ")}]. Steering consumes observations of behavior, never acceptance verdicts.`
-    );
-  }
-  return findings;
+	const leaks = findings.filter(isJudgeVerdict);
+	if (leaks.length > 0) throw new Error(`${context}: a judge verdict cannot be admitted as steering input — that is the held-out judge leaking into the loop. Offending judge-derived findings: [${leaks.map((f) => f.finding_id).join(", ")}]. Steering consumes observations of behavior, never acceptance verdicts.`);
+	return findings;
 }
-export {
-  ANALYST_SEVERITIES,
-  AnalystRegistry,
-  CanonicalRawAnalystFindingSchema,
-  DEFAULT_TRACE_ANALYST_KINDS,
-  FAILURE_MODE_KIND_SPEC,
-  FINDING_SUBJECT_GRAMMAR_PROMPT,
-  FINDING_SUBJECT_KINDS,
-  FINDING_SUBJECT_SYNTAX,
-  FindingSubjectStringSchema,
-  FindingsStore,
-  IMPROVEMENT_KIND_SPEC,
-  KIND_EXPECTED_SUBJECTS,
-  KNOWLEDGE_GAP_KIND_SPEC,
-  KNOWLEDGE_POISONING_KIND_SPEC,
-  RAW_FINDING_SCHEMA_PROMPT,
-  RawAnalystEvidenceSchema,
-  RawAnalystFindingSchema,
-  SKILL_USAGE_ANALYST,
-  SkillUsageAnalyst,
-  assertNoJudgeVerdict,
-  behavioralAnalyst,
-  buildDefaultAnalystRegistry,
-  buildSkillUsageReport,
-  buildTraceToolsForGroup,
-  coerceJson,
-  coerceToFindingRows,
-  computeFindingId,
-  createAnalystAi,
-  createChatClient,
-  createJudgeAdapter,
-  createRunCriticAdapter,
-  createSemanticConceptJudgeAdapter,
-  createTraceAnalystKind,
-  createVerifierAdapter,
-  defaultIsMaterial,
-  deriveEfficiencyFindings,
-  diffFindings,
-  emitSkillUsageFindings,
-  evidenceRefsFromRawFinding,
-  findingSubjectGrammarPromptFor,
-  isJudgeVerdict,
-  isTraceObservable,
-  liftSeverity,
-  makeFinding,
-  parseCanonicalRawFinding,
-  parseFindingSubject,
-  parseRawFinding,
-  renderFindingSubject,
-  renderPriorFindings,
-  renderUpstreamFindings,
-  stripCodeFences,
-  structureFindings
-};
+//#endregion
+export { ANALYST_SEVERITIES, AnalystRegistry, DEFAULT_TRACE_ANALYST_KINDS, FAILURE_MODE_KIND_SPEC, FINDING_SUBJECT_GRAMMAR_PROMPT, FINDING_SUBJECT_KINDS, FINDING_SUBJECT_SYNTAX, FindingSubjectStringSchema, FindingsStore, IMPROVEMENT_KIND_SPEC, KIND_EXPECTED_SUBJECTS, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, RAW_FINDING_SCHEMA_PROMPT, RawAnalystEvidenceSchema, RawAnalystFindingSchema, SKILL_USAGE_ANALYST, SkillUsageAnalyst, assertNoJudgeVerdict, behavioralAnalyst, buildDefaultAnalystRegistry, buildSkillUsageReport, buildTraceToolsForGroup, coerceJson, coerceToFindingRows, computeFindingId, createAnalystAi, createChatClient, createJudgeAdapter, createRunCriticAdapter, createSemanticConceptJudgeAdapter, createTraceAnalystKind, createVerifierAdapter, defaultIsMaterial, deriveEfficiencyFindings, diffFindings, emitSkillUsageFindings, evidenceRefsFromRawFinding, findingSubjectGrammarPromptFor, isJudgeVerdict, isTraceObservable, liftSeverity, makeFinding, parseFindingSubject, parseRawFinding, renderFindingSubject, renderPriorFindings, renderUpstreamFindings, stripCodeFences, structureFindings };
+
 //# sourceMappingURL=index.js.map