@tangle-network/agent-eval 0.136.0 → 0.137.0

package/dist/integrity-CCXTftiL.js

@@ -0,0 +1,1360 @@
+import { f as isRolloutLine, i as ROLLOUT_SCHEMA, m as validateRolloutLine } from "./schema-C6DW4ZHR.js";
+import { c as unscreenedRewardFields } from "./reward-nw2xZGZG.js";
+//#region src/supervisor-run/integrity-issues.ts
+function evidence(path, value) {
+	return {
+		path,
+		value
+	};
+}
+function issue(init) {
+	return {
+		...init,
+		evidence: init.evidence ?? []
+	};
+}
+//#endregion
+//#region src/supervisor-run/integrity-steer.ts
+function idListDetail(ids) {
+	const examples = ids.slice(0, 20).map((id) => JSON.stringify(id)).join(", ");
+	return ids.length <= 20 ? examples : `${examples}, and ${ids.length - 20} more`;
+}
+function steerIssues(joined, rootCompleted) {
+	const { facts } = joined;
+	const subject = facts.workerId ?? joined.spawn.id;
+	const prefix = `workers/${facts.sourceIndex}`;
+	const out = [];
+	if (!facts.inboxCaptured || !facts.eventsCaptured || facts.inboxInvalidRows > 0 || facts.eventsInvalidRows > 0) {
+		const missing = [...facts.inboxCaptured ? [] : ["inbox"], ...facts.eventsCaptured ? [] : ["events"]];
+		const malformed = [...facts.inboxInvalidRows > 0 ? [`inbox:${facts.inboxInvalidRows}`] : [], ...facts.eventsInvalidRows > 0 ? [`events:${facts.eventsInvalidRows}`] : []];
+		out.push(issue({
+			code: "worker-controls-unavailable",
+			area: "capture-integrity",
+			severity: "medium",
+			subject,
+			claim: "Steer delivery integrity is unavailable for a worker with missing control artifacts",
+			detail: missing.length > 0 ? `${JSON.stringify(subject)} is missing ${missing.join(" and ")}.` : `${JSON.stringify(subject)} has malformed control rows (${malformed.join(", ")}).`,
+			evidence: [
+				...missing.map((artifact) => evidence(`${prefix}/${artifact}`, null)),
+				...facts.inboxInvalidRows > 0 ? [evidence(`${prefix}/inbox/malformed-rows/count`, facts.inboxInvalidRows)] : [],
+				...facts.eventsInvalidRows > 0 ? [evidence(`${prefix}/events/malformed-rows/count`, facts.eventsInvalidRows)] : []
+			],
+			recommendedAction: "Retain both control artifacts and repair malformed rows before correlating requests.",
+			metadata: {
+				assessment: "unavailable",
+				missing_artifacts: missing,
+				malformed_rows: malformed
+			}
+		}));
+		return out;
+	}
+	const requestsById = /* @__PURE__ */ new Map();
+	const unidentifiedRequests = facts.steerRequests.filter((request) => request.requestId === null);
+	for (const request of facts.steerRequests) {
+		if (request.requestId === null) continue;
+		const rows = requestsById.get(request.requestId) ?? [];
+		rows.push(request);
+		requestsById.set(request.requestId, rows);
+	}
+	if (unidentifiedRequests.length > 0) out.push(issue({
+		code: "steer-request-id-unavailable",
+		area: "capture-integrity",
+		severity: "high",
+		subject,
+		claim: "Some queued steer requests cannot be correlated because their ids are missing",
+		detail: `${unidentifiedRequests.length} queued request(s) omit id.`,
+		evidence: unidentifiedRequests.slice(0, 20).map((request) => evidence(`${prefix}/inbox/${request.row}/id`, null)),
+		recommendedAction: "Assign one stable request id before appending a steer to the inbox.",
+		metadata: {
+			assessment: "unavailable",
+			unavailable_count: unidentifiedRequests.length
+		}
+	}));
+	const duplicateRequestIds = [...requestsById].filter(([, rows]) => rows.length > 1).map(([id]) => id);
+	if (duplicateRequestIds.length > 0) out.push(issue({
+		code: "duplicate-steer-request-id",
+		area: "control-integrity",
+		severity: "high",
+		subject,
+		claim: "A worker inbox contains duplicate steer request ids",
+		detail: `${duplicateRequestIds.length} duplicate id(s): ${idListDetail(duplicateRequestIds)}.`,
+		evidence: [evidence(`${prefix}/inbox/duplicate-request-ids`, duplicateRequestIds.slice(0, 20))],
+		recommendedAction: "Generate a unique request id for every queued steer."
+	}));
+	const acknowledgementsById = /* @__PURE__ */ new Map();
+	const unidentifiedAcks = facts.steerAcknowledgements.filter((ack) => ack.requestId === null);
+	for (const ack of facts.steerAcknowledgements) {
+		if (ack.requestId === null) continue;
+		const rows = acknowledgementsById.get(ack.requestId) ?? [];
+		rows.push(ack);
+		acknowledgementsById.set(ack.requestId, rows);
+	}
+	if (unidentifiedAcks.length > 0) out.push(issue({
+		code: "steer-ack-id-unavailable",
+		area: "capture-integrity",
+		severity: "high",
+		subject,
+		claim: "Some steer acknowledgements cannot be correlated because requestId is missing",
+		detail: `${unidentifiedAcks.length} down-leg event(s) omit requestId.`,
+		evidence: unidentifiedAcks.slice(0, 20).map((ack) => evidence(`${prefix}/events/${ack.row}/requestId`, null)),
+		recommendedAction: "Echo the queued request id on every worker acknowledgement.",
+		metadata: {
+			assessment: "unavailable",
+			unavailable_count: unidentifiedAcks.length
+		}
+	}));
+	const unknownAckIds = [...acknowledgementsById.keys()].filter((id) => !requestsById.has(id));
+	if (unknownAckIds.length > 0) out.push(issue({
+		code: "unknown-steer-ack",
+		area: "control-integrity",
+		severity: "high",
+		subject,
+		claim: "A worker acknowledged steer request ids absent from its captured inbox",
+		detail: `${unknownAckIds.length} unknown id(s): ${idListDetail(unknownAckIds)}.`,
+		evidence: [evidence(`${prefix}/events/unknown-request-ids`, unknownAckIds.slice(0, 20))],
+		recommendedAction: "Reject acknowledgements whose request id was not queued for this worker."
+	}));
+	const duplicateAckIds = [...acknowledgementsById].filter(([, rows]) => rows.length > 1).map(([id]) => id);
+	if (duplicateAckIds.length > 0) out.push(issue({
+		code: "duplicate-steer-ack",
+		area: "control-integrity",
+		severity: "high",
+		subject,
+		claim: "A worker emitted duplicate acknowledgements for steer request ids",
+		detail: `${duplicateAckIds.length} duplicated id(s): ${idListDetail(duplicateAckIds)}.`,
+		evidence: [evidence(`${prefix}/events/duplicate-request-ids`, duplicateAckIds.slice(0, 20))],
+		recommendedAction: "Make steer acknowledgement append idempotent by request id."
+	}));
+	const missingAckIds = [...requestsById.keys()].filter((id) => !acknowledgementsById.has(id));
+	if (rootCompleted && missingAckIds.length > 0) out.push(issue({
+		code: "missing-steer-ack",
+		area: "control-integrity",
+		severity: "high",
+		subject,
+		claim: "A completed supervisor run has queued steer requests without acknowledgements",
+		detail: `${missingAckIds.length}/${requestsById.size} request id(s) are unacknowledged: ${idListDetail(missingAckIds)}.`,
+		evidence: [evidence(`${prefix}/inbox/unacknowledged-request-ids`, missingAckIds.slice(0, 20))],
+		recommendedAction: "Record one delivered or failed acknowledgement for every queued request id."
+	}));
+	const statusUnavailableIds = [];
+	const notDeliveredIds = [];
+	for (const [id, acknowledgements] of acknowledgementsById) {
+		if (!requestsById.has(id) || acknowledgements.length !== 1) continue;
+		const delivered = acknowledgements[0]?.delivered;
+		if (delivered === null || delivered === void 0) statusUnavailableIds.push(id);
+		else if (!delivered) notDeliveredIds.push(id);
+	}
+	if (statusUnavailableIds.length > 0) out.push(issue({
+		code: "steer-ack-status-unavailable",
+		area: "capture-integrity",
+		severity: "high",
+		subject,
+		claim: "Some steer acknowledgements omit delivery status",
+		detail: `${statusUnavailableIds.length} id(s): ${idListDetail(statusUnavailableIds)}.`,
+		evidence: [evidence(`${prefix}/events/status-unavailable-request-ids`, statusUnavailableIds.slice(0, 20))],
+		recommendedAction: "Record delivered: true or delivered: false on each acknowledgement.",
+		metadata: {
+			assessment: "unavailable",
+			unavailable_count: statusUnavailableIds.length
+		}
+	}));
+	if (notDeliveredIds.length > 0) out.push(issue({
+		code: "steer-not-delivered",
+		area: "control-integrity",
+		severity: "high",
+		subject,
+		claim: "Queued steer requests were acknowledged but not delivered",
+		detail: `${notDeliveredIds.length} id(s): ${idListDetail(notDeliveredIds)}.`,
+		evidence: [evidence(`${prefix}/events/not-delivered-request-ids`, notDeliveredIds.slice(0, 20))],
+		recommendedAction: "Retry or explicitly fail the control request instead of treating it as delivered."
+	}));
+	return out;
+}
+//#endregion
+//#region src/supervisor-run/integrity-source.ts
+function sourceIdentityIssues(facts) {
+	const out = [];
+	const malformedSpawns = facts.spawns.filter((spawn) => !spawn.valid);
+	if (facts.journalInvalidRows > 0 || malformedSpawns.length > 0) out.push(issue({
+		code: "source-row-malformed",
+		area: "capture-integrity",
+		severity: "high",
+		subject: "journal-rows",
+		claim: "Some supervisor journal rows are malformed",
+		detail: `${facts.journalInvalidRows} non-object or invalid JSON row(s) and ${malformedSpawns.length} malformed spawn row(s) were excluded from structural conclusions.`,
+		evidence: [evidence("journal/malformed-json-rows/count", facts.journalInvalidRows), ...malformedSpawns.slice(0, 20).map((spawn) => evidence(`journal/spawns/${spawn.sourceRow}/invalid-fields`, spawn.invalidFields))],
+		recommendedAction: "Repair or reject malformed journal rows before using the run for structural analysis.",
+		metadata: {
+			assessment: "unavailable",
+			malformed_json_rows: facts.journalInvalidRows,
+			malformed_spawn_rows: malformedSpawns.length
+		}
+	}));
+	const unidentifiedSpawns = malformedSpawns.filter((spawn) => spawn.id.length === 0);
+	const unidentifiedCloses = facts.closes.filter((close) => close.id.length === 0);
+	if (unidentifiedSpawns.length + unidentifiedCloses.length > 0) out.push(issue({
+		code: "source-event-identity-unavailable",
+		area: "capture-integrity",
+		severity: "high",
+		subject: "journal-event-identity",
+		claim: "Some supervisor journal events have no usable invocation id",
+		detail: `${unidentifiedSpawns.length} spawn and ${unidentifiedCloses.length} terminal event(s) lack an id.`,
+		evidence: [evidence("journal/unidentified-spawns/count", unidentifiedSpawns.length), evidence("journal/unidentified-terminals/count", unidentifiedCloses.length)],
+		recommendedAction: "Reject or repair control events that omit their stable invocation id.",
+		metadata: {
+			assessment: "unavailable",
+			checks: ["journal-event-linkage"]
+		}
+	}));
+	const spawnCounts = /* @__PURE__ */ new Map();
+	for (const spawn of facts.spawns) {
+		if (!spawn.valid || spawn.id.length === 0) continue;
+		spawnCounts.set(spawn.id, (spawnCounts.get(spawn.id) ?? 0) + 1);
+	}
+	for (const [id, count] of spawnCounts) {
+		if (count < 2) continue;
+		out.push(issue({
+			code: "duplicate-spawn",
+			area: "control-integrity",
+			severity: "critical",
+			subject: id,
+			claim: "An invocation has more than one spawned control event",
+			detail: `${count} spawned events name invocation ${JSON.stringify(id)}.`,
+			evidence: [evidence(`journal/spawn-count/${encodeURIComponent(id)}`, count)],
+			recommendedAction: "Make spawn event append idempotent."
+		}));
+	}
+	const closeCounts = /* @__PURE__ */ new Map();
+	for (const close of facts.closes) {
+		if (close.id.length === 0) continue;
+		closeCounts.set(close.id, (closeCounts.get(close.id) ?? 0) + 1);
+	}
+	const uncertainSpawnIds = new Set(malformedSpawns.filter((spawn) => spawn.id.length > 0).map((spawn) => spawn.id));
+	if (unidentifiedSpawns.length === 0 && facts.journalInvalidRows === 0) {
+		const orphanCloses = /* @__PURE__ */ new Map();
+		for (const close of facts.closes) {
+			if (close.id.length === 0 || spawnCounts.has(close.id) || uncertainSpawnIds.has(close.id)) continue;
+			const rows = orphanCloses.get(close.id) ?? [];
+			rows.push(close);
+			orphanCloses.set(close.id, rows);
+		}
+		for (const [id, closes] of orphanCloses) out.push(issue({
+			code: "orphan-terminal",
+			area: "control-integrity",
+			severity: "critical",
+			subject: id,
+			claim: "A terminal control event names an invocation that was never spawned",
+			detail: `${closes.length} terminal event(s) for ${JSON.stringify(id)} have no matching spawn.`,
+			evidence: [evidence(`journal/closes/${encodeURIComponent(id)}/count`, closes.length), ...closes.slice(0, 20).map((close, index) => evidence(`journal/closes/${encodeURIComponent(id)}/${index}`, close))],
+			recommendedAction: "Retain the matching spawn event or reject the orphan terminal event."
+		}));
+	}
+	for (const [id, count] of closeCounts) {
+		if (count < 2) continue;
+		out.push(issue({
+			code: "duplicate-terminal",
+			area: "control-integrity",
+			severity: "critical",
+			subject: id,
+			claim: "An invocation has more than one terminal control event",
+			detail: `${count} settled/cancelled events name invocation ${JSON.stringify(id)}.`,
+			evidence: [evidence(`journal/terminal-count/${encodeURIComponent(id)}`, count)],
+			recommendedAction: "Make terminal event append idempotent."
+		}));
+	}
+	return out;
+}
+function joinWorkerControls(facts) {
+	const spawnsById = /* @__PURE__ */ new Map();
+	const spawnsByLabel = /* @__PURE__ */ new Map();
+	for (const spawn of facts.workerSpawns) {
+		const ids = spawnsById.get(spawn.id) ?? [];
+		ids.push(spawn);
+		spawnsById.set(spawn.id, ids);
+		const labels = spawnsByLabel.get(spawn.label) ?? [];
+		labels.push(spawn);
+		spawnsByLabel.set(spawn.label, labels);
+	}
+	const rowsWithoutIdByLabel = /* @__PURE__ */ new Map();
+	for (const row of facts.workerLogRows) {
+		if (row.workerId !== null && row.workerId.length > 0) continue;
+		const matches = rowsWithoutIdByLabel.get(row.label) ?? [];
+		matches.push(row);
+		rowsWithoutIdByLabel.set(row.label, matches);
+	}
+	const rowsBySpawn = /* @__PURE__ */ new Map();
+	const unmatchedRows = [];
+	const ambiguousRows = [];
+	for (const row of facts.workerLogRows) {
+		const matches = row.workerId !== null && row.workerId.length > 0 ? spawnsById.get(row.workerId) ?? [] : (rowsWithoutIdByLabel.get(row.label)?.length ?? 0) === 1 ? spawnsByLabel.get(row.label) ?? [] : [];
+		if (matches.length === 0) {
+			unmatchedRows.push(row.sourceIndex);
+			continue;
+		}
+		if (matches.length !== 1) {
+			ambiguousRows.push(row.sourceIndex);
+			continue;
+		}
+		const spawn = matches[0];
+		const joined = rowsBySpawn.get(spawn.id) ?? [];
+		joined.push(row);
+		rowsBySpawn.set(spawn.id, joined);
+	}
+	const joined = [];
+	const missingSpawnIds = [];
+	const duplicateSpawnIds = [];
+	for (const spawn of facts.workerSpawns) {
+		if ((spawnsById.get(spawn.id)?.length ?? 0) !== 1) continue;
+		const rows = rowsBySpawn.get(spawn.id) ?? [];
+		if (rows.length === 0) missingSpawnIds.push(spawn.id);
+		else if (rows.length > 1) duplicateSpawnIds.push(spawn.id);
+		else joined.push({
+			spawn,
+			facts: rows[0]
+		});
+	}
+	if (missingSpawnIds.length === 0 && duplicateSpawnIds.length === 0 && unmatchedRows.length === 0 && ambiguousRows.length === 0) return {
+		joined,
+		issue: null
+	};
+	return {
+		joined,
+		issue: issue({
+			code: "worker-control-join-unavailable",
+			area: "capture-integrity",
+			severity: "high",
+			subject: "worker-control-join",
+			claim: "Worker control-log coverage does not match recorded child invocations",
+			detail: `${missingSpawnIds.length} spawn(s) have no log, ${duplicateSpawnIds.length} have duplicate logs, ${unmatchedRows.length} log row(s) match no spawn, and ${ambiguousRows.length} row(s) are ambiguous.`,
+			evidence: [
+				evidence("workers/join/missing-spawn-ids", missingSpawnIds.slice(0, 20)),
+				evidence("workers/join/duplicate-spawn-ids", duplicateSpawnIds.slice(0, 20)),
+				evidence("workers/join/unmatched-source-rows", unmatchedRows.slice(0, 20)),
+				evidence("workers/join/ambiguous-source-rows", ambiguousRows.slice(0, 20))
+			],
+			recommendedAction: "Retain exactly one worker control row with workerId for every spawned invocation.",
+			metadata: {
+				assessment: "unavailable",
+				missing_count: missingSpawnIds.length,
+				duplicate_count: duplicateSpawnIds.length,
+				unmatched_count: unmatchedRows.length,
+				ambiguous_count: ambiguousRows.length
+			}
+		})
+	};
+}
+function sourceIssues(source, facts, tree) {
+	const out = sourceIdentityIssues(facts);
+	if (source.workers === null) {
+		const reason = source.workersMissingReason ?? "worker control-log store was not captured";
+		out.push(issue({
+			code: "worker-controls-unavailable",
+			area: "capture-integrity",
+			severity: "medium",
+			subject: "steer-delivery",
+			claim: "Steer delivery integrity is unavailable because worker control logs were not captured",
+			detail: reason,
+			evidence: [evidence("sources/workers", null)],
+			recommendedAction: "Retain each worker inbox and event stream.",
+			metadata: {
+				assessment: "unavailable",
+				reason
+			}
+		}));
+		return out;
+	}
+	const joined = joinWorkerControls(facts);
+	if (joined.issue !== null) out.push(joined.issue);
+	const rootCompleted = tree.rootId !== null && tree.nodes.filter((node) => node.rollout_id === tree.rootId).length === 1 && tree.nodes.find((node) => node.rollout_id === tree.rootId)?.outcome.is_completed === true;
+	for (const row of joined.joined) out.push(...steerIssues(row, rootCompleted));
+	return out;
+}
+//#endregion
+//#region src/supervisor-run/integrity-tree.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function parentValue(raw) {
+	if (raw.parent_rollout_id === null) return null;
+	return nonEmptyString(raw.parent_rollout_id) ?? void 0;
+}
+function terminalValue(outcome) {
+	if (outcome === null) return null;
+	if (typeof outcome.is_completed !== "boolean" || typeof outcome.is_truncated !== "boolean") return null;
+	if (outcome.error !== null && typeof outcome.error !== "string") return null;
+	return outcome.is_completed || outcome.is_truncated || outcome.error !== null;
+}
+function nodeRecord(value, index) {
+	const raw = isRecord(value) ? value : {};
+	const policy = isRecord(raw.policy) ? raw.policy : null;
+	const outcome = isRecord(raw.outcome) ? raw.outcome : null;
+	return {
+		index,
+		raw,
+		errors: validateRolloutLine(value),
+		id: nonEmptyString(raw.rollout_id),
+		parent: parentValue(raw),
+		runId: nonEmptyString(raw.run_id),
+		role: nonEmptyString(raw.role),
+		messages: Array.isArray(raw.messages) ? raw.messages : null,
+		profileId: policy === null ? null : nonEmptyString(policy.agent_profile_cell_id),
+		completed: outcome !== null && typeof outcome.is_completed === "boolean" ? outcome.is_completed : null,
+		terminal: terminalValue(outcome)
+	};
+}
+function metric(record, keys) {
+	const outcome = isRecord(record.raw.outcome) ? record.raw.outcome : null;
+	const metrics = outcome !== null && isRecord(outcome.metrics) ? outcome.metrics : null;
+	if (metrics === null) return null;
+	for (const key of keys) {
+		const value = metrics[key];
+		if (typeof value === "number" && Number.isFinite(value)) return {
+			key,
+			value
+		};
+	}
+	return null;
+}
+function nodeEvidence(record, path, value) {
+	const key = record.id ?? `index-${record.index}`;
+	return evidence(`nodes/${encodeURIComponent(key)}/${path}`, value);
+}
+function unavailableNodeChecks(record) {
+	const checks = [];
+	if (record.id === null) checks.push("identity", "root-membership", "parent-link", "cycle");
+	if (record.parent === void 0) checks.push("parent-link", "cycle");
+	if (record.runId === null) checks.push("cross-run-parent");
+	if (record.role === null) checks.push("root-role");
+	if (!isRecord(record.raw.outcome)) checks.push("timing", "terminal-state");
+	return [...new Set(checks)];
+}
+function treeIssues(tree, uncertainty = {}) {
+	const out = [];
+	const records = tree.nodes.map(nodeRecord);
+	const malformedSourceRows = tree.gaps.filter((gap) => gap.code === "source-row-malformed").reduce((count, gap) => count + (gap.count ?? 1), 0);
+	for (const record of records) {
+		if (record.errors.length === 0) continue;
+		out.push(issue({
+			code: "node-schema-invalid",
+			area: "capture-integrity",
+			severity: "high",
+			subject: record.id ?? `node-${record.index}`,
+			claim: "A supervisor-tree node fails canonical rollout validation",
+			detail: record.errors.join("; "),
+			evidence: [evidence(`nodes/${record.index}/validation`, record.errors)],
+			recommendedAction: "Fix the producer so every node validates as the existing tangle.rollout.v1 shape before analysis.",
+			metadata: { validation_errors: record.errors }
+		}));
+		const unavailableChecks = unavailableNodeChecks(record);
+		if (unavailableChecks.length === 0) continue;
+		out.push(issue({
+			code: "node-checks-unavailable",
+			area: "capture-integrity",
+			severity: "medium",
+			subject: record.id ?? `node-${record.index}`,
+			claim: "Some integrity checks are unavailable for a malformed supervisor-tree node",
+			detail: `Unavailable checks: ${unavailableChecks.join(", ")}.`,
+			evidence: [evidence(`nodes/${record.index}/unavailable-checks`, unavailableChecks)],
+			recommendedAction: "Retain the named identity and relationship fields with their canonical types.",
+			metadata: {
+				assessment: "unavailable",
+				checks: unavailableChecks
+			}
+		}));
+	}
+	const byId = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		if (record.id === null) continue;
+		const matches = byId.get(record.id) ?? [];
+		matches.push(record);
+		byId.set(record.id, matches);
+	}
+	for (const [rolloutId, matches] of byId) {
+		if (matches.length < 2) continue;
+		out.push(issue({
+			code: "duplicate-rollout-id",
+			area: "control-integrity",
+			severity: "critical",
+			subject: rolloutId,
+			claim: "A rollout id is duplicated within one supervisor tree",
+			detail: `${matches.length} nodes claim rollout_id ${JSON.stringify(rolloutId)}, so references are ambiguous.`,
+			evidence: [evidence(`duplicates/${encodeURIComponent(rolloutId)}/count`, matches.length), ...matches.slice(0, 20).map((record) => evidence(`nodes/${record.index}/identity`, {
+				rollout_id: record.id,
+				parent_rollout_id: record.parent,
+				role: record.role
+			}))],
+			recommendedAction: "Give every invocation one stable rollout id and regenerate the tree."
+		}));
+	}
+	const unknownIdentityRows = records.filter((record) => record.id === null).length + Math.max(malformedSourceRows, uncertainty.unknownIdentityRows ?? 0);
+	const unique = records.filter((record) => record.id !== null && byId.get(record.id)?.length === 1);
+	let root;
+	if (tree.rootId === null) out.push(issue({
+		code: "root-unavailable",
+		area: "capture-integrity",
+		severity: "high",
+		subject: "tree-root",
+		claim: "The supervisor-tree root is unavailable",
+		detail: `rootId is null while ${records.length} node row(s) were captured.`,
+		evidence: [evidence("rootId", null)],
+		recommendedAction: "Capture the root spawned event and preserve its rollout id as rootId.",
+		metadata: {
+			assessment: "unavailable",
+			node_rows: records.length
+		}
+	}));
+	else {
+		const rootRows = byId.get(tree.rootId) ?? [];
+		if (rootRows.length === 1) root = rootRows[0];
+		else if (rootRows.length === 0 && unknownIdentityRows > 0) out.push(issue({
+			code: "node-checks-unavailable",
+			area: "capture-integrity",
+			severity: "high",
+			subject: tree.rootId,
+			claim: "Root membership is unavailable because a malformed node lost its rollout id",
+			detail: `${unknownIdentityRows} malformed node row(s) have no usable rollout_id, so absence of root ${JSON.stringify(tree.rootId)} cannot be established.`,
+			evidence: [evidence("rootId", tree.rootId)],
+			recommendedAction: "Retain rollout_id even when another node field fails validation.",
+			metadata: {
+				assessment: "unavailable",
+				checks: ["root-membership"]
+			}
+		}));
+		else if (rootRows.length === 0) out.push(issue({
+			code: "declared-root-missing",
+			area: "control-integrity",
+			severity: "critical",
+			subject: tree.rootId,
+			claim: "The declared supervisor-tree root has no matching invocation node",
+			detail: `rootId ${JSON.stringify(tree.rootId)} is absent from ${records.length} node row(s).`,
+			evidence: [evidence("rootId", tree.rootId)],
+			recommendedAction: "Restore the root rollout row or correct rootId."
+		}));
+	}
+	if (root !== void 0) {
+		if (root.parent !== void 0 && root.parent !== null) out.push(issue({
+			code: "root-has-parent",
+			area: "control-integrity",
+			severity: "critical",
+			subject: root.id ?? tree.rootId ?? "tree-root",
+			claim: "The declared supervisor-tree root has a parent",
+			detail: `Root points to parent ${JSON.stringify(root.parent)}.`,
+			evidence: [nodeEvidence(root, "parent_rollout_id", root.parent)],
+			recommendedAction: "Record the root with parent_rollout_id null."
+		}));
+		if (root.role !== null && root.role !== "supervisor") out.push(issue({
+			code: "root-role-invalid",
+			area: "control-integrity",
+			severity: "high",
+			subject: root.id ?? tree.rootId ?? "tree-root",
+			claim: "The declared supervisor-tree root is not labeled as a supervisor",
+			detail: `Root has role ${JSON.stringify(root.role)}.`,
+			evidence: [nodeEvidence(root, "role", root.role)],
+			recommendedAction: "Preserve the root invocation role as supervisor when minting rollout rows."
+		}));
+	}
+	for (const record of unique) {
+		if (record.parent === void 0) continue;
+		if (record.parent === null) {
+			if (record.id !== tree.rootId) out.push(issue({
+				code: "detached-node",
+				area: "control-integrity",
+				severity: "critical",
+				subject: record.id,
+				claim: "A non-root invocation is recorded as a detached parentless root",
+				detail: `Node ${JSON.stringify(record.id)} is parentless while rootId is ${JSON.stringify(tree.rootId)}.`,
+				evidence: [nodeEvidence(record, "parent_rollout_id", null), evidence("rootId", tree.rootId)],
+				recommendedAction: "Attach the invocation to its spawning parent or record a separate run."
+			}));
+			continue;
+		}
+		const parentRows = byId.get(record.parent) ?? [];
+		if (parentRows.length === 0) {
+			if (unknownIdentityRows > 0 || uncertainty.uncertainIds?.has(record.parent) === true) out.push(issue({
+				code: "node-checks-unavailable",
+				area: "capture-integrity",
+				severity: "high",
+				subject: record.id,
+				claim: "Parent membership is unavailable because a malformed node lost its rollout id",
+				detail: uncertainty.uncertainIds?.has(record.parent) === true ? `Parent ${JSON.stringify(record.parent)} appears only in a malformed source row, so its absence cannot be established.` : `Parent ${JSON.stringify(record.parent)} cannot be matched while ${unknownIdentityRows} row(s) have no usable rollout_id.`,
+				evidence: [nodeEvidence(record, "parent_rollout_id", record.parent)],
+				recommendedAction: "Retain rollout_id on every row before assessing detached children.",
+				metadata: {
+					assessment: "unavailable",
+					checks: ["parent-membership"]
+				}
+			}));
+			else out.push(issue({
+				code: "parent-missing",
+				area: "control-integrity",
+				severity: "critical",
+				subject: record.id,
+				claim: "An invocation points to a parent absent from the supervisor tree",
+				detail: `Node ${JSON.stringify(record.id)} names missing parent ${JSON.stringify(record.parent)}.`,
+				evidence: [nodeEvidence(record, "parent_rollout_id", record.parent)],
+				recommendedAction: "Retain the parent invocation or remove the dangling edge."
+			}));
+			continue;
+		}
+		if (parentRows.length !== 1) continue;
+		const parent = parentRows[0];
+		if (record.runId !== null && parent.runId !== null && record.runId !== parent.runId) out.push(issue({
+			code: "cross-run-parent",
+			area: "control-integrity",
+			severity: "critical",
+			subject: record.id,
+			claim: "A parent-child edge crosses supervisor-run identities",
+			detail: `Child run_id ${JSON.stringify(record.runId)} differs from parent run_id ${JSON.stringify(parent.runId)}.`,
+			evidence: [nodeEvidence(record, "run_id", record.runId), nodeEvidence(parent, "run_id", parent.runId)],
+			recommendedAction: "Keep one run_id across a supervision tree or remove the cross-run edge."
+		}));
+		const childStart = metric(record, ["spawned_at", "started_at"]);
+		const parentStart = metric(parent, ["spawned_at", "started_at"]);
+		if (childStart !== null && parentStart !== null && childStart.value < parentStart.value) out.push(issue({
+			code: "child-before-parent",
+			area: "control-integrity",
+			severity: "high",
+			subject: record.id,
+			claim: "A child invocation is timestamped before its parent started",
+			detail: `Child ${childStart.key} ${childStart.value} precedes parent ${parentStart.key} ${parentStart.value}.`,
+			evidence: [nodeEvidence(record, `outcome.metrics.${childStart.key}`, childStart.value), nodeEvidence(parent, `outcome.metrics.${parentStart.key}`, parentStart.value)],
+			recommendedAction: "Use one ordered clock for spawn events or retain clock metadata."
+		}));
+		const parentClose = metric(parent, [
+			"settled_at",
+			"completed_at",
+			"finished_at"
+		]);
+		if (childStart !== null && parentClose !== null && childStart.value > parentClose.value) out.push(issue({
+			code: "child-after-parent-close",
+			area: "control-integrity",
+			severity: "critical",
+			subject: record.id,
+			claim: "A child invocation is timestamped after its parent closed",
+			detail: `Child ${childStart.key} ${childStart.value} follows parent ${parentClose.key} ${parentClose.value}.`,
+			evidence: [nodeEvidence(record, `outcome.metrics.${childStart.key}`, childStart.value), nodeEvidence(parent, `outcome.metrics.${parentClose.key}`, parentClose.value)],
+			recommendedAction: "Correct the causal timestamps or attach the child to its actual spawner."
+		}));
+	}
+	for (const record of unique) {
+		const start = metric(record, ["spawned_at", "started_at"]);
+		const close = metric(record, [
+			"settled_at",
+			"completed_at",
+			"finished_at"
+		]);
+		if (start === null || close === null || close.value >= start.value) continue;
+		out.push(issue({
+			code: "close-before-start",
+			area: "control-integrity",
+			severity: "high",
+			subject: record.id,
+			claim: "An invocation is timestamped as closing before it started",
+			detail: `${start.key} is ${start.value} and ${close.key} is ${close.value}.`,
+			evidence: [nodeEvidence(record, `outcome.metrics.${start.key}`, start.value), nodeEvidence(record, `outcome.metrics.${close.key}`, close.value)],
+			recommendedAction: "Correct the event ordering or retain clock-domain metadata."
+		}));
+	}
+	const emittedCycles = /* @__PURE__ */ new Set();
+	const resolved = /* @__PURE__ */ new Set();
+	for (const start of unique) {
+		if (resolved.has(start.id)) continue;
+		const path = [];
+		const positions = /* @__PURE__ */ new Map();
+		let current = start.id;
+		while (current !== null) {
+			if (resolved.has(current)) break;
+			const position = positions.get(current);
+			if (position !== void 0) {
+				const cycle = path.slice(position);
+				const key = [...cycle].sort().join("\0");
+				if (!emittedCycles.has(key)) {
+					emittedCycles.add(key);
+					out.push(issue({
+						code: "parent-cycle",
+						area: "control-integrity",
+						severity: "critical",
+						subject: [...cycle].sort()[0] ?? "cycle",
+						claim: "The supervisor tree contains a parent cycle",
+						detail: `${cycle.join(" -> ")} -> ${cycle[0]}`,
+						evidence: cycle.slice(0, 20).flatMap((id) => {
+							const rows = byId.get(id);
+							const record = rows?.length === 1 ? rows[0] : void 0;
+							return record === void 0 ? [] : [nodeEvidence(record, "parent_rollout_id", record.parent)];
+						}),
+						recommendedAction: "Correct parent ids at ingestion; a cyclic graph is not a run tree."
+					}));
+				}
+				break;
+			}
+			positions.set(current, path.length);
+			path.push(current);
+			const rows = byId.get(current);
+			if (rows?.length !== 1) break;
+			const parent = rows[0]?.parent;
+			if (parent === void 0) break;
+			current = parent;
+		}
+		for (const id of path) resolved.add(id);
+	}
+	if (root?.completed === true) {
+		const missingTerminal = unique.filter((record) => record.id !== root?.id && record.terminal === false);
+		if (missingTerminal.length > 0) out.push(issue({
+			code: "child-terminal-unavailable",
+			area: "capture-integrity",
+			severity: "high",
+			subject: "child-terminal-outcomes",
+			claim: "A completed supervisor run has children with no captured terminal outcome",
+			detail: `${missingTerminal.length}/${Math.max(0, unique.length - 1)} child node(s) are neither completed, truncated, nor errored.`,
+			evidence: [evidence("children/missing-terminal/count", missingTerminal.length), ...missingTerminal.slice(0, 20).map((record) => nodeEvidence(record, "outcome", record.raw.outcome))],
+			recommendedAction: "Retain each child settlement or cancellation event.",
+			metadata: {
+				assessment: "unavailable",
+				unavailable_count: missingTerminal.length
+			}
+		}));
+	}
+	const missingTranscripts = records.filter((record) => record.messages?.length === 0);
+	if (missingTranscripts.length > 0) out.push(issue({
+		code: "transcript-unavailable",
+		area: "capture-integrity",
+		severity: "medium",
+		subject: "decision-transcripts",
+		claim: "Decision transcripts are unavailable for some supervisor-tree invocations",
+		detail: `${missingTranscripts.length}/${records.length} node row(s) have messages: [].`,
+		evidence: [evidence("capture/missing-transcripts/count", missingTranscripts.length), ...missingTranscripts.slice(0, 20).map((record) => nodeEvidence(record, "messages", []))],
+		recommendedAction: "Hydrate canonical messages from the retained session transcript.",
+		metadata: {
+			assessment: "unavailable",
+			unavailable_count: missingTranscripts.length
+		}
+	}));
+	const missingProfiles = records.filter((record) => record.profileId === null);
+	if (missingProfiles.length > 0) out.push(issue({
+		code: "profile-id-unavailable",
+		area: "capture-integrity",
+		severity: "medium",
+		subject: "agent-profile-identity",
+		claim: "Canonical agent-profile identity is unavailable for some supervisor-tree invocations",
+		detail: `${missingProfiles.length}/${records.length} node row(s) omit policy.agent_profile_cell_id.`,
+		evidence: [evidence("capture/missing-agent-profile-cell-id/count", missingProfiles.length), ...missingProfiles.slice(0, 20).map((record) => nodeEvidence(record, "policy.agent_profile_cell_id", null))],
+		recommendedAction: "Record policy.agent_profile_cell_id on every invocation at dispatch time.",
+		metadata: {
+			assessment: "unavailable",
+			unavailable_count: missingProfiles.length
+		}
+	}));
+	return out;
+}
+//#endregion
+//#region src/supervisor-run/integrity-types.ts
+const SUPERVISOR_RUN_INTEGRITY_SCHEMA = "tangle.supervisor-run-integrity@1";
+//#endregion
+//#region src/supervisor-run/source-facts.ts
+function asRecord(v) {
+	return typeof v === "object" && v !== null ? v : {};
+}
+function num(v) {
+	return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function readSpend(v) {
+	const rec = asRecord(v);
+	const tok = asRecord(rec.tokens);
+	const cacheRead = tok.cacheRead ?? tok.cache_read;
+	const cacheWrite = tok.cacheWrite ?? tok.cache_write;
+	return {
+		tokens: {
+			input: num(tok.input),
+			output: num(tok.output),
+			cacheRead: num(cacheRead),
+			cacheWrite: num(cacheWrite),
+			hasCache: cacheRead !== void 0 || cacheWrite !== void 0
+		},
+		usd: num(rec.usd)
+	};
+}
+function parseJsonl(text) {
+	return parseJsonlWithDiagnostics(text).rows;
+}
+function parseJsonlWithDiagnostics(text) {
+	if (text === null) return {
+		rows: [],
+		invalidRows: 0
+	};
+	const out = [];
+	let invalidRows = 0;
+	for (const line of text.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const parsed = JSON.parse(trimmed);
+			if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) out.push(parsed);
+			else invalidRows += 1;
+		} catch {
+			invalidRows += 1;
+		}
+	}
+	return {
+		rows: out,
+		invalidRows
+	};
+}
+function parseJson(text) {
+	if (text === null) return null;
+	try {
+		const parsed = JSON.parse(text);
+		return typeof parsed === "object" && parsed !== null ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function ms(at) {
+	if (typeof at !== "string") return null;
+	const t = Date.parse(at);
+	return Number.isFinite(t) ? t : null;
+}
+function readVerdict(v) {
+	if (typeof v === "string") return {
+		label: v,
+		valid: null,
+		score: null,
+		raw: v
+	};
+	if (typeof v !== "object" || v === null) return {
+		label: null,
+		valid: null,
+		score: null,
+		raw: null
+	};
+	const rec = v;
+	const valid = typeof rec.valid === "boolean" ? rec.valid : null;
+	return {
+		label: valid === null ? null : valid ? "valid" : "invalid",
+		valid,
+		score: typeof rec.score === "number" && Number.isFinite(rec.score) ? rec.score : null,
+		raw: v
+	};
+}
+function workerSourceKey(worker) {
+	return worker.workerId ?? worker.label;
+}
+function parseSupervisorTree(src) {
+	const parsedJournal = parseJsonlWithDiagnostics(src.journal);
+	const events = parsedJournal.rows;
+	const state = parseJson(src.state);
+	const spawns = [];
+	const closes = [];
+	let brainIn = 0;
+	let brainOut = 0;
+	let brainCacheRead = 0;
+	let brainCacheWrite = 0;
+	let brainHasCache = false;
+	let brainUsd = 0;
+	let meteredCount = 0;
+	let rootId = null;
+	for (const [sourceRow, ev] of events.entries()) {
+		const kind = typeof ev.kind === "string" ? ev.kind : "";
+		const id = typeof ev.id === "string" ? ev.id : "";
+		if (kind === "spawned") {
+			const parent = typeof ev.parent === "string" && ev.parent.length > 0 ? ev.parent : null;
+			const label = typeof ev.label === "string" ? ev.label : "";
+			const invalidFields = [];
+			if (id.length === 0) invalidFields.push("id");
+			const parentOmittedForFirstRoot = ev.parent === void 0 && rootId === null;
+			if (ev.parent !== null && !parentOmittedForFirstRoot && !(typeof ev.parent === "string" && ev.parent.length > 0)) invalidFields.push("parent");
+			if (label.length === 0) invalidFields.push("label");
+			if (ev.role !== void 0 && ev.role !== "supervisor" && ev.role !== "worker") invalidFields.push("role");
+			const role = ev.role === "supervisor" || ev.role === "worker" ? ev.role : parent === null ? "supervisor" : "worker";
+			const valid = invalidFields.length === 0;
+			if (valid && parent === null && rootId === null) rootId = id;
+			spawns.push({
+				sourceRow,
+				id,
+				parent,
+				label,
+				role,
+				at: ms(ev.at),
+				valid,
+				invalidFields
+			});
+		} else if (kind === "settled") {
+			const verdict = readVerdict(ev.verdict);
+			closes.push({
+				id,
+				kind: "settled",
+				status: typeof ev.status === "string" ? ev.status : null,
+				verdict: verdict.label,
+				valid: verdict.valid,
+				score: verdict.score,
+				rawVerdict: verdict.raw,
+				at: ms(ev.at),
+				spend: readSpend(ev.spent),
+				hasSpend: asRecord(ev.spent).tokens !== void 0
+			});
+		} else if (kind === "cancelled") closes.push({
+			id,
+			kind: "cancelled",
+			status: "cancelled",
+			verdict: typeof ev.reason === "string" ? ev.reason : null,
+			valid: null,
+			score: null,
+			rawVerdict: typeof ev.reason === "string" ? ev.reason : null,
+			at: ms(ev.at),
+			spend: {
+				tokens: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					hasCache: false
+				},
+				usd: 0
+			},
+			hasSpend: false
+		});
+		else if (kind === "metered") {
+			const s = readSpend(ev.spend);
+			brainIn += s.tokens.input;
+			brainOut += s.tokens.output;
+			brainCacheRead += s.tokens.cacheRead;
+			brainCacheWrite += s.tokens.cacheWrite;
+			brainHasCache = brainHasCache || s.tokens.hasCache;
+			brainUsd += s.usd;
+			meteredCount += 1;
+		}
+	}
+	const workerSpawns = spawns.filter((s) => s.valid && s.id !== rootId);
+	const workerIds = new Set(workerSpawns.map((s) => s.id));
+	const workerCloses = closes.filter((c) => workerIds.has(c.id));
+	const workerLogs = /* @__PURE__ */ new Map();
+	const workerLogRows = [];
+	for (const [sourceIndex, w] of (src.workers ?? []).entries()) {
+		const facts = {
+			sourceIndex,
+			workerId: w.workerId ?? null,
+			label: w.label,
+			inboxCaptured: w.inbox !== null,
+			eventsCaptured: w.events !== null,
+			inboxInvalidRows: 0,
+			eventsInvalidRows: 0,
+			started: null,
+			finished: false,
+			finishedAt: null,
+			passed: null,
+			score: null,
+			finishedPatchBytes: null,
+			evidenceBytes: 0,
+			steersQueued: null,
+			steersDelivered: null,
+			steersQueuedUnavailable: null,
+			steersDeliveredUnavailable: null,
+			questions: 0,
+			steerRequests: [],
+			steerAcknowledgements: []
+		};
+		const parsedInbox = parseJsonlWithDiagnostics(w.inbox);
+		const parsedEvents = parseJsonlWithDiagnostics(w.events);
+		facts.inboxInvalidRows = parsedInbox.invalidRows;
+		facts.eventsInvalidRows = parsedEvents.invalidRows;
+		for (const [row, req] of parsedInbox.rows.entries()) {
+			if (typeof req.message !== "string" || req.message.trim().length === 0) continue;
+			facts.steerRequests.push({
+				requestId: typeof req.id === "string" && req.id.length > 0 ? req.id : null,
+				row
+			});
+		}
+		for (const [row, ev] of parsedEvents.rows.entries()) {
+			const kind = ev.kind;
+			if (kind === "message") {
+				if (ev.direction === "up") {
+					facts.questions += 1;
+					continue;
+				}
+				facts.steerAcknowledgements.push({
+					requestId: typeof ev.requestId === "string" && ev.requestId.length > 0 ? ev.requestId : null,
+					delivered: typeof ev.delivered === "boolean" ? ev.delivered : null,
+					row
+				});
+			} else if (kind === "started") facts.started = ms(ev.at);
+			else if (kind === "finished") {
+				facts.finished = true;
+				facts.finishedAt = ms(ev.at);
+				facts.passed = typeof ev.passed === "boolean" ? ev.passed : null;
+				facts.score = typeof ev.score === "number" && Number.isFinite(ev.score) ? ev.score : null;
+				facts.finishedPatchBytes = typeof ev.patchBytes === "number" ? ev.patchBytes : null;
+				facts.evidenceBytes = typeof ev.evidence === "string" ? ev.evidence.length : 0;
+			}
+		}
+		const requestsById = /* @__PURE__ */ new Map();
+		for (const request of facts.steerRequests) {
+			if (request.requestId === null) continue;
+			requestsById.set(request.requestId, (requestsById.get(request.requestId) ?? 0) + 1);
+		}
+		const acknowledgementsById = /* @__PURE__ */ new Map();
+		for (const acknowledgement of facts.steerAcknowledgements) {
+			if (acknowledgement.requestId === null) continue;
+			const matches = acknowledgementsById.get(acknowledgement.requestId) ?? [];
+			matches.push(acknowledgement);
+			acknowledgementsById.set(acknowledgement.requestId, matches);
+		}
+		const queueProblems = [];
+		if (!facts.inboxCaptured) queueProblems.push("inbox absent");
+		if (!facts.eventsCaptured) queueProblems.push("events absent");
+		if (facts.inboxInvalidRows > 0) queueProblems.push("inbox contains malformed rows");
+		if (facts.eventsInvalidRows > 0) queueProblems.push("events contain malformed rows");
+		if (facts.steerRequests.some((request) => request.requestId === null)) queueProblems.push("queued request id missing");
+		if ([...requestsById.values()].some((count) => count > 1)) queueProblems.push("queued request id duplicated");
+		if (facts.steerAcknowledgements.some((acknowledgement) => acknowledgement.requestId === null)) queueProblems.push("acknowledgement request id missing");
+		if ([...acknowledgementsById.keys()].some((id) => !requestsById.has(id))) queueProblems.push("acknowledgement has no queued request");
+		if (queueProblems.length === 0) facts.steersQueued = requestsById.size;
+		else facts.steersQueuedUnavailable = [...new Set(queueProblems)].join("; ");
+		const deliveryProblems = [...queueProblems];
+		if ([...acknowledgementsById.values()].some((rows) => rows.length > 1)) deliveryProblems.push("acknowledgement request id duplicated");
+		if (facts.steerAcknowledgements.some((acknowledgement) => acknowledgement.delivered === null)) deliveryProblems.push("acknowledgement delivery status missing");
+		if (deliveryProblems.length === 0) facts.steersDelivered = [...requestsById.keys()].filter((id) => {
+			const acknowledgement = acknowledgementsById.get(id);
+			return acknowledgement?.length === 1 && acknowledgement[0]?.delivered === true;
+		}).length;
+		else facts.steersDeliveredUnavailable = [...new Set(deliveryProblems)].join("; ");
+		workerLogRows.push(facts);
+		workerLogs.set(workerSourceKey(w), facts);
+	}
+	const startedAt = ms(state?.startedAt) ?? spawns[0]?.at ?? null;
+	const completedAt = ms(state?.completedAt) ?? [...spawns.map((s) => s.at), ...closes.map((c) => c.at)].reduce((acc, t) => t === null ? acc : acc === null ? t : Math.max(acc, t), null);
+	return {
+		rootId,
+		spawns,
+		closes,
+		workerSpawns,
+		workerCloses,
+		brain: {
+			tokensIn: brainIn,
+			tokensOut: brainOut,
+			cacheRead: brainCacheRead,
+			cacheWrite: brainCacheWrite,
+			hasCache: brainHasCache,
+			usd: brainUsd,
+			meteredCount
+		},
+		workerLogs,
+		workerLogRows,
+		journalInvalidRows: parsedJournal.invalidRows,
+		state,
+		startedAt,
+		completedAt
+	};
+}
+//#endregion
+//#region src/supervisor-run/rollout-nodes.ts
+/**
+* The supervision tree as `tangle.rollout.v1` rows.
+*
+* A supervisor run IS a tree of rollouts, so its nodes are not a new shape:
+* the root becomes one `RolloutLine` with `role: 'supervisor'`, and every
+* spawned invocation keeps its explicit supervisor/worker role with
+* `parent_rollout_id` pointing at its spawner. The rows append to the same
+* ledger as solo-agent rollouts and join to them with the same keys.
+*
+* What the journal CANNOT supply is the transcript: a worker's messages live
+* in its harness store (opencode sqlite, Claude Code jsonl), which the
+* `src/rollout/readers/*` intake readers own. Rows minted here are therefore
+* GAP lines (`messages: []`, `provenance.gap` set) carrying identity,
+* structure, outcome and cost; hydrating them with messages is the readers'
+* job, keyed on `artifacts.transcript_ref`.
+*
+* Timing lives in `outcome.metrics` (`spawned_at` / `settled_at` / `wall_ms`)
+* rather than a schema field: `tangle.rollout.v1` describes ONE invocation,
+* and the inter-invocation event timeline — which is what waves, concurrency,
+* idle and utilization are computed from — is a property of the journal, not
+* of any single row. The analyzer reads that timeline; these rows carry the
+* per-node facts.
+*/
+const EMPTY_COST = {
+	usd: null,
+	tokens_in: null,
+	tokens_out: null,
+	tokens_reasoning: null,
+	cache_read: null,
+	cache_write: null,
+	wall_s: null
+};
+function hasWorkerId(worker) {
+	return worker.workerId !== void 0;
+}
+/**
+* Mint the supervision tree as rollout rows. Returns the rows plus the gaps
+* that made any of them incomplete — same unavailable-vs-zero discipline as
+* the report: a row with no transcript says WHY, it never pretends to be empty.
+*/
+function supervisorRunRolloutLines(src, opts = {}) {
+	return supervisorRunRolloutLinesFromFacts(src, parseSupervisorTree(src), opts);
+}
+/** Mint rollout rows from an already parsed source without reading its JSONL again. */
+function supervisorRunRolloutLinesFromFacts(src, tree, opts = {}) {
+	const gaps = [];
+	if (src.journal === null) {
+		gaps.push({
+			code: "journal-unavailable",
+			message: `${src.supRunDir === null ? "no supervisor run dir" : "journal absent"}; no nodes recoverable`
+		});
+		return {
+			rootId: null,
+			nodes: [],
+			gaps
+		};
+	}
+	const malformedSourceRows = tree.journalInvalidRows + tree.spawns.filter((spawn) => !spawn.valid).length;
+	if (malformedSourceRows > 0) gaps.push({
+		code: "source-row-malformed",
+		message: `${malformedSourceRows} malformed journal row(s) were excluded from the tree`,
+		count: malformedSourceRows
+	});
+	const state = tree.state;
+	const result = parseJson(src.result);
+	const judge = parseJson(src.judge);
+	const stateResult = asRecord(state?.result);
+	const rootId = tree.rootId;
+	const runId = opts.runId ?? rootId ?? src.runRef;
+	const suite = opts.suite ?? "supervisor-run";
+	const instanceId = src.instanceId ?? src.runRef;
+	const split = opts.split ?? "search";
+	const capturedAt = opts.capturedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	const base = {
+		schema: ROLLOUT_SCHEMA,
+		run_id: runId,
+		experiment_id: opts.experimentId ?? null,
+		candidate_id: opts.candidateId ?? null,
+		generation: opts.generation ?? null,
+		candidate_index: opts.candidateIndex ?? null,
+		task: {
+			suite,
+			instance_id: instanceId,
+			split,
+			seed: opts.seed ?? null,
+			rep: opts.rep ?? 0
+		},
+		messages: [],
+		tool_defs: []
+	};
+	const nodes = [];
+	if (rootId !== null) {
+		const rootSpawn = tree.spawns.find((spawn) => spawn.valid && spawn.id === rootId);
+		const judgeResolved = typeof judge?.resolved === "boolean" ? judge.resolved : null;
+		const reward = (typeof judge?.score === "number" ? judge.score : null) ?? (judgeResolved === null ? null : judgeResolved ? 1 : 0);
+		if (reward === null) gaps.push({
+			code: "root-reward-unavailable",
+			message: "no judge verdict for this run",
+			nodeId: rootId
+		});
+		const wallMs = tree.startedAt !== null && tree.completedAt !== null && tree.completedAt >= tree.startedAt ? tree.completedAt - tree.startedAt : null;
+		nodes.push({
+			...base,
+			rollout_id: rootId,
+			parent_rollout_id: null,
+			role: rootSpawn?.role ?? "supervisor",
+			policy: {
+				harness: opts.supervisorHarness ?? null,
+				harness_version: null,
+				model: opts.supervisorModel ?? null,
+				provider: null,
+				profile_commit: null,
+				sampling: null
+			},
+			outcome: {
+				...unscreenedRewardFields(reward),
+				reward_source: src.judgeSource,
+				verdict: judge ?? null,
+				metrics: {
+					arm: src.arm,
+					sup_status: typeof state?.status === "string" ? state.status : null,
+					sup_verdict: typeof state?.verdict === "string" ? state.verdict : null,
+					delivered: typeof stateResult.delivered === "boolean" ? stateResult.delivered : null,
+					verify_pass: typeof result?.verify_pass === "boolean" ? result.verify_pass : null,
+					started_at: tree.startedAt,
+					completed_at: tree.completedAt,
+					workers_spawned: tree.workerSpawns.length,
+					brain_metered_events: tree.brain.meteredCount
+				},
+				is_completed: state?.status === "completed",
+				is_truncated: false,
+				error: null,
+				realness_gated: false
+			},
+			cost: {
+				...EMPTY_COST,
+				usd: src.limits.spendUsd !== null ? null : typeof stateResult.spentUsd === "number" ? stateResult.spentUsd : tree.brain.usd,
+				tokens_in: src.limits.managerTokens === null ? tree.brain.tokensIn : null,
+				tokens_out: src.limits.managerTokens === null ? tree.brain.tokensOut : null,
+				cache_read: src.limits.managerTokens === null && tree.brain.hasCache ? tree.brain.cacheRead : null,
+				cache_write: src.limits.managerTokens === null && tree.brain.hasCache ? tree.brain.cacheWrite : null,
+				wall_s: wallMs === null ? null : wallMs / 1e3
+			},
+			artifacts: {
+				patch_path: typeof result?.patchPath === "string" ? result.patchPath : null,
+				run_dir: src.supRunDir,
+				transcript_ref: src.rootTranscriptRef !== void 0 ? src.rootTranscriptRef : src.supRunDir === null ? null : `${src.supRunDir}/journal.jsonl`
+			},
+			provenance: {
+				captured_at: capturedAt,
+				capture: "backfill",
+				gap: "supervision journal carries structure and spend, not the brain transcript"
+			}
+		});
+	} else gaps.push({
+		code: "root-spawn-unavailable",
+		message: "no parentless spawned event in the journal"
+	});
+	const closeById = new Map(tree.closes.map((c) => [c.id, c]));
+	const sourceById = new Map((src.workers ?? []).filter(hasWorkerId).map((worker) => [worker.workerId, worker]));
+	const fallbackSourceByLabel = new Map((src.workers ?? []).filter((worker) => worker.workerId === void 0).map((worker) => [worker.label, worker]));
+	for (const spawn of tree.workerSpawns) {
+		const close = closeById.get(spawn.id) ?? null;
+		const workerSource = sourceById.get(spawn.id) ?? fallbackSourceByLabel.get(spawn.label) ?? null;
+		const facts = tree.workerLogs.get(workerSource?.workerId ?? workerSource?.label ?? spawn.label) ?? null;
+		const wallMs = facts?.started != null && facts.finishedAt != null ? facts.finishedAt - facts.started : null;
+		const score = close?.score ?? facts?.score ?? null;
+		const passed = close?.valid ?? facts?.passed ?? null;
+		const reward = score ?? (passed === null ? null : passed ? 1 : 0);
+		if (reward === null) gaps.push({
+			code: "child-reward-unavailable",
+			message: `child ${JSON.stringify(spawn.label)} has no verify verdict`,
+			nodeId: spawn.id
+		});
+		const isSupervisor = spawn.role === "supervisor";
+		nodes.push({
+			...base,
+			rollout_id: spawn.id,
+			parent_rollout_id: spawn.parent,
+			role: spawn.role,
+			policy: {
+				harness: isSupervisor ? opts.supervisorHarness ?? null : opts.workerHarness ?? null,
+				harness_version: null,
+				model: isSupervisor ? opts.supervisorModel ?? null : opts.workerModel ?? null,
+				provider: null,
+				profile_commit: null,
+				sampling: null
+			},
+			outcome: {
+				...unscreenedRewardFields(reward),
+				reward_source: reward === null ? null : score === null ? "worker-self-verify" : "worker-verdict-score",
+				verdict: close === null ? null : {
+					kind: close.kind,
+					status: close.status,
+					verdict: close.rawVerdict,
+					valid: close.valid,
+					score: close.score
+				},
+				metrics: {
+					label: spawn.label,
+					spawned_at: spawn.at,
+					settled_at: close?.at ?? null,
+					started_at: facts?.started ?? null,
+					finished_at: facts?.finishedAt ?? null,
+					wall_ms: wallMs,
+					patch_bytes: workerSource?.patchBytes ?? facts?.finishedPatchBytes ?? null,
+					evidence_bytes: facts?.evidenceBytes ?? null,
+					steers_queued: facts?.steersQueued ?? null,
+					steers_delivered: facts?.steersDelivered ?? null,
+					questions: facts?.questions ?? null
+				},
+				is_completed: close?.kind === "settled",
+				is_truncated: close?.kind === "cancelled",
+				error: close?.kind === "cancelled" ? close.verdict ?? "cancelled" : null,
+				realness_gated: false
+			},
+			cost: {
+				...EMPTY_COST,
+				usd: src.limits.spendUsd !== null || !close?.hasSpend ? null : close.spend.usd,
+				tokens_in: workerSource?.tokensIn ?? (close?.hasSpend ? close.spend.tokens.input : null),
+				tokens_out: workerSource?.tokensOut ?? (close?.hasSpend ? close.spend.tokens.output : null),
+				cache_read: workerSource?.cacheRead ?? (close?.hasSpend && close.spend.tokens.hasCache ? close.spend.tokens.cacheRead : null),
+				cache_write: workerSource?.cacheWrite ?? (close?.hasSpend && close.spend.tokens.hasCache ? close.spend.tokens.cacheWrite : null),
+				wall_s: wallMs === null ? null : wallMs / 1e3
+			},
+			artifacts: {
+				patch_path: workerSource?.patchPath !== void 0 ? workerSource.patchPath : src.supRunDir === null ? null : `${src.supRunDir}/workers/${spawn.label}.patch`,
+				run_dir: src.supRunDir,
+				transcript_ref: workerSource?.transcriptRef !== void 0 ? workerSource.transcriptRef : src.supRunDir === null ? null : `${src.supRunDir}/workers/${spawn.label}.ndjson`
+			},
+			provenance: {
+				captured_at: capturedAt,
+				capture: "backfill",
+				gap: workerSource?.transcriptRef == null ? "worker transcript lives in the harness session store — hydrate via src/rollout/readers" : "worker transcript recorded by the harness; messages not inlined into this row"
+			}
+		});
+	}
+	const invalid = nodes.filter((n) => !isRolloutLine(n));
+	if (invalid.length > 0) gaps.push({
+		code: "node-schema-invalid",
+		message: `${invalid.length} node(s) failed tangle.rollout.v1 validation`,
+		count: invalid.length
+	});
+	return {
+		rootId,
+		nodes,
+		gaps
+	};
+}
+//#endregion
+//#region src/supervisor-run/integrity.ts
+function isTree(input) {
+	return "nodes" in input && Array.isArray(input.nodes);
+}
+function treeRunRef(tree) {
+	const runIds = [...new Set(tree.nodes.map((node) => node.run_id).filter((runId) => typeof runId === "string" && runId.length > 0))].sort();
+	if (runIds.length === 1) return runIds[0];
+	if (runIds.length > 1) return `mixed-runs:${runIds.join(",")}`;
+	return tree.rootId ?? "unidentified-tree";
+}
+/**
+* Run deterministic integrity checks over source bytes or an already minted tree.
+* Source input is parsed exactly once and reused by projection and source-only checks.
+*/
+function analyzeSupervisorRunIntegrity(input, options = {}) {
+	if (isTree(input)) {
+		const sourceOnlyChecks = [
+			"journal-event-cardinality",
+			"worker-control-join",
+			"steer-ack-correlation"
+		];
+		return {
+			schema: SUPERVISOR_RUN_INTEGRITY_SCHEMA,
+			runRef: treeRunRef(input),
+			input: "tree",
+			tree: input,
+			issues: [...treeIssues(input), issue({
+				code: "source-checks-unavailable",
+				area: "capture-integrity",
+				severity: "medium",
+				subject: "source-only-control-checks",
+				claim: "Source-only control checks are unavailable for SupervisorRunTree input",
+				detail: "Rollout rows do not retain journal event multiplicity or worker inbox and acknowledgement rows.",
+				evidence: [evidence("input/source-only-checks", sourceOnlyChecks)],
+				recommendedAction: "Pass SupervisorRunSources when journal and worker control checks are required.",
+				metadata: {
+					assessment: "unavailable",
+					checks: sourceOnlyChecks
+				}
+			})]
+		};
+	}
+	const facts = parseSupervisorTree(input);
+	const tree = supervisorRunRolloutLinesFromFacts(input, facts, { capturedAt: options.capturedAt });
+	return {
+		schema: SUPERVISOR_RUN_INTEGRITY_SCHEMA,
+		runRef: input.runRef,
+		input: "sources",
+		tree,
+		issues: [...treeIssues(tree, {
+			unknownIdentityRows: facts.journalInvalidRows + facts.spawns.filter((spawn) => !spawn.valid && spawn.id.length === 0).length,
+			uncertainIds: new Set(facts.spawns.filter((spawn) => !spawn.valid && spawn.id.length > 0).map((spawn) => spawn.id))
+		}), ...sourceIssues(input, facts, tree)]
+	};
+}
+//#endregion
+export { parseJsonl as a, SUPERVISOR_RUN_INTEGRITY_SCHEMA as c, parseJson as i, supervisorRunRolloutLines as n, parseSupervisorTree as o, asRecord as r, workerSourceKey as s, analyzeSupervisorRunIntegrity as t };
+
+//# sourceMappingURL=integrity-CCXTftiL.js.map