@tangle-network/agent-eval 0.215.1 → 0.216.0

package/dist/analyst/index.js

@@ -1,18 +1,26 @@
+import { i as nominalAgreement } from "../agreement-irr-DsTURxdr.js";
 import { i as CostLedger } from "../cost-ledger-D2FnJPBF.js";
-import { n as isProposalFinding, t as assertProposalFindings } from "../proposal-findings-CXblsskH.js";
-import { B as FINDING_SUBJECT_SYNTAX, F as parseRawFinding, G as DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS, H as findingSubjectGrammarPromptFor, I as parseTraceSpanEvidenceUri, K as resolveTraceAnalystLimits, L as coerceJson, M as RAW_FINDING_SCHEMA_PROMPT, N as RawAnalystFindingSchema, P as evidenceRefsFromRawFinding, R as stripCodeFences, U as parseFindingSubject, V as KIND_EXPECTED_SUBJECTS, W as renderFindingSubject, i as buildTraceToolsForGroup, n as renderPriorFindings, r as runTraceAnalyst, t as createTraceAnalyst, z as FINDING_SUBJECT_KINDS } from "../kind-factory-AaEhUADH.js";
+import { t as FileLedgerJournal } from "../journal-DvKCvjty.js";
+import { a as merkleRoot } from "../ledger-core-B2hahzrt.js";
+import { A as parseAnalystFinding, C as ProposalFindingSchema, D as lineageRoots, E as independentUnitCount, M as spanningWindow, O as mergeEvidenceUnits, S as FINDING_LAYERS, T as findingLayerRank, j as readFindingScope, k as mostSevere, w as UNKNOWN_LINEAGE, x as AnalystFindingSchema } from "../external-optimizer-subprocess-DcerlZSG.js";
+import { a as makeFinding, i as computeFindingId, o as makeProposalFinding, r as FINDING_SCOPE_FIELDS, t as ANALYST_FINDING_SCHEMA_VERSIONS } from "../types-IXD2HJzu.js";
+import { n as isProposalFinding, t as assertProposalFindings } from "../proposal-findings-BZiMTzAF.js";
+import { B as FINDING_SUBJECT_SYNTAX, F as parseRawFinding, G as DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS, H as findingSubjectGrammarPromptFor, I as parseTraceSpanEvidenceUri, K as resolveTraceAnalystLimits, L as coerceJson, M as RAW_FINDING_SCHEMA_PROMPT, N as RawAnalystFindingSchema, P as evidenceRefsFromRawFinding, R as stripCodeFences, U as parseFindingSubject, V as KIND_EXPECTED_SUBJECTS, W as renderFindingSubject, i as buildTraceToolsForGroup, n as renderPriorFindings, r as runTraceAnalyst, t as createTraceAnalyst, z as FINDING_SUBJECT_KINDS } from "../kind-factory-CbZ-6tvu.js";
 import { i as validateUsageSettlementTimeout, n as settleUsageReceiptFromCostLedger } from "../usage-receipt-Cx3xNeyB.js";
-import { a as KNOWLEDGE_POISONING_KIND_SPEC, c as FAILURE_MODE_KIND_SPEC, d as emitControlIntegrityFindings, f as behavioralAnalyst, i as DEFAULT_TRACE_ANALYST_KINDS, l as CONTROL_INTEGRITY_ANALYST, n as AnalystRegistry, o as KNOWLEDGE_GAP_KIND_SPEC, p as deriveEfficiencyFindings, r as ExactAnalystRunExecutionError, s as IMPROVEMENT_KIND_SPEC, t as buildDefaultAnalystRegistry, u as ControlIntegrityAnalyst } from "../default-registry-KP4-Tolz.js";
-import { i as makeProposalFinding, n as computeFindingId, r as makeFinding } from "../types-CW5b90JH.js";
-import { t as createDspyRlmTraceEngine } from "../dspy-rlm-engine-DZfHM7kT.js";
-import { a as diffFindings, i as defaultIsMaterial, n as runSemanticConceptJudge, o as createChatTraceEngine, r as FindingsStore, t as SEMANTIC_CONCEPT_JUDGE_VERSION } from "../semantic-concept-judge-BPqbwIVs.js";
+import { a as KNOWLEDGE_POISONING_KIND_SPEC, c as FAILURE_MODE_KIND_SPEC, d as emitControlIntegrityFindings, f as behavioralAnalyst, i as DEFAULT_TRACE_ANALYST_KINDS, l as CONTROL_INTEGRITY_ANALYST, n as AnalystRegistry, o as KNOWLEDGE_GAP_KIND_SPEC, p as deriveEfficiencyFindings, r as ExactAnalystRunExecutionError, s as IMPROVEMENT_KIND_SPEC, t as buildDefaultAnalystRegistry, u as ControlIntegrityAnalyst } from "../default-registry-Cn1LQ2Ve.js";
+import { t as createDspyRlmTraceEngine } from "../dspy-rlm-engine-D-KX_e64.js";
+import { a as diffFindings, i as defaultIsMaterial, n as runSemanticConceptJudge, o as createChatTraceEngine, r as FindingsStore, t as SEMANTIC_CONCEPT_JUDGE_VERSION } from "../semantic-concept-judge-zQBG9hHU.js";
 import { t as createChatClient } from "../chat-client-DthPOYGd.js";
+import { systemOneAnalyst } from "../systemone.js";
 import { a as scoreAnalystFindings, i as summarizeAnalystBenchmarkRunner, n as runAnalystBenchmark, r as traceStoreEvidenceResolver, t as registryBenchmarkRunner } from "../benchmark-BywPeAUo.js";
-import { $ as ANALYST_BENCHMARK_MANIFEST_FILE, A as readAnalystInstructionsOverride, B as parseVerificationOutcome, C as emptyPublicBenchmarkRunner, D as summarizeCodeTraceCalibration, E as renderCodeTraceCalibrationMarkdown, F as publicBenchmarkRlmInstructions, G as ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256, H as ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES, I as publicBenchmarkSystemPrompt, J as ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, K as ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM, L as DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES, M as MAX_INCORRECT_BLOCKS, N as MAX_INCORRECT_BLOCK_STEPS, O as analystInstructionsOverrideFromText, P as publicBenchmarkProtocolSha256, Q as ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, R as appendVerificationArtifactsToOtlp, S as adaptPublicBenchmarkFindings, T as readAnalystBenchmarkArtifact, U as ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256, V as ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM, W as ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256, X as analystBenchmarkImplementationDigest, Y as analystBenchmarkDependencyLockDigest, Z as ANALYST_BENCHMARK_COST_LEDGER_FILE, _ as publicDirectAnalystDefinition, a as primeCodeTraceAnalystDefinition, at as codeTraceBenchCase, b as analystDefinitionAsymmetries, c as preparePublicAnalystBenchmark, ct as agentRxPredictionsToFindings, d as selectPublicBenchmarkRows, dt as normalizeBenchmarkLabel, et as ANALYST_BENCHMARK_OBSERVATIONS_FILE, f as createPublicBenchmarkRlmRunner, g as createPublicBenchmarkDirectRunner, h as runReplVariableAnalystDefinition, i as primeAnalystProtocolSha256, it as summarizeAgentRxCalibration, j as CODE_TRACE_BENCH_ANALYST_PROMPT, k as effectiveAnalystProtocolSha256, l as publicBenchmarkDistributions, lt as normalizeAgentRxCategory, m as rlmEngineLimits, n as renderAnalystBenchmarkMarkdown, nt as AGENT_RX_UPSTREAM_REVISION, o as runInlineAnalystDefinition, ot as codeTracerPredictionsToFindings, p as publicRlmAnalystDefinition, q as ANALYST_BENCHMARK_IMPLEMENTATION_FILES, r as createPrimeBenchmarkRunner, rt as renderAgentRxCalibrationMarkdown, s as loadPublicBenchmarkRows, st as agentRxBenchmarkCase, t as runAnalystBenchmarkCommand, tt as compareAnalystRunners, u as publicBenchmarkSelectionReport, ut as roundAgentRxStep, v as runChunkedAnalystDefinition, w as expandCodeTraceFailureBlocks, x as analystDefinitionProtocolSha256, y as AnalystExpressivenessError, z as loadCodeTraceVerificationArtifacts } from "../benchmark-command-CgpGi7vY.js";
+import { $ as ANALYST_BENCHMARK_MANIFEST_FILE, A as readAnalystInstructionsOverride, B as parseVerificationOutcome, C as emptyPublicBenchmarkRunner, D as summarizeCodeTraceCalibration, E as renderCodeTraceCalibrationMarkdown, F as publicBenchmarkRlmInstructions, G as ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256, H as ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES, I as publicBenchmarkSystemPrompt, J as ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, K as ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM, L as DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES, M as MAX_INCORRECT_BLOCKS, N as MAX_INCORRECT_BLOCK_STEPS, O as analystInstructionsOverrideFromText, P as publicBenchmarkProtocolSha256, Q as ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, R as appendVerificationArtifactsToOtlp, S as adaptPublicBenchmarkFindings, T as readAnalystBenchmarkArtifact, U as ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256, V as ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM, W as ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256, X as analystBenchmarkImplementationDigest, Y as analystBenchmarkDependencyLockDigest, Z as ANALYST_BENCHMARK_COST_LEDGER_FILE, _ as publicDirectAnalystDefinition, a as primeCodeTraceAnalystDefinition, at as codeTraceBenchCase, b as analystDefinitionAsymmetries, c as preparePublicAnalystBenchmark, ct as agentRxPredictionsToFindings, d as selectPublicBenchmarkRows, dt as normalizeBenchmarkLabel, et as ANALYST_BENCHMARK_OBSERVATIONS_FILE, f as createPublicBenchmarkRlmRunner, g as createPublicBenchmarkDirectRunner, h as runReplVariableAnalystDefinition, i as primeAnalystProtocolSha256, it as summarizeAgentRxCalibration, j as CODE_TRACE_BENCH_ANALYST_PROMPT, k as effectiveAnalystProtocolSha256, l as publicBenchmarkDistributions, lt as normalizeAgentRxCategory, m as rlmEngineLimits, n as renderAnalystBenchmarkMarkdown, nt as AGENT_RX_UPSTREAM_REVISION, o as runInlineAnalystDefinition, ot as codeTracerPredictionsToFindings, p as publicRlmAnalystDefinition, q as ANALYST_BENCHMARK_IMPLEMENTATION_FILES, r as createPrimeBenchmarkRunner, rt as renderAgentRxCalibrationMarkdown, s as loadPublicBenchmarkRows, st as agentRxBenchmarkCase, t as runAnalystBenchmarkCommand, tt as compareAnalystRunners, u as publicBenchmarkSelectionReport, ut as roundAgentRxStep, v as runChunkedAnalystDefinition, w as expandCodeTraceFailureBlocks, x as analystDefinitionProtocolSha256, y as AnalystExpressivenessError, z as loadCodeTraceVerificationArtifacts } from "../benchmark-command-CByl9dxG.js";
 import { a as extractPrimeJsonObject, c as primeProtocolSha256, d as runPrimeExchange, f as decodeReplyRows, i as emptyPrimeRawUsage, l as primeReplyDefect, n as buildPrimePrompt, o as mergePrimeRawUsage, r as buildPrimeRepairPrompt, s as normalizePrimeUsage, t as analystUsageReceiptFromPrimeUsage, u as projectPrimeTrajectory } from "../prime-protocol-DcAK9pC8.js";
 import { t as nodeHttpPrimeBridgeTransport } from "../prime-bridge-transport-Z3cpKGoV.js";
+import { t as clusterBootstrapMean } from "../cluster-bootstrap-B3JywQQn.js";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { z } from "zod";
 import { join } from "node:path";
+import { readFile } from "node:fs/promises";
 //#region src/analyst/adapters.ts
 /**
 * Adapter factory — lifts the semantic-concept judge into the Analyst
@@ -163,6 +171,673 @@ function defineCustomAnalyst(options) {
 	};
 }
 //#endregion
+//#region src/analyst/domain-taxonomy.ts
+/**
+* Domain taxonomy — one versioned tree that both the layer ladder and the
+* domain hierarchy live in.
+*
+* Domain nodes nest to any depth ("building systems" → "cryptographic" →
+* "zk proving" → "binary fields"). Problems attach to one primary domain path
+* plus free tags, plays attach to a problem, and runs attach to a play. Every
+* node hangs under the implicit `lab` root, so one parent map answers both
+* "which play holds this run" and "which domain holds this problem", and
+* `promote` walks a single ladder: run → play → problem → domain path → lab.
+*
+* Plain data in, plain data out: every function returns a new value or a
+* typed failure, and nothing here reads a file or the network.
+*/
+const DOMAIN_TAXONOMY_SCHEMA = "agent-eval.domain-taxonomy.v1";
+/** Id of the implicit root every top-level domain hangs under. */
+const LAB_NODE_ID = "lab";
+/** Layers a taxonomy node can sit at, lowest first. */
+const TAXONOMY_NODE_LAYERS = [
+	"run",
+	"play",
+	"problem",
+	"domain"
+];
+/** The layer a node of each kind must hang under. */
+const PARENT_LAYER = {
+	run: "play",
+	play: "problem",
+	problem: "domain",
+	domain: "domain"
+};
+function fail(message) {
+	return {
+		succeeded: false,
+		error: { message }
+	};
+}
+/**
+* Validate a taxonomy: unique ids, known parents, each node under a parent of
+* the right layer, no cycles. `lab` is reserved for the implicit root.
+*/
+function defineDomainTaxonomy(input) {
+	if (typeof input.version !== "string" || !input.version.trim()) return fail("taxonomy version must be a non-empty string");
+	const nodes = input.nodes.map((node) => ({
+		id: node.id,
+		label: node.label,
+		layer: node.layer,
+		parent: node.parent,
+		...node.tags === void 0 ? {} : { tags: [...node.tags] }
+	}));
+	const byId = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		if (typeof node.id !== "string" || !node.id.trim()) return fail("node ids must be non-empty");
+		if (node.id === "lab") return fail(`'lab' is the implicit root id`);
+		if (byId.has(node.id)) return fail(`node '${node.id}' appears twice`);
+		if (!TAXONOMY_NODE_LAYERS.includes(node.layer)) return fail(`node '${node.id}' has unknown layer '${String(node.layer)}'`);
+		if (typeof node.label !== "string" || !node.label.trim()) return fail(`node '${node.id}' needs a label`);
+		byId.set(node.id, node);
+	}
+	for (const node of nodes) {
+		if (node.parent === null) {
+			if (node.layer !== "domain") return fail(`${node.layer} '${node.id}' needs a parent`);
+			continue;
+		}
+		const parent = byId.get(node.parent);
+		if (!parent) return fail(`node '${node.id}' names unknown parent '${node.parent}'`);
+		if (parent.layer !== PARENT_LAYER[node.layer]) return fail(`${node.layer} '${node.id}' must hang under a ${PARENT_LAYER[node.layer]}, not ${parent.layer} '${parent.id}'`);
+	}
+	for (const node of nodes) {
+		const seen = /* @__PURE__ */ new Set();
+		let current = node;
+		while (current) {
+			if (seen.has(current.id)) return fail(`node '${node.id}' sits on a parent cycle`);
+			seen.add(current.id);
+			current = current.parent === null ? void 0 : byId.get(current.parent);
+		}
+	}
+	return {
+		succeeded: true,
+		value: {
+			schema: DOMAIN_TAXONOMY_SCHEMA,
+			version: input.version,
+			nodes
+		}
+	};
+}
+/** Attach a problem to one primary domain path, a play to a problem, or a run to a play. */
+function attachToTaxonomy(taxonomy, attachment) {
+	let parent;
+	if (attachment.layer === "problem") {
+		if (!attachment.path || attachment.path.length === 0) return fail(`problem '${attachment.id}' needs a primary domain path`);
+		const resolved = resolveDomainPath(taxonomy, attachment.path);
+		if (!resolved.succeeded) return resolved;
+		parent = attachment.path[attachment.path.length - 1];
+	} else {
+		if (!attachment.parent) return fail(`${attachment.layer} '${attachment.id}' needs a parent`);
+		parent = attachment.parent;
+	}
+	return defineDomainTaxonomy({
+		version: taxonomy.version,
+		nodes: [...taxonomy.nodes, {
+			id: attachment.id,
+			label: attachment.label,
+			layer: attachment.layer,
+			parent,
+			...attachment.tags === void 0 ? {} : { tags: [...attachment.tags] }
+		}]
+	});
+}
+/** Check that a path is a top-down chain of domain nodes. */
+function resolveDomainPath(taxonomy, path) {
+	const byId = nodeIndex(taxonomy);
+	const chain = [];
+	let expectedParent = null;
+	for (const id of path) {
+		const node = byId.get(id);
+		if (node?.layer !== "domain") return fail(`'${id}' is not a domain node`);
+		if (node.parent !== expectedParent) return fail(`domain path breaks at '${id}': its parent is '${node.parent ?? "lab"}'`);
+		chain.push(node);
+		expectedParent = id;
+	}
+	return {
+		succeeded: true,
+		value: chain
+	};
+}
+/** Layer of a node id, with `lab` for the implicit root; undefined when unknown. */
+function taxonomyLayerOf(taxonomy, id) {
+	if (id === "lab") return "lab";
+	return nodeIndex(taxonomy).get(id)?.layer;
+}
+/** Parent id, with `lab` above every top-level domain and null above `lab`. */
+function taxonomyParentOf(taxonomy, id) {
+	if (id === "lab") return null;
+	const node = nodeIndex(taxonomy).get(id);
+	if (!node) return void 0;
+	return node.parent ?? "lab";
+}
+/** The node and its ancestors, nearest first, ending at `lab`. Empty for an unknown id. */
+function taxonomyAncestry(taxonomy, id) {
+	const byId = nodeIndex(taxonomy);
+	const chain = [];
+	let current = id;
+	while (current !== null) {
+		if (current === "lab") {
+			chain.push(current);
+			break;
+		}
+		const node = byId.get(current);
+		if (!node) return [];
+		chain.push(current);
+		current = node.parent ?? "lab";
+	}
+	return chain;
+}
+/** Domain path of a node, broadest first: the domain ids above it, and itself when a domain. */
+function domainPathOf(taxonomy, id) {
+	const byId = nodeIndex(taxonomy);
+	return taxonomyAncestry(taxonomy, id).filter((ancestor) => byId.get(ancestor)?.layer === "domain").reverse();
+}
+/**
+* Deepest node that is an ancestor of (or equal to) every id, or undefined
+* when an id is unknown. `lab` is the answer when they share nothing else.
+*/
+function lowestCommonAncestor(taxonomy, ids) {
+	if (ids.length === 0) return void 0;
+	const chains = ids.map((id) => taxonomyAncestry(taxonomy, id));
+	if (chains.some((chain) => chain.length === 0)) return void 0;
+	const others = chains.slice(1).map((chain) => new Set(chain));
+	return chains[0].find((id) => others.every((chain) => chain.has(id)));
+}
+function nodeIndex(taxonomy) {
+	return new Map(taxonomy.nodes.map((node) => [node.id, node]));
+}
+//#endregion
+//#region src/analyst/failure-modes.ts
+/**
+* failure-modes — a judged analyst with fixed-choice labels, gated on its own
+* calibration.
+*
+* Labels are adapted from the MAST multi-agent failure taxonomy (Cemri et al.,
+* "Why Do Multi-Agent LLM Systems Fail?", 2025): its fourteen modes in three
+* groups, plus four single-agent modes so the public AgentRx set maps onto the
+* same labels, plus `none`. Two more fixed questions cover delegation-brief
+* completeness and steer handling.
+*
+* The judge runs through the System One decision path (`systemOneAnalyst`).
+* Construction requires a calibration — gold labels compared with the judge's
+* labels on the same items — and refuses to build an analyst whose Cohen's κ
+* is below `FAILURE_MODES_MIN_KAPPA`. A rubric that does not agree with its
+* gold set has nothing to report, so it reports nothing.
+*/
+const FAILURE_MODES_ANALYST_ID = "failure-modes";
+const FAILURE_MODES_VERSION = "1";
+/** κ below this refuses the rubric. */
+const FAILURE_MODES_MIN_KAPPA = .6;
+const FAILURE_MODE_LABELS = {
+	"disobey-task-specification": "Ignored or violated the stated task requirements or constraints.",
+	"disobey-role-specification": "Acted outside its assigned role or took over another role.",
+	"step-repetition": "Repeated a step already completed without new reason.",
+	"loss-of-conversation-history": "Lost earlier context and acted as if it was never given.",
+	"unaware-of-termination-conditions": "Did not recognize when the task was done or must stop.",
+	"conversation-reset": "Restarted the exchange and discarded progress.",
+	"fail-to-ask-for-clarification": "Proceeded on an ambiguous instruction without asking.",
+	"task-derailment": "Drifted from the task toward a different goal.",
+	"information-withholding": "Kept back information another agent needed.",
+	"ignored-other-agent-input": "Disregarded another agent's input or recommendation.",
+	"reasoning-action-mismatch": "Acted against its own stated reasoning or plan.",
+	"premature-termination": "Stopped before the goal of the task was met.",
+	"no-or-incomplete-verification": "Delivered without verifying, or verified only part.",
+	"incorrect-verification": "Verified, but the check was wrong or passed bad output.",
+	"invented-information": "Stated facts, results or tool output that do not exist.",
+	"invalid-tool-invocation": "Called a tool with an invalid name, argument or format.",
+	"misread-tool-output": "Misinterpreted what a tool or handoff returned.",
+	"system-failure": "Failed because of infrastructure, not the agent.",
+	none: "No failure mode applies."
+};
+/**
+* AgentRx root-cause category → failure-mode label. `null` categories have no
+* counterpart here and are left out of the gold set, counted as unmapped.
+*/
+const AGENT_RX_FAILURE_MODE_MAP = {
+	"instruction-plan-adherence-failure": "disobey-task-specification",
+	"invention-of-new-information": "invented-information",
+	"invalid-invocation": "invalid-tool-invocation",
+	"misinterpretation-of-tool-output-handoff-failure": "misread-tool-output",
+	"intent-plan-misalignment": "task-derailment",
+	"underspecified-user-intent": "fail-to-ask-for-clarification",
+	"intent-not-supported": null,
+	"guardrails-triggered": null,
+	"system-failure": "system-failure",
+	inconclusive: null
+};
+const FAILURE_MODES_QUESTIONS = {
+	failure_mode: {
+		type: "choice",
+		instructions: "Which single failure mode best explains why this agent or team fell short? Choose none when it did not fail.",
+		criteria: FAILURE_MODE_LABELS
+	},
+	delegation_brief: {
+		type: "choice",
+		instructions: "When this agent delegated work, did the brief state the goal, the constraints, the expected output, and how the result would be checked?",
+		criteria: {
+			complete: "Every delegated brief stated goal, constraints, output and check.",
+			partial: "Some brief left out one or more of goal, constraints, output or check.",
+			missing: "Work was delegated with no usable brief.",
+			"no-delegation": "Nothing was delegated."
+		}
+	},
+	steer_handling: {
+		type: "choice",
+		instructions: "When a steer or correction arrived mid-task, what did the agent do with it?",
+		criteria: {
+			applied: "Changed course as the steer asked.",
+			ignored: "Continued as before, or acknowledged without acting.",
+			"no-steer": "No steer arrived."
+		}
+	}
+};
+function isLabel(value) {
+	return typeof value === "string" && Object.hasOwn(FAILURE_MODE_LABELS, value);
+}
+/** Gold labels from AgentRx rows: each trajectory's root-cause category, mapped onto this set. */
+function failureModeGoldFromAgentRx(rows) {
+	const gold = [];
+	const unmapped = [];
+	for (const row of rows) {
+		const id = `agentrx:${String(row.trajectory_id)}`;
+		const rootId = row.root_cause_failure_id ?? row.root_cause?.failure_id;
+		const root = row.failures.find((failure) => String(failure.failure_id) === String(rootId));
+		if (!root) throw new TypeError(`AgentRx trajectory '${row.trajectory_id}' has no root-cause failure`);
+		const category = normalizeAgentRxCategory(root.failure_category);
+		if (!Object.hasOwn(AGENT_RX_FAILURE_MODE_MAP, category)) throw new RangeError(`AgentRx category '${root.failure_category}' is outside the AgentRx taxonomy`);
+		const label = AGENT_RX_FAILURE_MODE_MAP[category];
+		if (label === null || label === void 0) unmapped.push({
+			id,
+			category
+		});
+		else gold.push({
+			id,
+			label
+		});
+	}
+	return {
+		gold,
+		unmapped
+	};
+}
+/** Validate a caller's gold file: a JSON array of `{ id, label }` with unique ids and known labels. */
+function parseFailureModeGold(raw) {
+	if (!Array.isArray(raw)) return {
+		succeeded: false,
+		error: {
+			kind: "invalid",
+			message: "gold must be a JSON array"
+		}
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const items = [];
+	for (const [index, row] of raw.entries()) {
+		const id = row?.id;
+		const label = row?.label;
+		if (typeof id !== "string" || !id.trim() || !isLabel(label)) return {
+			succeeded: false,
+			error: {
+				kind: "invalid",
+				message: `gold row ${index} needs a string id and a known label`
+			}
+		};
+		if (seen.has(id)) return {
+			succeeded: false,
+			error: {
+				kind: "invalid",
+				message: `gold id '${id}' repeats`
+			}
+		};
+		seen.add(id);
+		items.push({
+			id,
+			label
+		});
+	}
+	return {
+		succeeded: true,
+		value: items
+	};
+}
+/**
+* Load the calibration gold set from the public AgentRx labels and the
+* caller's gold file, through the analyst module's public-dataset loader.
+* Ids must be unique across both sources. No source, or no gold item, is a
+* failure: an empty gold set would calibrate to an undefined κ.
+*/
+async function loadFailureModeGold(sources) {
+	const invalid = (message) => ({
+		succeeded: false,
+		error: {
+			kind: "invalid",
+			message
+		}
+	});
+	const gold = [];
+	let agentRxRows = 0;
+	let unmapped = [];
+	try {
+		if (sources.agentRxLabelsPath !== void 0) {
+			const rows = await loadPublicBenchmarkRows(sources.agentRxLabelsPath);
+			agentRxRows = rows.length;
+			const mapped = failureModeGoldFromAgentRx(rows);
+			gold.push(...mapped.gold);
+			unmapped = mapped.unmapped;
+		}
+		if (sources.goldPath !== void 0) {
+			const parsed = parseFailureModeGold(JSON.parse(await readFile(sources.goldPath, "utf8")));
+			if (!parsed.succeeded) return parsed;
+			gold.push(...parsed.value);
+		}
+	} catch (error) {
+		return invalid(error instanceof Error ? error.message : String(error));
+	}
+	if (gold.length === 0) return invalid("failure-modes calibration needs at least one gold item");
+	const ids = /* @__PURE__ */ new Set();
+	for (const item of gold) {
+		if (ids.has(item.id)) return invalid(`gold id '${item.id}' repeats across sources`);
+		ids.add(item.id);
+	}
+	return {
+		succeeded: true,
+		value: {
+			gold,
+			agentRxRows,
+			unmapped
+		}
+	};
+}
+/**
+* Score the judge's labels against gold labels for the same items, usually
+* the set `loadFailureModeGold` returns.
+*/
+function calibrateFailureModes(gold, predictions) {
+	const predicted = /* @__PURE__ */ new Map();
+	for (const prediction of predictions) {
+		if (predicted.has(prediction.id)) throw new TypeError(`prediction id '${prediction.id}' repeats`);
+		predicted.set(prediction.id, prediction.label);
+	}
+	const ids = /* @__PURE__ */ new Set();
+	let missingPredictions = 0;
+	const pairs = [];
+	for (const item of gold) {
+		if (ids.has(item.id)) throw new TypeError(`gold id '${item.id}' repeats`);
+		ids.add(item.id);
+		const label = predicted.get(item.id);
+		if (label === void 0) missingPredictions += 1;
+		pairs.push([item.label, label ?? "(no prediction)"]);
+	}
+	const agreement = nominalAgreement(pairs);
+	return {
+		gold_n: agreement.n,
+		agreement: agreement.agreement,
+		kappa: agreement.kappa,
+		missingPredictions
+	};
+}
+/**
+* Build the failure-modes analyst, or refuse when its calibration does not
+* clear `FAILURE_MODES_MIN_KAPPA`. An undefined κ (no gold, or one label
+* everywhere) is refused the same way.
+*/
+function createFailureModesAnalyst(options) {
+	const { calibration, layer, model, renderState, scope, subject, ...transport } = options;
+	if (!(calibration.gold_n > 0) || !(calibration.kappa >= .6)) return {
+		succeeded: false,
+		error: {
+			kind: "uncalibrated",
+			message: `failure-modes rubric has kappa ${Number.isNaN(calibration.kappa) ? "undefined" : calibration.kappa.toFixed(3)} over ${calibration.gold_n} gold items; reporting requires kappa >= ${FAILURE_MODES_MIN_KAPPA}`
+		}
+	};
+	const method = {
+		kind: "judged",
+		name: FAILURE_MODES_ANALYST_ID,
+		version: "1",
+		calibration: {
+			gold_n: calibration.gold_n,
+			agreement: calibration.agreement,
+			kappa: calibration.kappa
+		}
+	};
+	return {
+		succeeded: true,
+		value: systemOneAnalyst({
+			...transport,
+			model,
+			renderState,
+			id: FAILURE_MODES_ANALYST_ID,
+			description: "Labels agent, team and run failures with a calibrated fixed-choice rubric.",
+			inputKind: "custom",
+			version: "1",
+			questions: FAILURE_MODES_QUESTIONS,
+			findings: (value, input, context) => {
+				const judgedSubject = subject?.(input, context);
+				const base = {
+					analyst_id: FAILURE_MODES_ANALYST_ID,
+					derived_from_judge: true,
+					layer,
+					scope: scope(input, context),
+					method,
+					evidence_refs: [{
+						kind: "artifact",
+						uri: `run://${context.runId}`
+					}],
+					...judgedSubject === void 0 ? {} : { subject: judgedSubject }
+				};
+				const out = [];
+				const mode = value.answers.failure_mode;
+				if (mode.choice !== "none") out.push(makeFinding({
+					...base,
+					area: "failure-mode",
+					severity: "medium",
+					confidence: mode.confidence,
+					claim: `Failure mode: ${mode.choice}`,
+					claim_id: `failure-mode:${mode.choice}`,
+					rationale: FAILURE_MODE_LABELS[mode.choice]
+				}));
+				const brief = value.answers.delegation_brief;
+				if (brief.choice === "partial" || brief.choice === "missing") out.push(makeFinding({
+					...base,
+					area: "delegation-brief",
+					severity: brief.choice === "missing" ? "high" : "medium",
+					confidence: brief.confidence,
+					claim: `Delegation brief ${brief.choice}`,
+					claim_id: `delegation-brief:${brief.choice}`
+				}));
+				const steer = value.answers.steer_handling;
+				if (steer.choice === "ignored") out.push(makeFinding({
+					...base,
+					area: "steer-handling",
+					severity: "high",
+					confidence: steer.confidence,
+					claim: "Steer ignored",
+					claim_id: "steer-handling:ignored"
+				}));
+				return out;
+			}
+		})
+	};
+}
+//#endregion
+//#region src/analyst/findings-ledger.ts
+/**
+* Findings ledger — analyst findings in the shared ledger-core journal.
+*
+* Each appended finding is one hash-chained, canonical JSON entry, fsynced and
+* pinned to a trusted head, so a later reader can prove nothing was rewritten
+* or cut from the end. A row is validated by `AnalystFindingSchema` before it
+* is written and again when it is read, so a 1.1.0 finding whose declared
+* population disagrees with its evidence never enters the record.
+*
+* Appends are idempotent per (run, finding): replaying a run's findings is a
+* no-op, and the same finding id with different content is a conflict.
+* `FindingsStore` remains the unchained JSONL store for existing consumers.
+*/
+const schema = "agent-eval.findings-ledger.v1";
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+const identity = z.string().min(1).refine((value) => value.trim() === value, { message: "must not carry surrounding space" });
+const eventSchema = z.object({
+	kind: z.literal("finding"),
+	eventId: identity,
+	run_id: identity,
+	finding: AnalystFindingSchema
+}).strict();
+const entrySchema = z.object({
+	schema: z.literal(schema),
+	sequence: z.number().int().nonnegative(),
+	previousHash: digest.nullable(),
+	event: eventSchema,
+	entryHash: digest
+}).strict();
+var FindingsLedgerConflictError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FindingsLedgerConflictError";
+	}
+};
+var FindingsLedgerInvalidError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FindingsLedgerInvalidError";
+	}
+};
+function codec() {
+	return {
+		subject: "findings ledger",
+		header: { schema },
+		integrityError: (message, options) => new Error(message, options),
+		conflictError: (message) => new FindingsLedgerConflictError(message),
+		parseEntry: (raw, context) => {
+			const decoded = entrySchema.safeParse(raw);
+			if (!decoded.success) {
+				const issue = decoded.error.issues[0];
+				throw new FindingsLedgerInvalidError(`findings ledger ${context.path}:${context.line} is invalid at ${(issue?.path ?? []).join(".")}: ${issue?.message}`);
+			}
+			return {
+				...decoded.data,
+				event: decoded.data.event,
+				previousHash: decoded.data.previousHash,
+				entryHash: decoded.data.entryHash
+			};
+		},
+		checkEntryHeader: (entry) => {
+			if (entry.schema !== schema) throw new FindingsLedgerInvalidError("unsupported ledger schema");
+		},
+		createProjector: () => {
+			const rows = [];
+			return {
+				apply: (entry) => {
+					const { event } = entry;
+					if (event.eventId !== eventIdFor(event.run_id, event.finding.finding_id)) throw new FindingsLedgerInvalidError(`event id ${event.eventId} does not name its finding`);
+					rows.push({
+						...event.finding,
+						run_id: event.run_id,
+						sequence: entry.sequence,
+						entryHash: entry.entryHash
+					});
+				},
+				snapshot: () => [...rows]
+			};
+		}
+	};
+}
+function eventIdFor(runId, findingId) {
+	return `finding:${runId}:${findingId}`;
+}
+async function outcome(operation) {
+	try {
+		return {
+			succeeded: true,
+			value: await operation()
+		};
+	} catch (error) {
+		return {
+			succeeded: false,
+			error: {
+				kind: error instanceof FindingsLedgerConflictError ? "conflict" : error instanceof FindingsLedgerInvalidError || error instanceof z.ZodError ? "invalid" : "unavailable",
+				message: error instanceof Error ? error.message : String(error)
+			}
+		};
+	}
+}
+/** Open (or create on first append) the findings journal at `path`; every reopen requires its pin. */
+function openFindingsLedger(options) {
+	if (!options.path.trim()) throw new TypeError("findings ledger: path is empty");
+	const journal = new FileLedgerJournal(options.path, codec(), { requireTrustedHead: true });
+	return {
+		path: journal.path,
+		append: (runId, findings) => outcome(async () => {
+			identity.parse(runId);
+			let appended = 0;
+			let replayed = 0;
+			for (const finding of findings) {
+				const parsed = AnalystFindingSchema.safeParse(finding);
+				if (!parsed.success) {
+					const issue = parsed.error.issues[0];
+					throw new FindingsLedgerInvalidError(`finding ${finding.finding_id} is invalid at ${(issue?.path ?? []).join(".")}: ${issue?.message}`);
+				}
+				if ((await journal.append({
+					kind: "finding",
+					eventId: eventIdFor(runId, finding.finding_id),
+					run_id: runId,
+					finding: parsed.data
+				}, { pinHead: true })).appended) appended += 1;
+				else replayed += 1;
+			}
+			return {
+				appended,
+				replayed
+			};
+		}),
+		read: () => outcome(async () => {
+			const findings = await journal.replay();
+			return {
+				findings,
+				merkleRoot: merkleRoot(findings.map((row) => row.entryHash))
+			};
+		})
+	};
+}
+/** Filter ledger rows. Every set criterion must hold; 1.0.0 rows have no layer and never match one. */
+function queryFindings(rows, query) {
+	const layers = query.layer === void 0 ? null : new Set(typeof query.layer === "string" ? [query.layer] : query.layer);
+	return rows.filter((row) => {
+		if (layers && (row.layer === void 0 || !layers.has(row.layer))) return false;
+		if (query.subject !== void 0 && row.subject !== query.subject) return false;
+		if (query.analystId !== void 0 && row.analyst_id !== query.analystId) return false;
+		if (query.runId !== void 0 && row.run_id !== query.runId) return false;
+		if (query.claimId !== void 0 && row.claim_id !== query.claimId) return false;
+		if (query.domainPath !== void 0) {
+			const path = row.scope?.domain_path;
+			if (!path || path.length < query.domainPath.length) return false;
+			if (query.domainPath.some((id, index) => path[index] !== id)) return false;
+		}
+		return true;
+	});
+}
+/**
+* Diff each run against the run before it, in the order runs first entered
+* the ledger. Uses `diffFindings`, so `appeared`, `disappeared`, `persisted`
+* and `changed` mean exactly what they mean for two runs.
+*/
+function diffFindingsOverTime(rows, policy = {}) {
+	const runs = [];
+	const byRun = /* @__PURE__ */ new Map();
+	for (const row of [...rows].sort((a, b) => a.sequence - b.sequence)) {
+		const list = byRun.get(row.run_id);
+		if (list) list.push(row);
+		else {
+			runs.push(row.run_id);
+			byRun.set(row.run_id, [row]);
+		}
+	}
+	return runs.slice(1).map((runId, index) => ({
+		previous_run_id: runs[index],
+		run_id: runId,
+		diff: diffFindings(byRun.get(runs[index]), byRun.get(runId), policy)
+	}));
+}
+//#endregion
 //#region src/analyst/kinds/skill-usage.ts
 /**
 * Skill-usage analyst — a DETERMINISTIC `Analyst` over a Claude/Codex skill
@@ -377,6 +1052,866 @@ var SkillUsageAnalyst = class {
 };
 const SKILL_USAGE_ANALYST = new SkillUsageAnalyst();
 //#endregion
+//#region src/analyst/promote.ts
+/**
+* Promotion — the only way a claim moves above the layer it was measured at.
+*
+* A claim is restated at a parent node only when at least `k` independent
+* children carry the same `claim_id` with intervals that agree. Otherwise it
+* stays where it is, reported as untested above. The rule is the same on every
+* rung of the ladder: run → play → problem → each domain node up the path →
+* lab.
+*
+* The rule, exactly:
+*   - A finding sits at the node that is the lowest common ancestor of its
+*     `scope.population` in the taxonomy, and that node's layer must equal the
+*     finding's `layer`. Four runs of one play place a claim at that play; the
+*     same claim stored at `domain` or `lab` is refused as exceeding its
+*     evidence.
+*   - Only children with `measure.interval` vote. Voters must name the same
+*     measure and unit, and their intervals must share a common point.
+*   - Children are counted by lineage, not by node: two children whose evidence
+*     units share a lineage root (run 2 built on run 1's code) count once, and
+*     a child with no recorded lineage shares one root with every other such
+*     child.
+*   - Promoted findings cite every voting child by `finding://<finding_id>`.
+*
+* Event, turn, agent, team and meta findings sit outside the ladder and never
+* promote.
+*/
+/** Bump when the promotion rule changes, so promoted findings name the rule that lifted them. */
+const PROMOTE_VERSION = "1";
+/** The analyst id a promoted finding carries when its children came from different analysts. */
+const PROMOTE_ANALYST_ID = "promote";
+const LADDER = [
+	"run",
+	"play",
+	"problem",
+	"domain",
+	"lab"
+];
+function promote(findings, taxonomy, options = {}) {
+	const k = options.k ?? 2;
+	if (!Number.isInteger(k) || k < 2) throw new RangeError(`promote: k must be an integer of at least 2, got ${k}`);
+	const unplaced = [];
+	const buckets = /* @__PURE__ */ new Map();
+	const addPlacement = (placement) => {
+		const depth = taxonomyAncestry(taxonomy, placement.node).length;
+		const bucket = buckets.get(depth) ?? [];
+		bucket.push(placement);
+		buckets.set(depth, bucket);
+	};
+	for (const finding of findings) {
+		const placed = place(finding, taxonomy);
+		if ("reason" in placed) unplaced.push(placed);
+		else addPlacement(placed);
+	}
+	const roots = lineageRoots(mergeEvidenceUnits(findings.flatMap((finding) => finding.evidence_units ?? [])));
+	const promoted = [];
+	const untestedAbove = [];
+	const hold = (placement, reason) => {
+		untestedAbove.push({
+			finding_id: placement.finding.finding_id,
+			claim_id: placement.claimId,
+			node: placement.node,
+			reason
+		});
+	};
+	for (let depth = Math.max(0, ...buckets.keys()); depth > 1; depth -= 1) {
+		const groups = /* @__PURE__ */ new Map();
+		for (const placement of buckets.get(depth) ?? []) {
+			const parent = taxonomyParentOf(taxonomy, placement.node);
+			if (parent === null || parent === void 0) continue;
+			const key = JSON.stringify([placement.claimId, parent]);
+			const group = groups.get(key) ?? {
+				parent,
+				members: []
+			};
+			group.members.push(placement);
+			groups.set(key, group);
+		}
+		for (const { parent, members } of groups.values()) {
+			const verdict = judgeGroup(members, k, roots);
+			if (!verdict.lift) {
+				for (const member of members) hold(member, verdict.reason);
+				continue;
+			}
+			const lifted = liftedFinding(verdict.voters, parent, taxonomy, options.produced_at);
+			promoted.push(lifted);
+			addPlacement({
+				finding: lifted,
+				claimId: members[0].claimId,
+				node: parent
+			});
+			for (const member of members) if (!verdict.voters.includes(member)) hold(member, "no interval, so it could not vote; the claim was lifted by its siblings");
+		}
+	}
+	return {
+		findings: [...findings, ...promoted],
+		promoted,
+		untestedAbove,
+		unplaced
+	};
+}
+function place(finding, taxonomy) {
+	const unplaced = (reason, node = null) => ({
+		finding_id: finding.finding_id,
+		claim_id: finding.claim_id ?? null,
+		node,
+		reason
+	});
+	if (finding.schema_version !== "1.1.0" || !finding.layer || !finding.scope) return unplaced("no layer or scope (schema 1.0.0)");
+	if (finding.layer === "meta") return unplaced("meta findings describe the instrument and never promote");
+	if (!LADDER.includes(finding.layer)) return unplaced(`${finding.layer} findings sit below the run → lab ladder`);
+	if (!finding.claim_id) return unplaced("no claim_id to match siblings by");
+	const population = finding.scope.population;
+	if (population.length === 0) return unplaced("population names no units");
+	const node = lowestCommonAncestor(taxonomy, population);
+	if (node === void 0) return unplaced("population names ids outside the taxonomy");
+	const nodeLayer = taxonomyLayerOf(taxonomy, node);
+	if (nodeLayer !== finding.layer) return unplaced(LADDER.indexOf(finding.layer) > LADDER.indexOf(nodeLayer) ? `stated at ${finding.layer} but its population sits within ${nodeLayer} '${node}'` : `stated at ${finding.layer} but its population spans ${nodeLayer} '${node}'`, node);
+	const path = finding.scope.domain_path;
+	if (path) {
+		const expected = domainPathOf(taxonomy, node);
+		if (path.length !== expected.length || path.some((id, index) => id !== expected[index])) return unplaced(`domain_path ${JSON.stringify(path)} disagrees with the taxonomy`, node);
+	}
+	return {
+		finding,
+		claimId: finding.claim_id,
+		node
+	};
+}
+function judgeGroup(members, k, roots) {
+	const voters = members.filter((member) => member.finding.measure?.interval !== void 0);
+	if (voters.length === 0) return {
+		lift: false,
+		reason: "no child carries an interval"
+	};
+	const first = voters[0].finding.measure;
+	if (voters.some(({ finding }) => finding.measure.name !== first.name || finding.measure.unit !== first.unit)) return {
+		lift: false,
+		reason: "children measure different quantities"
+	};
+	if (Math.max(...voters.map(({ finding }) => finding.measure.interval[0])) > Math.min(...voters.map(({ finding }) => finding.measure.interval[1]))) return {
+		lift: false,
+		reason: "child intervals do not agree"
+	};
+	const independent = independentChildren(voters, roots);
+	if (independent < k) {
+		const children = new Set(voters.map((voter) => voter.node)).size;
+		return {
+			lift: false,
+			reason: children > independent ? `${children} children agree but share lineage, leaving ${independent} independent of ${k} required` : `${independent} independent agreeing child${independent === 1 ? "" : "ren"} of ${k} required`
+		};
+	}
+	return {
+		lift: true,
+		voters
+	};
+}
+/**
+* Children joined when they share a lineage root, counted as components. A
+* child's roots are those of all its voters' evidence units; a voter with no
+* units has unknown lineage.
+*/
+function independentChildren(voters, roots) {
+	const rootsByNode = /* @__PURE__ */ new Map();
+	for (const voter of voters) {
+		const set = rootsByNode.get(voter.node) ?? /* @__PURE__ */ new Set();
+		const units = voter.finding.evidence_units;
+		if (!units) set.add(UNKNOWN_LINEAGE);
+		else for (const unit of units) set.add(roots.get(unit.id) ?? "?unknown-lineage");
+		rootsByNode.set(voter.node, set);
+	}
+	const parent = /* @__PURE__ */ new Map();
+	const find = (id) => {
+		let current = id;
+		while (parent.get(current) !== current) current = parent.get(current);
+		return current;
+	};
+	const owner = /* @__PURE__ */ new Map();
+	for (const [node, nodeRoots] of rootsByNode) {
+		parent.set(node, node);
+		for (const root of nodeRoots) {
+			const other = owner.get(root);
+			if (other === void 0) owner.set(root, node);
+			else parent.set(find(node), find(other));
+		}
+	}
+	return new Set([...rootsByNode.keys()].map(find)).size;
+}
+function liftedFinding(voters, parent, taxonomy, producedAt) {
+	const findings = voters.map((voter) => voter.finding);
+	const first = findings[0];
+	const measures = findings.map((finding) => finding.measure);
+	const level = new Set(measures.map((measure) => measure.level)).size === 1 ? measures[0].level : void 0;
+	const population = [...new Set(findings.flatMap((finding) => finding.scope.population))].sort();
+	const allUnits = findings.every((finding) => finding.evidence_units !== void 0) ? mergeEvidenceUnits(findings.flatMap((finding) => finding.evidence_units)) : void 0;
+	const confounders = [...new Set(findings.flatMap((finding) => finding.confounders ?? []))].sort();
+	const analysts = new Set(findings.map((finding) => finding.analyst_id));
+	const domainPath = domainPathOf(taxonomy, parent);
+	const parentLayer = taxonomyLayerOf(taxonomy, parent);
+	return makeFinding({
+		analyst_id: analysts.size === 1 ? first.analyst_id : PROMOTE_ANALYST_ID,
+		area: first.area,
+		claim: first.claim,
+		claim_id: first.claim_id,
+		id_basis: `${first.claim_id}@${parent}`,
+		subject: parent,
+		severity: mostSevere(findings),
+		confidence: Math.min(...findings.map((finding) => finding.confidence)),
+		evidence_refs: findings.map((finding) => ({
+			kind: "finding",
+			uri: `finding://${finding.finding_id}`
+		})),
+		layer: parentLayer,
+		scope: {
+			population,
+			n: population.length,
+			window: spanningWindow(findings),
+			...domainPath.length > 0 && parent !== "lab" ? { domain_path: domainPath } : {}
+		},
+		method: {
+			kind: "computed",
+			name: "promote",
+			version: "1"
+		},
+		measure: {
+			name: measures[0].name,
+			unit: measures[0].unit,
+			value: measures.reduce((sum, measure) => sum + measure.value, 0) / measures.length,
+			interval: [Math.max(...measures.map((measure) => measure.interval[0])), Math.min(...measures.map((measure) => measure.interval[1]))],
+			...level === void 0 ? {} : { level }
+		},
+		...confounders.length > 0 ? { confounders } : {},
+		...allUnits ? { evidence_units: allUnits } : {},
+		rationale: `Lifted to ${parentLayer} '${parent}': ${new Set(voters.map((voter) => voter.node)).size} children carry claim '${first.claim_id}' with intervals that share [${Math.max(...measures.map((m) => m.interval[0]))}, ${Math.min(...measures.map((m) => m.interval[1]))}].`,
+		metadata: {
+			taxonomy_version: taxonomy.version,
+			promoted_from: [...new Set(voters.map((voter) => voter.node))].sort()
+		},
+		...producedAt === void 0 ? {} : { produced_at: producedAt }
+	});
+}
+//#endregion
+//#region src/analyst/rollup.ts
+/**
+* rollup — run findings aggregated up the ladder, with bootstrap intervals and
+* denominators, lifted only where `promote` allows.
+*
+* Run-layer findings that share a `claim_id` and a measure are pooled per play
+* into one play-layer finding. Its interval is a cluster bootstrap where each
+* cluster is a lineage root, so runs that built on each other move together
+* and four runs of one lineage yield one cluster and no interval. Those play
+* findings then go through `promote`; each finding it lifts to a problem,
+* domain node or the lab gets the pooled bootstrap over every run underneath
+* it, with its observation and cluster counts.
+*/
+const ROLLUP_ANALYST_ID = "rollup";
+const ROLLUP_VERSION = "1";
+function rollupFindings(findings, taxonomy, options = {}) {
+	const confidence = options.confidence ?? .95;
+	const skipped = [];
+	const skip = (finding, reason) => {
+		skipped.push({
+			finding_id: finding.finding_id,
+			claim_id: finding.claim_id ?? null,
+			node: null,
+			reason
+		});
+	};
+	const roots = lineageRoots(findings.flatMap((finding) => finding.evidence_units ?? []));
+	const observations = [];
+	for (const finding of findings) {
+		if (finding.layer !== "run" || !finding.scope) continue;
+		if (!finding.claim_id) {
+			skip(finding, "no claim_id");
+			continue;
+		}
+		if (!finding.measure) {
+			skip(finding, "no measure to aggregate");
+			continue;
+		}
+		const run = lowestCommonAncestor(taxonomy, finding.scope.population);
+		if (run === void 0 || taxonomyLayerOf(taxonomy, run) !== "run") {
+			skip(finding, "population is not one run in the taxonomy");
+			continue;
+		}
+		const units = finding.evidence_units;
+		const runRoots = new Set(units ? units.map((unit) => roots.get(unit.id) ?? "?unknown-lineage") : [UNKNOWN_LINEAGE]);
+		observations.push({
+			finding,
+			claimId: finding.claim_id,
+			run,
+			value: finding.measure.value,
+			cluster: [...runRoots].sort()[0]
+		});
+	}
+	const groups = /* @__PURE__ */ new Map();
+	for (const observation of observations) {
+		const play = taxonomyParentOf(taxonomy, observation.run);
+		const key = JSON.stringify([observation.claimId, play]);
+		const group = groups.get(key) ?? {
+			play,
+			members: []
+		};
+		group.members.push(observation);
+		groups.set(key, group);
+	}
+	const aggregates = [];
+	for (const { play, members } of groups.values()) {
+		const measure = members[0].finding.measure;
+		if (members.some(({ finding }) => finding.measure.name !== measure.name || finding.measure.unit !== measure.unit)) {
+			for (const member of members) skip(member.finding, `runs of play '${play}' measure different quantities`);
+			continue;
+		}
+		const pooled = pool(members, options, confidence);
+		const findingsInGroup = members.map((member) => member.finding);
+		const population = [...new Set(members.map((member) => member.run))].sort();
+		const units = findingsInGroup.every((finding) => finding.evidence_units !== void 0) ? mergeEvidenceUnits(findingsInGroup.flatMap((finding) => finding.evidence_units)) : void 0;
+		const domainPath = domainPathOf(taxonomy, play);
+		const first = findingsInGroup[0];
+		aggregates.push(makeFinding({
+			analyst_id: ROLLUP_ANALYST_ID,
+			area: first.area,
+			claim: first.claim,
+			claim_id: first.claim_id,
+			id_basis: `${first.claim_id}@${play}`,
+			subject: play,
+			severity: mostSevere(findingsInGroup),
+			confidence: Math.min(...findingsInGroup.map((finding) => finding.confidence)),
+			evidence_refs: findingsInGroup.map((finding) => ({
+				kind: "finding",
+				uri: `finding://${finding.finding_id}`
+			})),
+			layer: "play",
+			scope: {
+				population,
+				n: population.length,
+				window: spanningWindow(findingsInGroup),
+				...domainPath.length > 0 ? { domain_path: domainPath } : {}
+			},
+			method: {
+				kind: "computed",
+				name: ROLLUP_ANALYST_ID,
+				version: "1"
+			},
+			measure: {
+				name: measure.name,
+				unit: measure.unit,
+				...pooled.measure
+			},
+			...units ? { evidence_units: units } : {},
+			metadata: { denominators: pooled.denominators },
+			...options.produced_at === void 0 ? {} : { produced_at: options.produced_at }
+		}));
+	}
+	const promotion = promote(aggregates, taxonomy, {
+		...options.k === void 0 ? {} : { k: options.k },
+		...options.produced_at === void 0 ? {} : { produced_at: options.produced_at }
+	});
+	const promoted = promotion.promoted.map((finding) => {
+		const covered = new Set(finding.scope.population);
+		const pooled = pool(observations.filter((observation) => observation.claimId === finding.claim_id && covered.has(observation.run)), options, confidence);
+		return {
+			...finding,
+			measure: {
+				name: finding.measure.name,
+				unit: finding.measure.unit,
+				...pooled.measure
+			},
+			metadata: {
+				...finding.metadata,
+				denominators: pooled.denominators
+			}
+		};
+	});
+	return {
+		findings: [...aggregates, ...promoted],
+		untestedAbove: promotion.untestedAbove,
+		skipped: [...skipped, ...promotion.unplaced]
+	};
+}
+/**
+* Cluster bootstrap of the run values. With one cluster there is no spread
+* between independent sources, so the measure carries no interval and cannot
+* vote in `promote`.
+*/
+function pool(members, options, confidence) {
+	const result = clusterBootstrapMean(members.map((member) => ({
+		cluster: member.cluster,
+		value: member.value
+	})), {
+		confidence,
+		...options.seed === void 0 ? {} : { seed: options.seed },
+		...options.resamples === void 0 ? {} : { resamples: options.resamples }
+	});
+	return {
+		measure: result.clusters >= 2 ? {
+			value: result.mean,
+			interval: [result.low, result.high],
+			level: confidence
+		} : { value: result.mean },
+		denominators: {
+			observations: result.n,
+			independent_clusters: result.clusters
+		}
+	};
+}
+/** The rollup analyst: emits the play aggregates and every finding promote lifted from them. */
+function rollupAnalyst() {
+	return {
+		id: ROLLUP_ANALYST_ID,
+		description: "Aggregates run findings up run → play → problem → domain → lab with bootstrap intervals.",
+		inputKind: "custom",
+		cost: { kind: "deterministic" },
+		version: "1",
+		async analyze(input) {
+			return rollupFindings(input.findings, input.taxonomy, input.options).findings;
+		}
+	};
+}
+//#endregion
+//#region src/analyst/team-shape.ts
+const TEAM_SHAPE_ANALYST_ID = "team-shape";
+const TEAM_SHAPE_THRESHOLDS = {
+	/** Share of the root's children that delegate at or above which depth ≥ 2 is a hive. */
+	hiveDelegatingShare: .5,
+	/** Lateral share of C edges at or above which a one-dispatcher team is a fleet. */
+	fleetLateralCShare: .2,
+	/** Root share of integrating commits at or above which a flat star reads `root integrates`. */
+	rootIntegrationShare: .5
+};
+/** Version 1, provisional, with the thresholds it was decided at. */
+const TEAM_SHAPE_VERSION = `1-provisional;hive-delegating=${TEAM_SHAPE_THRESHOLDS.hiveDelegatingShare};fleet-lateral-c=${TEAM_SHAPE_THRESHOLDS.fleetLateralCShare};root-integration=${TEAM_SHAPE_THRESHOLDS.rootIntegrationShare}`;
+const TEAM_SHAPE_CLASSES = [
+	"single",
+	"governed-swarm",
+	"fleet",
+	"partition",
+	"hive",
+	"star-with-sub-leads",
+	"flat-star"
+];
+const NOT_OBSERVABLE = "not observable from this record";
+/** Team-shape input for a run read through a supervisor-run reader. */
+function teamShapeInputFromSources(sources, integrations) {
+	if (sources.journal === null) return {
+		succeeded: false,
+		error: { message: sources.journalMissingReason ?? `no spawn journal for ${sources.runRef}` }
+	};
+	return {
+		succeeded: true,
+		value: {
+			runRef: sources.runRef,
+			spawnJournal: sources.journal,
+			coordinationLog: sources.coordinationLog ?? null,
+			...integrations === void 0 ? {} : { integrations }
+		}
+	};
+}
+function classifyTeamShape(input) {
+	const spawnLog = parseSpawnRows(input.spawnJournal);
+	const coordination = typeof input.coordinationLog === "string" ? parseCoordinationRows(input.coordinationLog) : null;
+	const spawnedAt = /* @__PURE__ */ new Map();
+	for (const row of spawnLog.rows) {
+		if (row.kind !== "spawned") continue;
+		spawnedAt.set(row.id, Math.min(row.at, spawnedAt.get(row.id) ?? Number.POSITIVE_INFINITY));
+	}
+	const rootIds = [...new Set(spawnLog.rows.filter((row) => row.kind === "spawned" && row.journal === row.id).map((r) => r.id))];
+	if (rootIds.length !== 1) return {
+		succeeded: false,
+		error: { message: `spawn journal for ${input.runRef} has ${rootIds.length} root markers; team-shape needs exactly one` }
+	};
+	const rootId = rootIds[0];
+	const agents = new Set(spawnedAt.keys());
+	const parentOf = /* @__PURE__ */ new Map();
+	let unplacedAgents = 0;
+	for (const id of agents) {
+		if (id === rootId) continue;
+		const parent = pathParent(id);
+		if (parent !== null && agents.has(parent) && id.startsWith(`${rootId}:`)) parentOf.set(id, parent);
+		else unplacedAgents += 1;
+	}
+	const children = /* @__PURE__ */ new Map();
+	const command = /* @__PURE__ */ new Map();
+	for (const [child, parent] of parentOf) {
+		children.set(parent, [...children.get(parent) ?? [], child]);
+		addEdge(command, parent, child);
+	}
+	const depthOf = (id) => {
+		let hops = 0;
+		for (let at = parentOf.get(id); at !== void 0; at = parentOf.get(at)) hops += 1;
+		return hops;
+	};
+	const depth = Math.max(0, ...[...parentOf.keys()].map(depthOf));
+	const rootChildren = children.get(rootId) ?? [];
+	const leads = rootChildren.filter((child) => (children.get(child)?.length ?? 0) > 0);
+	const delegatingShare = rootChildren.length === 0 ? null : leads.length / rootChildren.length;
+	const subtreeOf = (id) => {
+		let at = id;
+		while (at !== void 0 && parentOf.get(at) !== rootId) at = parentOf.get(at);
+		return at ?? null;
+	};
+	let peerSpawns = 0;
+	for (const row of spawnLog.rows) {
+		if (row.kind !== "spawned" || row.id === rootId) continue;
+		if (row.owner !== row.id && row.owner !== parentOf.get(row.id)) peerSpawns += 1;
+	}
+	const governance = /* @__PURE__ */ new Map();
+	const settlementsByReceiver = {};
+	const governorsByParent = /* @__PURE__ */ new Map();
+	const governorsOf = (child) => {
+		const parent = parentOf.get(child) ?? `unplaced:${child}`;
+		const entry = governorsByParent.get(parent) ?? {
+			agents: /* @__PURE__ */ new Set(),
+			digests: /* @__PURE__ */ new Set()
+		};
+		governorsByParent.set(parent, entry);
+		return entry;
+	};
+	let gResolved = 0;
+	let gUnresolved = 0;
+	let gNonParent = 0;
+	let firstSettlement = Number.POSITIVE_INFINITY;
+	for (const row of spawnLog.rows) {
+		if (row.kind !== "settled" || row.owner === row.id) continue;
+		firstSettlement = Math.min(firstSettlement, row.at);
+		settlementsByReceiver[row.owner] = (settlementsByReceiver[row.owner] ?? 0) + 1;
+		addEdge(governance, row.owner, row.id);
+		governorsOf(row.id).agents.add(row.owner);
+		gResolved += 1;
+		if (parentOf.get(row.id) !== row.owner) gNonParent += 1;
+	}
+	const reHires = [...spawnedAt.entries()].filter(([id, at]) => id !== rootId && at > firstSettlement).length;
+	const communication = /* @__PURE__ */ new Map();
+	let messages = 0;
+	let cResolved = 0;
+	let cUnresolved = 0;
+	let cLateral = 0;
+	let cCrossSubtree = 0;
+	let gCrossSubtree = 0;
+	const steers = {
+		sent: 0,
+		delivered: 0
+	};
+	const isAgent = (value) => value !== void 0 && agents.has(value);
+	for (const row of coordination?.rows ?? []) {
+		if (row.type === "instruction" || row.type === "delivery-attempt") continue;
+		if (row.toWorker === void 0 && row.from === void 0 && row.by === void 0) continue;
+		messages += 1;
+		if (row.type === "steer") {
+			steers.sent += 1;
+			if (row.delivered === true) steers.delivered += 1;
+		}
+		if (!isAgent(row.toWorker) || row.delivered === false) continue;
+		const receiver = row.toWorker;
+		const agentSender = [row.from, row.by].find(isAgent);
+		const sender = agentSender ?? (row.owner === null ? null : `owner:${row.owner}`);
+		if (sender === null) continue;
+		addEdge(communication, sender, receiver);
+		if (agentSender === void 0) cUnresolved += 1;
+		else {
+			cResolved += 1;
+			const parent = parentOf.get(receiver);
+			if (parent !== void 0 && parent === parentOf.get(agentSender)) cLateral += 1;
+			if (crosses(subtreeOf(agentSender), subtreeOf(receiver))) cCrossSubtree += 1;
+		}
+		if (row.type === "steer") {
+			addEdge(governance, sender, receiver);
+			if (agentSender === void 0) {
+				gUnresolved += 1;
+				governorsOf(receiver).digests.add(sender);
+			} else {
+				gResolved += 1;
+				governorsOf(receiver).agents.add(agentSender);
+				if (parentOf.get(receiver) !== agentSender) gNonParent += 1;
+				if (crosses(subtreeOf(agentSender), subtreeOf(receiver))) gCrossSubtree += 1;
+			}
+		}
+	}
+	for (const [child, receiver] of spawnLog.rows.filter((row) => row.kind === "settled" && row.owner !== row.id).map((row) => [row.id, row.owner])) if (crosses(subtreeOf(receiver), subtreeOf(child))) gCrossSubtree += 1;
+	const cTotal = cResolved + cUnresolved;
+	const gTotal = gResolved + gUnresolved;
+	const lateralCShare = coordination === null || cTotal === 0 || cUnresolved > 0 ? NOT_OBSERVABLE : cLateral / cTotal;
+	const nonParentGShare = gTotal === 0 || gUnresolved > 0 ? NOT_OBSERVABLE : gNonParent / gTotal;
+	const integrations = input.integrations ?? [];
+	const rootIntegrationShare = integrations.length === 0 ? NOT_OBSERVABLE : integrations.filter((row) => row.by === rootId).length / integrations.length;
+	const features = {
+		agents: agents.size,
+		tasks: agents.size - 1,
+		unplacedAgents,
+		depth,
+		fanOut: {
+			root: rootChildren.length,
+			max: Math.max(0, ...[...children.values()].map((c) => c.length))
+		},
+		delegatingShare,
+		reHires,
+		settlementsByReceiver,
+		steers,
+		messagesPerTask: coordination === null || agents.size < 2 ? null : messages / (agents.size - 1),
+		lateralCShare,
+		nonParentGShare,
+		rootIntegrationShare
+	};
+	const checks = {};
+	checks.single = verdict(agents.size === 1, `${agents.size} agents`);
+	const rotating = [...governorsByParent.entries()].find(([, g]) => g.agents.size > 1);
+	const digestTeams = [...governorsByParent.values()].filter((g) => g.digests.size > 1).length;
+	checks["governed-swarm"] = peerSpawns > 0 ? {
+		result: "yes",
+		reason: `${peerSpawns} spawns recorded by a peer, not the parent`
+	} : rotating !== void 0 ? {
+		result: "yes",
+		reason: `children of ${rotating[0]} are governed by ${[...rotating[1].agents].join(", ")}`
+	} : digestTeams > 0 ? {
+		result: NOT_OBSERVABLE,
+		reason: `${digestTeams} teams were steered by more than one owner digest; a digest is not an agent id, so a rotating governor cannot be told from the operator`
+	} : {
+		result: "no",
+		reason: "every E edge runs parent to child and no team changed governor"
+	};
+	const dispatchers = [...children.keys()];
+	if (dispatchers.length !== 1 || unplacedAgents > 0) checks.fleet = {
+		result: unplacedAgents > 0 && dispatchers.length <= 1 ? NOT_OBSERVABLE : "no",
+		reason: unplacedAgents > 0 && dispatchers.length <= 1 ? `${unplacedAgents} unplaced agents hide who dispatched their work` : `${dispatchers.length} agents dispatch work`
+	};
+	else if (gNonParent > 0) checks.fleet = {
+		result: "yes",
+		reason: `${gNonParent} G edges come from a non-parent agent`
+	};
+	else if (cLateral / Math.max(cTotal, 1) >= TEAM_SHAPE_THRESHOLDS.fleetLateralCShare) checks.fleet = {
+		result: "yes",
+		reason: `lateral C ${cLateral} of ${cTotal}`
+	};
+	else if (gUnresolved > 0 || lateralCShare === "not observable from this record") checks.fleet = {
+		result: NOT_OBSERVABLE,
+		reason: `one dispatcher; ${gUnresolved} steer G and ${cUnresolved} C edges are sent from owner digests that no record joins to an agent${coordination === null ? ", and the run has no coordination log" : ""}`
+	};
+	else checks.fleet = verdict(false, `one dispatcher, no non-parent G, lateral C ${cLateral} of ${cTotal}`);
+	const rootSettledByLeads = spawnLog.rows.filter((row) => row.kind === "settled" && row.owner === rootId && leads.includes(row.id)).length;
+	if (leads.length < 2 || rootSettledByLeads > 0 || gCrossSubtree > 0 || cCrossSubtree > 0) checks.partition = verdict(false, `${leads.length} lead subtrees, ${rootSettledByLeads} lead settlements to the root, ${gCrossSubtree + cCrossSubtree} edges between subtrees`);
+	else if (gUnresolved > 0 || cUnresolved > 0 || coordination === null) checks.partition = {
+		result: NOT_OBSERVABLE,
+		reason: `${leads.length} lead subtrees and no lead settles to the root, but edges sent from owner digests cannot be placed in a subtree`
+	};
+	else checks.partition = verdict(true, `${leads.length} lead subtrees with no C or G between them`);
+	const delegating = `${leads.length} of ${rootChildren.length} root children delegate`;
+	const hive = depth >= 2 && (delegatingShare ?? 0) >= TEAM_SHAPE_THRESHOLDS.hiveDelegatingShare;
+	checks.hive = verdict(hive, `depth ${depth}; ${delegating}`);
+	checks["star-with-sub-leads"] = verdict(depth >= 2 && !hive, `depth ${depth}; ${delegating}`);
+	checks["flat-star"] = verdict(depth === 1, `depth ${depth}`);
+	const shapeClass = TEAM_SHAPE_CLASSES.find((name) => checks[name].result === "yes");
+	if (shapeClass === void 0) return {
+		succeeded: false,
+		error: { message: `no team-shape class matches ${input.runRef} (depth ${depth})` }
+	};
+	const qualifier = shapeClass !== "flat-star" ? null : rootIntegrationShare === "not observable from this record" ? "integration unknown" : rootIntegrationShare >= TEAM_SHAPE_THRESHOLDS.rootIntegrationShare ? "root integrates" : "root does not integrate";
+	const label = shapeClass === "hive" ? `hive depth ${depth}` : qualifier === null ? shapeClass : `${shapeClass} (${qualifier})`;
+	const times = [...spawnLog.rows.map((row) => row.at), ...(coordination?.rows ?? []).flatMap((row) => row.at === null ? [] : [row.at])];
+	return {
+		succeeded: true,
+		value: {
+			class: shapeClass,
+			depth,
+			qualifier,
+			label,
+			rootId,
+			features,
+			checks,
+			graph: {
+				command: [...command.values()],
+				governance: [...governance.values()],
+				communication: [...communication.values()]
+			},
+			invalidRows: {
+				spawn: spawnLog.invalid,
+				coordination: coordination?.invalid ?? 0
+			},
+			window: times.length === 0 ? null : {
+				from: new Date(Math.min(...times)).toISOString(),
+				to: new Date(Math.max(...times)).toISOString()
+			}
+		}
+	};
+}
+function verdict(holds, reason) {
+	return {
+		result: holds ? "yes" : "no",
+		reason
+	};
+}
+function crosses(a, b) {
+	return a !== null && b !== null && a !== b;
+}
+function pathParent(id) {
+	const match = /^(.+):s\d+$/.exec(id);
+	return match ? match[1] : null;
+}
+function addEdge(edges, from, to) {
+	const key = JSON.stringify([from, to]);
+	const edge = edges.get(key);
+	if (edge) edge.count += 1;
+	else edges.set(key, {
+		from,
+		to,
+		count: 1
+	});
+}
+function jsonLines(text) {
+	return text.split("\n").filter((line) => line.trim()).map((line) => {
+		try {
+			const value = JSON.parse(line);
+			return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+		} catch {
+			return null;
+		}
+	});
+}
+function asRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function epochMs(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string") {
+		const ms = Date.parse(value);
+		return Number.isNaN(ms) ? null : ms;
+	}
+	return null;
+}
+/**
+* Spawned and settled rows from a Runtime envelope (`{ root, event }`) or a
+* reduced row (`{ kind, journal, id, at }`). Other Runtime event kinds are
+* read and skipped; a spawned or settled row without an id, journal or time
+* is invalid.
+*/
+function parseSpawnRows(text) {
+	const rows = [];
+	let invalid = 0;
+	for (const line of jsonLines(text)) {
+		if (line === null) {
+			invalid += 1;
+			continue;
+		}
+		const event = asRecord(line.event) ?? line;
+		const journal = event === line ? line.journal : line.root;
+		const { kind, id } = event;
+		if (kind !== "spawned" && kind !== "settled") continue;
+		const at = epochMs(event.at);
+		if (typeof id !== "string" || typeof journal !== "string" || at === null) {
+			invalid += 1;
+			continue;
+		}
+		rows.push({
+			kind,
+			journal,
+			owner: journal.slice(journal.lastIndexOf("/") + 1),
+			id,
+			at
+		});
+	}
+	return {
+		rows,
+		invalid
+	};
+}
+/**
+* Coordination rows from a Runtime record (`{ at, ownerId, event: { type,
+* <body> } }`, endpoints inside the event's one object-valued field) or a
+* reduced row (`{ at, type, owner, ... }`).
+*/
+function parseCoordinationRows(text) {
+	const rows = [];
+	let invalid = 0;
+	for (const line of jsonLines(text)) {
+		const event = line === null ? null : asRecord(line.event) ?? line;
+		if (line === null || event === null || typeof event.type !== "string") {
+			invalid += 1;
+			continue;
+		}
+		const body = event === line ? line : Object.entries(event).filter(([key]) => key !== "type").map(([, value]) => asRecord(value)).find((value) => value !== null) ?? {};
+		const owner = typeof line.owner === "string" ? line.owner : line.ownerId;
+		const row = {
+			at: epochMs(line.at),
+			type: event.type,
+			owner: typeof owner === "string" && owner ? owner : null
+		};
+		for (const key of [
+			"toWorker",
+			"from",
+			"by"
+		]) {
+			const value = body[key];
+			if (typeof value === "string") row[key] = value;
+		}
+		const delivered = body.delivered ?? line.delivered;
+		if (typeof delivered === "boolean") row.delivered = delivered;
+		rows.push(row);
+	}
+	return {
+		rows,
+		invalid
+	};
+}
+/**
+* The team-shape analyst: one `team`-layer finding per run naming its class,
+* with the features and every class check in metadata. A record with no
+* timestamps fails the analyst instead of emitting a shape it did not measure.
+*/
+function teamShapeAnalyst() {
+	return {
+		id: TEAM_SHAPE_ANALYST_ID,
+		description: "Classifies a supervision tree as single, governed swarm, fleet, partition, hive, star with sub-leads or flat star.",
+		inputKind: "custom",
+		cost: { kind: "deterministic" },
+		version: TEAM_SHAPE_VERSION,
+		async analyze(input) {
+			const outcome = classifyTeamShape(input);
+			if (!outcome.succeeded) throw new Error(`team-shape: ${outcome.error.message}`);
+			const shape = outcome.value;
+			if (shape.window === null) throw new Error(`team-shape: record for ${input.runRef} carries no event timestamps`);
+			return [makeFinding({
+				analyst_id: TEAM_SHAPE_ANALYST_ID,
+				area: "team-shape",
+				severity: "info",
+				confidence: 1,
+				subject: shape.rootId,
+				claim: `Team shape is ${shape.label}`,
+				claim_id: `team-shape:${shape.class}`,
+				evidence_refs: [{
+					kind: "artifact",
+					uri: input.runRef
+				}],
+				layer: "team",
+				scope: {
+					population: [input.runRef],
+					n: 1,
+					window: shape.window
+				},
+				method: {
+					kind: "computed",
+					name: TEAM_SHAPE_ANALYST_ID,
+					version: TEAM_SHAPE_VERSION
+				},
+				metadata: {
+					class: shape.class,
+					depth: shape.depth,
+					qualifier: shape.qualifier,
+					features: shape.features,
+					checks: shape.checks,
+					edges: {
+						command: shape.graph.command.length,
+						governance: shape.graph.governance.length,
+						communication: shape.graph.communication.length
+					},
+					invalid_rows: shape.invalidRows
+				}
+			})];
+		}
+	};
+}
+//#endregion
 //#region src/analyst/trace-questions.ts
 const QUESTION_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u;
 const DEFINITION_VERSION = "1.0.0";
@@ -582,6 +2117,6 @@ function errorText(error) {
 	return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
 }
 //#endregion
-export { AGENT_RX_UPSTREAM_REVISION, ANALYST_BENCHMARK_COST_LEDGER_FILE, ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM, ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES, ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM, ANALYST_BENCHMARK_IMPLEMENTATION_FILES, ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, ANALYST_BENCHMARK_MANIFEST_FILE, ANALYST_BENCHMARK_OBSERVATIONS_FILE, AnalystExpressivenessError, AnalystRegistry, CODE_TRACE_BENCH_ANALYST_PROMPT, CONTROL_INTEGRITY_ANALYST, ControlIntegrityAnalyst, DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES, DEFAULT_TRACE_ANALYST_KINDS, DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS, ExactAnalystRunExecutionError, FAILURE_MODE_KIND_SPEC, FINDING_SUBJECT_KINDS, FINDING_SUBJECT_SYNTAX, FindingsStore, IMPROVEMENT_KIND_SPEC, KIND_EXPECTED_SUBJECTS, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, MAX_INCORRECT_BLOCKS, MAX_INCORRECT_BLOCK_STEPS, RAW_FINDING_SCHEMA_PROMPT, RawAnalystFindingSchema, SKILL_USAGE_ANALYST, adaptPublicBenchmarkFindings, agentRxBenchmarkCase, agentRxPredictionsToFindings, analystBenchmarkDependencyLockDigest, analystBenchmarkImplementationDigest, analystDefinitionAsymmetries, analystDefinitionProtocolSha256, analystInstructionsOverrideFromText, analystUsageReceiptFromPrimeUsage, appendVerificationArtifactsToOtlp, askTraceQuestions, assertProposalFindings, behavioralAnalyst, bindAnalyst, buildDefaultAnalystRegistry, buildPrimePrompt, buildPrimeRepairPrompt, buildSkillUsageReport, buildTraceToolsForGroup, citedSpansOnly, codeTraceBenchCase, codeTracerPredictionsToFindings, coerceJson, compareAnalystRunners, computeFindingId, createChatClient, createChatTraceEngine, createDspyRlmTraceEngine, createPrimeBenchmarkRunner, createPublicBenchmarkDirectRunner, createPublicBenchmarkRlmRunner, createSemanticConceptJudgeAdapter, createTraceAnalyst, decodeReplyRows, defaultIsMaterial, defineCustomAnalyst, defineTraceAnalyst, deriveEfficiencyFindings, diffFindings, effectiveAnalystProtocolSha256, emitControlIntegrityFindings, emitSkillUsageFindings, emptyPrimeRawUsage, emptyPublicBenchmarkRunner, evidenceRefsFromRawFinding, expandCodeTraceFailureBlocks, extractPrimeJsonObject, findingSubjectGrammarPromptFor, isProposalFinding, loadCodeTraceVerificationArtifacts, loadPublicBenchmarkRows, makeFinding, makeProposalFinding, mergePrimeRawUsage, nodeHttpPrimeBridgeTransport, normalizeAgentRxCategory, normalizeBenchmarkLabel, normalizePrimeUsage, parseFindingSubject, parseRawFinding, parseVerificationOutcome, preparePublicAnalystBenchmark, primeAnalystProtocolSha256, primeCodeTraceAnalystDefinition, primeProtocolSha256, primeReplyDefect, projectPrimeTrajectory, publicBenchmarkDistributions, publicBenchmarkProtocolSha256, publicBenchmarkRlmInstructions, publicBenchmarkSelectionReport, publicBenchmarkSystemPrompt, publicDirectAnalystDefinition, publicRlmAnalystDefinition, readAnalystBenchmarkArtifact, readAnalystInstructionsOverride, registryBenchmarkRunner, renderAgentRxCalibrationMarkdown, renderAnalystBenchmarkMarkdown, renderCodeTraceCalibrationMarkdown, renderFindingSubject, renderPriorFindings, resolveTraceAnalystLimits, rlmEngineLimits, roundAgentRxStep, runAnalystBenchmark, runAnalystBenchmarkCommand, runPrimeExchange, runTraceAnalyst, scoreAnalystFindings, selectPublicBenchmarkRows, stripCodeFences, summarizeAgentRxCalibration, summarizeAnalystBenchmarkRunner, summarizeCodeTraceCalibration, traceStoreEvidenceResolver };
+export { AGENT_RX_FAILURE_MODE_MAP, AGENT_RX_UPSTREAM_REVISION, ANALYST_BENCHMARK_COST_LEDGER_FILE, ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM, ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES, ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256, ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM, ANALYST_BENCHMARK_IMPLEMENTATION_FILES, ANALYST_BENCHMARK_IMPLEMENTATION_SHA256, ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE, ANALYST_BENCHMARK_MANIFEST_FILE, ANALYST_BENCHMARK_OBSERVATIONS_FILE, ANALYST_FINDING_SCHEMA_VERSIONS, AnalystExpressivenessError, AnalystFindingSchema, AnalystRegistry, CODE_TRACE_BENCH_ANALYST_PROMPT, CONTROL_INTEGRITY_ANALYST, ControlIntegrityAnalyst, DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES, DEFAULT_TRACE_ANALYST_KINDS, DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS, DOMAIN_TAXONOMY_SCHEMA, ExactAnalystRunExecutionError, FAILURE_MODES_ANALYST_ID, FAILURE_MODES_MIN_KAPPA, FAILURE_MODES_QUESTIONS, FAILURE_MODES_VERSION, FAILURE_MODE_KIND_SPEC, FAILURE_MODE_LABELS, FINDING_LAYERS, FINDING_SCOPE_FIELDS, FINDING_SUBJECT_KINDS, FINDING_SUBJECT_SYNTAX, FindingsStore, IMPROVEMENT_KIND_SPEC, KIND_EXPECTED_SUBJECTS, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, LAB_NODE_ID, MAX_INCORRECT_BLOCKS, MAX_INCORRECT_BLOCK_STEPS, NOT_OBSERVABLE, PROMOTE_ANALYST_ID, PROMOTE_VERSION, ProposalFindingSchema, RAW_FINDING_SCHEMA_PROMPT, ROLLUP_ANALYST_ID, ROLLUP_VERSION, RawAnalystFindingSchema, SKILL_USAGE_ANALYST, TAXONOMY_NODE_LAYERS, TEAM_SHAPE_ANALYST_ID, TEAM_SHAPE_CLASSES, TEAM_SHAPE_THRESHOLDS, TEAM_SHAPE_VERSION, UNKNOWN_LINEAGE, adaptPublicBenchmarkFindings, agentRxBenchmarkCase, agentRxPredictionsToFindings, analystBenchmarkDependencyLockDigest, analystBenchmarkImplementationDigest, analystDefinitionAsymmetries, analystDefinitionProtocolSha256, analystInstructionsOverrideFromText, analystUsageReceiptFromPrimeUsage, appendVerificationArtifactsToOtlp, askTraceQuestions, assertProposalFindings, attachToTaxonomy, behavioralAnalyst, bindAnalyst, buildDefaultAnalystRegistry, buildPrimePrompt, buildPrimeRepairPrompt, buildSkillUsageReport, buildTraceToolsForGroup, calibrateFailureModes, citedSpansOnly, classifyTeamShape, codeTraceBenchCase, codeTracerPredictionsToFindings, coerceJson, compareAnalystRunners, computeFindingId, createChatClient, createChatTraceEngine, createDspyRlmTraceEngine, createFailureModesAnalyst, createPrimeBenchmarkRunner, createPublicBenchmarkDirectRunner, createPublicBenchmarkRlmRunner, createSemanticConceptJudgeAdapter, createTraceAnalyst, decodeReplyRows, defaultIsMaterial, defineCustomAnalyst, defineDomainTaxonomy, defineTraceAnalyst, deriveEfficiencyFindings, diffFindings, diffFindingsOverTime, domainPathOf, effectiveAnalystProtocolSha256, emitControlIntegrityFindings, emitSkillUsageFindings, emptyPrimeRawUsage, emptyPublicBenchmarkRunner, evidenceRefsFromRawFinding, expandCodeTraceFailureBlocks, extractPrimeJsonObject, findingLayerRank, findingSubjectGrammarPromptFor, independentUnitCount, isProposalFinding, lineageRoots, loadCodeTraceVerificationArtifacts, loadFailureModeGold, loadPublicBenchmarkRows, lowestCommonAncestor, makeFinding, makeProposalFinding, mergeEvidenceUnits, mergePrimeRawUsage, nodeHttpPrimeBridgeTransport, normalizeAgentRxCategory, normalizeBenchmarkLabel, normalizePrimeUsage, openFindingsLedger, parseAnalystFinding, parseFailureModeGold, parseFindingSubject, parseRawFinding, parseVerificationOutcome, preparePublicAnalystBenchmark, primeAnalystProtocolSha256, primeCodeTraceAnalystDefinition, primeProtocolSha256, primeReplyDefect, projectPrimeTrajectory, promote, publicBenchmarkDistributions, publicBenchmarkProtocolSha256, publicBenchmarkRlmInstructions, publicBenchmarkSelectionReport, publicBenchmarkSystemPrompt, publicDirectAnalystDefinition, publicRlmAnalystDefinition, queryFindings, readAnalystBenchmarkArtifact, readAnalystInstructionsOverride, readFindingScope, registryBenchmarkRunner, renderAgentRxCalibrationMarkdown, renderAnalystBenchmarkMarkdown, renderCodeTraceCalibrationMarkdown, renderFindingSubject, renderPriorFindings, resolveDomainPath, resolveTraceAnalystLimits, rlmEngineLimits, rollupAnalyst, rollupFindings, roundAgentRxStep, runAnalystBenchmark, runAnalystBenchmarkCommand, runPrimeExchange, runTraceAnalyst, scoreAnalystFindings, selectPublicBenchmarkRows, stripCodeFences, summarizeAgentRxCalibration, summarizeAnalystBenchmarkRunner, summarizeCodeTraceCalibration, taxonomyAncestry, taxonomyLayerOf, taxonomyParentOf, teamShapeAnalyst, teamShapeInputFromSources, traceStoreEvidenceResolver };
 
 //# sourceMappingURL=index.js.map