@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/{default-registry-BmktKy8r.js → chat-client-Bp4Ebuuc.js}

@@ -1,1348 +1,1267 @@
-import { n as LlmClient } from "./llm-client-DzvMUsS_.js";
+import { i as hashCanonical, r as canonicalString } from "./canonical-D-XsTQ6_.js";
+import { a as combineAbortSignals } from "./run-score-lDzV0X8j.js";
+import { c as deepFreezeCanonicalJson, i as assertValidAnalystUsageReceipt, n as makeFinding, s as validateUsageSettlementTimeout } from "./types-BI4fT3HN.js";
+import { R as findingSubjectGrammarPromptFor, X as spanEpochMillis, nt as snapshotExactExecutionComponentIdentity, rt as snapshotExactExecutionPlan, t as createTraceAnalyst } from "./kind-factory-CPmSd58s.js";
 import { LLM_CONTEXT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_OUTPUT_TOKEN_ATTR_KEYS, TOOL_NAME_ATTR_KEYS } from "./trace-attributes.js";
+import { n as LlmClient } from "./llm-client-d0-2TT1g.js";
 import { t as executionTrackByLane } from "./execution-tracks-CpgFPpS5.js";
-import { H as snapshotExactExecutionPlan, Q as spanEpochMillis, R as findingSubjectGrammarPromptFor, V as snapshotExactExecutionComponentIdentity, t as createTraceAnalyst } from "./kind-factory-B8-r8-y8.js";
-import { a as deepFreezeCanonicalJson, i as validateUsageSettlementTimeout, s as makeFinding, t as assertValidAnalystUsageReceipt } from "./usage-receipt-t7vAzCRQ.js";
-import { i as hashCanonical, r as canonicalString } from "./canonical-D011XM8r.js";
-import { t as analyzeSupervisorRunIntegrity } from "./integrity-DY6tIbl0.js";
-import { o as combineAbortSignals } from "./proposal-findings-2GIUo1et.js";
-import { z } from "zod";
+import { t as analyzeSupervisorRunIntegrity } from "./integrity-DysDBWDu.js";
 import { randomUUID } from "node:crypto";
-//#region src/analyst/chat-client.ts
-/**
-* Provider-neutral chat contract for every model call made by agent-eval.
-*
-* Callers choose the transport at the package boundary with `createChatClient`.
-* Evaluation code receives canonical requests and results without importing a
-* provider SDK.
-*/
-/**
-* Build a ChatClient bound to a specific transport. The returned client
-* is safe to share across analysts in a single registry run.
-*/
-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,
-			maximumAttempts: opts.maximumAttempts
-		}));
-		case "cli-bridge": return wrapLlmClient(opts.transport, opts.defaultModel, new LlmClient({
-			baseUrl: opts.baseUrl ?? "http://127.0.0.1:3344/v1",
-			apiKey: opts.bearer ?? "",
-			maximumAttempts: opts.maximumAttempts
-		}));
-		case "direct-provider": return wrapLlmClient(opts.transport, opts.defaultModel, new LlmClient({
-			baseUrl: opts.baseUrl,
-			apiKey: opts.apiKey,
-			maximumAttempts: opts.maximumAttempts
-		}));
-		case "sandbox-sdk": return {
-			transport: "sandbox-sdk",
-			defaultModel: opts.defaultModel,
-			maximumAttempts: opts.maximumAttempts,
-			chat: async (req, callOpts) => opts.chat(resolveModel(req, opts.defaultModel), callOpts)
-		};
-		case "custom": return {
-			transport: "custom",
-			defaultModel: opts.defaultModel,
-			maximumAttempts: opts.maximumAttempts,
-			chat: async (req, callOpts) => opts.chat(resolveModel(req, opts.defaultModel), callOpts)
-		};
-		case "mock": return {
-			transport: "mock",
-			defaultModel: opts.defaultModel,
-			maximumAttempts: 1,
-			chat: async (req, callOpts) => opts.handler(resolveModel(req, opts.defaultModel), callOpts)
-		};
-	}
+import { z } from "zod";
+//#region src/feedback-trajectory-review.ts
+/** Bind an analyst finding's complete canonical JSON content to a stable digest. */
+function analystFindingDigest(finding) {
+	return hashCanonical(snapshotAnalystFinding(finding, "analyst finding"));
 }
-function wrapLlmClient(transport, defaultModel, inner) {
-	return {
-		transport,
-		defaultModel,
-		maximumAttempts: inner.maximumAttempts,
-		chat: (req, callOpts) => {
-			const request = {
-				model: resolveModel(req, defaultModel).model,
-				messages: req.messages,
-				jsonMode: req.jsonMode,
-				jsonSchema: req.jsonSchema,
-				temperature: req.temperature,
-				maxTokens: req.maxTokens,
-				thinking: req.thinking,
-				timeoutMs: req.timeoutMs
-			};
-			return inner.call(request, {
-				signal: callOpts?.signal,
-				idempotencyKey: callOpts?.idempotencyKey
-			});
-		}
-	};
+/** Bind the complete analyst result to one immutable review target. */
+function analystRunDigest(run) {
+	return hashCanonical(snapshotAnalystRun(run, "analyst run"));
 }
-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
-	};
+function snapshotAnalystRun(value, context = "analyst run") {
+	const snapshot = snapshotAnalystRunRecord(value, context);
+	if (snapshot.execution_plan !== void 0) return sealExactAnalystRunReceipt(snapshot, context);
+	if (snapshot.completion !== void 0) throw new TypeError(`${context} completion is valid only for an exact run`);
+	return snapshot;
 }
-//#endregion
-//#region src/trace-analyst/behavioral-metrics.ts
-/**
-* Deterministic behavioral metrics over OTLP spans — pure arithmetic, no LLM.
-*
-* It computes token growth, output decay, tool monoculture, and missing
-* self-verification once in TypeScript with no model judgment.
-*
-* General, not trace-specific: the detectors key off token trajectories and
-* tool usage present in any agentic OTLP trace, not any one benchmark.
-*/
-/** ≥ this input-token growth ratio across a run, with no compression, fires. */
-const INPUT_GROWTH_FACTOR = 3;
-/** Tool-usage signals need at least this many calls to be meaningful. */
-const MIN_TOOL_CALLS = 3;
-/**
-* Serial calls required before a strictly-decreasing output run counts as decay.
-*
-* A run of n independent lengths is strictly decreasing by chance with
-* probability 1/n!, so the old minimum of 3 fired on roughly one sequence in
-* six. The paired `inputIsMonotonic && inputGrew` guard does not offset that:
-* context accumulates by construction in a serial agent loop, so input growth
-* is very nearly free evidence. At 5 calls chance alone accounts for under 1%,
-* which is the bar a signal reported at full confidence has to clear.
-*/
-const OUTPUT_DECAY_MINIMUM_CALLS = 5;
-/**
-* The last output must fall to at most this fraction of the first.
-*
-* Length wanders between turns for reasons that are not degradation, so
-* direction alone is not a finding — an observed 784 → 646 run (18%) was
-* reported as decay and was noise. Requiring the response to lose most of its
-* length keeps the signal on the failure it names: late steps that quietly
-* stop doing the work.
-*/
-const OUTPUT_DECAY_MAXIMUM_RETAINED_FRACTION = .6;
-/** Tool names that read or check state count as self-verification, not mutation.
-*  Covers the inspect verbs plus the read/search tools real harnesses use to
-*  verify (Claude Code Read/Grep/Glob, codex read_file/ls/cat, git status/diff,
-*  test/lint). A pure shell tool (Bash/exec_command) is intentionally NOT matched
-*  — its name can't tell a `pytest` from an `rm`. */
-const VERIFY_RE = /verif|eval|inspect|check|assert|validat|review|confirm|read|grep|glob|search|view|\blist\b|\bls\b|\bcat\b|\bfind\b|diff|status|\btest|lint|typecheck/i;
-function num(v) {
-	return typeof v === "number" && Number.isFinite(v) ? v : null;
+/** Canonicalize, validate, and deeply freeze one complete or failed exact-run receipt. */
+function snapshotExactAnalystRunReceipt(value, context = "exact analyst run receipt") {
+	return sealExactAnalystRunReceipt(snapshotAnalystRunRecord(value, context), context);
 }
-function numAttr(attrs, keys) {
-	for (const key of keys) {
-		const value = num(attrs[key]);
-		if (value !== null) return value;
+function snapshotAnalystRunRecord(value, context) {
+	let snapshot;
+	try {
+		snapshot = JSON.parse(canonicalString(value));
+	} catch (cause) {
+		throw new TypeError(`${context} must have a canonical JSON representation`, { cause });
 	}
-	return null;
-}
-function inputTokensOf(s) {
-	const exactContext = num(s.attributes[LLM_CONTEXT_TOKENS]);
-	if (exactContext !== null) return exactContext;
-	return numAttr(s.attributes, LLM_INPUT_TOKEN_ATTR_KEYS) ?? num(s.attributes["llm.usage.input_tokens"]);
+	if (!isRecord(snapshot)) throw new TypeError(`${context} must be an object`);
+	assertOnlyKeys(snapshot, [
+		"run_id",
+		"correlation_id",
+		"started_at",
+		"ended_at",
+		"findings",
+		"per_analyst",
+		"total_cost_usd",
+		"total_cost_provenance",
+		"execution_plan",
+		"completion"
+	], context);
+	requiredString(snapshot.run_id, `${context} run_id`);
+	requiredString(snapshot.correlation_id, `${context} correlation_id`);
+	canonicalTimestamp(snapshot.started_at, `${context} started_at`);
+	canonicalTimestamp(snapshot.ended_at, `${context} ended_at`);
+	snapshot.findings = snapshotAnalystFindings(snapshot.findings, `${context} findings`);
+	if (!Array.isArray(snapshot.per_analyst)) throw new TypeError(`${context} per_analyst must be an array`);
+	for (const [index, summary] of snapshot.per_analyst.entries()) assertAnalystRunSummary(summary, `${context} per_analyst ${index}`);
+	if (typeof snapshot.total_cost_usd !== "number" || !Number.isFinite(snapshot.total_cost_usd) || snapshot.total_cost_usd < 0) throw new TypeError(`${context} total_cost_usd must be a finite non-negative number`);
+	if (snapshot.total_cost_provenance !== void 0) assertCostProvenance(snapshot.total_cost_provenance, `${context} total_cost_provenance`);
+	return snapshot;
 }
-function outputTokensOf(s) {
-	return numAttr(s.attributes, LLM_OUTPUT_TOKEN_ATTR_KEYS) ?? num(s.attributes["llm.usage.output_tokens"]);
+function assertAnalystRunSummary(value, context) {
+	if (!isRecord(value)) throw new TypeError(`${context} must be an object`);
+	assertOnlyKeys(value, [
+		"analyst_id",
+		"status",
+		"reason",
+		"findings_count",
+		"latency_ms",
+		"usage",
+		"allocated_budget_usd",
+		"error"
+	], context);
+	requiredString(value.analyst_id, `${context} analyst_id`);
+	if (value.status !== "ok" && value.status !== "skipped" && value.status !== "failed") throw new TypeError(`${context} status is invalid`);
+	if (value.reason !== void 0) requiredString(value.reason, `${context} reason`);
+	if (value.status === "skipped" && value.reason === void 0) throw new TypeError(`${context} skipped summary requires reason`);
+	nonnegativeSafeInteger(value.findings_count, `${context} findings_count`);
+	finiteNonnegative(value.latency_ms, `${context} latency_ms`);
+	assertAnalystUsageReceipt(value.usage, `${context} usage`);
+	if (value.allocated_budget_usd !== void 0 && value.allocated_budget_usd !== null) finiteNonnegative(value.allocated_budget_usd, `${context} allocated_budget_usd`);
+	if (value.error !== void 0) {
+		if (value.status !== "failed" || !isRecord(value.error)) throw new TypeError(`${context} error is valid only for failed summaries`);
+		assertOnlyKeys(value.error, ["class", "message"], `${context} error`);
+		requiredString(value.error.class, `${context} error class`);
+		requiredString(value.error.message, `${context} error message`);
+	} else if (value.status === "failed") throw new TypeError(`${context} failed summary requires error`);
 }
-function stepOf(s) {
-	return num(s.attributes.step);
+function assertAnalystUsageReceipt(value, context) {
+	if (!isRecord(value)) throw new TypeError(`${context} must be an object`);
+	assertOnlyKeys(value, [
+		"calls",
+		"tokens",
+		"cost",
+		"knownCostUsd"
+	], context);
+	for (const field of [
+		"calls",
+		"tokens",
+		"cost"
+	]) if (!Object.hasOwn(value, field)) throw new TypeError(`${context} ${field} is required`);
+	if (value.tokens !== null) {
+		if (!isRecord(value.tokens)) throw new TypeError(`${context} tokens must be an object or null`);
+		assertOnlyKeys(value.tokens, [
+			"input",
+			"output",
+			"reasoning",
+			"cached",
+			"cacheWrite"
+		], `${context} tokens`);
+	}
+	assertCostProvenance(value.cost, `${context} cost`);
+	assertValidAnalystUsageReceipt(value, context);
 }
-function toolNameOf(s) {
-	if (s.tool_name) return s.tool_name;
-	for (const key of TOOL_NAME_ATTR_KEYS) {
-		const t = s.attributes[key];
-		if (typeof t === "string" && t.length > 0) return t;
+function assertCostProvenance(value, context) {
+	if (!isRecord(value)) throw new TypeError(`${context} must be an object`);
+	assertOnlyKeys(value, ["kind", "usd"], context);
+	if (value.kind === "uncaptured") {
+		if (value.usd !== null) throw new TypeError(`${context} uncaptured usd must be null`);
+		return;
 	}
-	return null;
+	if (value.kind !== "observed" && value.kind !== "estimated") throw new TypeError(`${context} kind is invalid`);
+	finiteNonnegative(value.usd, `${context} usd`);
 }
-/**
-* Reduce a span list to behavioral metrics + fired suboptimality signals.
-* Pure + deterministic: same spans → same output, on any machine, no model.
-*/
-function computeTraceMetrics(spans) {
-	const traceIds = new Set(spans.map((span) => span.trace_id));
-	if (traceIds.size > 1) throw new Error(`computeTraceMetrics: expected spans from one trace, received ${traceIds.size} traces`);
-	const traceId = traceIds.values().next().value ?? null;
-	const samples = spans.map((span) => ({
-		span,
-		input: inputTokensOf(span),
-		output: outputTokensOf(span),
-		step: stepOf(span)
-	}));
-	const llmSamples = samples.filter((sample) => sample.span.kind === "LLM");
-	const tokenSamples = llmSamples.length > 0 ? llmSamples : samples.filter((sample) => sample.input !== null || sample.output !== null);
-	const tokenSequences = buildTokenSequences(tokenSamples, spans);
-	const primarySequence = tokenSequences[0];
-	const inputTokenTrajectory = primarySequence?.inputTokenTrajectory.filter((value) => value !== null) ?? [];
-	const outputTokenTrajectory = primarySequence?.outputTokenTrajectory.filter((value) => value !== null) ?? [];
-	const toolHistogram = {};
-	let hasSelfVerification = false;
-	for (const s of spans) {
-		const tool = toolNameOf(s);
-		if (tool) {
-			toolHistogram[tool] = (toolHistogram[tool] ?? 0) + 1;
-			if (VERIFY_RE.test(tool)) hasSelfVerification = true;
+function sealExactAnalystRunReceipt(run, context) {
+	if (run.execution_plan === void 0) throw new TypeError(`${context} exact run requires execution_plan`);
+	const plan = snapshotExactExecutionPlan(run.execution_plan, `${context} execution_plan`);
+	const completion = snapshotExactRunCompletion(run.completion, `${context} completion`);
+	run.execution_plan = plan;
+	run.completion = completion;
+	const summaries = run.per_analyst;
+	const findings = run.findings;
+	const planned = plan.analysts.map((analyst) => analyst.id);
+	const completed = summaries.map((summary) => summary.analyst_id);
+	if (!completed.every((analystId, index) => analystId === planned[index]) || completion.status === "complete" && completed.length !== planned.length) throw new TypeError(completion.status === "complete" ? `${context} complete receipt must contain every execution_plan analyst in exact order` : `${context} failed receipt per_analyst must be an execution_plan prefix`);
+	const completedIds = new Set(completed);
+	for (const finding of findings) if (!completedIds.has(finding.analyst_id)) throw new TypeError(`${context} finding names an analyst absent from per_analyst`);
+	for (const summary of summaries) {
+		const actual = findings.filter((finding) => finding.analyst_id === summary.analyst_id).length;
+		if (summary.findings_count !== actual) throw new TypeError(`${context} findings_count does not match findings for "${summary.analyst_id}"`);
+		const hasAllocation = Object.hasOwn(summary, "allocated_budget_usd");
+		if (summary.status === "skipped") {
+			if (hasAllocation) throw new TypeError(`${context} skipped summary "${summary.analyst_id}" cannot report an allocated budget`);
+			continue;
 		}
+		const allocation = summary.allocated_budget_usd;
+		if (!(hasAllocation && (plan.policy.budget.kind === "none" ? allocation === null : typeof allocation === "number" && plan.policy.budget.allocations_usd[summary.analyst_id] !== null && plan.policy.budget.allocations_usd[summary.analyst_id] !== void 0 && allocation <= plan.policy.budget.allocations_usd[summary.analyst_id]))) throw new TypeError(`${context} summary "${summary.analyst_id}" allocation does not match its execution plan`);
 	}
-	const totalToolCalls = Object.values(toolHistogram).reduce((a, b) => a + b, 0);
-	const distinctTools = Object.keys(toolHistogram).length;
-	const toolDiversityRatio = totalToolCalls === 0 ? 1 : distinctTools / totalToolCalls;
-	const signals = [];
-	const seenTokenSignals = /* @__PURE__ */ new Set();
-	for (const sequence of tokenSequences) for (const signal of tokenSignals(sequence)) {
-		if (seenTokenSignals.has(signal.code)) continue;
-		seenTokenSignals.add(signal.code);
-		signals.push(signal);
+	let knownCost = 0;
+	for (const summary of summaries) {
+		const amount = summary.usage.cost.kind === "uncaptured" ? summary.usage.knownCostUsd ?? 0 : summary.usage.cost.usd ?? 0;
+		knownCost = finiteNonnegative(knownCost + amount, `${context} aggregate known cost`);
 	}
-	if (totalToolCalls >= MIN_TOOL_CALLS && distinctTools === 1) {
-		const only = Object.keys(toolHistogram)[0];
-		signals.push({
-			code: "single-tool-dependency",
-			severity: "medium",
-			detail: `All ${totalToolCalls} observed tool calls are \`${only}\`; no alternate tool call was observed.`,
-			evidence: {
-				tool: only,
-				calls: totalToolCalls,
-				distinct_tools: 1
-			}
-		});
+	if (run.total_cost_usd !== knownCost) throw new TypeError(`${context} total_cost_usd does not match per_analyst usage`);
+	if (run.total_cost_provenance === void 0) throw new TypeError(`${context} exact run requires total_cost_provenance`);
+	const costs = summaries.map((summary) => summary.usage.cost);
+	const expectedProvenance = costs.some((cost) => cost.kind === "uncaptured") ? {
+		kind: "uncaptured",
+		usd: null
+	} : {
+		kind: costs.some((cost) => cost.kind === "estimated") ? "estimated" : "observed",
+		usd: costs.reduce((sum, cost) => finiteNonnegative(sum + (cost.usd ?? 0), `${context} aggregate captured cost`), 0)
+	};
+	if (hashCanonical(run.total_cost_provenance) !== hashCanonical(expectedProvenance)) throw new TypeError(`${context} total_cost_provenance does not match per_analyst usage`);
+	return deepFreezeCanonicalJson(run);
+}
+function snapshotExactRunCompletion(value, context) {
+	if (!isRecord(value)) throw new TypeError(`${context} must be an object`);
+	if (value.status === "complete") {
+		assertOnlyKeys(value, ["status"], context);
+		return value;
 	}
-	if (totalToolCalls >= MIN_TOOL_CALLS && !hasSelfVerification) signals.push({
-		code: "no-self-verification",
-		severity: "medium",
-		detail: `${totalToolCalls} tool calls were observed without a verification-named tool call.`,
-		evidence: {
-			tool_calls: totalToolCalls,
-			verification_calls: 0
+	if (value.status !== "failed") throw new TypeError(`${context} status must be complete or failed`);
+	assertOnlyKeys(value, ["status", "error"], context);
+	if (!isRecord(value.error)) throw new TypeError(`${context} failed receipt requires error`);
+	assertOnlyKeys(value.error, ["class", "message"], `${context} error`);
+	requiredString(value.error.class, `${context} error class`);
+	requiredString(value.error.message, `${context} error message`);
+	return value;
+}
+function finiteNonnegative(value, context) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new TypeError(`${context} must be a non-negative finite number`);
+	return value;
+}
+function nonnegativeSafeInteger(value, context) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${context} must be a non-negative safe integer`);
+	return value;
+}
+function snapshotAnalystFindings(value, context = "analyst run findings") {
+	if (!Array.isArray(value)) throw new TypeError(`${context} must be an array`);
+	const findings = value.map((finding, index) => snapshotAnalystFinding(finding, `${context} finding ${index}`));
+	assertUniqueFindingIds(findings.map((finding) => finding.finding_id));
+	return findings;
+}
+function readAnalystReview(trajectory) {
+	const analystAttempts = trajectory.attempts.filter((attempt) => isRecord(attempt.artifact) && attempt.artifact.type === "analyst-run");
+	const analysis = isRecord(trajectory.metadata?.analysis) ? trajectory.metadata.analysis : void 0;
+	if (analystAttempts.length === 0) {
+		if (analysis?.kind === "analyst-run") throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" is missing its archived run`);
+		return;
+	}
+	if (analystAttempts.length !== 1) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" must contain exactly one archived run`);
+	if (analysis?.kind !== "analyst-run") throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" is missing review state`);
+	const artifact = analystAttempts[0].artifact;
+	if (!isRecord(artifact)) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" has an invalid archived run`);
+	const runId = requiredString(artifact.analystRunId, `analyst trajectory "${trajectory.id}" run id`);
+	if (analysis.runId !== runId) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" run identity does not match its review state`);
+	const artifactRunDigest = requiredDigest(artifact.runDigest, `analyst trajectory "${trajectory.id}" archived run digest`);
+	const storedRunDigest = requiredDigest(analysis.runDigest, `analyst trajectory "${trajectory.id}" review run digest`);
+	if (artifactRunDigest !== storedRunDigest) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" run digest does not match its review state`);
+	const findings = snapshotAnalystFindings(artifact.findings, `analyst trajectory "${trajectory.id}"`);
+	const findingIds = findings.map((finding) => finding.finding_id);
+	const analystIds = stringArray(artifact.analystIds, `analyst trajectory "${trajectory.id}" analyst ids`);
+	const attemptMetadata = analystAttempts[0].metadata;
+	if (!isRecord(attemptMetadata)) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" is missing archived run metadata`);
+	const archivedRun = snapshotAnalystRun({
+		run_id: runId,
+		correlation_id: artifact.correlationId,
+		started_at: analysis.startedAt,
+		ended_at: analysis.endedAt,
+		findings,
+		per_analyst: attemptMetadata.perAnalyst,
+		total_cost_usd: analysis.knownCostUsd,
+		...analysis.costProvenance === void 0 ? {} : { total_cost_provenance: analysis.costProvenance },
+		...artifact.executionPlan === void 0 ? {} : {
+			execution_plan: artifact.executionPlan,
+			completion: artifact.completion
 		}
+	}, `analyst trajectory "${trajectory.id}" archived run`);
+	const knownAnalystIds = new Set(analystIds);
+	for (const [index, finding] of findings.entries()) if (!knownAnalystIds.has(finding.analyst_id)) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" omits generating analyst "${finding.analyst_id}" at finding ${index}`);
+	const reviewDecisions = validateAnalystReviewDecisions({
+		runId,
+		runDigest: storedRunDigest,
+		findings,
+		analystIds,
+		decisions: analysis.reviewDecisions,
+		requireComplete: true
 	});
+	const expectedRunDigest = analystRunDigest(archivedRun);
+	if (storedRunDigest !== expectedRunDigest) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" archived run digest mismatch`);
 	return {
-		traceId,
-		llmCallCount: tokenSamples.length,
-		tokenSequences,
-		inputTokenTrajectory,
-		outputTokenTrajectory,
-		toolHistogram,
-		totalToolCalls,
-		distinctTools,
-		toolDiversityRatio,
-		hasSelfVerification,
-		signals
+		runId,
+		runDigest: expectedRunDigest,
+		findings,
+		findingIds,
+		analystIds,
+		reviewDecisions
 	};
 }
-function buildTokenSequences(samples, spans) {
-	const executionScopeFor = createTokenExecutionScopeResolver(new Map(spans.map((span) => [span.span_id, span])));
-	const scopedSamples = samples.map((sample) => ({
-		sample,
-		...executionScopeFor(sample.span)
-	}));
-	const trackByLane = executionTrackByLane(scopedSamples);
-	const byTrack = /* @__PURE__ */ new Map();
-	for (const scoped of scopedSamples) {
-		const trackId = trackByLane.get(scoped.key);
-		const track = byTrack.get(trackId) ?? {
-			scopeId: scoped.scopeId,
-			samples: []
-		};
-		track.samples.push(scoped.sample);
-		byTrack.set(trackId, track);
-	}
-	const sequences = [];
-	for (const { scopeId, samples: tracked } of byTrack.values()) {
-		const runs = serialTokenRuns([...tracked].sort(compareTokenSamples));
-		runs.forEach((run, index) => {
-			sequences.push({
-				scopeId: runs.length === 1 ? scopeId : `${scopeId}#${index + 1}`,
-				spanIds: run.map((sample) => sample.span.span_id),
-				inputTokenTrajectory: run.map((sample) => sample.input),
-				outputTokenTrajectory: run.map((sample) => sample.output)
-			});
-		});
-	}
-	return sequences.sort((a, b) => b.spanIds.length - a.spanIds.length || a.scopeId.localeCompare(b.scopeId) || a.spanIds[0].localeCompare(b.spanIds[0]));
-}
-function createTokenExecutionScopeResolver(spansById) {
-	const cache = /* @__PURE__ */ new Map();
-	return (span) => {
-		const ancestry = resolveAncestorScope(span.parent_span_id, spansById, cache);
-		const rootId = ancestry.rootId;
-		const scopeId = ancestry.agentId ? `span:${ancestry.agentId}` : ancestry.missingParentId ? `parent:${ancestry.missingParentId}` : rootId ? `root:${rootId}` : span.agent_name ? `agent:${span.agent_name}` : `trace:${span.trace_id}`;
-		const scopeSpanId = ancestry.agentId ?? ancestry.missingParentId ?? rootId;
-		const laneSpan = ancestry.laneSpanId ? spansById.get(ancestry.laneSpanId) : void 0;
-		const direct = scopeSpanId === null || ancestry.laneSpanId === scopeSpanId;
-		const timedSpan = direct ? span : laneSpan;
-		return {
-			key: JSON.stringify([scopeId, direct ? span.span_id : ancestry.laneSpanId]),
-			scopeKey: scopeId,
-			scopeId,
-			start: timedSpan ? spanEpochMillis(timedSpan.start_time) : null,
-			end: timedSpan ? spanEpochMillis(timedSpan.end_time) : null
-		};
+function completedAnalystReviewQuality(review) {
+	const findingDecisions = review.reviewDecisions.filter((decision) => decision.verdict !== "completeness_assessed");
+	const completeness = review.reviewDecisions.filter((decision) => decision.verdict === "completeness_assessed");
+	if (completeness.length !== 1) throw new TypeError("feedbackTrajectoryToOptimizerRow: analyst run requires exactly one independent completeness_assessed decision");
+	const confirmed = findingDecisions.filter((decision) => decision.verdict === "confirmed").length;
+	const rejected = findingDecisions.length - confirmed;
+	const emitted = review.findingIds.length;
+	const missed = completeness[0].missedIssues.length;
+	const precision = emitted === 0 ? 1 : confirmed / emitted;
+	const recallDenominator = confirmed + missed;
+	const recall = recallDenominator === 0 ? 1 : confirmed / recallDenominator;
+	return {
+		precision,
+		recall,
+		f1: precision + recall === 0 ? 0 : 2 * precision * recall / (precision + recall),
+		counts: {
+			emitted,
+			confirmed,
+			rejected,
+			missed
+		}
 	};
 }
-function resolveAncestorScope(startId, spansById, cache) {
-	const empty = {
-		agentId: null,
-		rootId: null,
-		missingParentId: null,
-		laneSpanId: null
-	};
-	if (!startId) return empty;
-	const path = [];
-	const pathIndex = /* @__PURE__ */ new Map();
-	let currentId = startId;
-	let resolved = empty;
-	while (currentId) {
-		const cached = cache.get(currentId);
-		if (cached) {
-			resolved = cached;
-			break;
-		}
-		const cycleStart = pathIndex.get(currentId);
-		if (cycleStart !== void 0) {
-			resolved = {
-				agentId: null,
-				rootId: [...path.slice(cycleStart)].sort()[0],
-				missingParentId: null,
-				laneSpanId: [...path.slice(cycleStart)].sort()[0]
-			};
-			break;
-		}
-		const current = spansById.get(currentId);
-		if (!current) {
-			resolved = {
-				agentId: null,
-				rootId: null,
-				missingParentId: currentId,
-				laneSpanId: currentId
-			};
-			break;
-		}
-		if (current.kind === "AGENT") {
-			resolved = {
-				agentId: current.span_id,
-				rootId: null,
-				missingParentId: null,
-				laneSpanId: current.span_id
+function validateAnalystReviewDecisions(input) {
+	if (!Array.isArray(input.decisions)) throw new TypeError("analyst review decisions must be an array");
+	const findings = snapshotAnalystFindings(input.findings);
+	const expectedRunDigest = requiredDigest(input.runDigest, "analyst review run digest");
+	const findingsById = new Map(findings.map((finding) => [finding.finding_id, finding]));
+	const generatingAnalystIds = new Set(input.analystIds);
+	const seenFindingIds = /* @__PURE__ */ new Set();
+	let completenessCount = 0;
+	const decisions = input.decisions.map((value, index) => {
+		if (!isRecord(value)) throw new TypeError(`analyst review decision ${index} must be an object`);
+		const source = requiredString(value.source, `analyst review decision ${index} source`);
+		if (!isAnalystReviewSource(source)) throw new TypeError(`analyst review decision ${index} source must be user, judge, environment, metric, or policy`);
+		const reviewerId = requiredString(value.reviewerId, `analyst review decision ${index} reviewerId`);
+		if (generatingAnalystIds.has(reviewerId)) throw new TypeError(`analyst review decision ${index} reviewerId must differ from the generating analyst`);
+		const reviewId = requiredString(value.reviewId, `analyst review decision ${index} reviewId`);
+		if (reviewId === input.runId) throw new TypeError(`analyst review decision ${index} reviewId must identify an independent review`);
+		const reason = requiredString(value.reason, `analyst review decision ${index} reason`);
+		const decidedAt = canonicalTimestamp(value.decidedAt, `analyst review decision ${index} decidedAt`);
+		const runDigest = requiredDigest(value.runDigest, `analyst review decision ${index} runDigest`);
+		if (runDigest !== expectedRunDigest) throw new TypeError(`analyst review decision ${index} run digest mismatch`);
+		if (value.verdict === "completeness_assessed") {
+			assertOnlyKeys(value, [
+				"runDigest",
+				"verdict",
+				"missedIssues",
+				"source",
+				"reviewerId",
+				"reviewId",
+				"reason",
+				"decidedAt"
+			], `analyst review decision ${index}`);
+			completenessCount += 1;
+			if (completenessCount > 1) throw new TypeError("duplicate completeness_assessed analyst review decision");
+			return {
+				runDigest,
+				verdict: "completeness_assessed",
+				missedIssues: validateMissedIssues(value.missedIssues, findingsById, `analyst review decision ${index}`),
+				source,
+				reviewerId,
+				reviewId,
+				reason,
+				decidedAt
 			};
-			break;
 		}
-		pathIndex.set(currentId, path.length);
-		path.push(currentId);
-		currentId = current.parent_span_id;
-	}
-	for (let index = path.length - 1; index >= 0; index -= 1) {
-		if (resolved.agentId === null && resolved.rootId === null) resolved = {
-			...resolved,
-			rootId: path[index],
-			laneSpanId: path[index]
-		};
-		else if (resolved.laneSpanId === (resolved.agentId ?? resolved.missingParentId ?? resolved.rootId)) resolved = {
-			...resolved,
-			laneSpanId: path[index]
+		if (value.verdict !== "confirmed" && value.verdict !== "rejected") throw new TypeError(`analyst review decision ${index} verdict must be confirmed, rejected, or completeness_assessed`);
+		assertOnlyKeys(value, [
+			"runDigest",
+			"findingId",
+			"findingDigest",
+			"verdict",
+			"source",
+			"reviewerId",
+			"reviewId",
+			"reason",
+			"decidedAt"
+		], `analyst review decision ${index}`);
+		const findingId = requiredString(value.findingId, `analyst review decision ${index} findingId`);
+		const finding = findingsById.get(findingId);
+		if (!finding) throw new TypeError(`analyst review decision references unknown finding id "${findingId}"`);
+		if (seenFindingIds.has(findingId)) throw new TypeError(`duplicate analyst review decision for finding id "${findingId}"`);
+		seenFindingIds.add(findingId);
+		const findingDigest = requiredString(value.findingDigest, `analyst review decision ${index} findingDigest`);
+		const expectedDigest = analystFindingDigest(finding);
+		if (findingDigest !== expectedDigest) throw new TypeError(`analyst review decision ${index} digest mismatch for finding id "${findingId}"`);
+		return {
+			runDigest,
+			findingId,
+			findingDigest: expectedDigest,
+			verdict: value.verdict,
+			source,
+			reviewerId,
+			reviewId,
+			reason,
+			decidedAt
 		};
-		cache.set(path[index], resolved);
+	});
+	if (input.requireComplete) {
+		const missing = findings.map((finding) => finding.finding_id).filter((findingId) => !seenFindingIds.has(findingId));
+		if (missing.length > 0) throw new TypeError(`feedbackTrajectoryToOptimizerRow: missing independent decisions for finding ids: ${missing.join(", ")}`);
+		if (completenessCount !== 1) throw new TypeError("feedbackTrajectoryToOptimizerRow: analyst run requires exactly one independent completeness_assessed decision");
 	}
-	return resolved;
-}
-function compareTokenSamples(a, b) {
-	const aStart = spanEpochMillis(a.span.start_time);
-	const bStart = spanEpochMillis(b.span.start_time);
-	if (aStart === null && bStart !== null) return 1;
-	if (aStart !== null && bStart === null) return -1;
-	if (aStart !== null && bStart !== null && aStart !== bStart) return aStart - bStart;
-	if (a.step !== null && b.step !== null && a.step !== b.step) return a.step - b.step;
-	return a.span.span_id.localeCompare(b.span.span_id);
+	return decisions;
 }
-function serialTokenRuns(ordered) {
-	const runs = [];
-	let serial = [];
-	let overlap = [];
-	let overlapEnd = Number.NEGATIVE_INFINITY;
-	const flushSerial = () => {
-		if (serial.length > 0) runs.push(serial);
-		serial = [];
-	};
-	const flushOverlap = () => {
-		if (overlap.length === 1) serial.push(overlap[0]);
-		else if (overlap.length > 1) {
-			flushSerial();
-			for (const sample of overlap) runs.push([sample]);
-		}
-		overlap = [];
-		overlapEnd = Number.NEGATIVE_INFINITY;
-	};
-	for (const sample of ordered) {
-		const start = spanEpochMillis(sample.span.start_time);
-		const end = spanEpochMillis(sample.span.end_time);
-		if (start === null || end === null || sample.span.duration_ms <= 0 || end < start) {
-			flushOverlap();
-			flushSerial();
-			runs.push([sample]);
-			continue;
-		}
-		if (overlap.length > 0 && start >= overlapEnd) flushOverlap();
-		overlap.push(sample);
-		overlapEnd = Math.max(overlapEnd, end);
+function assertUniqueFindingIds(findingIds) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const findingId of findingIds) {
+		if (findingId.trim().length === 0) throw new TypeError("analyst finding id must not be empty");
+		if (seen.has(findingId)) throw new TypeError(`analyst run contains duplicate finding id "${findingId}"`);
+		seen.add(findingId);
 	}
-	flushOverlap();
-	flushSerial();
-	return runs;
 }
-function tokenSignals(sequence) {
-	const signals = [];
-	const inputs = sequence.inputTokenTrajectory;
-	const outputs = sequence.outputTokenTrajectory;
-	if (inputs.length >= 3 && inputs.every((value) => value !== null)) {
-		const first = inputs[0];
-		const last = inputs[inputs.length - 1];
-		const isMonotonic = everyAdjacent(inputs, (previous, current) => current >= previous);
-		const growthFromZero = first === 0 && last > 0;
-		const growth = growthFromZero ? Infinity : first > 0 ? last / first : 0;
-		if (isMonotonic && last > first && growth >= INPUT_GROWTH_FACTOR) {
-			const growthLabel = growthFromZero ? "0→nonzero (unbounded)" : `${growth.toFixed(1)}x`;
-			signals.push({
-				code: "monotonic-input-growth",
-				severity: "high",
-				detail: `LLM input tokens grew ${growthLabel} (${first}→${last}) across ${inputs.length} serial calls without an intervening decrease.`,
-				evidence: {
-					first,
-					last,
-					growth_x: growthFromZero ? "unbounded" : Number(growth.toFixed(2)),
-					calls: inputs.length,
-					scope: sequence.scopeId,
-					first_span_id: sequence.spanIds[0],
-					last_span_id: sequence.spanIds[sequence.spanIds.length - 1]
-				}
-			});
-		}
-	}
-	if (inputs.length >= OUTPUT_DECAY_MINIMUM_CALLS && inputs.length === outputs.length && inputs.every((value) => value !== null) && outputs.every((value) => value !== null)) {
-		const first = outputs[0];
-		const last = outputs[outputs.length - 1];
-		const inputIsMonotonic = everyAdjacent(inputs, (previous, current) => current >= previous);
-		const outputIsMonotonic = everyAdjacent(outputs, (previous, current) => current <= previous);
-		const inputGrew = inputs[inputs.length - 1] > inputs[0];
-		const decayIsMaterial = last <= first * OUTPUT_DECAY_MAXIMUM_RETAINED_FRACTION;
-		if (inputIsMonotonic && inputGrew && outputIsMonotonic && decayIsMaterial) signals.push({
-			code: "output-length-decay",
-			severity: "medium",
-			detail: `LLM output tokens shrank ${first}→${last} over ${outputs.length} serial calls while input tokens increased monotonically.`,
-			evidence: {
-				first,
-				last,
-				calls: outputs.length,
-				scope: sequence.scopeId,
-				first_span_id: sequence.spanIds[0],
-				last_span_id: sequence.spanIds[sequence.spanIds.length - 1]
-			}
-		});
+function snapshotAnalystFinding(value, context) {
+	let snapshot;
+	try {
+		snapshot = JSON.parse(canonicalString(value));
+	} catch (cause) {
+		throw new TypeError(`${context} must have a canonical JSON representation`, { cause });
 	}
-	return signals;
-}
-function everyAdjacent(values, predicate) {
-	return values.slice(1).every((current, index) => predicate(values[index], current));
+	assertAnalystFinding(snapshot, context);
+	return snapshot;
 }
-//#endregion
-//#region src/analyst/behavioral-analyst.ts
-/**
-* Deterministic behavioral analysis over arithmetic in trace spans.
-* This pass is cheap and repeatable; semantic analysis remains the job of
-* model-backed analysts. Relative quality requires a labeled comparison.
-*/
-const RECOMMENDED_ACTION = {
-	"monotonic-input-growth": "Inspect context assembly; if prior history is repeatedly included, summarize completed work before the next model call.",
-	"output-length-decay": "Check late-step completeness; if shorter responses omit required work, add explicit completion criteria to the agent instructions.",
-	"single-tool-dependency": "Test whether an inspect or verification tool improves outcomes after the repeated call fails or returns no progress.",
-	"no-self-verification": "After state-changing actions, require an observable check before the agent proceeds."
-};
-const ANALYST_ID$1 = "efficiency-behavioral";
-const DEFAULT_MAX_TRACES = 1e3;
-const DEFAULT_MAX_EVIDENCE_REFS = 20;
-const TRACE_PAGE_SIZE = 200;
-const AGGREGATE_CLAIM = {
-	"monotonic-input-growth": (observed, analyzed) => `${observed}/${analyzed} analyzed traces showed input tokens grow from zero to nonzero or to at least 3x their initial value across at least 3 serial model calls without a decrease.`,
-	"output-length-decay": (observed, analyzed) => `${observed}/${analyzed} analyzed traces showed output tokens decrease while input tokens increased monotonically across at least 3 serial model calls.`,
-	"single-tool-dependency": (observed, analyzed) => `${observed}/${analyzed} analyzed traces used only one named tool across at least 3 tool calls.`,
-	"no-self-verification": (observed, analyzed) => `${observed}/${analyzed} analyzed traces had at least 3 tool calls without a verification-named tool call.`
-};
-async function listTraceIds(store, maxTraces, signal) {
-	const traceIds = /* @__PURE__ */ new Set();
-	let offset = 0;
-	let expectedTotal;
-	while (true) {
-		signal?.throwIfAborted();
-		const page = await store.queryTraces({
-			limit: TRACE_PAGE_SIZE,
-			offset
-		});
-		if (expectedTotal === void 0) expectedTotal = page.total;
-		if (page.total !== expectedTotal) throw new Error(`behavioralAnalyst: trace count changed during pagination (${expectedTotal} to ${page.total})`);
-		if (page.total > maxTraces) throw new RangeError(`behavioralAnalyst: ${page.total} traces exceed maxTraces=${maxTraces}; filter the store or raise the explicit limit`);
-		for (const trace of page.traces) traceIds.add(trace.trace_id);
-		if (traceIds.size > maxTraces) throw new RangeError(`behavioralAnalyst: more than maxTraces=${maxTraces} unique traces were returned`);
-		if (!page.has_more) break;
-		if (page.traces.length === 0) throw new Error("behavioralAnalyst: trace store returned an empty page with has_more=true");
-		offset += page.traces.length;
-	}
-	if (traceIds.size !== expectedTotal) throw new Error(`behavioralAnalyst: pagination returned ${traceIds.size}/${expectedTotal ?? 0} unique traces`);
-	return [...traceIds].sort();
+function assertAnalystFinding(value, context) {
+	if (!isRecord(value)) throw new TypeError(`${context} must be an object`);
+	assertOnlyKeys(value, [
+		"schema_version",
+		"finding_id",
+		"analyst_id",
+		"produced_at",
+		"severity",
+		"area",
+		"claim",
+		"rationale",
+		"evidence_refs",
+		"recommended_action",
+		"validation_plan",
+		"confidence",
+		"subject",
+		"derived_from_judge",
+		"metadata"
+	], context);
+	if (value.schema_version !== "1.0.0") throw new TypeError(`${context} schema_version must be "1.0.0"`);
+	requiredString(value.finding_id, `${context} finding_id`);
+	requiredString(value.analyst_id, `${context} analyst_id`);
+	canonicalTimestamp(value.produced_at, `${context} produced_at`);
+	if (value.severity !== "critical" && value.severity !== "high" && value.severity !== "medium" && value.severity !== "low" && value.severity !== "info") throw new TypeError(`${context} severity is invalid`);
+	requiredString(value.area, `${context} area`);
+	requiredString(value.claim, `${context} claim`);
+	optionalString(value.rationale, `${context} rationale`);
+	value.evidence_refs = validateEvidenceRefs(value.evidence_refs, `${context} evidence_refs`);
+	optionalString(value.recommended_action, `${context} recommended_action`);
+	optionalString(value.validation_plan, `${context} validation_plan`);
+	if (typeof value.confidence !== "number" || !Number.isFinite(value.confidence) || value.confidence < 0 || value.confidence > 1) throw new TypeError(`${context} confidence must be a finite number from 0 through 1`);
+	optionalString(value.subject, `${context} subject`);
+	if (value.derived_from_judge !== void 0 && typeof value.derived_from_judge !== "boolean") throw new TypeError(`${context} derived_from_judge must be a boolean`);
+	if (value.metadata !== void 0 && !isRecord(value.metadata)) throw new TypeError(`${context} metadata must be an object`);
 }
-/**
-* Map computed signals → structured AnalystFindings. Pure: no LLM, no clock
-* dependence beyond `produced_at` (overridable for deterministic tests).
-*/
-function deriveEfficiencyFindings(metrics, opts = {}) {
-	const analystId = opts.analystId ?? ANALYST_ID$1;
-	const traceId = metrics.traceId;
-	return metrics.signals.map((sig) => makeFinding({
-		analyst_id: analystId,
-		area: "efficiency",
-		subject: sig.code,
-		claim: sig.detail,
-		severity: sig.severity,
-		confidence: 1,
-		evidence_refs: [{
-			kind: "metric",
-			uri: traceId ? `metric://trace/${encodeURIComponent(traceId)}/efficiency/${sig.code}` : `metric://efficiency/${sig.code}`,
-			excerpt: JSON.stringify(sig.evidence)
-		}],
-		recommended_action: RECOMMENDED_ACTION[sig.code],
-		metadata: {
-			deterministic: true,
-			evidence: sig.evidence,
-			...traceId ? { trace_id: traceId } : {}
-		},
-		id_basis: sig.code,
-		...opts.producedAt ? { produced_at: opts.producedAt } : {}
-	}));
+function validateMissedIssues(value, findingsById, context) {
+	if (!Array.isArray(value)) throw new TypeError(`${context} missedIssues must be an array`);
+	const seen = /* @__PURE__ */ new Set();
+	return value.map((issue, index) => {
+		const issueContext = `${context} missedIssues ${index}`;
+		if (!isRecord(issue)) throw new TypeError(`${issueContext} must be an object`);
+		assertOnlyKeys(issue, [
+			"id",
+			"reason",
+			"evidence"
+		], issueContext);
+		const id = requiredString(issue.id, `${issueContext} id`);
+		if (findingsById.has(id)) throw new TypeError(`${issueContext} id "${id}" is already an emitted finding id`);
+		if (seen.has(id)) throw new TypeError(`duplicate missed issue id "${id}"`);
+		seen.add(id);
+		return {
+			id,
+			reason: requiredString(issue.reason, `${issueContext} reason`),
+			...issue.evidence === void 0 ? {} : { evidence: validateEvidenceRefs(issue.evidence, `${issueContext} evidence`) }
+		};
+	});
 }
-/** The deterministic behavioral/efficiency analyst (no LLM, any-model). */
-function behavioralAnalyst(options = {}) {
-	const maxTraces = positiveInteger(options.maxTraces ?? DEFAULT_MAX_TRACES, "maxTraces");
-	const maxEvidenceRefsPerFinding = positiveInteger(options.maxEvidenceRefsPerFinding ?? DEFAULT_MAX_EVIDENCE_REFS, "maxEvidenceRefsPerFinding");
-	return {
-		id: ANALYST_ID$1,
-		description: "Deterministic behavioral/efficiency findings over OTLP spans — token-growth, output-decay, tool-monoculture, missing self-verification. Zero LLM; model-agnostic by construction.",
-		inputKind: "trace-store",
-		cost: { kind: "deterministic" },
-		version: "2.0.0",
-		executionConfig: {
-			kind: "behavioral-efficiency",
-			max_traces: maxTraces,
-			max_evidence_refs_per_finding: maxEvidenceRefsPerFinding
-		},
-		async analyze(store, context) {
-			const analyzedTraceIds = await listTraceIds(store, maxTraces, context.signal);
-			const findingsById = /* @__PURE__ */ new Map();
-			for (const traceId of analyzedTraceIds) {
-				context.signal?.throwIfAborted();
-				const viewed = await store.viewTrace({ trace_id: traceId });
-				if (viewed.trace_id !== traceId) throw new Error(`behavioralAnalyst: requested trace '${traceId}', received '${viewed.trace_id}'`);
-				if (!viewed.spans) throw new Error(`behavioralAnalyst: trace '${traceId}' is oversized; complete spans are required`);
-				const metrics = computeTraceMetrics(viewed.spans);
-				if (metrics.traceId !== null && metrics.traceId !== traceId) throw new Error(`behavioralAnalyst: requested trace '${traceId}', received '${metrics.traceId}'`);
-				for (const finding of deriveEfficiencyFindings(metrics)) {
-					const current = findingsById.get(finding.finding_id);
-					if (!current) {
-						findingsById.set(finding.finding_id, {
-							finding,
-							observedTraceCount: 1,
-							evidenceTraceIds: [traceId],
-							evidence: [...finding.evidence_refs]
-						});
-						continue;
-					}
-					current.observedTraceCount += 1;
-					if (current.evidence.length < maxEvidenceRefsPerFinding) {
-						current.evidenceTraceIds.push(traceId);
-						current.evidence.push(...finding.evidence_refs);
-					}
-				}
-			}
-			return [...findingsById.values()].map(({ finding, observedTraceCount, evidenceTraceIds, evidence }) => ({
-				...finding,
-				claim: AGGREGATE_CLAIM[finding.subject](observedTraceCount, analyzedTraceIds.length),
-				rationale: `${observedTraceCount}/${analyzedTraceIds.length} analyzed traces exhibited this pattern.`,
-				evidence_refs: evidence,
-				metadata: {
-					deterministic: true,
-					evidence_trace_ids: evidenceTraceIds,
-					omitted_evidence_trace_count: observedTraceCount - evidenceTraceIds.length,
-					observed_trace_count: observedTraceCount,
-					analyzed_trace_count: analyzedTraceIds.length
-				}
-			}));
-		}
-	};
+function validateEvidenceRefs(value, context) {
+	if (!Array.isArray(value)) throw new TypeError(`${context} must be an array`);
+	return value.map((evidence, index) => {
+		const evidenceContext = `${context} ${index}`;
+		if (!isRecord(evidence)) throw new TypeError(`${evidenceContext} must be an object`);
+		assertOnlyKeys(evidence, [
+			"kind",
+			"uri",
+			"excerpt"
+		], evidenceContext);
+		if (evidence.kind !== "span" && evidence.kind !== "event" && evidence.kind !== "artifact" && evidence.kind !== "finding" && evidence.kind !== "metric") throw new TypeError(`${evidenceContext} kind is invalid`);
+		const uri = requiredString(evidence.uri, `${evidenceContext} uri`);
+		const excerpt = evidence.excerpt;
+		optionalString(excerpt, `${evidenceContext} excerpt`);
+		return {
+			kind: evidence.kind,
+			uri,
+			...excerpt === void 0 ? {} : { excerpt }
+		};
+	});
 }
-function positiveInteger(value, name) {
-	if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`behavioralAnalyst: ${name} must be a positive safe integer`);
+function assertOnlyKeys(value, allowed, name) {
+	const allowedKeys = new Set(allowed);
+	const unexpected = Object.keys(value).filter((key) => !allowedKeys.has(key));
+	if (unexpected.length > 0) throw new TypeError(`${name} contains unknown fields: ${unexpected.sort().join(", ")}`);
+}
+function stringArray(value, name) {
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new TypeError(`${name} must be an array of strings`);
+	const strings = value.map((item) => requiredString(item, name));
+	if (new Set(strings).size !== strings.length) throw new TypeError(`${name} must contain unique values`);
+	return strings;
+}
+function requiredString(value, name) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new TypeError(`${name} must be a non-empty string`);
 	return value;
 }
-//#endregion
-//#region src/analyst/kinds/control-integrity.ts
-const ANALYST_ID = "control-integrity";
-function shown(value) {
-	if (value === void 0) return "<absent>";
-	const encoded = JSON.stringify(value);
-	return encoded === void 0 ? String(value) : encoded;
+function requiredDigest(value, name) {
+	const digest = requiredString(value, name);
+	if (!/^sha256:[a-f0-9]{64}$/.test(digest)) throw new TypeError(`${name} must be a sha256 digest`);
+	return digest;
 }
-function evidenceRef(namespace, value) {
-	return {
-		kind: "metric",
-		uri: `supervisor-run://${encodeURIComponent(namespace)}/${value.path}`,
-		excerpt: shown(value.value)
-	};
+function optionalString(value, name) {
+	if (value !== void 0 && typeof value !== "string") throw new TypeError(`${name} must be a string`);
 }
-/** Translate typed supervisor-run integrity issues into the shared analyst envelope. */
-function emitControlIntegrityFindings(input, producedAt) {
-	const report = analyzeSupervisorRunIntegrity(input, { capturedAt: producedAt });
-	return report.issues.map((issue) => makeFinding({
-		analyst_id: ANALYST_ID,
-		produced_at: producedAt,
-		area: issue.area,
-		severity: issue.severity,
-		subject: `${report.runRef}/${issue.subject}`,
-		claim: issue.claim,
-		rationale: issue.detail,
-		evidence_refs: issue.evidence.map((value) => evidenceRef(report.runRef, value)),
-		recommended_action: issue.recommendedAction,
-		validation_plan: "Re-run this deterministic analyst on the retained SupervisorRunSources or SupervisorRunTree after correcting the producer.",
-		confidence: 1,
-		metadata: {
-			integrity_code: issue.code,
-			integrity_input: report.input,
-			integrity_run_ref: report.runRef,
-			integrity_subject: issue.subject,
-			...issue.metadata
-		}
-	}));
+function canonicalTimestamp(value, name) {
+	const timestamp = requiredString(value, name);
+	const parsed = new Date(timestamp);
+	if (Number.isNaN(parsed.valueOf()) || parsed.toISOString() !== timestamp) throw new TypeError(`${name} must be a canonical ISO 8601 UTC timestamp`);
+	return timestamp;
+}
+function isAnalystReviewSource(value) {
+	return value === "user" || value === "judge" || value === "environment" || value === "metric" || value === "policy";
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-/** Deterministic Analyst adapter for `SupervisorRunSources | SupervisorRunTree`. */
-var ControlIntegrityAnalyst = class {
-	id = ANALYST_ID;
-	description = "Deterministic supervisor-run integrity checks with explicit unavailable evidence.";
-	inputKind = "custom";
-	cost = {
-		kind: "deterministic",
-		est_usd_per_run: 0
-	};
-	version = "2.0.0";
-	executionConfig = {
-		kind: "control-integrity",
-		produced_at_source: "tags.producedAt-or-system-clock"
-	};
-	async analyze(input, ctx) {
-		const findings = emitControlIntegrityFindings(input, ctx.tags?.producedAt ?? (/* @__PURE__ */ new Date()).toISOString());
-		ctx.log?.(`control-integrity: ${findings.length} finding(s)`, { input: "nodes" in input ? "SupervisorRunTree" : "SupervisorRunSources" });
-		return findings;
-	}
-};
-const CONTROL_INTEGRITY_ANALYST = new ControlIntegrityAnalyst();
-const FAILURE_MODE_KIND_SPEC = {
-	id: "failure-mode",
-	description: "Ranks failures by the work each one burned — spans, model calls, and wall-clock between the error and the span where the agent resumed — and treats a failure that reached a human as the most expensive class.",
-	area: "failure-mode",
-	version: "2.0.0",
-	instructions: `You are a failure-cost analyst for an OTLP trace dataset. Your job is to find the failures that **burned the most agent work** and to price each one in spans, model calls, and wall-clock. How often an error occurred is not its cost and is not your output.
-
-${findingSubjectGrammarPromptFor("failure-mode")}
-
-Use a lowercase cluster label that names the cost shape, not the error string: "human-corrected-file-overwrite", "unrecovered-auth-loop", "long-detour-schema-guess".
-
-WORKLIST → RECOVERY BOUNDARY → PRICE → CITE protocol:
-
-1. \`getDatasetOverview({})\` first. Read \`errors.trace_count\`, \`errors.span_count\`, and \`error_clusters[]\` — each cluster carries \`signature\`, \`tool_name\`, \`trace_count\`, \`span_count\`, \`prevalence\`, \`exemplar_trace_ids\`, and \`exemplar_span_ids\`. This is the deterministic analyzer's output, already computed for free. It is your WORKLIST: the exemplar ids name the spans you go price. It is never your findings.
-2. Reach error-bearing traces the exemplars miss with \`queryTraces(filters={"has_errors": true}, limit=...)\`. Prefer long traces and traces whose errors sit early: a failure has room to be expensive only when work followed it.
-3. Take one candidate error span E and read its trace in order. \`viewTrace\` returns that trace's spans sorted by \`start_time\`, which is the ordering every distance below is counted in. When \`viewTrace\` returns \`oversized\` instead of spans, locate candidates with \`searchTrace\` and pull the exact ids with \`viewSpans\`; use \`searchSpan\` when one span's payload is truncated.
-4. Find the RECOVERY BOUNDARY R — the first span after E in which the agent resumed productive work. Productive means a different, task-advancing action. A retry of the same call with the same arguments, a re-read of the same file, a re-plan of the same step, and an apology are all still inside the failure. Then price it:
-   - spans_burned: spans strictly between E and R
-   - model_calls_burned: how many of those spans have kind \`LLM\`
-   - wall_clock_ms: R \`end_time\` minus E \`start_time\`
-   Report all three. If the agent never resumed, R is the trace's last span and the failure is UNRECOVERED.
-5. Set severity from what ENDED the failure and from the measured distance, never from how many times the signature appears:
-   - HUMAN-CORRECTED — a human turn after E supplies the correction. This is the most expensive class at any span count, because the failure escaped the agent entirely and reached the user: severity critical. Detect it as a new user-role message in a later \`LLM\` span's input attributes, or a new root-level \`AGENT\` span in which the user restates or repairs the task. Search with patterns like \`"role"\\s*:\\s*"user"\`, \`(that|this) is (wrong|not what)\`, \`I (said|asked|told you)\`, \`stop\`, \`undo\`, \`revert\`, \`you (deleted|broke|missed|ignored)\`, \`try again\`. Quote the human's words exactly.
-   - UNRECOVERED — the trace ends without resumption: severity critical.
-   - LONG DETOUR — 10 or more spans burned, or 3 or more \`LLM\` spans burned: severity high.
-   - SHORT DETOUR — 2 to 9 spans burned: severity medium.
-   - SELF-RECOVERED ON THE NEXT SPAN — cost is approximately zero. Do not emit it. That is resilience, and reporting it dilutes the ranking.
-   One error that cost 20 spans outranks 50 errors that each cost one retry. Frequency may appear in a finding only as a multiplier on a measured per-instance cost, never as the reason for its severity.
-6. **Cluster, do not enumerate.** Errors sharing a root cause AND a recovery shape are ONE finding: report the summed cost across instances, state how many instances it covers, and cite the bounding pair of the single most expensive instance. Two errors with the same signature but different recovery shapes — one shrugged off, one human-corrected — are NOT the same finding; the expensive one is the finding and the cheap one is noise.
-
-FORBIDDEN OUTPUT. Each of the following duplicates the deterministic pass, and a duplicate finding is worse than no finding because it costs a reviewer the same attention while carrying no new information:
-   - a count of errors by tool ("Bash is the dominant failure surface, 54 error spans")
-   - a count or inventory of error signatures ("47 distinct error signatures")
-   - an error rate ("79 of 5260 tool calls ended in errors")
-   - any restatement of \`prevalence\`, \`trace_count\`, or \`span_count\` from \`error_clusters[]\`
-Every finding MUST state its measured cost — spans burned, model calls burned, wall-clock — in the claim, and MUST cite the two spans that bound it: the error span and the recovery span, or the escaping human turn, or the trace's last span when unrecovered. A failure you cannot bound with two spans is one you did not measure: drop it.
-
-**Adjudicate boundaries with subqueries.** The single judgement call in this protocol is whether a post-error span is genuine resumption or more flailing. Load E, the spans between, and the candidate R, then send one bounded \`llm_query\` per candidate carrying those exact excerpts and asking which span first advances the task. Subqueries cannot call trace tools, so a trace id tells them nothing — paste the excerpts. Accept a boundary only when the excerpts you loaded support the answer.
-
-Confidence 0.9+ when both bounding spans are quoted and the spans between them were counted directly; 0.6-0.8 when an oversized trace forced you to sample the interval and the distance is an estimate; below 0.5 does not belong in this analyst, because an unmeasurable cost is not a finding. Keep the recommended action a short imperative; the improvement analyst expands it.
-
-If every error in this dataset was recovered on the next span, return an empty findings array. That is the correct answer for a dataset whose failures were all cheap. Do not backfill it with the counts listed above and do not pad it with speculation.`,
-	toolGroup: "all",
-	limits: {
-		maxLlmCalls: 8,
-		maxIterations: 24,
-		maxToolCalls: 80
-	},
-	minimumEvidenceCitations: 2
-};
-const 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.2.0",
-	instructions: `You are a 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.
-
-${findingSubjectGrammarPromptFor("improvement")}
-
-DISCOVERY → CANDIDATE-FIXES → COMPETE → CITE protocol:
-
-1. \`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** — add an instruction, remove a misleading one, restructure precedence
-   - **Tool description edit** — rewrite a tool's description so the agent picks it correctly / passes valid args
-   - **New tool** — add a tool the agent kept emulating in code
-   - **RAG ingestion** — add a document or correct a stale one
-   - **Memory invalidation** — clear cached prior-run decisions that no longer apply
-   - **Scaffolding** — add a precondition check, a retry policy, a turn budget, a verification step
-   - **Output schema** — narrow the agent's output to forbid the failure shape
-   - **Skill / MCP / hook / subagent** — change the reusable profile component responsible for the behavior
-   - **Workflow / rollout policy** — change orchestration, budget, sampling, or stopping behavior
-   - **Code** — change an implementation path when profile edits cannot repair the behavior
-3. **Compare candidate fixes with bounded subqueries.** Load the representative failure excerpts, then send one \`llm_query\` per candidate-fix axis the same evidence. Ask for likely effect, side effects, and implementation scope. Subqueries cannot call trace tools; trace ids alone are insufficient context.
-4. After the comparisons return, **pick the winning candidate per cluster** based on expected effect and risk, then emit ONE finding. Keep the alternatives and rejection reasons in the rationale so the recommendation is auditable.
-5. **Cross-reference upstream findings.** Cite prior failure-mode or knowledge-gap findings as \`finding://<prior-finding-id>\`. 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. Use one exact locus from the subject grammar and state the edit in one sentence. Match leverage to the source failure's severity; use medium for quality-of-life changes and info for cleanup with no behavioral effect. Cite the targeted \`finding://<id>\` when available and the most representative span when useful. Quote the problem being fixed. Use confidence 0.85+ for a mechanical fix to a well-evidenced failure, 0.6-0.8 when judgment is required, and <0.5 for speculation. Explain in at most two sentences why this candidate beat its alternatives. The recommended action must be the literal diff, quoted replacement, tool description, or setting change.
-
-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.). Prefer upstream findings when present because the analysts 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.`,
-	toolGroup: "all",
-	limits: {
-		maxLlmCalls: 8,
-		maxIterations: 30,
-		maxToolCalls: 80,
-		maxOutputChars: 12e3
-	}
-};
-const INTENT_DIVERGENCE_KIND_SPEC = {
-	id: "intent-divergence",
-	description: "Anchors each corrective human turn to the earliest assistant turn where the divergence from stated intent was already detectable, and prices it in burned turns.",
-	area: "intent-divergence",
-	version: "1.0.0",
-	instructions: `You are an intent-divergence analyst for an OTLP trace dataset. Your job is to find where the agent stopped doing what the user asked, and to establish **how early that was knowable**.
-
-This dataset carries ground truth the other analysts do not have. When a human turn corrects the agent — "no, I meant…", "stop doing X", "why are you still asking" — the user has labelled a divergence for you. That label marks the END of the divergence, not its start. Your finding is the start: the earliest assistant turn already off-intent, the signal in the user's stated intent it contradicted, and the number of turns burned before the correction landed.
-
-${findingSubjectGrammarPromptFor("intent-divergence")}
-
-DISCOVERY → BACKTRACK → QUANTIFY → CITE protocol:
-
-1. \`getDatasetOverview({})\` first. Note the agent names and \`sample_trace_ids\`; conversational datasets carry several human turns per trace and those are the ones worth pulling.
-2. **DISCOVERY — find the corrective human turns.** Use \`searchTrace\` for user-authored corrections:
-   Every pattern MUST begin with \`(?i)\`. The trace store compiles a search pattern case-sensitively unless it opens with that flag, and corrections are overwhelmingly sentence-initial and capitalised ("Stop", "No,", "I said"), so a lowercase pattern silently returns zero hits.
-   - Imperative stops: \`(?i)\\bstop\\b\`, \`(?i)\\b(don'?t|do not)\\b\`, \`(?i)^\\s*no[,.!]\`, \`(?i)\\bnot what I (wanted|asked|meant)\\b\`, \`(?i)\\bthat'?s not what\\b\`, \`(?i)\\brevert\\b\`, \`(?i)\\bstart over\\b\`
-   - Repetition and frustration: \`(?i)\\bI (said|asked|told you)\\b\`, \`(?i)\\balready told you\\b\`, \`(?i)\\bwhy are you (still )?\\w+ing\\b\`, \`(?i)\\bjust (do|use|write|make)\\b\`, \`(?i)\\bagain\\b\`
-   - Clarification markers (second-order, see step 6): \`(?i)\\bI mean(t)?\\b\`, \`(?i)\\bto be clear\\b\`, \`(?i)\\bactually,? I (want|need)\\b\`, \`(?i)\\bwhat I meant\\b\`, \`(?i)\\blet me rephrase\\b\`
-   Attribute every match to a role before using it. The same phrases inside an assistant turn are hedging, not correction.
-3. **BACKTRACK — walk the trace backward from the correction.** Read the ordered turns preceding it with \`viewTrace\` / \`viewSpans\`. Locate the user's ORIGINAL statement of intent (usually the first human turn, sometimes a constraint added mid-run), then locate the FIRST assistant turn that contradicts it. That turn, not the correction, anchors the finding. Name the concrete signal already available at that turn: an explicit constraint the agent violated, a scope it exceeded, a different question it answered, a file or target the user never named, a decision the user had already made.
-4. **QUANTIFY — count the burned turns.** K = (index of the corrective human turn) − (index of the earliest detectable assistant turn). Report both indices and K. If you cannot locate an earliest-detectable turn, you have a correction and not a divergence: drop it.
-5. **CLUSTER.** Repeated corrections about the same misread intent are ONE finding citing all of them, not one finding per corrective turn. Corrections about genuinely different intents in the same trace are separate findings.
-6. **Second-order — the request itself was ambiguous.** When the user CLARIFIES rather than corrects ("I mean the staging config, not prod"), the agent's reading was defensible and the request was underspecified or self-contradictory. Emit those against a \`scaffolding:*\` locus — a clarifying-question policy or a plan checkpoint — because the fix is one sharp question before acting, priced against the K turns the ambiguity cost. Do not charge the agent's instructions for a request that could not be resolved from its own text.
-
-**Test competing anchors with subqueries.** After the backward walk, load the excerpts for the original intent turn, your candidate earliest-detectable turn, and the turn before it. Send one bounded \`llm_query\` per candidate anchor asking whether the divergence is already present in that turn's text alone. Subqueries cannot call trace tools, and a turn index alone is insufficient context. Take the EARLIEST candidate the loaded excerpts support.
-
-For each cluster, emit ONE finding. Use an exact locus from the subject grammar — the surface whose edit prevents the divergence, not the surface where it surfaced. State the claim in the shape "turn N did X against stated intent Y; user corrected at turn N+K, burning K turns." Rate it critical when the divergence produced a user-visible or irreversible action, high when K is 3 or more or the run ended without the intent satisfied, medium for one or two burned turns, and low for a cosmetic correction. Cite BOTH spans with exact quotes: the earliest-detectable assistant turn and the corrective human turn. Use confidence 0.85+ when the stated intent and the diverging turn are both quotable and the contradiction is explicit, and 0.6-0.8 when the earliest-detectable turn is inferred from surrounding context. The recommended action must be the literal instruction, question, or checkpoint to add.
-
-Do NOT report a divergence the agent noticed and reversed inside the same turn — that is self-correction and it cost the user nothing. Do NOT report a human turn that adds NEW scope; a changed mind is not a divergence. If the dataset holds no corrective or clarifying human turns, return an empty findings array instead of grading tone.`,
-	toolGroup: "all",
-	limits: {
-		maxLlmCalls: 6,
-		maxIterations: 22,
-		maxToolCalls: 64
-	},
-	minimumEvidenceCitations: 2
-};
-const KNOWLEDGE_GAP_KIND_SPEC = {
-	id: "knowledge-gap",
-	description: "Identifies missing or stale pieces of knowledge — primarily against the agent-knowledge wiki — 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.2.0",
-	instructions: `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\` — 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 — or an outdated/contradictory fact the agent picked up from a non-wiki source.
-
-${findingSubjectGrammarPromptFor("knowledge-gap")}
-
-DISCOVERY → ATTRIBUTE-TO-LAYER → CITE protocol:
-
-1. \`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…", "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 \`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** and use its exact locus from the subject grammar above.
-4. For each defensible gap, emit ONE finding. Use an exact locus from the subject grammar and name the missing or stale knowledge (for example, "wiki has no page on invoice line-item shape; agent re-derived it from raw spans"). Rate it high when it caused failure or a clarifying question, medium for unnecessary turns, and low for minor inefficiency. Cite the span where the question, correction, retrieval miss, or stale result surfaced and quote it exactly. Use confidence 0.85+ when the agent articulated the gap and 0.6-0.8 when inferred. Recommend a concrete wiki edit for an agent-knowledge locus or a prompt/tool-description edit otherwise.
-
-**Compare layers over loaded evidence.** After the first scan, load the exact excerpts behind candidates across \`agent-knowledge:*\`, \`websearch:outdated\`, \`tool-doc:*\`, \`system-prompt:*\`, and \`memory:*\`. Use one bounded \`llm_query\` per layer to classify those excerpts. Subqueries cannot call trace tools. Merge their classifications into the final finding set only when the source excerpts support them.
-
-Do NOT report a gap that the agent later recovered from cleanly within the same turn. That is resilience, not a gap. Cite the non-recovery version when both exist.`,
-	toolGroup: "discoveryAndSearch",
-	limits: {
-		maxLlmCalls: 5,
-		maxIterations: 18,
-		maxToolCalls: 48
-	}
-};
-const 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.2.0",
-	instructions: `You are a knowledge-poisoning analyst for an OTLP trace dataset. Your job is to identify cases where the agent **confidently used wrong information** — not where it lacked information (that's the knowledge-gap analyst).
-
-${findingSubjectGrammarPromptFor("knowledge-poisoning")}
-
-DISCOVERY → DUAL-VERIFY → CITE protocol:
-
-1. \`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 — 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 \`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 supported. If you can only support one, drop it because single-evidence poisoning findings are too speculative to be useful.
-
-**Independently assess both halves.** Load the action excerpt and contradicting excerpt yourself, then send bounded \`llm_query\` calls the exact evidence for "did the agent act?" and "does the trace contradict the belief?" Subqueries cannot call trace tools. Accept a poisoning only when both assessments and the source excerpts support it.
-
-For each confirmed poisoning, emit ONE finding. Use the source of the false belief as the exact subject. State "agent believed X (from source S); trace evidence shows X is false." Rate it critical for a wrong user-visible action, high when caught internally after significant waste, and medium for inefficiency. Cite BOTH the action span and the contradicting span with exact quotes. Use confidence 0.85+ when both halves have exact quotes and 0.6-0.8 when one half is inferred. Recommend the literal source correction: update the wiki claim, invalidate and re-curate the raw source, or replace the stale prompt/tool instruction.
-
-Do NOT report a finding if the agent caught and corrected the false belief in the same turn. Reserve poisoning for cases where the false belief shaped downstream action.`,
-	toolGroup: "all",
-	limits: {
-		maxLlmCalls: 8,
-		maxIterations: 20,
-		maxToolCalls: 64
-	},
-	minimumEvidenceCitations: 2
-};
 //#endregion
-//#region src/analyst/kinds/index.ts
+//#region src/trace-analyst/behavioral-metrics.ts
 /**
-* The default kind suite. Order is the run order operators should use:
-* failure-mode and intent-divergence first (neither reads upstream
-* findings), gap + poisoning next (both explain the problems those two
-* found), improvement last (chains all four). Intent-divergence sits
-* ahead of improvement deliberately — a proposed edit should be able to
-* act on a priced divergence, and it is the only kind whose findings
-* carry a burned-turn cost to rank against.
+* Deterministic behavioral metrics over OTLP spans — pure arithmetic, no LLM.
+*
+* It computes token growth, output decay, tool monoculture, and missing
+* self-verification once in TypeScript with no model judgment.
+*
+* General, not trace-specific: the detectors key off token trajectories and
+* tool usage present in any agentic OTLP trace, not any one benchmark.
 */
-const DEFAULT_TRACE_ANALYST_KINDS = [
-	FAILURE_MODE_KIND_SPEC,
-	INTENT_DIVERGENCE_KIND_SPEC,
-	KNOWLEDGE_GAP_KIND_SPEC,
-	KNOWLEDGE_POISONING_KIND_SPEC,
-	IMPROVEMENT_KIND_SPEC
-];
-//#endregion
-//#region src/feedback-trajectory-review.ts
-/** Bind an analyst finding's complete canonical JSON content to a stable digest. */
-function analystFindingDigest(finding) {
-	return hashCanonical(snapshotAnalystFinding(finding, "analyst finding"));
+/** ≥ this input-token growth ratio across a run, with no compression, fires. */
+const INPUT_GROWTH_FACTOR = 3;
+/** Tool-usage signals need at least this many calls to be meaningful. */
+const MIN_TOOL_CALLS = 3;
+/**
+* Serial calls required before a strictly-decreasing output run counts as decay.
+*
+* A run of n independent lengths is strictly decreasing by chance with
+* probability 1/n!, so the old minimum of 3 fired on roughly one sequence in
+* six. The paired `inputIsMonotonic && inputGrew` guard does not offset that:
+* context accumulates by construction in a serial agent loop, so input growth
+* is very nearly free evidence. At 5 calls chance alone accounts for under 1%,
+* which is the bar a signal reported at full confidence has to clear.
+*/
+const OUTPUT_DECAY_MINIMUM_CALLS = 5;
+/**
+* The last output must fall to at most this fraction of the first.
+*
+* Length wanders between turns for reasons that are not degradation, so
+* direction alone is not a finding — an observed 784 → 646 run (18%) was
+* reported as decay and was noise. Requiring the response to lose most of its
+* length keeps the signal on the failure it names: late steps that quietly
+* stop doing the work.
+*/
+const OUTPUT_DECAY_MAXIMUM_RETAINED_FRACTION = .6;
+/** Tool names that read or check state count as self-verification, not mutation.
+*  Covers the inspect verbs plus the read/search tools real harnesses use to
+*  verify (Claude Code Read/Grep/Glob, codex read_file/ls/cat, git status/diff,
+*  test/lint). A pure shell tool (Bash/exec_command) is intentionally NOT matched
+*  — its name can't tell a `pytest` from an `rm`. */
+const VERIFY_RE = /verif|eval|inspect|check|assert|validat|review|confirm|read|grep|glob|search|view|\blist\b|\bls\b|\bcat\b|\bfind\b|diff|status|\btest|lint|typecheck/i;
+function num(v) {
+	return typeof v === "number" && Number.isFinite(v) ? v : null;
 }
-/** Bind the complete analyst result to one immutable review target. */
-function analystRunDigest(run) {
-	return hashCanonical(snapshotAnalystRun(run, "analyst run"));
+function numAttr(attrs, keys) {
+	for (const key of keys) {
+		const value = num(attrs[key]);
+		if (value !== null) return value;
+	}
+	return null;
 }
-function snapshotAnalystRun(value, context = "analyst run") {
-	const snapshot = snapshotAnalystRunRecord(value, context);
-	if (snapshot.execution_plan !== void 0) return sealExactAnalystRunReceipt(snapshot, context);
-	if (snapshot.completion !== void 0) throw new TypeError(`${context} completion is valid only for an exact run`);
-	return snapshot;
+function inputTokensOf(s) {
+	const exactContext = num(s.attributes[LLM_CONTEXT_TOKENS]);
+	if (exactContext !== null) return exactContext;
+	return numAttr(s.attributes, LLM_INPUT_TOKEN_ATTR_KEYS) ?? num(s.attributes["llm.usage.input_tokens"]);
 }
-/** Canonicalize, validate, and deeply freeze one complete or failed exact-run receipt. */
-function snapshotExactAnalystRunReceipt(value, context = "exact analyst run receipt") {
-	return sealExactAnalystRunReceipt(snapshotAnalystRunRecord(value, context), context);
+function outputTokensOf(s) {
+	return numAttr(s.attributes, LLM_OUTPUT_TOKEN_ATTR_KEYS) ?? num(s.attributes["llm.usage.output_tokens"]);
 }
-function snapshotAnalystRunRecord(value, context) {
-	let snapshot;
-	try {
-		snapshot = JSON.parse(canonicalString(value));
-	} catch (cause) {
-		throw new TypeError(`${context} must have a canonical JSON representation`, { cause });
+function stepOf(s) {
+	return num(s.attributes.step);
+}
+function toolNameOf(s) {
+	if (s.tool_name) return s.tool_name;
+	for (const key of TOOL_NAME_ATTR_KEYS) {
+		const t = s.attributes[key];
+		if (typeof t === "string" && t.length > 0) return t;
 	}
-	if (!isRecord(snapshot)) throw new TypeError(`${context} must be an object`);
-	assertOnlyKeys(snapshot, [
-		"run_id",
-		"correlation_id",
-		"started_at",
-		"ended_at",
-		"findings",
-		"per_analyst",
-		"total_cost_usd",
-		"total_cost_provenance",
-		"execution_plan",
-		"completion"
-	], context);
-	requiredString(snapshot.run_id, `${context} run_id`);
-	requiredString(snapshot.correlation_id, `${context} correlation_id`);
-	canonicalTimestamp(snapshot.started_at, `${context} started_at`);
-	canonicalTimestamp(snapshot.ended_at, `${context} ended_at`);
-	snapshot.findings = snapshotAnalystFindings(snapshot.findings, `${context} findings`);
-	if (!Array.isArray(snapshot.per_analyst)) throw new TypeError(`${context} per_analyst must be an array`);
-	for (const [index, summary] of snapshot.per_analyst.entries()) assertAnalystRunSummary(summary, `${context} per_analyst ${index}`);
-	if (typeof snapshot.total_cost_usd !== "number" || !Number.isFinite(snapshot.total_cost_usd) || snapshot.total_cost_usd < 0) throw new TypeError(`${context} total_cost_usd must be a finite non-negative number`);
-	if (snapshot.total_cost_provenance !== void 0) assertCostProvenance(snapshot.total_cost_provenance, `${context} total_cost_provenance`);
-	return snapshot;
+	return null;
 }
-function assertAnalystRunSummary(value, context) {
-	if (!isRecord(value)) throw new TypeError(`${context} must be an object`);
-	assertOnlyKeys(value, [
-		"analyst_id",
-		"status",
-		"reason",
-		"findings_count",
-		"latency_ms",
-		"usage",
-		"allocated_budget_usd",
-		"error"
-	], context);
-	requiredString(value.analyst_id, `${context} analyst_id`);
-	if (value.status !== "ok" && value.status !== "skipped" && value.status !== "failed") throw new TypeError(`${context} status is invalid`);
-	if (value.reason !== void 0) requiredString(value.reason, `${context} reason`);
-	if (value.status === "skipped" && value.reason === void 0) throw new TypeError(`${context} skipped summary requires reason`);
-	nonnegativeSafeInteger(value.findings_count, `${context} findings_count`);
-	finiteNonnegative(value.latency_ms, `${context} latency_ms`);
-	assertAnalystUsageReceipt(value.usage, `${context} usage`);
-	if (value.allocated_budget_usd !== void 0 && value.allocated_budget_usd !== null) finiteNonnegative(value.allocated_budget_usd, `${context} allocated_budget_usd`);
-	if (value.error !== void 0) {
-		if (value.status !== "failed" || !isRecord(value.error)) throw new TypeError(`${context} error is valid only for failed summaries`);
-		assertOnlyKeys(value.error, ["class", "message"], `${context} error`);
-		requiredString(value.error.class, `${context} error class`);
-		requiredString(value.error.message, `${context} error message`);
-	} else if (value.status === "failed") throw new TypeError(`${context} failed summary requires error`);
+/**
+* Reduce a span list to behavioral metrics + fired suboptimality signals.
+* Pure + deterministic: same spans → same output, on any machine, no model.
+*/
+function computeTraceMetrics(spans) {
+	const traceIds = new Set(spans.map((span) => span.trace_id));
+	if (traceIds.size > 1) throw new Error(`computeTraceMetrics: expected spans from one trace, received ${traceIds.size} traces`);
+	const traceId = traceIds.values().next().value ?? null;
+	const samples = spans.map((span) => ({
+		span,
+		input: inputTokensOf(span),
+		output: outputTokensOf(span),
+		step: stepOf(span)
+	}));
+	const llmSamples = samples.filter((sample) => sample.span.kind === "LLM");
+	const tokenSamples = llmSamples.length > 0 ? llmSamples : samples.filter((sample) => sample.input !== null || sample.output !== null);
+	const tokenSequences = buildTokenSequences(tokenSamples, spans);
+	const primarySequence = tokenSequences[0];
+	const inputTokenTrajectory = primarySequence?.inputTokenTrajectory.filter((value) => value !== null) ?? [];
+	const outputTokenTrajectory = primarySequence?.outputTokenTrajectory.filter((value) => value !== null) ?? [];
+	const toolHistogram = {};
+	let hasSelfVerification = false;
+	for (const s of spans) {
+		const tool = toolNameOf(s);
+		if (tool) {
+			toolHistogram[tool] = (toolHistogram[tool] ?? 0) + 1;
+			if (VERIFY_RE.test(tool)) hasSelfVerification = true;
+		}
+	}
+	const totalToolCalls = Object.values(toolHistogram).reduce((a, b) => a + b, 0);
+	const distinctTools = Object.keys(toolHistogram).length;
+	const toolDiversityRatio = totalToolCalls === 0 ? 1 : distinctTools / totalToolCalls;
+	const signals = [];
+	const seenTokenSignals = /* @__PURE__ */ new Set();
+	for (const sequence of tokenSequences) for (const signal of tokenSignals(sequence)) {
+		if (seenTokenSignals.has(signal.code)) continue;
+		seenTokenSignals.add(signal.code);
+		signals.push(signal);
+	}
+	if (totalToolCalls >= MIN_TOOL_CALLS && distinctTools === 1) {
+		const only = Object.keys(toolHistogram)[0];
+		signals.push({
+			code: "single-tool-dependency",
+			severity: "medium",
+			detail: `All ${totalToolCalls} observed tool calls are \`${only}\`; no alternate tool call was observed.`,
+			evidence: {
+				tool: only,
+				calls: totalToolCalls,
+				distinct_tools: 1
+			}
+		});
+	}
+	if (totalToolCalls >= MIN_TOOL_CALLS && !hasSelfVerification) signals.push({
+		code: "no-self-verification",
+		severity: "medium",
+		detail: `${totalToolCalls} tool calls were observed without a verification-named tool call.`,
+		evidence: {
+			tool_calls: totalToolCalls,
+			verification_calls: 0
+		}
+	});
+	return {
+		traceId,
+		llmCallCount: tokenSamples.length,
+		tokenSequences,
+		inputTokenTrajectory,
+		outputTokenTrajectory,
+		toolHistogram,
+		totalToolCalls,
+		distinctTools,
+		toolDiversityRatio,
+		hasSelfVerification,
+		signals
+	};
 }
-function assertAnalystUsageReceipt(value, context) {
-	if (!isRecord(value)) throw new TypeError(`${context} must be an object`);
-	assertOnlyKeys(value, [
-		"calls",
-		"tokens",
-		"cost",
-		"knownCostUsd"
-	], context);
-	for (const field of [
-		"calls",
-		"tokens",
-		"cost"
-	]) if (!Object.hasOwn(value, field)) throw new TypeError(`${context} ${field} is required`);
-	if (value.tokens !== null) {
-		if (!isRecord(value.tokens)) throw new TypeError(`${context} tokens must be an object or null`);
-		assertOnlyKeys(value.tokens, [
-			"input",
-			"output",
-			"reasoning",
-			"cached",
-			"cacheWrite"
-		], `${context} tokens`);
+function buildTokenSequences(samples, spans) {
+	const executionScopeFor = createTokenExecutionScopeResolver(new Map(spans.map((span) => [span.span_id, span])));
+	const scopedSamples = samples.map((sample) => ({
+		sample,
+		...executionScopeFor(sample.span)
+	}));
+	const trackByLane = executionTrackByLane(scopedSamples);
+	const byTrack = /* @__PURE__ */ new Map();
+	for (const scoped of scopedSamples) {
+		const trackId = trackByLane.get(scoped.key);
+		const track = byTrack.get(trackId) ?? {
+			scopeId: scoped.scopeId,
+			samples: []
+		};
+		track.samples.push(scoped.sample);
+		byTrack.set(trackId, track);
+	}
+	const sequences = [];
+	for (const { scopeId, samples: tracked } of byTrack.values()) {
+		const runs = serialTokenRuns([...tracked].sort(compareTokenSamples));
+		runs.forEach((run, index) => {
+			sequences.push({
+				scopeId: runs.length === 1 ? scopeId : `${scopeId}#${index + 1}`,
+				spanIds: run.map((sample) => sample.span.span_id),
+				inputTokenTrajectory: run.map((sample) => sample.input),
+				outputTokenTrajectory: run.map((sample) => sample.output)
+			});
+		});
 	}
-	assertCostProvenance(value.cost, `${context} cost`);
-	assertValidAnalystUsageReceipt(value, context);
+	return sequences.sort((a, b) => b.spanIds.length - a.spanIds.length || a.scopeId.localeCompare(b.scopeId) || a.spanIds[0].localeCompare(b.spanIds[0]));
 }
-function assertCostProvenance(value, context) {
-	if (!isRecord(value)) throw new TypeError(`${context} must be an object`);
-	assertOnlyKeys(value, ["kind", "usd"], context);
-	if (value.kind === "uncaptured") {
-		if (value.usd !== null) throw new TypeError(`${context} uncaptured usd must be null`);
-		return;
+function createTokenExecutionScopeResolver(spansById) {
+	const cache = /* @__PURE__ */ new Map();
+	return (span) => {
+		const ancestry = resolveAncestorScope(span.parent_span_id, spansById, cache);
+		const rootId = ancestry.rootId;
+		const scopeId = ancestry.agentId ? `span:${ancestry.agentId}` : ancestry.missingParentId ? `parent:${ancestry.missingParentId}` : rootId ? `root:${rootId}` : span.agent_name ? `agent:${span.agent_name}` : `trace:${span.trace_id}`;
+		const scopeSpanId = ancestry.agentId ?? ancestry.missingParentId ?? rootId;
+		const laneSpan = ancestry.laneSpanId ? spansById.get(ancestry.laneSpanId) : void 0;
+		const direct = scopeSpanId === null || ancestry.laneSpanId === scopeSpanId;
+		const timedSpan = direct ? span : laneSpan;
+		return {
+			key: JSON.stringify([scopeId, direct ? span.span_id : ancestry.laneSpanId]),
+			scopeKey: scopeId,
+			scopeId,
+			start: timedSpan ? spanEpochMillis(timedSpan.start_time) : null,
+			end: timedSpan ? spanEpochMillis(timedSpan.end_time) : null
+		};
+	};
+}
+function resolveAncestorScope(startId, spansById, cache) {
+	const empty = {
+		agentId: null,
+		rootId: null,
+		missingParentId: null,
+		laneSpanId: null
+	};
+	if (!startId) return empty;
+	const path = [];
+	const pathIndex = /* @__PURE__ */ new Map();
+	let currentId = startId;
+	let resolved = empty;
+	while (currentId) {
+		const cached = cache.get(currentId);
+		if (cached) {
+			resolved = cached;
+			break;
+		}
+		const cycleStart = pathIndex.get(currentId);
+		if (cycleStart !== void 0) {
+			resolved = {
+				agentId: null,
+				rootId: [...path.slice(cycleStart)].sort()[0],
+				missingParentId: null,
+				laneSpanId: [...path.slice(cycleStart)].sort()[0]
+			};
+			break;
+		}
+		const current = spansById.get(currentId);
+		if (!current) {
+			resolved = {
+				agentId: null,
+				rootId: null,
+				missingParentId: currentId,
+				laneSpanId: currentId
+			};
+			break;
+		}
+		if (current.kind === "AGENT") {
+			resolved = {
+				agentId: current.span_id,
+				rootId: null,
+				missingParentId: null,
+				laneSpanId: current.span_id
+			};
+			break;
+		}
+		pathIndex.set(currentId, path.length);
+		path.push(currentId);
+		currentId = current.parent_span_id;
 	}
-	if (value.kind !== "observed" && value.kind !== "estimated") throw new TypeError(`${context} kind is invalid`);
-	finiteNonnegative(value.usd, `${context} usd`);
+	for (let index = path.length - 1; index >= 0; index -= 1) {
+		if (resolved.agentId === null && resolved.rootId === null) resolved = {
+			...resolved,
+			rootId: path[index],
+			laneSpanId: path[index]
+		};
+		else if (resolved.laneSpanId === (resolved.agentId ?? resolved.missingParentId ?? resolved.rootId)) resolved = {
+			...resolved,
+			laneSpanId: path[index]
+		};
+		cache.set(path[index], resolved);
+	}
+	return resolved;
 }
-function sealExactAnalystRunReceipt(run, context) {
-	if (run.execution_plan === void 0) throw new TypeError(`${context} exact run requires execution_plan`);
-	const plan = snapshotExactExecutionPlan(run.execution_plan, `${context} execution_plan`);
-	const completion = snapshotExactRunCompletion(run.completion, `${context} completion`);
-	run.execution_plan = plan;
-	run.completion = completion;
-	const summaries = run.per_analyst;
-	const findings = run.findings;
-	const planned = plan.analysts.map((analyst) => analyst.id);
-	const completed = summaries.map((summary) => summary.analyst_id);
-	if (!completed.every((analystId, index) => analystId === planned[index]) || completion.status === "complete" && completed.length !== planned.length) throw new TypeError(completion.status === "complete" ? `${context} complete receipt must contain every execution_plan analyst in exact order` : `${context} failed receipt per_analyst must be an execution_plan prefix`);
-	const completedIds = new Set(completed);
-	for (const finding of findings) if (!completedIds.has(finding.analyst_id)) throw new TypeError(`${context} finding names an analyst absent from per_analyst`);
-	for (const summary of summaries) {
-		const actual = findings.filter((finding) => finding.analyst_id === summary.analyst_id).length;
-		if (summary.findings_count !== actual) throw new TypeError(`${context} findings_count does not match findings for "${summary.analyst_id}"`);
-		const hasAllocation = Object.hasOwn(summary, "allocated_budget_usd");
-		if (summary.status === "skipped") {
-			if (hasAllocation) throw new TypeError(`${context} skipped summary "${summary.analyst_id}" cannot report an allocated budget`);
+function compareTokenSamples(a, b) {
+	const aStart = spanEpochMillis(a.span.start_time);
+	const bStart = spanEpochMillis(b.span.start_time);
+	if (aStart === null && bStart !== null) return 1;
+	if (aStart !== null && bStart === null) return -1;
+	if (aStart !== null && bStart !== null && aStart !== bStart) return aStart - bStart;
+	if (a.step !== null && b.step !== null && a.step !== b.step) return a.step - b.step;
+	return a.span.span_id.localeCompare(b.span.span_id);
+}
+function serialTokenRuns(ordered) {
+	const runs = [];
+	let serial = [];
+	let overlap = [];
+	let overlapEnd = Number.NEGATIVE_INFINITY;
+	const flushSerial = () => {
+		if (serial.length > 0) runs.push(serial);
+		serial = [];
+	};
+	const flushOverlap = () => {
+		if (overlap.length === 1) serial.push(overlap[0]);
+		else if (overlap.length > 1) {
+			flushSerial();
+			for (const sample of overlap) runs.push([sample]);
+		}
+		overlap = [];
+		overlapEnd = Number.NEGATIVE_INFINITY;
+	};
+	for (const sample of ordered) {
+		const start = spanEpochMillis(sample.span.start_time);
+		const end = spanEpochMillis(sample.span.end_time);
+		if (start === null || end === null || sample.span.duration_ms <= 0 || end < start) {
+			flushOverlap();
+			flushSerial();
+			runs.push([sample]);
 			continue;
 		}
-		const allocation = summary.allocated_budget_usd;
-		if (!(hasAllocation && (plan.policy.budget.kind === "none" ? allocation === null : typeof allocation === "number" && plan.policy.budget.allocations_usd[summary.analyst_id] !== null && plan.policy.budget.allocations_usd[summary.analyst_id] !== void 0 && allocation <= plan.policy.budget.allocations_usd[summary.analyst_id]))) throw new TypeError(`${context} summary "${summary.analyst_id}" allocation does not match its execution plan`);
+		if (overlap.length > 0 && start >= overlapEnd) flushOverlap();
+		overlap.push(sample);
+		overlapEnd = Math.max(overlapEnd, end);
 	}
-	let knownCost = 0;
-	for (const summary of summaries) {
-		const amount = summary.usage.cost.kind === "uncaptured" ? summary.usage.knownCostUsd ?? 0 : summary.usage.cost.usd ?? 0;
-		knownCost = finiteNonnegative(knownCost + amount, `${context} aggregate known cost`);
+	flushOverlap();
+	flushSerial();
+	return runs;
+}
+function tokenSignals(sequence) {
+	const signals = [];
+	const inputs = sequence.inputTokenTrajectory;
+	const outputs = sequence.outputTokenTrajectory;
+	if (inputs.length >= 3 && inputs.every((value) => value !== null)) {
+		const first = inputs[0];
+		const last = inputs[inputs.length - 1];
+		const isMonotonic = everyAdjacent(inputs, (previous, current) => current >= previous);
+		const growthFromZero = first === 0 && last > 0;
+		const growth = growthFromZero ? Infinity : first > 0 ? last / first : 0;
+		if (isMonotonic && last > first && growth >= INPUT_GROWTH_FACTOR) {
+			const growthLabel = growthFromZero ? "0→nonzero (unbounded)" : `${growth.toFixed(1)}x`;
+			signals.push({
+				code: "monotonic-input-growth",
+				severity: "high",
+				detail: `LLM input tokens grew ${growthLabel} (${first}→${last}) across ${inputs.length} serial calls without an intervening decrease.`,
+				evidence: {
+					first,
+					last,
+					growth_x: growthFromZero ? "unbounded" : Number(growth.toFixed(2)),
+					calls: inputs.length,
+					scope: sequence.scopeId,
+					first_span_id: sequence.spanIds[0],
+					last_span_id: sequence.spanIds[sequence.spanIds.length - 1]
+				}
+			});
+		}
+	}
+	if (inputs.length >= OUTPUT_DECAY_MINIMUM_CALLS && inputs.length === outputs.length && inputs.every((value) => value !== null) && outputs.every((value) => value !== null)) {
+		const first = outputs[0];
+		const last = outputs[outputs.length - 1];
+		const inputIsMonotonic = everyAdjacent(inputs, (previous, current) => current >= previous);
+		const outputIsMonotonic = everyAdjacent(outputs, (previous, current) => current <= previous);
+		const inputGrew = inputs[inputs.length - 1] > inputs[0];
+		const decayIsMaterial = last <= first * OUTPUT_DECAY_MAXIMUM_RETAINED_FRACTION;
+		if (inputIsMonotonic && inputGrew && outputIsMonotonic && decayIsMaterial) signals.push({
+			code: "output-length-decay",
+			severity: "medium",
+			detail: `LLM output tokens shrank ${first}→${last} over ${outputs.length} serial calls while input tokens increased monotonically.`,
+			evidence: {
+				first,
+				last,
+				calls: outputs.length,
+				scope: sequence.scopeId,
+				first_span_id: sequence.spanIds[0],
+				last_span_id: sequence.spanIds[sequence.spanIds.length - 1]
+			}
+		});
+	}
+	return signals;
+}
+function everyAdjacent(values, predicate) {
+	return values.slice(1).every((current, index) => predicate(values[index], current));
+}
+//#endregion
+//#region src/analyst/behavioral-analyst.ts
+/**
+* Deterministic behavioral analysis over arithmetic in trace spans.
+* This pass is cheap and repeatable; semantic analysis remains the job of
+* model-backed analysts. Relative quality requires a labeled comparison.
+*/
+const RECOMMENDED_ACTION = {
+	"monotonic-input-growth": "Inspect context assembly; if prior history is repeatedly included, summarize completed work before the next model call.",
+	"output-length-decay": "Check late-step completeness; if shorter responses omit required work, add explicit completion criteria to the agent instructions.",
+	"single-tool-dependency": "Test whether an inspect or verification tool improves outcomes after the repeated call fails or returns no progress.",
+	"no-self-verification": "After state-changing actions, require an observable check before the agent proceeds."
+};
+const ANALYST_ID$1 = "efficiency-behavioral";
+const DEFAULT_MAX_TRACES = 1e3;
+const DEFAULT_MAX_EVIDENCE_REFS = 20;
+const TRACE_PAGE_SIZE = 200;
+const AGGREGATE_CLAIM = {
+	"monotonic-input-growth": (observed, analyzed) => `${observed}/${analyzed} analyzed traces showed input tokens grow from zero to nonzero or to at least 3x their initial value across at least 3 serial model calls without a decrease.`,
+	"output-length-decay": (observed, analyzed) => `${observed}/${analyzed} analyzed traces showed output tokens decrease while input tokens increased monotonically across at least 3 serial model calls.`,
+	"single-tool-dependency": (observed, analyzed) => `${observed}/${analyzed} analyzed traces used only one named tool across at least 3 tool calls.`,
+	"no-self-verification": (observed, analyzed) => `${observed}/${analyzed} analyzed traces had at least 3 tool calls without a verification-named tool call.`
+};
+async function listTraceIds(store, maxTraces, signal) {
+	const traceIds = /* @__PURE__ */ new Set();
+	let offset = 0;
+	let expectedTotal;
+	while (true) {
+		signal?.throwIfAborted();
+		const page = await store.queryTraces({
+			limit: TRACE_PAGE_SIZE,
+			offset
+		});
+		if (expectedTotal === void 0) expectedTotal = page.total;
+		if (page.total !== expectedTotal) throw new Error(`behavioralAnalyst: trace count changed during pagination (${expectedTotal} to ${page.total})`);
+		if (page.total > maxTraces) throw new RangeError(`behavioralAnalyst: ${page.total} traces exceed maxTraces=${maxTraces}; filter the store or raise the explicit limit`);
+		for (const trace of page.traces) traceIds.add(trace.trace_id);
+		if (traceIds.size > maxTraces) throw new RangeError(`behavioralAnalyst: more than maxTraces=${maxTraces} unique traces were returned`);
+		if (!page.has_more) break;
+		if (page.traces.length === 0) throw new Error("behavioralAnalyst: trace store returned an empty page with has_more=true");
+		offset += page.traces.length;
 	}
-	if (run.total_cost_usd !== knownCost) throw new TypeError(`${context} total_cost_usd does not match per_analyst usage`);
-	if (run.total_cost_provenance === void 0) throw new TypeError(`${context} exact run requires total_cost_provenance`);
-	const costs = summaries.map((summary) => summary.usage.cost);
-	const expectedProvenance = costs.some((cost) => cost.kind === "uncaptured") ? {
-		kind: "uncaptured",
-		usd: null
-	} : {
-		kind: costs.some((cost) => cost.kind === "estimated") ? "estimated" : "observed",
-		usd: costs.reduce((sum, cost) => finiteNonnegative(sum + (cost.usd ?? 0), `${context} aggregate captured cost`), 0)
-	};
-	if (hashCanonical(run.total_cost_provenance) !== hashCanonical(expectedProvenance)) throw new TypeError(`${context} total_cost_provenance does not match per_analyst usage`);
-	return deepFreezeCanonicalJson(run);
+	if (traceIds.size !== expectedTotal) throw new Error(`behavioralAnalyst: pagination returned ${traceIds.size}/${expectedTotal ?? 0} unique traces`);
+	return [...traceIds].sort();
 }
-function snapshotExactRunCompletion(value, context) {
-	if (!isRecord(value)) throw new TypeError(`${context} must be an object`);
-	if (value.status === "complete") {
-		assertOnlyKeys(value, ["status"], context);
-		return value;
-	}
-	if (value.status !== "failed") throw new TypeError(`${context} status must be complete or failed`);
-	assertOnlyKeys(value, ["status", "error"], context);
-	if (!isRecord(value.error)) throw new TypeError(`${context} failed receipt requires error`);
-	assertOnlyKeys(value.error, ["class", "message"], `${context} error`);
-	requiredString(value.error.class, `${context} error class`);
-	requiredString(value.error.message, `${context} error message`);
-	return value;
+/**
+* Map computed signals → structured AnalystFindings. Pure: no LLM, no clock
+* dependence beyond `produced_at` (overridable for deterministic tests).
+*/
+function deriveEfficiencyFindings(metrics, opts = {}) {
+	const analystId = opts.analystId ?? ANALYST_ID$1;
+	const traceId = metrics.traceId;
+	return metrics.signals.map((sig) => makeFinding({
+		analyst_id: analystId,
+		area: "efficiency",
+		subject: sig.code,
+		claim: sig.detail,
+		severity: sig.severity,
+		confidence: 1,
+		evidence_refs: [{
+			kind: "metric",
+			uri: traceId ? `metric://trace/${encodeURIComponent(traceId)}/efficiency/${sig.code}` : `metric://efficiency/${sig.code}`,
+			excerpt: JSON.stringify(sig.evidence)
+		}],
+		recommended_action: RECOMMENDED_ACTION[sig.code],
+		metadata: {
+			deterministic: true,
+			evidence: sig.evidence,
+			...traceId ? { trace_id: traceId } : {}
+		},
+		id_basis: sig.code,
+		...opts.producedAt ? { produced_at: opts.producedAt } : {}
+	}));
 }
-function finiteNonnegative(value, context) {
-	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new TypeError(`${context} must be a non-negative finite number`);
-	return value;
+/** The deterministic behavioral/efficiency analyst (no LLM, any-model). */
+function behavioralAnalyst(options = {}) {
+	const maxTraces = positiveInteger(options.maxTraces ?? DEFAULT_MAX_TRACES, "maxTraces");
+	const maxEvidenceRefsPerFinding = positiveInteger(options.maxEvidenceRefsPerFinding ?? DEFAULT_MAX_EVIDENCE_REFS, "maxEvidenceRefsPerFinding");
+	return {
+		id: ANALYST_ID$1,
+		description: "Deterministic behavioral/efficiency findings over OTLP spans — token-growth, output-decay, tool-monoculture, missing self-verification. Zero LLM; model-agnostic by construction.",
+		inputKind: "trace-store",
+		cost: { kind: "deterministic" },
+		version: "2.0.0",
+		executionConfig: {
+			kind: "behavioral-efficiency",
+			max_traces: maxTraces,
+			max_evidence_refs_per_finding: maxEvidenceRefsPerFinding
+		},
+		async analyze(store, context) {
+			const analyzedTraceIds = await listTraceIds(store, maxTraces, context.signal);
+			const findingsById = /* @__PURE__ */ new Map();
+			for (const traceId of analyzedTraceIds) {
+				context.signal?.throwIfAborted();
+				const viewed = await store.viewTrace({ trace_id: traceId });
+				if (viewed.trace_id !== traceId) throw new Error(`behavioralAnalyst: requested trace '${traceId}', received '${viewed.trace_id}'`);
+				if (!viewed.spans) throw new Error(`behavioralAnalyst: trace '${traceId}' is oversized; complete spans are required`);
+				const metrics = computeTraceMetrics(viewed.spans);
+				if (metrics.traceId !== null && metrics.traceId !== traceId) throw new Error(`behavioralAnalyst: requested trace '${traceId}', received '${metrics.traceId}'`);
+				for (const finding of deriveEfficiencyFindings(metrics)) {
+					const current = findingsById.get(finding.finding_id);
+					if (!current) {
+						findingsById.set(finding.finding_id, {
+							finding,
+							observedTraceCount: 1,
+							evidenceTraceIds: [traceId],
+							evidence: [...finding.evidence_refs]
+						});
+						continue;
+					}
+					current.observedTraceCount += 1;
+					if (current.evidence.length < maxEvidenceRefsPerFinding) {
+						current.evidenceTraceIds.push(traceId);
+						current.evidence.push(...finding.evidence_refs);
+					}
+				}
+			}
+			return [...findingsById.values()].map(({ finding, observedTraceCount, evidenceTraceIds, evidence }) => ({
+				...finding,
+				claim: AGGREGATE_CLAIM[finding.subject](observedTraceCount, analyzedTraceIds.length),
+				rationale: `${observedTraceCount}/${analyzedTraceIds.length} analyzed traces exhibited this pattern.`,
+				evidence_refs: evidence,
+				metadata: {
+					deterministic: true,
+					evidence_trace_ids: evidenceTraceIds,
+					omitted_evidence_trace_count: observedTraceCount - evidenceTraceIds.length,
+					observed_trace_count: observedTraceCount,
+					analyzed_trace_count: analyzedTraceIds.length
+				}
+			}));
+		}
+	};
 }
-function nonnegativeSafeInteger(value, context) {
-	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${context} must be a non-negative safe integer`);
+function positiveInteger(value, name) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`behavioralAnalyst: ${name} must be a positive safe integer`);
 	return value;
 }
-function snapshotAnalystFindings(value, context = "analyst run findings") {
-	if (!Array.isArray(value)) throw new TypeError(`${context} must be an array`);
-	const findings = value.map((finding, index) => snapshotAnalystFinding(finding, `${context} finding ${index}`));
-	assertUniqueFindingIds(findings.map((finding) => finding.finding_id));
-	return findings;
-}
-function readAnalystReview(trajectory) {
-	const analystAttempts = trajectory.attempts.filter((attempt) => isRecord(attempt.artifact) && attempt.artifact.type === "analyst-run");
-	const analysis = isRecord(trajectory.metadata?.analysis) ? trajectory.metadata.analysis : void 0;
-	if (analystAttempts.length === 0) {
-		if (analysis?.kind === "analyst-run") throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" is missing its archived run`);
-		return;
-	}
-	if (analystAttempts.length !== 1) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" must contain exactly one archived run`);
-	if (analysis?.kind !== "analyst-run") throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" is missing review state`);
-	const artifact = analystAttempts[0].artifact;
-	if (!isRecord(artifact)) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" has an invalid archived run`);
-	const runId = requiredString(artifact.analystRunId, `analyst trajectory "${trajectory.id}" run id`);
-	if (analysis.runId !== runId) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" run identity does not match its review state`);
-	const artifactRunDigest = requiredDigest(artifact.runDigest, `analyst trajectory "${trajectory.id}" archived run digest`);
-	const storedRunDigest = requiredDigest(analysis.runDigest, `analyst trajectory "${trajectory.id}" review run digest`);
-	if (artifactRunDigest !== storedRunDigest) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" run digest does not match its review state`);
-	const findings = snapshotAnalystFindings(artifact.findings, `analyst trajectory "${trajectory.id}"`);
-	const findingIds = findings.map((finding) => finding.finding_id);
-	const analystIds = stringArray(artifact.analystIds, `analyst trajectory "${trajectory.id}" analyst ids`);
-	const attemptMetadata = analystAttempts[0].metadata;
-	if (!isRecord(attemptMetadata)) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" is missing archived run metadata`);
-	const archivedRun = snapshotAnalystRun({
-		run_id: runId,
-		correlation_id: artifact.correlationId,
-		started_at: analysis.startedAt,
-		ended_at: analysis.endedAt,
-		findings,
-		per_analyst: attemptMetadata.perAnalyst,
-		total_cost_usd: analysis.knownCostUsd,
-		...analysis.costProvenance === void 0 ? {} : { total_cost_provenance: analysis.costProvenance },
-		...artifact.executionPlan === void 0 ? {} : {
-			execution_plan: artifact.executionPlan,
-			completion: artifact.completion
-		}
-	}, `analyst trajectory "${trajectory.id}" archived run`);
-	const knownAnalystIds = new Set(analystIds);
-	for (const [index, finding] of findings.entries()) if (!knownAnalystIds.has(finding.analyst_id)) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" omits generating analyst "${finding.analyst_id}" at finding ${index}`);
-	const reviewDecisions = validateAnalystReviewDecisions({
-		runId,
-		runDigest: storedRunDigest,
-		findings,
-		analystIds,
-		decisions: analysis.reviewDecisions,
-		requireComplete: true
-	});
-	const expectedRunDigest = analystRunDigest(archivedRun);
-	if (storedRunDigest !== expectedRunDigest) throw new TypeError(`feedbackTrajectoryToOptimizerRow: analyst trajectory "${trajectory.id}" archived run digest mismatch`);
-	return {
-		runId,
-		runDigest: expectedRunDigest,
-		findings,
-		findingIds,
-		analystIds,
-		reviewDecisions
-	};
+//#endregion
+//#region src/analyst/kinds/control-integrity.ts
+const ANALYST_ID = "control-integrity";
+function shown(value) {
+	if (value === void 0) return "<absent>";
+	const encoded = JSON.stringify(value);
+	return encoded === void 0 ? String(value) : encoded;
 }
-function completedAnalystReviewQuality(review) {
-	const findingDecisions = review.reviewDecisions.filter((decision) => decision.verdict !== "completeness_assessed");
-	const completeness = review.reviewDecisions.filter((decision) => decision.verdict === "completeness_assessed");
-	if (completeness.length !== 1) throw new TypeError("feedbackTrajectoryToOptimizerRow: analyst run requires exactly one independent completeness_assessed decision");
-	const confirmed = findingDecisions.filter((decision) => decision.verdict === "confirmed").length;
-	const rejected = findingDecisions.length - confirmed;
-	const emitted = review.findingIds.length;
-	const missed = completeness[0].missedIssues.length;
-	const precision = emitted === 0 ? 1 : confirmed / emitted;
-	const recallDenominator = confirmed + missed;
-	const recall = recallDenominator === 0 ? 1 : confirmed / recallDenominator;
+function evidenceRef(namespace, value) {
 	return {
-		precision,
-		recall,
-		f1: precision + recall === 0 ? 0 : 2 * precision * recall / (precision + recall),
-		counts: {
-			emitted,
-			confirmed,
-			rejected,
-			missed
-		}
+		kind: "metric",
+		uri: `supervisor-run://${encodeURIComponent(namespace)}/${value.path}`,
+		excerpt: shown(value.value)
 	};
-}
-function validateAnalystReviewDecisions(input) {
-	if (!Array.isArray(input.decisions)) throw new TypeError("analyst review decisions must be an array");
-	const findings = snapshotAnalystFindings(input.findings);
-	const expectedRunDigest = requiredDigest(input.runDigest, "analyst review run digest");
-	const findingsById = new Map(findings.map((finding) => [finding.finding_id, finding]));
-	const generatingAnalystIds = new Set(input.analystIds);
-	const seenFindingIds = /* @__PURE__ */ new Set();
-	let completenessCount = 0;
-	const decisions = input.decisions.map((value, index) => {
-		if (!isRecord(value)) throw new TypeError(`analyst review decision ${index} must be an object`);
-		const source = requiredString(value.source, `analyst review decision ${index} source`);
-		if (!isAnalystReviewSource(source)) throw new TypeError(`analyst review decision ${index} source must be user, judge, environment, metric, or policy`);
-		const reviewerId = requiredString(value.reviewerId, `analyst review decision ${index} reviewerId`);
-		if (generatingAnalystIds.has(reviewerId)) throw new TypeError(`analyst review decision ${index} reviewerId must differ from the generating analyst`);
-		const reviewId = requiredString(value.reviewId, `analyst review decision ${index} reviewId`);
-		if (reviewId === input.runId) throw new TypeError(`analyst review decision ${index} reviewId must identify an independent review`);
-		const reason = requiredString(value.reason, `analyst review decision ${index} reason`);
-		const decidedAt = canonicalTimestamp(value.decidedAt, `analyst review decision ${index} decidedAt`);
-		const runDigest = requiredDigest(value.runDigest, `analyst review decision ${index} runDigest`);
-		if (runDigest !== expectedRunDigest) throw new TypeError(`analyst review decision ${index} run digest mismatch`);
-		if (value.verdict === "completeness_assessed") {
-			assertOnlyKeys(value, [
-				"runDigest",
-				"verdict",
-				"missedIssues",
-				"source",
-				"reviewerId",
-				"reviewId",
-				"reason",
-				"decidedAt"
-			], `analyst review decision ${index}`);
-			completenessCount += 1;
-			if (completenessCount > 1) throw new TypeError("duplicate completeness_assessed analyst review decision");
-			return {
-				runDigest,
-				verdict: "completeness_assessed",
-				missedIssues: validateMissedIssues(value.missedIssues, findingsById, `analyst review decision ${index}`),
-				source,
-				reviewerId,
-				reviewId,
-				reason,
-				decidedAt
-			};
+}
+/** Translate typed supervisor-run integrity issues into the shared analyst envelope. */
+function emitControlIntegrityFindings(input, producedAt) {
+	const report = analyzeSupervisorRunIntegrity(input, { capturedAt: producedAt });
+	return report.issues.map((issue) => makeFinding({
+		analyst_id: ANALYST_ID,
+		produced_at: producedAt,
+		area: issue.area,
+		severity: issue.severity,
+		subject: `${report.runRef}/${issue.subject}`,
+		claim: issue.claim,
+		rationale: issue.detail,
+		evidence_refs: issue.evidence.map((value) => evidenceRef(report.runRef, value)),
+		recommended_action: issue.recommendedAction,
+		validation_plan: "Re-run this deterministic analyst on the retained SupervisorRunSources or SupervisorRunTree after correcting the producer.",
+		confidence: 1,
+		metadata: {
+			integrity_code: issue.code,
+			integrity_input: report.input,
+			integrity_run_ref: report.runRef,
+			integrity_subject: issue.subject,
+			...issue.metadata
 		}
-		if (value.verdict !== "confirmed" && value.verdict !== "rejected") throw new TypeError(`analyst review decision ${index} verdict must be confirmed, rejected, or completeness_assessed`);
-		assertOnlyKeys(value, [
-			"runDigest",
-			"findingId",
-			"findingDigest",
-			"verdict",
-			"source",
-			"reviewerId",
-			"reviewId",
-			"reason",
-			"decidedAt"
-		], `analyst review decision ${index}`);
-		const findingId = requiredString(value.findingId, `analyst review decision ${index} findingId`);
-		const finding = findingsById.get(findingId);
-		if (!finding) throw new TypeError(`analyst review decision references unknown finding id "${findingId}"`);
-		if (seenFindingIds.has(findingId)) throw new TypeError(`duplicate analyst review decision for finding id "${findingId}"`);
-		seenFindingIds.add(findingId);
-		const findingDigest = requiredString(value.findingDigest, `analyst review decision ${index} findingDigest`);
-		const expectedDigest = analystFindingDigest(finding);
-		if (findingDigest !== expectedDigest) throw new TypeError(`analyst review decision ${index} digest mismatch for finding id "${findingId}"`);
-		return {
-			runDigest,
-			findingId,
-			findingDigest: expectedDigest,
-			verdict: value.verdict,
-			source,
-			reviewerId,
-			reviewId,
-			reason,
-			decidedAt
-		};
-	});
-	if (input.requireComplete) {
-		const missing = findings.map((finding) => finding.finding_id).filter((findingId) => !seenFindingIds.has(findingId));
-		if (missing.length > 0) throw new TypeError(`feedbackTrajectoryToOptimizerRow: missing independent decisions for finding ids: ${missing.join(", ")}`);
-		if (completenessCount !== 1) throw new TypeError("feedbackTrajectoryToOptimizerRow: analyst run requires exactly one independent completeness_assessed decision");
-	}
-	return decisions;
+	}));
 }
-function assertUniqueFindingIds(findingIds) {
-	const seen = /* @__PURE__ */ new Set();
-	for (const findingId of findingIds) {
-		if (findingId.trim().length === 0) throw new TypeError("analyst finding id must not be empty");
-		if (seen.has(findingId)) throw new TypeError(`analyst run contains duplicate finding id "${findingId}"`);
-		seen.add(findingId);
+/** Deterministic Analyst adapter for `SupervisorRunSources | SupervisorRunTree`. */
+var ControlIntegrityAnalyst = class {
+	id = ANALYST_ID;
+	description = "Deterministic supervisor-run integrity checks with explicit unavailable evidence.";
+	inputKind = "custom";
+	cost = {
+		kind: "deterministic",
+		est_usd_per_run: 0
+	};
+	version = "2.0.0";
+	executionConfig = {
+		kind: "control-integrity",
+		produced_at_source: "tags.producedAt-or-system-clock"
+	};
+	async analyze(input, ctx) {
+		const findings = emitControlIntegrityFindings(input, ctx.tags?.producedAt ?? (/* @__PURE__ */ new Date()).toISOString());
+		ctx.log?.(`control-integrity: ${findings.length} finding(s)`, { input: "nodes" in input ? "SupervisorRunTree" : "SupervisorRunSources" });
+		return findings;
 	}
-}
-function snapshotAnalystFinding(value, context) {
-	let snapshot;
-	try {
-		snapshot = JSON.parse(canonicalString(value));
-	} catch (cause) {
-		throw new TypeError(`${context} must have a canonical JSON representation`, { cause });
+};
+const CONTROL_INTEGRITY_ANALYST = new ControlIntegrityAnalyst();
+const FAILURE_MODE_KIND_SPEC = {
+	id: "failure-mode",
+	description: "Ranks failures by the work each one burned — spans, model calls, and wall-clock between the error and the span where the agent resumed — and treats a failure that reached a human as the most expensive class.",
+	area: "failure-mode",
+	version: "2.0.0",
+	instructions: `You are a failure-cost analyst for an OTLP trace dataset. Your job is to find the failures that **burned the most agent work** and to price each one in spans, model calls, and wall-clock. How often an error occurred is not its cost and is not your output.
+
+${findingSubjectGrammarPromptFor("failure-mode")}
+
+Use a lowercase cluster label that names the cost shape, not the error string: "human-corrected-file-overwrite", "unrecovered-auth-loop", "long-detour-schema-guess".
+
+WORKLIST → RECOVERY BOUNDARY → PRICE → CITE protocol:
+
+1. \`getDatasetOverview({})\` first. Read \`errors.trace_count\`, \`errors.span_count\`, and \`error_clusters[]\` — each cluster carries \`signature\`, \`tool_name\`, \`trace_count\`, \`span_count\`, \`prevalence\`, \`exemplar_trace_ids\`, and \`exemplar_span_ids\`. This is the deterministic analyzer's output, already computed for free. It is your WORKLIST: the exemplar ids name the spans you go price. It is never your findings.
+2. Reach error-bearing traces the exemplars miss with \`queryTraces(filters={"has_errors": true}, limit=...)\`. Prefer long traces and traces whose errors sit early: a failure has room to be expensive only when work followed it.
+3. Take one candidate error span E and read its trace in order. \`viewTrace\` returns that trace's spans sorted by \`start_time\`, which is the ordering every distance below is counted in. When \`viewTrace\` returns \`oversized\` instead of spans, locate candidates with \`searchTrace\` and pull the exact ids with \`viewSpans\`; use \`searchSpan\` when one span's payload is truncated.
+4. Find the RECOVERY BOUNDARY R — the first span after E in which the agent resumed productive work. Productive means a different, task-advancing action. A retry of the same call with the same arguments, a re-read of the same file, a re-plan of the same step, and an apology are all still inside the failure. Then price it:
+   - spans_burned: spans strictly between E and R
+   - model_calls_burned: how many of those spans have kind \`LLM\`
+   - wall_clock_ms: R \`end_time\` minus E \`start_time\`
+   Report all three. If the agent never resumed, R is the trace's last span and the failure is UNRECOVERED.
+5. Set severity from what ENDED the failure and from the measured distance, never from how many times the signature appears:
+   - HUMAN-CORRECTED — a human turn after E supplies the correction. This is the most expensive class at any span count, because the failure escaped the agent entirely and reached the user: severity critical. Detect it as a new user-role message in a later \`LLM\` span's input attributes, or a new root-level \`AGENT\` span in which the user restates or repairs the task. Search with patterns like \`"role"\\s*:\\s*"user"\`, \`(that|this) is (wrong|not what)\`, \`I (said|asked|told you)\`, \`stop\`, \`undo\`, \`revert\`, \`you (deleted|broke|missed|ignored)\`, \`try again\`. Quote the human's words exactly.
+   - UNRECOVERED — the trace ends without resumption: severity critical.
+   - LONG DETOUR — 10 or more spans burned, or 3 or more \`LLM\` spans burned: severity high.
+   - SHORT DETOUR — 2 to 9 spans burned: severity medium.
+   - SELF-RECOVERED ON THE NEXT SPAN — cost is approximately zero. Do not emit it. That is resilience, and reporting it dilutes the ranking.
+   One error that cost 20 spans outranks 50 errors that each cost one retry. Frequency may appear in a finding only as a multiplier on a measured per-instance cost, never as the reason for its severity.
+6. **Cluster, do not enumerate.** Errors sharing a root cause AND a recovery shape are ONE finding: report the summed cost across instances, state how many instances it covers, and cite the bounding pair of the single most expensive instance. Two errors with the same signature but different recovery shapes — one shrugged off, one human-corrected — are NOT the same finding; the expensive one is the finding and the cheap one is noise.
+
+FORBIDDEN OUTPUT. Each of the following duplicates the deterministic pass, and a duplicate finding is worse than no finding because it costs a reviewer the same attention while carrying no new information:
+   - a count of errors by tool ("Bash is the dominant failure surface, 54 error spans")
+   - a count or inventory of error signatures ("47 distinct error signatures")
+   - an error rate ("79 of 5260 tool calls ended in errors")
+   - any restatement of \`prevalence\`, \`trace_count\`, or \`span_count\` from \`error_clusters[]\`
+Every finding MUST state its measured cost — spans burned, model calls burned, wall-clock — in the claim, and MUST cite the two spans that bound it: the error span and the recovery span, or the escaping human turn, or the trace's last span when unrecovered. A failure you cannot bound with two spans is one you did not measure: drop it.
+
+**Adjudicate boundaries with subqueries.** The single judgement call in this protocol is whether a post-error span is genuine resumption or more flailing. Load E, the spans between, and the candidate R, then send one bounded \`llm_query\` per candidate carrying those exact excerpts and asking which span first advances the task. Subqueries cannot call trace tools, so a trace id tells them nothing — paste the excerpts. Accept a boundary only when the excerpts you loaded support the answer.
+
+Confidence 0.9+ when both bounding spans are quoted and the spans between them were counted directly; 0.6-0.8 when an oversized trace forced you to sample the interval and the distance is an estimate; below 0.5 does not belong in this analyst, because an unmeasurable cost is not a finding. Keep the recommended action a short imperative; the improvement analyst expands it.
+
+If every error in this dataset was recovered on the next span, return an empty findings array. That is the correct answer for a dataset whose failures were all cheap. Do not backfill it with the counts listed above and do not pad it with speculation.`,
+	toolGroup: "all",
+	limits: {
+		maxLlmCalls: 8,
+		maxIterations: 24,
+		maxToolCalls: 80
+	},
+	minimumEvidenceCitations: 2
+};
+const 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.2.0",
+	instructions: `You are a 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.
+
+${findingSubjectGrammarPromptFor("improvement")}
+
+DISCOVERY → CANDIDATE-FIXES → COMPETE → CITE protocol:
+
+1. \`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** — add an instruction, remove a misleading one, restructure precedence
+   - **Tool description edit** — rewrite a tool's description so the agent picks it correctly / passes valid args
+   - **New tool** — add a tool the agent kept emulating in code
+   - **RAG ingestion** — add a document or correct a stale one
+   - **Memory invalidation** — clear cached prior-run decisions that no longer apply
+   - **Scaffolding** — add a precondition check, a retry policy, a turn budget, a verification step
+   - **Output schema** — narrow the agent's output to forbid the failure shape
+   - **Skill / MCP / hook / subagent** — change the reusable profile component responsible for the behavior
+   - **Workflow / rollout policy** — change orchestration, budget, sampling, or stopping behavior
+   - **Code** — change an implementation path when profile edits cannot repair the behavior
+3. **Compare candidate fixes with bounded subqueries.** Load the representative failure excerpts, then send one \`llm_query\` per candidate-fix axis the same evidence. Ask for likely effect, side effects, and implementation scope. Subqueries cannot call trace tools; trace ids alone are insufficient context.
+4. After the comparisons return, **pick the winning candidate per cluster** based on expected effect and risk, then emit ONE finding. Keep the alternatives and rejection reasons in the rationale so the recommendation is auditable.
+5. **Cross-reference upstream findings.** Cite prior failure-mode or knowledge-gap findings as \`finding://<prior-finding-id>\`. 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. Use one exact locus from the subject grammar and state the edit in one sentence. Match leverage to the source failure's severity; use medium for quality-of-life changes and info for cleanup with no behavioral effect. Cite the targeted \`finding://<id>\` when available and the most representative span when useful. Quote the problem being fixed. Use confidence 0.85+ for a mechanical fix to a well-evidenced failure, 0.6-0.8 when judgment is required, and <0.5 for speculation. Explain in at most two sentences why this candidate beat its alternatives. The recommended action must be the literal diff, quoted replacement, tool description, or setting change.
+
+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.). Prefer upstream findings when present because the analysts 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.`,
+	toolGroup: "all",
+	limits: {
+		maxLlmCalls: 8,
+		maxIterations: 30,
+		maxToolCalls: 80,
+		maxOutputChars: 12e3
+	}
+};
+const INTENT_DIVERGENCE_KIND_SPEC = {
+	id: "intent-divergence",
+	description: "Anchors each corrective human turn to the earliest assistant turn where the divergence from stated intent was already detectable, and prices it in burned turns.",
+	area: "intent-divergence",
+	version: "1.0.0",
+	instructions: `You are an intent-divergence analyst for an OTLP trace dataset. Your job is to find where the agent stopped doing what the user asked, and to establish **how early that was knowable**.
+
+This dataset carries ground truth the other analysts do not have. When a human turn corrects the agent — "no, I meant…", "stop doing X", "why are you still asking" — the user has labelled a divergence for you. That label marks the END of the divergence, not its start. Your finding is the start: the earliest assistant turn already off-intent, the signal in the user's stated intent it contradicted, and the number of turns burned before the correction landed.
+
+${findingSubjectGrammarPromptFor("intent-divergence")}
+
+DISCOVERY → BACKTRACK → QUANTIFY → CITE protocol:
+
+1. \`getDatasetOverview({})\` first. Note the agent names and \`sample_trace_ids\`; conversational datasets carry several human turns per trace and those are the ones worth pulling.
+2. **DISCOVERY — find the corrective human turns.** Use \`searchTrace\` for user-authored corrections:
+   Every pattern MUST begin with \`(?i)\`. The trace store compiles a search pattern case-sensitively unless it opens with that flag, and corrections are overwhelmingly sentence-initial and capitalised ("Stop", "No,", "I said"), so a lowercase pattern silently returns zero hits.
+   - Imperative stops: \`(?i)\\bstop\\b\`, \`(?i)\\b(don'?t|do not)\\b\`, \`(?i)^\\s*no[,.!]\`, \`(?i)\\bnot what I (wanted|asked|meant)\\b\`, \`(?i)\\bthat'?s not what\\b\`, \`(?i)\\brevert\\b\`, \`(?i)\\bstart over\\b\`
+   - Repetition and frustration: \`(?i)\\bI (said|asked|told you)\\b\`, \`(?i)\\balready told you\\b\`, \`(?i)\\bwhy are you (still )?\\w+ing\\b\`, \`(?i)\\bjust (do|use|write|make)\\b\`, \`(?i)\\bagain\\b\`
+   - Clarification markers (second-order, see step 6): \`(?i)\\bI mean(t)?\\b\`, \`(?i)\\bto be clear\\b\`, \`(?i)\\bactually,? I (want|need)\\b\`, \`(?i)\\bwhat I meant\\b\`, \`(?i)\\blet me rephrase\\b\`
+   Attribute every match to a role before using it. The same phrases inside an assistant turn are hedging, not correction.
+3. **BACKTRACK — walk the trace backward from the correction.** Read the ordered turns preceding it with \`viewTrace\` / \`viewSpans\`. Locate the user's ORIGINAL statement of intent (usually the first human turn, sometimes a constraint added mid-run), then locate the FIRST assistant turn that contradicts it. That turn, not the correction, anchors the finding. Name the concrete signal already available at that turn: an explicit constraint the agent violated, a scope it exceeded, a different question it answered, a file or target the user never named, a decision the user had already made.
+4. **QUANTIFY — count the burned turns.** K = (index of the corrective human turn) − (index of the earliest detectable assistant turn). Report both indices and K. If you cannot locate an earliest-detectable turn, you have a correction and not a divergence: drop it.
+5. **CLUSTER.** Repeated corrections about the same misread intent are ONE finding citing all of them, not one finding per corrective turn. Corrections about genuinely different intents in the same trace are separate findings.
+6. **Second-order — the request itself was ambiguous.** When the user CLARIFIES rather than corrects ("I mean the staging config, not prod"), the agent's reading was defensible and the request was underspecified or self-contradictory. Emit those against a \`scaffolding:*\` locus — a clarifying-question policy or a plan checkpoint — because the fix is one sharp question before acting, priced against the K turns the ambiguity cost. Do not charge the agent's instructions for a request that could not be resolved from its own text.
+
+**Test competing anchors with subqueries.** After the backward walk, load the excerpts for the original intent turn, your candidate earliest-detectable turn, and the turn before it. Send one bounded \`llm_query\` per candidate anchor asking whether the divergence is already present in that turn's text alone. Subqueries cannot call trace tools, and a turn index alone is insufficient context. Take the EARLIEST candidate the loaded excerpts support.
+
+For each cluster, emit ONE finding. Use an exact locus from the subject grammar — the surface whose edit prevents the divergence, not the surface where it surfaced. State the claim in the shape "turn N did X against stated intent Y; user corrected at turn N+K, burning K turns." Rate it critical when the divergence produced a user-visible or irreversible action, high when K is 3 or more or the run ended without the intent satisfied, medium for one or two burned turns, and low for a cosmetic correction. Cite BOTH spans with exact quotes: the earliest-detectable assistant turn and the corrective human turn. Use confidence 0.85+ when the stated intent and the diverging turn are both quotable and the contradiction is explicit, and 0.6-0.8 when the earliest-detectable turn is inferred from surrounding context. The recommended action must be the literal instruction, question, or checkpoint to add.
+
+Do NOT report a divergence the agent noticed and reversed inside the same turn — that is self-correction and it cost the user nothing. Do NOT report a human turn that adds NEW scope; a changed mind is not a divergence. If the dataset holds no corrective or clarifying human turns, return an empty findings array instead of grading tone.`,
+	toolGroup: "all",
+	limits: {
+		maxLlmCalls: 6,
+		maxIterations: 22,
+		maxToolCalls: 64
+	},
+	minimumEvidenceCitations: 2
+};
+const KNOWLEDGE_GAP_KIND_SPEC = {
+	id: "knowledge-gap",
+	description: "Identifies missing or stale pieces of knowledge — primarily against the agent-knowledge wiki — 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.2.0",
+	instructions: `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\` — 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 — or an outdated/contradictory fact the agent picked up from a non-wiki source.
+
+${findingSubjectGrammarPromptFor("knowledge-gap")}
+
+DISCOVERY → ATTRIBUTE-TO-LAYER → CITE protocol:
+
+1. \`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…", "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 \`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** and use its exact locus from the subject grammar above.
+4. For each defensible gap, emit ONE finding. Use an exact locus from the subject grammar and name the missing or stale knowledge (for example, "wiki has no page on invoice line-item shape; agent re-derived it from raw spans"). Rate it high when it caused failure or a clarifying question, medium for unnecessary turns, and low for minor inefficiency. Cite the span where the question, correction, retrieval miss, or stale result surfaced and quote it exactly. Use confidence 0.85+ when the agent articulated the gap and 0.6-0.8 when inferred. Recommend a concrete wiki edit for an agent-knowledge locus or a prompt/tool-description edit otherwise.
+
+**Compare layers over loaded evidence.** After the first scan, load the exact excerpts behind candidates across \`agent-knowledge:*\`, \`websearch:outdated\`, \`tool-doc:*\`, \`system-prompt:*\`, and \`memory:*\`. Use one bounded \`llm_query\` per layer to classify those excerpts. Subqueries cannot call trace tools. Merge their classifications into the final finding set only when the source excerpts support them.
+
+Do NOT report a gap that the agent later recovered from cleanly within the same turn. That is resilience, not a gap. Cite the non-recovery version when both exist.`,
+	toolGroup: "discoveryAndSearch",
+	limits: {
+		maxLlmCalls: 5,
+		maxIterations: 18,
+		maxToolCalls: 48
 	}
-	assertAnalystFinding(snapshot, context);
-	return snapshot;
-}
-function assertAnalystFinding(value, context) {
-	if (!isRecord(value)) throw new TypeError(`${context} must be an object`);
-	assertOnlyKeys(value, [
-		"schema_version",
-		"finding_id",
-		"analyst_id",
-		"produced_at",
-		"severity",
-		"area",
-		"claim",
-		"rationale",
-		"evidence_refs",
-		"recommended_action",
-		"validation_plan",
-		"confidence",
-		"subject",
-		"derived_from_judge",
-		"metadata"
-	], context);
-	if (value.schema_version !== "1.0.0") throw new TypeError(`${context} schema_version must be "1.0.0"`);
-	requiredString(value.finding_id, `${context} finding_id`);
-	requiredString(value.analyst_id, `${context} analyst_id`);
-	canonicalTimestamp(value.produced_at, `${context} produced_at`);
-	if (value.severity !== "critical" && value.severity !== "high" && value.severity !== "medium" && value.severity !== "low" && value.severity !== "info") throw new TypeError(`${context} severity is invalid`);
-	requiredString(value.area, `${context} area`);
-	requiredString(value.claim, `${context} claim`);
-	optionalString(value.rationale, `${context} rationale`);
-	value.evidence_refs = validateEvidenceRefs(value.evidence_refs, `${context} evidence_refs`);
-	optionalString(value.recommended_action, `${context} recommended_action`);
-	optionalString(value.validation_plan, `${context} validation_plan`);
-	if (typeof value.confidence !== "number" || !Number.isFinite(value.confidence) || value.confidence < 0 || value.confidence > 1) throw new TypeError(`${context} confidence must be a finite number from 0 through 1`);
-	optionalString(value.subject, `${context} subject`);
-	if (value.derived_from_judge !== void 0 && typeof value.derived_from_judge !== "boolean") throw new TypeError(`${context} derived_from_judge must be a boolean`);
-	if (value.metadata !== void 0 && !isRecord(value.metadata)) throw new TypeError(`${context} metadata must be an object`);
-}
-function validateMissedIssues(value, findingsById, context) {
-	if (!Array.isArray(value)) throw new TypeError(`${context} missedIssues must be an array`);
-	const seen = /* @__PURE__ */ new Set();
-	return value.map((issue, index) => {
-		const issueContext = `${context} missedIssues ${index}`;
-		if (!isRecord(issue)) throw new TypeError(`${issueContext} must be an object`);
-		assertOnlyKeys(issue, [
-			"id",
-			"reason",
-			"evidence"
-		], issueContext);
-		const id = requiredString(issue.id, `${issueContext} id`);
-		if (findingsById.has(id)) throw new TypeError(`${issueContext} id "${id}" is already an emitted finding id`);
-		if (seen.has(id)) throw new TypeError(`duplicate missed issue id "${id}"`);
-		seen.add(id);
-		return {
-			id,
-			reason: requiredString(issue.reason, `${issueContext} reason`),
-			...issue.evidence === void 0 ? {} : { evidence: validateEvidenceRefs(issue.evidence, `${issueContext} evidence`) }
-		};
-	});
-}
-function validateEvidenceRefs(value, context) {
-	if (!Array.isArray(value)) throw new TypeError(`${context} must be an array`);
-	return value.map((evidence, index) => {
-		const evidenceContext = `${context} ${index}`;
-		if (!isRecord(evidence)) throw new TypeError(`${evidenceContext} must be an object`);
-		assertOnlyKeys(evidence, [
-			"kind",
-			"uri",
-			"excerpt"
-		], evidenceContext);
-		if (evidence.kind !== "span" && evidence.kind !== "event" && evidence.kind !== "artifact" && evidence.kind !== "finding" && evidence.kind !== "metric") throw new TypeError(`${evidenceContext} kind is invalid`);
-		const uri = requiredString(evidence.uri, `${evidenceContext} uri`);
-		const excerpt = evidence.excerpt;
-		optionalString(excerpt, `${evidenceContext} excerpt`);
-		return {
-			kind: evidence.kind,
-			uri,
-			...excerpt === void 0 ? {} : { excerpt }
-		};
-	});
-}
-function assertOnlyKeys(value, allowed, name) {
-	const allowedKeys = new Set(allowed);
-	const unexpected = Object.keys(value).filter((key) => !allowedKeys.has(key));
-	if (unexpected.length > 0) throw new TypeError(`${name} contains unknown fields: ${unexpected.sort().join(", ")}`);
-}
-function stringArray(value, name) {
-	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new TypeError(`${name} must be an array of strings`);
-	const strings = value.map((item) => requiredString(item, name));
-	if (new Set(strings).size !== strings.length) throw new TypeError(`${name} must contain unique values`);
-	return strings;
-}
-function requiredString(value, name) {
-	if (typeof value !== "string" || value.trim().length === 0) throw new TypeError(`${name} must be a non-empty string`);
-	return value;
-}
-function requiredDigest(value, name) {
-	const digest = requiredString(value, name);
-	if (!/^sha256:[a-f0-9]{64}$/.test(digest)) throw new TypeError(`${name} must be a sha256 digest`);
-	return digest;
-}
-function optionalString(value, name) {
-	if (value !== void 0 && typeof value !== "string") throw new TypeError(`${name} must be a string`);
-}
-function canonicalTimestamp(value, name) {
-	const timestamp = requiredString(value, name);
-	const parsed = new Date(timestamp);
-	if (Number.isNaN(parsed.valueOf()) || parsed.toISOString() !== timestamp) throw new TypeError(`${name} must be a canonical ISO 8601 UTC timestamp`);
-	return timestamp;
-}
-function isAnalystReviewSource(value) {
-	return value === "user" || value === "judge" || value === "environment" || value === "metric" || value === "policy";
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+};
+const 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.2.0",
+	instructions: `You are a knowledge-poisoning analyst for an OTLP trace dataset. Your job is to identify cases where the agent **confidently used wrong information** — not where it lacked information (that's the knowledge-gap analyst).
+
+${findingSubjectGrammarPromptFor("knowledge-poisoning")}
+
+DISCOVERY → DUAL-VERIFY → CITE protocol:
+
+1. \`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 — 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 \`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 supported. If you can only support one, drop it because single-evidence poisoning findings are too speculative to be useful.
+
+**Independently assess both halves.** Load the action excerpt and contradicting excerpt yourself, then send bounded \`llm_query\` calls the exact evidence for "did the agent act?" and "does the trace contradict the belief?" Subqueries cannot call trace tools. Accept a poisoning only when both assessments and the source excerpts support it.
+
+For each confirmed poisoning, emit ONE finding. Use the source of the false belief as the exact subject. State "agent believed X (from source S); trace evidence shows X is false." Rate it critical for a wrong user-visible action, high when caught internally after significant waste, and medium for inefficiency. Cite BOTH the action span and the contradicting span with exact quotes. Use confidence 0.85+ when both halves have exact quotes and 0.6-0.8 when one half is inferred. Recommend the literal source correction: update the wiki claim, invalidate and re-curate the raw source, or replace the stale prompt/tool instruction.
+
+Do NOT report a finding if the agent caught and corrected the false belief in the same turn. Reserve poisoning for cases where the false belief shaped downstream action.`,
+	toolGroup: "all",
+	limits: {
+		maxLlmCalls: 8,
+		maxIterations: 20,
+		maxToolCalls: 64
+	},
+	minimumEvidenceCitations: 2
+};
+//#endregion
+//#region src/analyst/kinds/index.ts
+/**
+* The default kind suite. Order is the run order operators should use:
+* failure-mode and intent-divergence first (neither reads upstream
+* findings), gap + poisoning next (both explain the problems those two
+* found), improvement last (chains all four). Intent-divergence sits
+* ahead of improvement deliberately — a proposed edit should be able to
+* act on a priced divergence, and it is the only kind whose findings
+* carry a burned-turn cost to rank against.
+*/
+const DEFAULT_TRACE_ANALYST_KINDS = [
+	FAILURE_MODE_KIND_SPEC,
+	INTENT_DIVERGENCE_KIND_SPEC,
+	KNOWLEDGE_GAP_KIND_SPEC,
+	KNOWLEDGE_POISONING_KIND_SPEC,
+	IMPROVEMENT_KIND_SPEC
+];
 //#endregion
 //#region src/analyst/registry.ts
 /**
@@ -2447,6 +2366,87 @@ function buildDefaultAnalystRegistry(options = {}) {
 	return registry;
 }
 //#endregion
-export { createChatClient as C, computeTraceMetrics as S, CONTROL_INTEGRITY_ANALYST as _, analystFindingDigest as a, behavioralAnalyst as b, completedAnalystReviewQuality as c, validateAnalystReviewDecisions as d, DEFAULT_TRACE_ANALYST_KINDS as f, FAILURE_MODE_KIND_SPEC as g, IMPROVEMENT_KIND_SPEC as h, assertExactRegistryRunOpts as i, readAnalystReview as l, KNOWLEDGE_GAP_KIND_SPEC as m, AnalystRegistry as n, analystRunDigest as o, KNOWLEDGE_POISONING_KIND_SPEC as p, ExactAnalystRunExecutionError as r, assertUniqueFindingIds as s, buildDefaultAnalystRegistry as t, snapshotAnalystRun as u, ControlIntegrityAnalyst as v, deriveEfficiencyFindings as x, emitControlIntegrityFindings as y };
+//#region src/analyst/chat-client.ts
+/**
+* Provider-neutral chat contract for every model call made by agent-eval.
+*
+* Callers choose the transport at the package boundary with `createChatClient`.
+* Evaluation code receives canonical requests and results without importing a
+* provider SDK.
+*/
+/**
+* Build a ChatClient bound to a specific transport. The returned client
+* is safe to share across analysts in a single registry run.
+*/
+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,
+			maximumAttempts: opts.maximumAttempts
+		}));
+		case "cli-bridge": return wrapLlmClient(opts.transport, opts.defaultModel, new LlmClient({
+			baseUrl: opts.baseUrl ?? "http://127.0.0.1:3344/v1",
+			apiKey: opts.bearer ?? "",
+			maximumAttempts: opts.maximumAttempts
+		}));
+		case "direct-provider": return wrapLlmClient(opts.transport, opts.defaultModel, new LlmClient({
+			baseUrl: opts.baseUrl,
+			apiKey: opts.apiKey,
+			maximumAttempts: opts.maximumAttempts
+		}));
+		case "sandbox-sdk": return {
+			transport: "sandbox-sdk",
+			defaultModel: opts.defaultModel,
+			maximumAttempts: opts.maximumAttempts,
+			chat: async (req, callOpts) => opts.chat(resolveModel(req, opts.defaultModel), callOpts)
+		};
+		case "custom": return {
+			transport: "custom",
+			defaultModel: opts.defaultModel,
+			maximumAttempts: opts.maximumAttempts,
+			chat: async (req, callOpts) => opts.chat(resolveModel(req, opts.defaultModel), callOpts)
+		};
+		case "mock": return {
+			transport: "mock",
+			defaultModel: opts.defaultModel,
+			maximumAttempts: 1,
+			chat: async (req, callOpts) => opts.handler(resolveModel(req, opts.defaultModel), callOpts)
+		};
+	}
+}
+function wrapLlmClient(transport, defaultModel, inner) {
+	return {
+		transport,
+		defaultModel,
+		maximumAttempts: inner.maximumAttempts,
+		chat: (req, callOpts) => {
+			const request = {
+				model: resolveModel(req, defaultModel).model,
+				messages: req.messages,
+				jsonMode: req.jsonMode,
+				jsonSchema: req.jsonSchema,
+				temperature: req.temperature,
+				maxTokens: req.maxTokens,
+				thinking: req.thinking,
+				timeoutMs: req.timeoutMs
+			};
+			return inner.call(request, {
+				signal: callOpts?.signal,
+				idempotencyKey: callOpts?.idempotencyKey
+			});
+		}
+	};
+}
+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
+	};
+}
+//#endregion
+export { validateAnalystReviewDecisions as S, analystRunDigest as _, assertExactRegistryRunOpts as a, readAnalystReview as b, KNOWLEDGE_GAP_KIND_SPEC as c, CONTROL_INTEGRITY_ANALYST as d, ControlIntegrityAnalyst as f, analystFindingDigest as g, deriveEfficiencyFindings as h, ExactAnalystRunExecutionError as i, IMPROVEMENT_KIND_SPEC as l, behavioralAnalyst as m, buildDefaultAnalystRegistry as n, DEFAULT_TRACE_ANALYST_KINDS as o, emitControlIntegrityFindings as p, AnalystRegistry as r, KNOWLEDGE_POISONING_KIND_SPEC as s, createChatClient as t, FAILURE_MODE_KIND_SPEC as u, assertUniqueFindingIds as v, snapshotAnalystRun as x, completedAnalystReviewQuality as y };
 
-//# sourceMappingURL=default-registry-BmktKy8r.js.map
+//# sourceMappingURL=chat-client-Bp4Ebuuc.js.map