@tangle-network/agent-eval 0.174.0 → 0.175.0

package/dist/report-command-DKlXfU5r.js

@@ -0,0 +1,1528 @@
+import { o as summarizeNumberSeries } from "./descriptive-1V17A-qa.js";
+import { n as findOpencodeSessionsByDirectory, r as openOpencodeDb, t as DEFAULT_OPENCODE_DB } from "./opencode-sqlite-CNw3vubS.js";
+import { a as SUPERVISOR_RUN_ROLLUP_SCHEMA, c as showMeasured, d as parseJson, f as parseJsonl, i as NO_SOURCE_LIMITS, l as unavailable, m as workerSourceKey, o as SUPERVISOR_RUN_SCHEMA, p as parseSupervisorTree, r as readTerminalRecord, s as isUnavailable, u as asRecord } from "./terminal-record-Ce9_UjRz.js";
+import { basename, join, resolve } from "node:path";
+import { appendFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+//#region src/supervisor-run/analyze.ts
+/**
+* The pure analyzer. Takes already-read bytes (`SupervisorRunSources`) and
+* returns the report — every metric derivable from a synthetic journal string
+* with no filesystem, no process, and no network. All I/O lives in a reader
+* (`loops-reader.ts` is one).
+*/
+const NO_CACHE_COUNTERS = "the journal carries no cache-token counters for this role";
+const NO_CACHE_BREAKDOWN = "Runtime recorded cacheBreakdownKnown:false — the provider reported a total without splitting cache reads from writes";
+/**
+* Analyze already-read supervisor-run bytes. Pure and synchronous: same bytes
+* in, same report out (modulo `generatedAt`, which `now` pins in tests).
+*/
+function analyzeSupervisorRunSources(src, now = Date.now) {
+	const gaps = [];
+	const gap = (what, reason) => {
+		gaps.push(`${what}: ${reason}`);
+		return unavailable(reason);
+	};
+	const journalMissing = src.journalMissingReason ?? (src.supRunDir === null ? "no supervisor run dir under <ws>/.agent/supervisor (or legacy <ws>/.loops/supervisor)" : "journal.jsonl absent");
+	const haveJournal = src.journal !== null;
+	const tree = parseSupervisorTree(src);
+	const state = tree.state;
+	const result = parseJson(src.result);
+	const judge = parseJson(src.judge);
+	const terminal = readTerminalRecord({
+		state,
+		result,
+		failure: src.failure === void 0 ? void 0 : parseJson(src.failure)
+	});
+	const { rootId, workerSpawns, workerCloses, startedAt, completedAt } = tree;
+	const rootSpawn = rootId === null ? null : tree.spawns.find((spawn) => spawn.id === rootId) ?? null;
+	const spawnById = new Map(workerSpawns.map((spawn) => [spawn.id, spawn]));
+	const spawnsByLabel = /* @__PURE__ */ new Map();
+	for (const spawn of workerSpawns) {
+		const matches = spawnsByLabel.get(spawn.label) ?? [];
+		matches.push(spawn);
+		spawnsByLabel.set(spawn.label, matches);
+	}
+	const spawnsForSource = (worker) => {
+		if (worker.workerId === void 0) return spawnsByLabel.get(worker.label) ?? [];
+		const spawn = spawnById.get(worker.workerId);
+		return spawn === void 0 ? [] : [spawn];
+	};
+	const spawnForSource = (worker) => {
+		const matches = spawnsForSource(worker);
+		return matches.length === 1 ? matches[0] ?? null : null;
+	};
+	const wallSpanStart = startedAt ?? tree.firstEventAt;
+	const wallSpanEnd = tree.lastEventAt;
+	let supervisorWallMs;
+	let supervisorWallSource;
+	if (startedAt !== null && completedAt !== null && completedAt >= startedAt) {
+		supervisorWallMs = completedAt - startedAt;
+		supervisorWallSource = "stamps";
+	} else if (completedAt === null && wallSpanStart !== null && wallSpanEnd !== null && wallSpanEnd >= wallSpanStart) {
+		supervisorWallMs = wallSpanEnd - wallSpanStart;
+		supervisorWallSource = "journal-span";
+	} else {
+		const reason = !haveJournal ? journalMissing : "no parseable start/complete timestamps in state.json or journal";
+		supervisorWallMs = gap("supervisorWallMs", reason);
+		supervisorWallSource = unavailable(reason);
+	}
+	const wallEndAt = completedAt ?? (supervisorWallSource === "journal-span" ? wallSpanEnd : null);
+	const steerRows = [];
+	let steerQueuedTotal = 0;
+	let steerDeliveredTotal = 0;
+	let upLegMessages = 0;
+	if (src.workers !== null) for (const w of src.workers) {
+		const facts = tree.workerLogs.get(workerSourceKey(w));
+		const queued = facts?.steersQueued ?? null;
+		const delivered = facts?.steersDelivered ?? null;
+		upLegMessages += facts?.questions ?? 0;
+		if (queued !== null && delivered !== null) steerRows.push({
+			workerId: w.workerId ?? null,
+			worker: w.label,
+			queued,
+			delivered
+		});
+		if (queued !== null) steerQueuedTotal += queued;
+		if (delivered !== null) steerDeliveredTotal += delivered;
+	}
+	const workersGapReason = src.workersMissingReason ?? "workers/ directory absent";
+	const unavailableReasons = (pick) => {
+		const reasons = tree.workerLogRows.map((facts) => pick(facts)).filter((reason) => reason !== null);
+		return reasons.length === 0 ? null : `exact steer accounting unavailable for ${reasons.length} worker row(s): ${[...new Set(reasons)].join(" | ")}`;
+	};
+	const queuedGapReason = unavailableReasons((facts) => facts.steersQueuedUnavailable);
+	const deliveredGapReason = unavailableReasons((facts) => facts.steersDeliveredUnavailable);
+	const workerEventsGapReason = unavailableReasons((facts) => !facts.eventsCaptured ? "events absent" : facts.eventsInvalidRows > 0 ? "events contain malformed rows" : null);
+	const steers = src.workers === null ? gap("steers", workersGapReason) : queuedGapReason === null ? steerQueuedTotal : gap("steers", queuedGapReason);
+	const steersDelivered = src.workers === null ? unavailable(workersGapReason) : deliveredGapReason === null ? steerDeliveredTotal : unavailable(deliveredGapReason);
+	const steersByWorker = src.workers === null ? unavailable(workersGapReason) : queuedGapReason === null && deliveredGapReason === null ? steerRows : unavailable(queuedGapReason ?? deliveredGapReason ?? workersGapReason);
+	const driverSteerCalls = src.driverLog === null ? gap("driverSteerCalls", "driver.log absent") : Math.max(0, (src.driverLog.match(/supervisor_steer/g) ?? []).length - registrationMentions(src.driverLog));
+	const timeline = [];
+	for (const s of workerSpawns) if (s.at !== null) timeline.push({
+		at: s.at,
+		delta: 1
+	});
+	for (const c of workerCloses) if (c.at !== null) timeline.push({
+		at: c.at,
+		delta: -1
+	});
+	timeline.sort((a, b) => a.at - b.at || a.delta - b.delta);
+	let waves = 0;
+	const waveSizes = [];
+	let closedSinceWaveStart = true;
+	for (const step of timeline) if (step.delta === 1) {
+		if (closedSinceWaveStart) {
+			waves += 1;
+			waveSizes.push(0);
+			closedSinceWaveStart = false;
+		}
+		waveSizes[waveSizes.length - 1] = (waveSizes[waveSizes.length - 1] ?? 0) + 1;
+	} else closedSinceWaveStart = true;
+	let live = 0;
+	let maxConcurrency = 0;
+	let idleMs = 0;
+	let sumWorkerWallMs = 0;
+	let prev = startedAt;
+	for (const step of timeline) {
+		if (prev !== null && step.at >= prev) {
+			const span = step.at - prev;
+			if (live === 0) idleMs += span;
+			sumWorkerWallMs += span * live;
+		}
+		live += step.delta;
+		if (live > maxConcurrency) maxConcurrency = live;
+		prev = step.at;
+	}
+	if (prev !== null && wallEndAt !== null && wallEndAt >= prev) {
+		const span = wallEndAt - prev;
+		if (live === 0) idleMs += span;
+		sumWorkerWallMs += span * live;
+	}
+	const firstWorkerSpawnAt = workerSpawns.reduce((acc, s) => s.at === null ? acc : acc === null ? s.at : Math.min(acc, s.at), null);
+	const closeById = new Map(workerCloses.map((close) => [close.id, close]));
+	const childSpawnsByParent = /* @__PURE__ */ new Map();
+	for (const spawn of workerSpawns) {
+		if (spawn.parent === null) continue;
+		const siblings = childSpawnsByParent.get(spawn.parent) ?? [];
+		siblings.push(spawn);
+		childSpawnsByParent.set(spawn.parent, siblings);
+	}
+	let respawns = 0;
+	let observeThenRespawn = 0;
+	let respawnWithoutEvidence = 0;
+	const repeatedLabelSet = /* @__PURE__ */ new Set();
+	for (const siblings of childSpawnsByParent.values()) {
+		const labelCounts = /* @__PURE__ */ new Map();
+		for (const spawn of siblings) labelCounts.set(spawn.label, (labelCounts.get(spawn.label) ?? 0) + 1);
+		for (const [label, count] of labelCounts) if (count > 1) repeatedLabelSet.add(label);
+		const orderedSpawns = siblings.map((spawn, index) => ({
+			spawn,
+			index
+		})).filter((row) => row.spawn.at !== null).sort((a, b) => a.spawn.at - b.spawn.at || a.index - b.index);
+		const directCloseTimes = siblings.map((spawn) => closeById.get(spawn.id)?.at ?? null).filter((at) => at !== null).sort((a, b) => a - b);
+		const firstDirectClose = directCloseTimes[0] ?? null;
+		for (let i = 1; i < orderedSpawns.length; i += 1) {
+			const previous = orderedSpawns[i - 1]?.spawn.at;
+			const current = orderedSpawns[i]?.spawn.at;
+			if (previous === void 0 || current === void 0) continue;
+			if (firstDirectClose === null || current <= firstDirectClose) continue;
+			respawns += 1;
+			if (hasNumberBetween(directCloseTimes, previous, current)) observeThenRespawn += 1;
+			else respawnWithoutEvidence += 1;
+		}
+	}
+	const repeatedLabels = [...repeatedLabelSet];
+	const parentOf = new Map(tree.spawns.map((s) => [s.id, s.parent]));
+	let delegationDepth = 0;
+	for (const s of workerSpawns) {
+		let d = 0;
+		let cur = s.id;
+		const seen = /* @__PURE__ */ new Set();
+		while (cur !== null && cur !== rootId && !seen.has(cur)) {
+			seen.add(cur);
+			d += 1;
+			cur = parentOf.get(cur) ?? null;
+		}
+		if (d > delegationDepth) delegationDepth = d;
+	}
+	const orchestration = {
+		workersSpawned: haveJournal ? workerSpawns.length : gap("workersSpawned", journalMissing),
+		workersSettled: haveJournal ? workerCloses.filter((c) => c.kind === "settled").length : unavailable(journalMissing),
+		workersCancelled: haveJournal ? workerCloses.filter((c) => c.kind === "cancelled").length : unavailable(journalMissing),
+		steers,
+		steersDelivered,
+		steersByWorker,
+		driverSteerCalls,
+		waves: haveJournal ? waves : unavailable(journalMissing),
+		waveSizes: haveJournal ? waveSizes : unavailable(journalMissing),
+		maxConcurrency: haveJournal ? maxConcurrency : unavailable(journalMissing),
+		respawns: haveJournal ? respawns : unavailable(journalMissing),
+		repeatedLabels: haveJournal ? repeatedLabels : unavailable(journalMissing),
+		delegationDepth: haveJournal ? delegationDepth : unavailable(journalMissing),
+		timeToFirstSpawnMs: startedAt !== null && firstWorkerSpawnAt !== null ? firstWorkerSpawnAt - startedAt : haveJournal ? unavailable("no worker spawn timestamps") : unavailable(journalMissing),
+		supervisorWallMs,
+		supervisorWallSource,
+		idleMs: isUnavailable(supervisorWallMs) ? unavailable(supervisorWallMs.unavailable) : idleMs,
+		idlePct: isUnavailable(supervisorWallMs) || supervisorWallMs === 0 ? isUnavailable(supervisorWallMs) ? unavailable(supervisorWallMs.unavailable) : unavailable("supervisor wall is 0ms") : round(idleMs / supervisorWallMs * 100, 1),
+		workerUtilization: isUnavailable(supervisorWallMs) || supervisorWallMs === 0 ? isUnavailable(supervisorWallMs) ? unavailable(supervisorWallMs.unavailable) : unavailable("supervisor wall is 0ms") : round(sumWorkerWallMs / supervisorWallMs, 3)
+	};
+	const settledByStatus = {};
+	const settledVerdicts = {};
+	for (const c of workerCloses) {
+		const key = c.status ?? "unknown";
+		settledByStatus[key] = (settledByStatus[key] ?? 0) + 1;
+		if (c.verdict !== null) settledVerdicts[c.verdict] = (settledVerdicts[c.verdict] ?? 0) + 1;
+	}
+	const verdictLimit = src.limits.workerVerdicts;
+	const deliverablesLimit = src.limits.deliverables;
+	let accepted = 0;
+	let emptyPass = 0;
+	let evidenceBytes = 0;
+	const sourceVerdicts = [];
+	for (const w of src.workers ?? []) {
+		const f = tree.workerLogs.get(workerSourceKey(w));
+		if (f?.finished) evidenceBytes += f.evidenceBytes;
+		const spawn = spawnForSource(w);
+		const passed = (spawn === null ? null : closeById.get(spawn.id) ?? null)?.valid ?? f?.passed ?? null;
+		if (passed !== null) sourceVerdicts.push(passed);
+		if (passed === true) if (deliverablesLimit !== null || (w.patchBytes ?? f?.finishedPatchBytes ?? 0) > 0) accepted += 1;
+		else emptyPass += 1;
+	}
+	const settledCloses = workerCloses.filter((close) => close.kind === "settled");
+	const structuredVerdicts = settledCloses.map((close) => close.valid).filter((valid) => valid !== null);
+	const journalVerdictsComplete = settledCloses.length > 0 && structuredVerdicts.length === settledCloses.length;
+	const sourceVerdictsComplete = sourceVerdicts.length > 0 && sourceVerdicts.length >= settledCloses.length;
+	const rejected = journalVerdictsComplete ? structuredVerdicts.filter((valid) => !valid).length : sourceVerdictsComplete ? sourceVerdicts.filter((valid) => !valid).length : 0;
+	const rejectedLimit = journalVerdictsComplete || sourceVerdictsComplete ? null : settledCloses.length > 0 ? verdictLimit ?? "a settled journal verdict has no validity and no matched worker log" : verdictLimit !== null ? verdictLimit : !haveJournal && src.workers === null ? workersGapReason : null;
+	const decision = {
+		settledByStatus: haveJournal ? settledByStatus : gap("settledByStatus", journalMissing),
+		settledVerdicts: verdictLimit !== null ? unavailable(verdictLimit) : haveJournal ? settledVerdicts : unavailable(journalMissing),
+		accepted: verdictLimit !== null ? gap("accepted", verdictLimit) : src.workers === null ? unavailable(workersGapReason) : accepted,
+		rejected: rejectedLimit === null ? rejected : unavailable(rejectedLimit),
+		emptyPass: verdictLimit !== null ? gap("emptyPass", verdictLimit) : deliverablesLimit !== null ? gap("emptyPass", deliverablesLimit) : src.workers === null ? unavailable(workersGapReason) : emptyPass,
+		observeThenRespawn: haveJournal ? observeThenRespawn : unavailable(journalMissing),
+		respawnWithoutEvidence: haveJournal ? respawnWithoutEvidence : unavailable(journalMissing),
+		reviewActions: src.workers === null ? unavailable(workersGapReason) : queuedGapReason === null ? steerQueuedTotal + upLegMessages : unavailable(queuedGapReason),
+		workerEvidenceBytes: src.workers === null ? unavailable(workersGapReason) : workerEventsGapReason === null ? evidenceBytes : unavailable(workerEventsGapReason)
+	};
+	const rootChildIds = new Set(workerSpawns.filter((spawn) => spawn.parent === rootId).map((spawn) => spawn.id));
+	const rootChildCloses = workerCloses.filter((close) => rootChildIds.has(close.id));
+	const rootChildSpends = rootChildCloses.filter((close) => close.hasSpend);
+	const workerUsdUnknownNodes = rootChildSpends.filter((close) => !close.spend.usdKnown).map((close) => close.id);
+	const workerTokensUnknownNodes = rootChildSpends.filter((close) => !close.spend.tokensKnown).map((close) => close.id);
+	const workerTokenSpends = rootChildSpends.filter((close) => close.spend.tokensKnown);
+	const journalWorkerIn = workerTokenSpends.reduce((a, c) => a + c.spend.tokens.input, 0);
+	const journalWorkerOut = workerTokenSpends.reduce((a, c) => a + c.spend.tokens.output, 0);
+	const journalWorkerUsd = rootChildSpends.filter((close) => close.spend.usdKnown).reduce((a, c) => a + c.spend.usd, 0);
+	const usdUnknownIds = new Set(workerCloses.filter((close) => close.hasSpend && !close.spend.usdKnown).map((c) => c.id));
+	const workerUsdById = /* @__PURE__ */ new Map();
+	for (const c of workerCloses) {
+		if (usdUnknownIds.has(c.id)) continue;
+		workerUsdById.set(c.id, (workerUsdById.get(c.id) ?? 0) + c.spend.usd);
+	}
+	const labelById = new Map(workerSpawns.map((spawn) => [spawn.id, spawn.label]));
+	const usdUnknownLabels = new Set([...usdUnknownIds].map((id) => labelById.get(id)).filter((l) => l !== void 0));
+	const workerUsdByLabel = /* @__PURE__ */ new Map();
+	for (const close of workerCloses) {
+		const label = labelById.get(close.id);
+		if (label === void 0 || usdUnknownLabels.has(label)) continue;
+		workerUsdByLabel.set(label, (workerUsdByLabel.get(label) ?? 0) + close.spend.usd);
+	}
+	const brainUsdUnknownNodes = tree.brain.usdUnknownCount > 0 && rootId !== null ? [rootId] : [];
+	const brainTokensUnknownNodes = tree.brain.tokensUnknownCount > 0 && rootId !== null ? [rootId] : [];
+	const usdKnownRecords = tree.brain.usdKnownCount + rootChildSpends.filter((close) => close.spend.usdKnown).length;
+	const usdUnknownRecords = tree.brain.usdUnknownCount + workerUsdUnknownNodes.length;
+	const usdUnknownNodes = [...brainUsdUnknownNodes, ...workerUsdUnknownNodes];
+	const NAMED_NODE_LIMIT = 5;
+	const nameNodes = (nodes) => {
+		if (nodes.length === 0) return "";
+		const shown = nodes.slice(0, NAMED_NODE_LIMIT);
+		const rest = nodes.length - shown.length;
+		return ` (${shown.join(", ")}${rest === 0 ? "" : ` +${rest} more`})`;
+	};
+	const unpriced = (unknown, total, nodes) => `Runtime recorded usdKnown:false on ${unknown} of ${total} spend record(s)${nameNodes(nodes)}`;
+	const unreportedTokens = (unknown, total, nodes) => `Runtime recorded tokensKnown:false on ${unknown} of ${total} spend record(s)${nameNodes(nodes)}`;
+	const usdPartial = usdKnownRecords > 0 && usdUnknownRecords > 0;
+	const usdAllUnknown = usdKnownRecords === 0 && usdUnknownRecords > 0;
+	const brainTokensUnreported = tree.brain.tokensUnknownCount === 0 ? null : unreportedTokens(tree.brain.tokensUnknownCount, tree.brain.meteredCount, brainTokensUnknownNodes);
+	const brainUsdUnreported = tree.brain.usdKnownCount > 0 || tree.brain.usdUnknownCount === 0 ? null : unpriced(tree.brain.usdUnknownCount, tree.brain.meteredCount, brainUsdUnknownNodes);
+	const workerUsdUnreported = workerUsdUnknownNodes.length === 0 || workerUsdUnknownNodes.length < rootChildSpends.length ? null : unpriced(workerUsdUnknownNodes.length, rootChildSpends.length, workerUsdUnknownNodes);
+	const sq = src.harnessWorkerTokens;
+	const harnessGapReason = src.harnessMissingReason ?? "harness session store unavailable and journal settled spend is 0";
+	const workerTokenLimit = src.limits.workerTokens;
+	const workerTokensUnreported = workerTokensUnknownNodes.length === 0 ? null : unreportedTokens(workerTokensUnknownNodes.length, rootChildSpends.length, workerTokensUnknownNodes);
+	const workerIn = workerTokenLimit !== null ? gap("workers.tokensIn", workerTokenLimit) : workerTokensUnreported !== null ? gap("workers.tokensIn", workerTokensUnreported) : sq !== null ? journalWorkerIn + sq.input : haveJournal ? journalWorkerIn : gap("workers.tokensIn", harnessGapReason);
+	const workerOut = workerTokenLimit !== null ? unavailable(workerTokenLimit) : workerTokensUnreported !== null ? unavailable(workerTokensUnreported) : sq !== null ? journalWorkerOut + sq.output : haveJournal ? journalWorkerOut : unavailable(harnessGapReason);
+	const stateResult = asRecord(state?.result);
+	const stateUsd = typeof stateResult.spentUsd === "number" ? stateResult.spentUsd : null;
+	const resultSpentTotal = asRecord(result?.spentTotal);
+	const resultCloseUsd = typeof resultSpentTotal.usd === "number" && Number.isFinite(resultSpentTotal.usd) ? resultSpentTotal.usd : null;
+	const closeUsd = stateUsd ?? resultCloseUsd;
+	const usdLimit = src.limits.spendUsd;
+	const closeUsdUnreported = stateUsd === null && resultCloseUsd !== null && resultSpentTotal.usdKnown === false;
+	const usdUnreportedReason = unpriced(usdUnknownRecords, usdKnownRecords + usdUnknownRecords, usdUnknownNodes);
+	const totalUsd = usdLimit !== null ? gap("totalUsd", usdLimit) : stateUsd !== null ? round(stateUsd, 6) : !haveJournal ? gap("totalUsd", journalMissing) : usdUnknownRecords > 0 ? gap("totalUsd", usdUnreportedReason) : round(tree.brain.usd + journalWorkerUsd, 6);
+	const journalSpendRecords = usdKnownRecords;
+	const journalDerivedAvailable = usdLimit === null && haveJournal && !usdAllUnknown;
+	const closeRecordAvailable = usdLimit === null && closeUsd !== null && !closeUsdUnreported;
+	const spend = {
+		journalDerived: {
+			usd: journalDerivedAvailable ? round(tree.brain.usd + journalWorkerUsd, 6) : unavailable(usdLimit ?? (haveJournal ? usdUnreportedReason : journalMissing)),
+			records: journalDerivedAvailable ? journalSpendRecords : 0,
+			unknownRecords: usdLimit === null && haveJournal ? usdUnknownRecords : 0,
+			partial: journalDerivedAvailable && usdPartial,
+			unknownNodes: usdLimit === null && haveJournal ? usdUnknownNodes : []
+		},
+		closeRecord: {
+			usd: closeRecordAvailable ? round(closeUsd, 6) : unavailable(usdLimit ?? (closeUsdUnreported ? "close record incomplete: result.json spentTotal.usdKnown is false" : "no close record: neither state.json result.spentUsd nor result.json spentTotal.usd is present")),
+			records: closeRecordAvailable ? 1 : 0,
+			unknownRecords: closeUsdUnreported ? 1 : 0,
+			partial: false,
+			unknownNodes: closeUsdUnreported && rootId !== null ? [rootId] : []
+		}
+	};
+	const perWorker = (src.workers ?? []).map((w) => {
+		const f = tree.workerLogs.get(workerSourceKey(w));
+		const matchingSpawns = spawnsForSource(w);
+		const spawn = spawnForSource(w);
+		const close = spawn === null ? null : closeById.get(spawn.id) ?? null;
+		const passed = close?.valid ?? f?.passed ?? null;
+		const matchingRoles = new Set(matchingSpawns.map((candidate) => candidate.role));
+		const matchingRuntimes = new Set(matchingSpawns.map((candidate) => candidate.runtime));
+		const matchingProfiles = new Set(matchingSpawns.map((candidate) => candidate.profileDigest));
+		const journalWallMs = spawn?.at !== null && spawn?.at !== void 0 && close?.at !== null && close?.at !== void 0 && close.at >= spawn.at ? close.at - spawn.at : null;
+		return {
+			workerId: w.workerId ?? null,
+			worker: w.label,
+			role: matchingRoles.size === 1 ? matchingSpawns[0]?.role ?? null : null,
+			runtime: matchingRuntimes.size === 1 ? matchingSpawns[0]?.runtime ?? null : null,
+			profileDigest: matchingProfiles.size === 1 ? matchingSpawns[0]?.profileDigest ?? null : null,
+			status: close?.status ?? null,
+			failure: close?.reason ?? null,
+			infra: close?.infra ?? null,
+			wallMs: f?.started != null && f.finishedAt != null ? f.finishedAt - f.started : journalWallMs,
+			tokensIn: w.tokensIn ?? (close?.hasSpend === true && close.spend.tokensKnown ? close.spend.tokens.input : null),
+			tokensOut: w.tokensOut ?? (close?.hasSpend === true && close.spend.tokensKnown ? close.spend.tokens.output : null),
+			usd: usdLimit !== null ? null : w.workerId === void 0 ? workerUsdByLabel.get(w.label) ?? null : workerUsdById.get(w.workerId) ?? null,
+			patchBytes: w.patchBytes ?? f?.finishedPatchBytes ?? null,
+			passed,
+			score: close?.score ?? f?.score ?? null
+		};
+	});
+	const wallDistribution = summarizeNumberSeries(perWorker.map((w) => w.wallMs).filter((w) => w !== null));
+	const brainCalls = parseJsonl(src.brainLog);
+	const managerTokenLimit = src.limits.managerTokens;
+	const economics = {
+		brain: {
+			tokensIn: managerTokenLimit !== null ? gap("brain.tokensIn", managerTokenLimit) : !haveJournal ? gap("brain.tokensIn", journalMissing) : brainTokensUnreported !== null ? gap("brain.tokensIn", brainTokensUnreported) : tree.brain.tokensIn,
+			tokensOut: managerTokenLimit !== null ? unavailable(managerTokenLimit) : !haveJournal ? unavailable(journalMissing) : brainTokensUnreported !== null ? unavailable(brainTokensUnreported) : tree.brain.tokensOut,
+			usd: usdLimit !== null ? unavailable(usdLimit) : !haveJournal ? unavailable(journalMissing) : brainUsdUnreported !== null ? unavailable(brainUsdUnreported) : round(tree.brain.usd, 6),
+			cacheRead: managerTokenLimit !== null ? unavailable(managerTokenLimit) : !haveJournal ? unavailable(journalMissing) : brainTokensUnreported !== null ? unavailable(brainTokensUnreported) : !tree.brain.hasCache ? unavailable(NO_CACHE_COUNTERS) : tree.brain.cacheBreakdownKnown ? tree.brain.cacheRead : unavailable(NO_CACHE_BREAKDOWN),
+			cacheWrite: managerTokenLimit !== null ? unavailable(managerTokenLimit) : !haveJournal ? unavailable(journalMissing) : brainTokensUnreported !== null ? unavailable(brainTokensUnreported) : !tree.brain.hasCache ? unavailable(NO_CACHE_COUNTERS) : tree.brain.cacheBreakdownKnown ? tree.brain.cacheWrite : unavailable(NO_CACHE_BREAKDOWN),
+			source: managerTokenLimit ?? (haveJournal ? `journal metered events (n=${tree.brain.meteredCount})${tree.brain.usdKnownCount > 0 && tree.brain.usdUnknownCount > 0 ? ` — ${tree.brain.usdUnknownCount} unpriced` : ""}` : journalMissing)
+		},
+		brainTruncations: src.brainLog === null ? gap("brain.brainTruncations", src.brainLogMissingReason ?? (src.supRunDir === null ? "no supervisor run dir under <ws>/.agent/supervisor (or legacy <ws>/.loops/supervisor)" : "brain.jsonl absent — loops predates the brain-call tap, so truncation cannot be ruled out")) : brainCalls.filter((c) => c.finish_reason === "length").length,
+		workers: {
+			tokensIn: workerIn,
+			tokensOut: workerOut,
+			cacheRead: workerTokenLimit !== null ? unavailable(workerTokenLimit) : sq?.cacheRead !== void 0 ? sq.cacheRead : unavailable(NO_CACHE_COUNTERS),
+			cacheWrite: workerTokenLimit !== null ? unavailable(workerTokenLimit) : sq?.cacheWrite !== void 0 ? sq.cacheWrite : unavailable(NO_CACHE_COUNTERS),
+			usd: usdLimit !== null ? unavailable(usdLimit) : !haveJournal ? unavailable(journalMissing) : workerUsdUnreported !== null ? unavailable(workerUsdUnreported) : round(journalWorkerUsd, 6),
+			source: `${workerTokenLimit !== null ? workerTokenLimit : sq !== null ? `journal settled spend + ${sq.store} sessions (n=${sq.sessions})` : `journal settled spend only — ${src.harnessMissingReason ?? "harness session store unavailable"}`}${workerUsdUnknownNodes.length > 0 && workerUsdUnknownNodes.length < rootChildSpends.length ? ` — ${workerUsdUnknownNodes.length} unpriced` : ""}`
+		},
+		spend,
+		totalUsd,
+		totalUsdSource: usdLimit !== null ? usdLimit : stateUsd !== null ? `state.json result.spentUsd${rootChildCloses.length > 0 && journalWorkerUsd === 0 ? " — brain-priced only; worker CLI inference is unpriced (see worker token counts)" : ""}` : !haveJournal ? journalMissing : usdUnknownRecords > 0 ? usdUnreportedReason : "journal metered + settled usd",
+		costPerAcceptedPatchUsd: isUnavailable(totalUsd) ? unavailable(totalUsd.unavailable) : isUnavailable(decision.accepted) ? unavailable(decision.accepted.unavailable) : decision.accepted === 0 ? unavailable("no accepted worker patch (cost has no denominator)") : round(totalUsd / decision.accepted, 6),
+		workerWallMsDistribution: wallDistribution === null ? unavailable(src.workers === null ? workersGapReason : "no worker start/finish pairs captured") : wallDistribution,
+		perWorker: src.workers === null ? unavailable(workersGapReason) : perWorker
+	};
+	const patchStats = src.patch === null ? gap("patch", src.limits.deliverables ?? "delivered patch file absent") : parsePatch(src.patch);
+	const outcome = {
+		supStatus: isUnavailable(terminal.supStatus) ? gap("supStatus", terminal.supStatus.unavailable) : terminal.supStatus,
+		supStatusSource: terminal.supStatusSource,
+		supReason: terminal.supReason,
+		failure: terminal.failure,
+		supVerdict: pickString(state, "verdict") ?? pickString(result, "sup_verdict") ?? unavailable("no state.json / result.json verdict"),
+		delivered: typeof stateResult.delivered === "boolean" ? stateResult.delivered : typeof result?.delivered === "boolean" ? result.delivered : unavailable("no delivered flag in state.json or result.json"),
+		judgeResolved: judge === null ? gap("judge", "judge.json absent") : typeof judge.resolved === "boolean" ? judge.resolved : null,
+		judgeScore: judge === null ? unavailable("judge.json absent") : typeof judge.score === "number" ? judge.score : null,
+		judgePassed: judge === null ? unavailable("judge.json absent") : typeof judge.passed === "number" ? judge.passed : null,
+		judgeTotal: judge === null ? unavailable("judge.json absent") : typeof judge.total === "number" ? judge.total : null,
+		verifyPass: typeof result?.verify_pass === "boolean" ? result.verify_pass : gap("verifyPass", "result.json absent or has no verify_pass"),
+		verifyRc: typeof result?.verify_rc === "number" ? result.verify_rc : unavailable("result.json absent or has no verify_rc"),
+		patch: patchStats,
+		judgeSource: src.judgeSource
+	};
+	return {
+		schema: SUPERVISOR_RUN_SCHEMA,
+		runRef: src.runRef,
+		instanceId: src.instanceId,
+		arm: src.arm,
+		supervisorId: rootId !== null ? rootId : unavailable(journalMissing),
+		supervisorProfileDigest: rootSpawn?.profileDigest !== null && rootSpawn?.profileDigest !== void 0 ? rootSpawn.profileDigest : gap("supervisorProfileDigest", "root spawned event has no profile digest"),
+		generatedAt: new Date(now()).toISOString(),
+		orchestration,
+		decision,
+		economics,
+		outcome,
+		gaps,
+		traceCommand: src.traceCommand ?? "npx --yes @tangle-network/traces@latest analyze --harness opencode --cwd <worker-clone-cwd>"
+	};
+}
+/** Whether sorted values contain one value in the inclusive interval. */
+function hasNumberBetween(sorted, low, high) {
+	let left = 0;
+	let right = sorted.length;
+	while (left < right) {
+		const middle = left + Math.floor((right - left) / 2);
+		if (sorted[middle] < low) left = middle + 1;
+		else right = middle;
+	}
+	return left < sorted.length && sorted[left] <= high;
+}
+/** `[driver] registered tools: …supervisor_steer…` is a banner, not an invocation. */
+function registrationMentions(driverLog) {
+	let n = 0;
+	for (const line of driverLog.split("\n")) if (line.includes("registered tools:") && line.includes("supervisor_steer")) n += 1;
+	return n;
+}
+function pickString(rec, key) {
+	const v = rec?.[key];
+	return typeof v === "string" ? v : null;
+}
+function round(v, digits) {
+	const f = 10 ** digits;
+	return Math.round(v * f) / f;
+}
+/** Unified-diff stats. Counts `+++ b/<path>` targets, body +/- lines, and test-file touches. */
+function parsePatch(text) {
+	const files = /* @__PURE__ */ new Set();
+	const testFiles = /* @__PURE__ */ new Set();
+	let added = 0;
+	let removed = 0;
+	for (const line of text.split("\n")) {
+		if (line.startsWith("+++ ")) {
+			const p = line.slice(4).trim().replace(/^b\//, "");
+			if (p !== "/dev/null") {
+				files.add(p);
+				if (isTestPath(p)) testFiles.add(p);
+			}
+			continue;
+		}
+		if (line.startsWith("--- ") || line.startsWith("diff --git") || line.startsWith("index ")) continue;
+		if (line.startsWith("+")) added += 1;
+		else if (line.startsWith("-")) removed += 1;
+	}
+	return {
+		files: files.size,
+		linesAdded: added,
+		linesRemoved: removed,
+		testFilesTouched: [...testFiles].sort()
+	};
+}
+function isTestPath(p) {
+	const base = p.split("/").pop() ?? p;
+	return /(^|\/)(tests?|__tests__|testing|spec)(\/|$)/.test(p) || /\.(test|spec)\.[cm]?[jt]sx?$/.test(base) || /^test_.*\.py$/.test(base) || /_test\.py$/.test(base);
+}
+/**
+* Aggregate many supervisor-run reports. A metric no run could measure stays
+* `unavailable` rather than becoming a 0-valued mean, and cells whose steer
+* count was unavailable are counted separately from cells that measured zero.
+*/
+function rollupSupervisorRuns(reports) {
+	const known = (vals) => vals.filter((v) => !isUnavailable(v));
+	const steerVals = known(reports.map((r) => r.orchestration.steers));
+	const waveVals = known(reports.map((r) => r.orchestration.waves));
+	const concVals = known(reports.map((r) => r.orchestration.maxConcurrency));
+	const utilVals = known(reports.map((r) => r.orchestration.workerUtilization));
+	const idleVals = known(reports.map((r) => r.orchestration.idlePct));
+	const spawnVals = known(reports.map((r) => r.orchestration.workersSpawned));
+	const acceptVals = known(reports.map((r) => r.decision.accepted));
+	const usdVals = known(reports.map((r) => r.economics.totalUsd));
+	const journalSpendVals = known(reports.map((r) => r.economics.spend.journalDerived.usd));
+	const closeSpendVals = known(reports.map((r) => r.economics.spend.closeRecord.usd));
+	const resolvedVals = known(reports.map((r) => r.outcome.judgeResolved));
+	const sum = (xs) => xs.reduce((a, b) => a + b, 0);
+	const mean = (xs) => xs.length === 0 ? unavailable("no cell reported this metric") : round(sum(xs) / xs.length, 3);
+	const perCell = reports.map((r) => ({
+		instanceId: r.instanceId,
+		arm: r.arm,
+		steers: r.orchestration.steers,
+		waves: r.orchestration.waves,
+		utilization: r.orchestration.workerUtilization,
+		idlePct: r.orchestration.idlePct,
+		resolved: r.outcome.judgeResolved,
+		usd: r.economics.totalUsd
+	}));
+	return {
+		schema: SUPERVISOR_RUN_ROLLUP_SCHEMA,
+		cells: reports.length,
+		steersTotal: steerVals.length === 0 ? unavailable("no cell reported a steer count") : sum(steerVals),
+		cellsWithSteers: steerVals.length === 0 ? unavailable("no cell reported a steer count") : steerVals.filter((n) => n > 0).length,
+		cellsWithUnavailableSteers: reports.filter((r) => isUnavailable(r.orchestration.steers)).length,
+		wavesMean: mean(waveVals),
+		maxConcurrencyMax: concVals.length === 0 ? unavailable("no cell reported concurrency") : Math.max(...concVals),
+		utilizationMean: mean(utilVals),
+		idlePctMean: mean(idleVals),
+		workersSpawnedTotal: spawnVals.length === 0 ? unavailable("no cell reported spawns") : sum(spawnVals),
+		acceptedTotal: acceptVals.length === 0 ? unavailable("no cell reported acceptance") : sum(acceptVals),
+		usdTotal: usdVals.length === 0 ? unavailable("no cell reported spend") : round(sum(usdVals), 6),
+		spendUsd: {
+			journalDerived: {
+				value: journalSpendVals.length === 0 ? unavailable("no cell measured journal-derived spend") : round(sum(journalSpendVals), 6),
+				runs: journalSpendVals.length
+			},
+			closeRecord: {
+				value: closeSpendVals.length === 0 ? unavailable("no cell carried a close record") : round(sum(closeSpendVals), 6),
+				runs: closeSpendVals.length
+			}
+		},
+		resolvedCount: resolvedVals.length === 0 ? unavailable("no cell reported a judge verdict") : resolvedVals.filter((v) => v === true).length,
+		perCell
+	};
+}
+//#endregion
+//#region src/supervisor-run/render.ts
+/**
+* Human-readable renderings of a supervisor-run report. Zero and unavailable
+* render differently on purpose (`0` vs `unavailable — <reason>`), because the
+* two have driven opposite conclusions about the same architecture.
+*/
+/**
+* The block appended to a run log after every run — the answers an operator asks
+* for, in the log tail, with no extra command.
+*/
+function renderSupervisorRunHeadline(r) {
+	const o = r.orchestration;
+	const steerNote = isUnavailable(o.steers) ? `unavailable — ${o.steers.unavailable}` : o.steers === 0 ? "0 (spawn→wait→respawn only; no mid-task steering)" : `${o.steers} queued / ${showMeasured(o.steersDelivered)} delivered`;
+	return [
+		`RUN-REPORT ${r.instanceId ?? "?"} [${r.arm ?? "?"}]`,
+		`  status=${showMeasured(r.outcome.supStatus)} source=${showMeasured(r.outcome.supStatusSource)} reason=${showMeasured(r.outcome.supReason)} failure=${fmtFailure(r.outcome.failure)}`,
+		`  steers=${steerNote}`,
+		`  waves=${showMeasured(o.waves)} sizes=${isUnavailable(o.waveSizes) ? `unavailable — ${o.waveSizes.unavailable}` : `[${o.waveSizes.join(",")}]`} workers=${showMeasured(o.workersSpawned)} settled=${showMeasured(o.workersSettled)} cancelled=${showMeasured(o.workersCancelled)}`,
+		`  concurrency max=${showMeasured(o.maxConcurrency)} utilization=${showMeasured(o.workerUtilization)} idle=${fmtMs(o.idleMs)} (${showMeasured(o.idlePct)}%) wall=${fmtMs(o.supervisorWallMs)}${o.supervisorWallSource === "journal-span" ? " (journal-span lower bound)" : ""}`,
+		`  respawns=${showMeasured(o.respawns)} evidence→respawn=${showMeasured(r.decision.observeThenRespawn)} blind-respawn=${showMeasured(r.decision.respawnWithoutEvidence)} depth=${showMeasured(o.delegationDepth)}`,
+		`  accepted=${showMeasured(r.decision.accepted)} rejected=${showMeasured(r.decision.rejected)} empty-pass=${showMeasured(r.decision.emptyPass)}`,
+		`  brain=$${showMeasured(r.economics.brain.usd)} total=$${showMeasured(r.economics.totalUsd)} judge.resolved=${showMeasured(r.outcome.judgeResolved)} score=${showMeasured(r.outcome.judgeScore)} verify=${showMeasured(r.outcome.verifyPass)}`,
+		r.gaps.length > 0 ? `  gaps(${r.gaps.length}): ${r.gaps.join("; ")}` : "  gaps: none"
+	].join("\n");
+}
+/**
+* The recorded error on one line; `none recorded` and `unavailable` stay
+* distinct, and a throw the run outlived is labeled so it is not read as the
+* outcome of the settled result beside it.
+*/
+function fmtFailure(v) {
+	if (isUnavailable(v)) return `unavailable — ${v.unavailable}`;
+	if (v === null) return "none recorded";
+	const name = v.name ?? "unavailable — record has no error.name";
+	const message = v.message ?? "unavailable — record has no error.message";
+	const attempt = v.earlierAttempt ? ", earlier attempt" : "";
+	return `${name}: ${message} [${v.source}${v.at === null ? "" : ` at ${v.at}`}${attempt}]`;
+}
+function fmtMs(v) {
+	if (isUnavailable(v)) return `unavailable — ${v.unavailable}`;
+	if (v < 1e3) return `${v}ms`;
+	const s = v / 1e3;
+	if (s < 120) return `${round(s, 1)}s`;
+	return `${round(s / 60, 1)}min`;
+}
+function renderSupervisorRunMarkdown(r) {
+	const o = r.orchestration;
+	const d = r.decision;
+	const e = r.economics;
+	const out = [];
+	out.push(`# Run report — ${r.instanceId ?? "unknown instance"} [${r.arm ?? "unknown arm"}]`);
+	out.push("");
+	out.push("```");
+	out.push(renderSupervisorRunHeadline(r));
+	out.push("```");
+	out.push("");
+	out.push(`- Run: \`${r.runRef}\``);
+	out.push(`- Supervisor: \`${showMeasured(r.supervisorId)}\``);
+	out.push(`- Supervisor profile: \`${showMeasured(r.supervisorProfileDigest)}\``);
+	out.push(`- Generated: ${r.generatedAt}`);
+	out.push("");
+	out.push("## Orchestration");
+	out.push("");
+	out.push("| Metric | Value |");
+	out.push("|---|---|");
+	out.push(`| Workers spawned | ${showMeasured(o.workersSpawned)} |`);
+	out.push(`| Workers settled | ${showMeasured(o.workersSettled)} |`);
+	out.push(`| Workers cancelled | ${showMeasured(o.workersCancelled)} |`);
+	out.push(`| **Steers (mid-task messages to live workers)** | **${showMeasured(o.steers)}** |`);
+	out.push(`| Steers delivered | ${showMeasured(o.steersDelivered)} |`);
+	out.push(`| Outer-driver \`supervisor_steer\` calls | ${showMeasured(o.driverSteerCalls)} |`);
+	out.push(`| Spawn waves | ${showMeasured(o.waves)} |`);
+	out.push(`| Wave sizes | ${isUnavailable(o.waveSizes) ? showMeasured(o.waveSizes) : `[${o.waveSizes.join(", ")}]`} |`);
+	out.push(`| Max concurrency | ${showMeasured(o.maxConcurrency)} |`);
+	out.push(`| Respawns (after same parent's first settle) | ${showMeasured(o.respawns)} |`);
+	out.push(`| Repeated labels | ${isUnavailable(o.repeatedLabels) ? showMeasured(o.repeatedLabels) : o.repeatedLabels.length === 0 ? "none" : o.repeatedLabels.join(", ")} |`);
+	out.push(`| Delegation depth | ${showMeasured(o.delegationDepth)} |`);
+	out.push(`| Time to first spawn | ${fmtMs(o.timeToFirstSpawnMs)} |`);
+	out.push(`| Supervisor wall | ${fmtMs(o.supervisorWallMs)}${isUnavailable(o.supervisorWallSource) ? "" : ` (source: ${o.supervisorWallSource}${o.supervisorWallSource === "journal-span" ? ", lower bound" : ""})`} |`);
+	out.push(`| Idle (zero live workers) | ${fmtMs(o.idleMs)} (${showMeasured(o.idlePct)}%) |`);
+	out.push(`| Worker utilization (Σ worker wall ÷ supervisor wall) | ${showMeasured(o.workerUtilization)} |`);
+	out.push("");
+	if (!isUnavailable(o.steersByWorker) && o.steersByWorker.length > 0) {
+		out.push("### Steers per worker");
+		out.push("");
+		out.push("| Worker id | Label | Queued | Delivered |");
+		out.push("|---|---|---:|---:|");
+		for (const s of o.steersByWorker) out.push(`| ${s.workerId === null ? "unavailable — legacy label join" : `\`${s.workerId}\``} | \`${s.worker}\` | ${s.queued} | ${s.delivered} |`);
+		out.push("");
+	} else if (isUnavailable(o.steersByWorker)) out.push(`### Steers per worker\n\nunavailable — ${o.steersByWorker.unavailable}\n`);
+	out.push("## Decision quality");
+	out.push("");
+	out.push("| Metric | Value |");
+	out.push("|---|---|");
+	out.push(`| Settled by status | ${fmtCounts(d.settledByStatus)} |`);
+	out.push(`| Settled verdicts | ${fmtCounts(d.settledVerdicts)} |`);
+	out.push(`| Accepted (verify green + patch bytes) | ${showMeasured(d.accepted)} |`);
+	out.push(`| Rejected (verify red) | ${showMeasured(d.rejected)} |`);
+	out.push(`| Empty pass (green, no patch) | ${showMeasured(d.emptyPass)} |`);
+	out.push(`| Evidence → respawn sequences | ${showMeasured(d.observeThenRespawn)} |`);
+	out.push(`| Respawn with no same-parent settled evidence in front | ${showMeasured(d.respawnWithoutEvidence)} |`);
+	out.push(`| Review actions (steers + worker questions) | ${showMeasured(d.reviewActions)} |`);
+	out.push(`| Worker evidence returned | ${isUnavailable(d.workerEvidenceBytes) ? showMeasured(d.workerEvidenceBytes) : `${d.workerEvidenceBytes} bytes`} |`);
+	out.push("");
+	out.push("## Economics");
+	out.push("");
+	out.push("| Role | Tokens in | Tokens out | Cache read | Cache write | USD | Source |");
+	out.push("|---|---:|---:|---:|---:|---:|---|");
+	out.push(`| brain | ${showMeasured(e.brain.tokensIn)} | ${showMeasured(e.brain.tokensOut)} | ${showMeasured(e.brain.cacheRead)} | ${showMeasured(e.brain.cacheWrite)} | ${showMeasured(e.brain.usd)} | ${e.brain.source} |`);
+	out.push(`| workers | ${showMeasured(e.workers.tokensIn)} | ${showMeasured(e.workers.tokensOut)} | ${showMeasured(e.workers.cacheRead)} | ${showMeasured(e.workers.cacheWrite)} | ${showMeasured(e.workers.usd)} | ${e.workers.source} |`);
+	out.push("");
+	if (!isUnavailable(e.brainTruncations) && e.brainTruncations > 0) out.push(`- **BRAIN OUTPUT TRUNCATED: ${e.brainTruncations} completion(s) hit \`finish_reason: "length"\`** — the supervisor acted on a half-written plan. Its output ceiling is too low; see \`brain.jsonl\` for the per-call \`req_max_tokens\`.`);
+	else out.push(`- Brain completions truncated (finish_reason=length): ${showMeasured(e.brainTruncations)}`);
+	out.push(`- Total USD: ${showMeasured(e.totalUsd)} (source: ${e.totalUsdSource})`);
+	out.push(`- Spend measured two ways: journal-derived $${showMeasured(e.spend.journalDerived.usd)} over ${e.spend.journalDerived.records} journal record(s) (execution accounting) · close-record $${showMeasured(e.spend.closeRecord.usd)} over ${e.spend.closeRecord.records} close record(s) (billing-shaped). Divergence is a signal, not an error.`);
+	out.push(`- Cost per accepted patch: ${showMeasured(e.costPerAcceptedPatchUsd)}`);
+	if (isUnavailable(e.workerWallMsDistribution)) out.push(`- Worker wall distribution: unavailable — ${e.workerWallMsDistribution.unavailable}`);
+	else {
+		const w = e.workerWallMsDistribution;
+		out.push(`- Worker wall (n=${w.n}): min ${fmtMs(w.min)} / p50 ${fmtMs(w.p50)} / p90 ${fmtMs(w.p90)} / max ${fmtMs(w.max)} / Σ ${fmtMs(w.sum)}`);
+	}
+	out.push("");
+	if (!isUnavailable(e.perWorker) && e.perWorker.length > 0) {
+		out.push("| Worker id | Label | Role | Runtime | Profile digest | Status | Failure | Infra | Wall | Tokens in | Tokens out | Patch bytes | Verify passed | Score |");
+		out.push("|---|---|---|---|---|---|---|---|---:|---:|---:|---:|---|---:|");
+		for (const w of e.perWorker) out.push(`| ${w.workerId === null ? "unavailable — legacy label join" : `\`${w.workerId}\``} | \`${w.worker}\` | ${w.role ?? "unavailable — source recorded no role"} | ${w.runtime ?? "unavailable — source recorded no runtime"} | ${w.profileDigest === null ? "unavailable — source recorded no profile digest" : `\`${w.profileDigest}\``} | ${w.status ?? "unavailable — no terminal event"} | ${w.failure ?? "none recorded"} | ${w.infra ?? "unavailable"} | ${w.wallMs === null ? "unavailable — no spawn/finish pair" : fmtMs(w.wallMs)} | ${w.tokensIn ?? "unavailable — store does not attribute tokens per worker"} | ${w.tokensOut ?? "unavailable — store does not attribute tokens per worker"} | ${w.patchBytes ?? "unavailable — no worker patch file"} | ${w.passed === null ? "unavailable — no verdict" : String(w.passed)} | ${w.score ?? "unavailable — no numeric score"} |`);
+		out.push("");
+	}
+	out.push("## Outcome");
+	out.push("");
+	out.push("| Metric | Value |");
+	out.push("|---|---|");
+	out.push(`| Supervisor status | ${showMeasured(r.outcome.supStatus)} |`);
+	out.push(`| Status source | ${showMeasured(r.outcome.supStatusSource)} |`);
+	out.push(`| Terminal reason | ${showMeasured(r.outcome.supReason)} |`);
+	out.push(`| Failure | ${fmtFailure(r.outcome.failure)} |`);
+	out.push(`| Supervisor verdict | ${showMeasured(r.outcome.supVerdict)} |`);
+	out.push(`| Delivered | ${showMeasured(r.outcome.delivered)} |`);
+	out.push(`| Judge resolved | ${showMeasured(r.outcome.judgeResolved)} |`);
+	out.push(`| Judge score | ${showMeasured(r.outcome.judgeScore)} |`);
+	out.push(`| Judge passed / total | ${showMeasured(r.outcome.judgePassed)} / ${showMeasured(r.outcome.judgeTotal)} |`);
+	out.push(`| Judge source | ${r.outcome.judgeSource ?? "unavailable — no judge.json and no ledger row"} |`);
+	out.push(`| Verify gate | pass=${showMeasured(r.outcome.verifyPass)} rc=${showMeasured(r.outcome.verifyRc)} |`);
+	if (isUnavailable(r.outcome.patch)) out.push(`| Patch | unavailable — ${r.outcome.patch.unavailable} |`);
+	else {
+		const p = r.outcome.patch;
+		out.push(`| Patch | ${p.files} file(s), +${p.linesAdded}/-${p.linesRemoved}, test files touched: ${p.testFilesTouched.length === 0 ? "none" : p.testFilesTouched.join(", ")} |`);
+	}
+	out.push("");
+	out.push("## Gaps");
+	out.push("");
+	if (r.gaps.length === 0) out.push("None — every metric above is backed by a present artifact.");
+	else for (const g of r.gaps) out.push(`- ${g}`);
+	out.push("");
+	out.push(`> Harness-session view of the same run (model calls, stuck loops, tool errors): \`${r.traceCommand}\``);
+	out.push("");
+	return out.join("\n");
+}
+function fmtCounts(v) {
+	if (isUnavailable(v)) return showMeasured(v);
+	const entries = Object.entries(v);
+	return entries.length === 0 ? "none" : entries.map(([k, n]) => `${k}=${n}`).join(", ");
+}
+function renderSupervisorRollupMarkdown(rollup, title = "Round rollup") {
+	const out = [];
+	out.push(`# ${title}`);
+	out.push("");
+	out.push(`- Cells: ${rollup.cells}`);
+	out.push(`- **Steers across all cells: ${showMeasured(rollup.steersTotal)}** (cells with ≥1 steer: ${showMeasured(rollup.cellsWithSteers)}; cells where the steer count is unavailable: ${rollup.cellsWithUnavailableSteers})`);
+	out.push(`- Waves per cell (mean): ${showMeasured(rollup.wavesMean)}`);
+	out.push(`- Max concurrency observed: ${showMeasured(rollup.maxConcurrencyMax)}`);
+	out.push(`- Worker utilization (mean): ${showMeasured(rollup.utilizationMean)}`);
+	out.push(`- Idle share (mean): ${showMeasured(rollup.idlePctMean)}%`);
+	out.push(`- Workers spawned: ${showMeasured(rollup.workersSpawnedTotal)} · accepted: ${showMeasured(rollup.acceptedTotal)}`);
+	out.push(`- Spend: $${showMeasured(rollup.usdTotal)} · judged resolved: ${showMeasured(rollup.resolvedCount)}/${rollup.cells}`);
+	out.push(`- Spend measured two ways: journal-derived $${showMeasured(rollup.spendUsd.journalDerived.value)} over ${rollup.spendUsd.journalDerived.runs}/${rollup.cells} runs (execution accounting) · close-record $${showMeasured(rollup.spendUsd.closeRecord.value)} over ${rollup.spendUsd.closeRecord.runs}/${rollup.cells} runs (billing-shaped)`);
+	out.push("");
+	out.push("| Instance | Arm | Steers | Waves | Utilization | Idle % | Resolved | USD |");
+	out.push("|---|---|---:|---:|---:|---:|---|---:|");
+	for (const c of rollup.perCell) out.push(`| ${c.instanceId ?? "?"} | ${c.arm ?? "?"} | ${showMeasured(c.steers)} | ${showMeasured(c.waves)} | ${showMeasured(c.utilization)} | ${showMeasured(c.idlePct)} | ${showMeasured(c.resolved)} | ${showMeasured(c.usd)} |`);
+	out.push("");
+	return out.join("\n");
+}
+//#endregion
+//#region src/supervisor-run/runtime-reader.ts
+/**
+* Reader for agent-runtime's file-backed supervision context.
+*
+* Runtime stores multiple recursive trees in one `spawn-journal.jsonl`.
+* Each line is an envelope whose `root` identifies the local tree. A journal
+* can connect a nested tree with `spawned.ownedTreeRoot`. It can also use the
+* spawned child id as the nested root and repeat the spawn as a parentless
+* marker when no owned tree is recorded. Descendant spawns must occur in the
+* tree their parent owns. This reader removes a duplicate marker and preserves
+* the other envelopes for the supervisor-run analyzer. Runtime stores profile
+* identity below `identity` and does not emit Eval's role field. This boundary
+* projects those fields without changing Runtime's dialect.
+*
+* The run's terminal record is Runtime's own: `result.json` is the
+* `SupervisedResult` that `supervise()` returned, verbatim, and its `kind`
+* (`winner`, `no-winner`, or whatever a later arm is called) is the status.
+* `failure.json` (`{ runId, pursuitId, at, error: { name, message } }`) is the
+* record Runtime writes when `supervise()` threw before a result landed. Both
+* pass through as bytes; `terminal-record.ts` reads them. The reader does not
+* decide which kinds count: a kind it refuses is a run that recorded its
+* outcome and got reported as having none. Nothing here manufactures a loops
+* `state.json` status from Runtime's documents: the analyzer names the record
+* a status came from, and a synthetic legacy document would mislabel it.
+*
+* `usdKnown: false` / `tokensKnown: false` on ONE record is not a limit of this
+* store. The store recorded every other record completely, so the flags travel
+* through to the analyzer per record, which reports the measured nodes and
+* names the unreported ones.
+*/
+const JOURNAL_FILE = "spawn-journal.jsonl";
+const OBSERVER_FILE = "observer.jsonl";
+const RESULT_FILE = "result.json";
+const FAILURE_FILE = "failure.json";
+/**
+* The files only Runtime's durable layer writes. Any one of them marks a
+* Runtime run directory: `supervise()` opens the spawn journal on its first
+* event, and `supervisePursuit` appends the observer's `before` event and, on
+* a throw, the failure record before any spawn.
+*
+* Measured motive (discovery-lab recursive smoke r1, 2026-09-06): the first
+* attempt threw on a caller input error 16 minutes before the corrected attempt
+* opened the spawn journal. At that instant the directory held `observer.jsonl`
+* (2 records) and the failure record and no journal, so a journal-only test
+* routed it to the loops reader, which reads neither file, and the recorded
+* throw was reported as no run at all.
+*/
+const RUNTIME_RUN_DIR_MARKERS = [
+	JOURNAL_FILE,
+	OBSERVER_FILE,
+	FAILURE_FILE
+];
+async function readMaybe$1(path) {
+	return readFile(path, "utf8").catch((error) => {
+		if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	});
+}
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function nonEmptyString(value) {
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function profileDigest(event) {
+	const direct = nonEmptyString(event.profileDigest);
+	if (direct !== null) return direct;
+	const identity = record(event.identity);
+	return identity === null ? null : nonEmptyString(identity.profileDigest);
+}
+function formatError(path, line, detail) {
+	return /* @__PURE__ */ new Error(`${path}:${line}: invalid Runtime spawn journal: ${detail}`);
+}
+function parseEnvelopeJournal(text, path) {
+	const begins = [];
+	const events = [];
+	const begun = /* @__PURE__ */ new Map();
+	for (const [index, sourceLine] of text.split("\n").entries()) {
+		const line = index + 1;
+		const trimmed = sourceLine.trim();
+		if (trimmed.length === 0) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			throw formatError(path, line, "line is not JSON");
+		}
+		const envelope = record(parsed);
+		if (envelope === null) throw formatError(path, line, "line is not an object");
+		const kind = nonEmptyString(envelope.kind);
+		const root = nonEmptyString(envelope.root);
+		if (root === null) throw formatError(path, line, "root must be a non-empty string");
+		if (kind === "begin") {
+			const at = nonEmptyString(envelope.at);
+			if (at === null || !Number.isFinite(Date.parse(at))) throw formatError(path, line, "begin.at must be an ISO timestamp");
+			if (begun.has(root)) throw formatError(path, line, `tree ${JSON.stringify(root)} began twice`);
+			const begin = {
+				root,
+				at,
+				line
+			};
+			begun.set(root, begin);
+			begins.push(begin);
+			continue;
+		}
+		if (kind !== "event") throw formatError(path, line, "kind must be 'begin' or 'event'");
+		if (!begun.has(root)) throw formatError(path, line, `event for tree ${JSON.stringify(root)} precedes begin`);
+		const event = record(envelope.event);
+		if (event === null) throw formatError(path, line, "event must be an object");
+		if (nonEmptyString(event.kind) === null) throw formatError(path, line, "event.kind must be a non-empty string");
+		events.push({
+			root,
+			event: { ...event },
+			line
+		});
+	}
+	if (begins.length === 0) throw formatError(path, 1, "no begin record");
+	const parentSpawnsById = /* @__PURE__ */ new Map();
+	const parentSpawnsByOwnedTreeRoot = /* @__PURE__ */ new Map();
+	const rootMarkersByTree = /* @__PURE__ */ new Map();
+	for (const entry of events) {
+		if (entry.event.kind !== "spawned") continue;
+		const id = nonEmptyString(entry.event.id);
+		if (id === null) continue;
+		if (nonEmptyString(entry.event.parent) !== null) {
+			const ownedTreeRoot = nonEmptyString(entry.event.ownedTreeRoot);
+			if (ownedTreeRoot !== null) {
+				const owners = parentSpawnsByOwnedTreeRoot.get(ownedTreeRoot) ?? [];
+				owners.push(entry);
+				parentSpawnsByOwnedTreeRoot.set(ownedTreeRoot, owners);
+			} else {
+				const matches = parentSpawnsById.get(id) ?? [];
+				matches.push(entry);
+				parentSpawnsById.set(id, matches);
+			}
+		}
+		if (entry.root === id && (entry.event.parent === void 0 || entry.event.parent === null)) {
+			const markers = rootMarkersByTree.get(entry.root) ?? [];
+			markers.push(entry);
+			rootMarkersByTree.set(entry.root, markers);
+		}
+	}
+	const nestedRoots = /* @__PURE__ */ new Set();
+	const nestedParentSpawns = /* @__PURE__ */ new Map();
+	for (const begin of begins) {
+		const parentSpawns = [.../* @__PURE__ */ new Set([...parentSpawnsByOwnedTreeRoot.get(begin.root) ?? [], ...parentSpawnsById.get(begin.root) ?? []])].filter((entry) => entry.root !== begin.root);
+		if (parentSpawns.length > 1) throw formatError(path, begin.line, `tree ${JSON.stringify(begin.root)} has ${parentSpawns.length} parent spawns`);
+		if (parentSpawns.length === 1) {
+			nestedRoots.add(begin.root);
+			nestedParentSpawns.set(begin.root, parentSpawns[0]);
+		}
+	}
+	const topRoots = begins.filter((begin) => !nestedRoots.has(begin.root));
+	if (topRoots.length !== 1) throw formatError(path, topRoots[0]?.line ?? 1, `expected one top-level tree, found ${topRoots.length}`);
+	const top = topRoots[0];
+	for (const nestedRoot of nestedRoots) {
+		const markers = rootMarkersByTree.get(nestedRoot) ?? [];
+		if (markers.length > 1) throw formatError(path, begun.get(nestedRoot)?.line ?? 1, `nested tree ${JSON.stringify(nestedRoot)} contains ${markers.length} root markers`);
+		const parentSpawn = nestedParentSpawns.get(nestedRoot);
+		if (parentSpawn === void 0) throw formatError(path, begun.get(nestedRoot)?.line ?? 1, `nested tree ${JSON.stringify(nestedRoot)} has no parent spawn`);
+		const markerDigest = profileDigest(markers[0]?.event ?? {});
+		const parentDigest = profileDigest(parentSpawn.event);
+		if (markerDigest !== null && parentDigest !== null && markerDigest !== parentDigest) throw formatError(path, markers[0]?.line ?? 1, `nested tree ${JSON.stringify(nestedRoot)} disagrees with its parent profile digest`);
+		if (parentDigest === null && markerDigest !== null) parentSpawn.event.profileDigest = markerDigest;
+	}
+	const ownedTreeBySupervisorId = /* @__PURE__ */ new Map([[top.root, top.root]]);
+	for (const [nestedRoot, parentSpawn] of nestedParentSpawns) {
+		const supervisorId = nonEmptyString(parentSpawn.event.id);
+		if (supervisorId === null) continue;
+		const priorTree = ownedTreeBySupervisorId.get(supervisorId);
+		if (priorTree !== void 0 && priorTree !== nestedRoot) throw formatError(path, parentSpawn.line, `spawn ${JSON.stringify(supervisorId)} owns both ${JSON.stringify(priorTree)} and ${JSON.stringify(nestedRoot)}`);
+		ownedTreeBySupervisorId.set(supervisorId, nestedRoot);
+	}
+	for (const entry of events) {
+		if (entry.event.kind !== "spawned") continue;
+		const parentId = nonEmptyString(entry.event.parent);
+		if (parentId === null) continue;
+		const parentTree = ownedTreeBySupervisorId.get(parentId);
+		if (parentTree === void 0) throw formatError(path, entry.line, `spawn ${JSON.stringify(entry.event.id)} names parent ${JSON.stringify(parentId)}, which owns no journal tree`);
+		if (entry.root !== parentTree) throw formatError(path, entry.line, `spawn ${JSON.stringify(entry.event.id)} is in tree ${JSON.stringify(entry.root)}, but parent ${JSON.stringify(parentId)} owns tree ${JSON.stringify(parentTree)}`);
+	}
+	const supervisorIds = /* @__PURE__ */ new Set([top.root, ...[...nestedParentSpawns.values()].map((entry) => nonEmptyString(entry.event.id)).filter((id) => id !== null)]);
+	const normalized = events.filter((entry) => !(nestedRoots.has(entry.root) && entry.event.kind === "spawned" && entry.event.id === entry.root && (entry.event.parent === void 0 || entry.event.parent === null))).map((entry) => {
+		const event = { ...entry.event };
+		if (event.kind === "spawned") {
+			const digest = profileDigest(event);
+			if (event.profileDigest === void 0 && digest !== null) event.profileDigest = digest;
+			if (event.role === void 0) event.role = supervisorIds.has(nonEmptyString(event.id) ?? "") ? "supervisor" : "worker";
+		}
+		return {
+			root: entry.root,
+			event
+		};
+	});
+	if ((rootMarkersByTree.get(top.root) ?? []).length !== 1) throw formatError(path, top.line, `top-level tree ${JSON.stringify(top.root)} must contain one root marker`);
+	return {
+		root: top.root,
+		startedAt: top.at,
+		journal: `${normalized.map((entry) => JSON.stringify({
+			kind: "event",
+			root: entry.root,
+			event: entry.event
+		})).join("\n")}\n`,
+		events: normalized.map((entry) => entry.event)
+	};
+}
+function parseOptionalRecord(text, path) {
+	if (text === null) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new Error(`${path}: invalid JSON`);
+	}
+	const value = record(parsed);
+	if (value === null) throw new Error(`${path}: expected a JSON object`);
+	return value;
+}
+function spendRecord(value) {
+	const spend = record(value);
+	if (spend === null) return null;
+	const tokens = record(spend.tokens);
+	if (tokens === null || typeof tokens.input !== "number" || !Number.isFinite(tokens.input) || tokens.input < 0 || typeof tokens.output !== "number" || !Number.isFinite(tokens.output) || tokens.output < 0 || typeof spend.usd !== "number" || !Number.isFinite(spend.usd) || spend.usd < 0 || spend.usdKnown !== void 0 && typeof spend.usdKnown !== "boolean") return null;
+	return spend;
+}
+function sourceLimits(root, events, workerIds) {
+	const rootMeters = events.filter((event) => event.kind === "metered" && event.id === root);
+	const invalidRootMeters = rootMeters.filter((event) => spendRecord(event.spend) === null);
+	const rootMeterReason = rootMeters.length === 0 ? "Runtime journal has no root metered event" : invalidRootMeters.length > 0 ? `${invalidRootMeters.length} root metered event(s) lack complete spend` : null;
+	const closes = events.filter((event) => workerIds.has(nonEmptyString(event.id) ?? "") && (event.kind === "settled" || event.kind === "cancelled"));
+	const settledById = /* @__PURE__ */ new Map();
+	for (const event of closes) {
+		const id = nonEmptyString(event.id);
+		if (id === null) continue;
+		const matches = settledById.get(id) ?? [];
+		matches.push(event);
+		settledById.set(id, matches);
+	}
+	const incompleteWorkers = [...workerIds].filter((id) => {
+		const terminal = settledById.get(id);
+		return terminal?.length !== 1 || terminal[0]?.kind !== "settled" || spendRecord(terminal[0]?.spent) === null;
+	});
+	const missingVerdicts = [...workerIds].filter((id) => {
+		const terminal = settledById.get(id)?.[0];
+		if (terminal?.kind !== "settled") return true;
+		return typeof record(terminal.verdict)?.valid !== "boolean";
+	});
+	return {
+		managerTokens: rootMeterReason,
+		workerTokens: incompleteWorkers.length === 0 ? null : `${incompleteWorkers.length}/${workerIds.size} child invocation(s) lack one settled spend record`,
+		spendUsd: rootMeterReason !== null ? rootMeterReason : incompleteWorkers.length > 0 ? "at least one child invocation lacks a settled spend record" : null,
+		workerVerdicts: missingVerdicts.length === 0 ? null : `${missingVerdicts.length}/${workerIds.size} child invocation(s) lack a structured validity verdict`,
+		deliverables: workerIds.size === 0 ? null : "Runtime FileRunContext does not retain per-child delivered patches"
+	};
+}
+/**
+* Refuse a `result.json` that belongs to another run. Runtime's result carries
+* its own `tree.root`; a settled record with a different root is a copied or
+* misplaced file, and reading its status onto this journal misreports the run.
+*/
+function assertResultMatchesJournal(root, result, resultPath) {
+	const resultKind = result === null ? null : nonEmptyString(result.kind);
+	if (resultKind === null || result === null) return;
+	const resultRoot = nonEmptyString(record(result.tree)?.root);
+	if (resultRoot === null) throw new Error(`${resultPath}: Runtime ${resultKind} result has no tree.root`);
+	if (resultRoot !== root) throw new Error(`${resultPath}: root ${JSON.stringify(resultRoot)} does not match journal root ${JSON.stringify(root)}`);
+}
+/**
+* Refuse a `failure.json` that is not a failure record. Runtime writes
+* `{ runId, pursuitId, at, error: { name, message } }`; a document without an
+* `error` object is not one, and reading it as a failure invents a terminal
+* state the run never recorded. The record carries no tree root, so its
+* identity is not checked against the journal.
+*/
+function assertFailureRecord(failure, failurePath) {
+	if (failure === null) return;
+	if (record(failure.error) === null) throw new Error(`${failurePath}: Runtime failure record has no error object`);
+}
+/**
+* The journal's begin stamp in the analyzer's state-document shape. It carries
+* the run identity and start instant only; the terminal status lives in
+* Runtime's own `result.json` / `failure.json`, which the analyzer reads by
+* name, so no legacy `status` field is fabricated here.
+*/
+function runtimeBeginState(root, startedAt) {
+	return JSON.stringify({
+		id: root,
+		startedAt
+	});
+}
+/**
+* Sources for a run dir whose spawn journal does not exist. Mirrors the
+* absent shape `readLoopsSupervisorRun` returns for a missing store: every
+* journal-dependent metric downstream reads `unavailable`, never 0.
+*/
+/**
+* The run identity a terminal record names when no journal exists yet: the
+* settle record's `tree.root`, else the failure record's `runId`. Both are
+* Runtime's own `runId`, so the report names the run the record is about
+* instead of `?`.
+*/
+function recordedRunId(result, failure) {
+	return nonEmptyString(record(result?.tree)?.root) ?? nonEmptyString(failure?.runId);
+}
+function absentRuntimeSupervisorRun(runDir, resultText, failureText, instanceId) {
+	const reason = `no Runtime spawn journal (${JOURNAL_FILE}) under ${runDir}`;
+	return {
+		runRef: runDir,
+		instanceId,
+		arm: null,
+		supRunDir: null,
+		journal: null,
+		journalMissingReason: reason,
+		brainLog: null,
+		brainLogMissingReason: "Runtime FileRunContext records spend but not model completion finish reasons",
+		state: null,
+		progress: null,
+		workers: null,
+		workersMissingReason: reason,
+		result: resultText,
+		failure: failureText,
+		judge: null,
+		judgeSource: null,
+		patch: null,
+		driverLog: null,
+		harnessWorkerTokens: null,
+		harnessMissingReason: "Runtime FileRunContext has no external worker-token join",
+		limits: NO_SOURCE_LIMITS,
+		rootTranscriptRef: null,
+		traceCommand: "unavailable — Runtime FileRunContext records no provider-session trace identity"
+	};
+}
+/**
+* Read one agent-runtime `createFileRunContext(dir)` directory.
+*
+* A run dir without `spawn-journal.jsonl` returns the same absent-shaped
+* sources `readLoopsSupervisorRun` returns for a missing store: `journal` and
+* `workers` null, each with its reason, so every dependent metric reads
+* `unavailable` — never 0 and never a throw. Its `result.json` and
+* `failure.json` are still read, so a run that died before its first spawn
+* reports the failure Runtime recorded. Pass `strict: true` to throw on the
+* missing journal instead. A journal, result, or failure document that exists
+* but cannot be parsed always throws: a corrupt record is a defect, not an
+* absence.
+*
+* The reader translates storage envelopes only. It does not assign research
+* roles, interpret artifacts, or turn process completion into a quality
+* verdict.
+*/
+async function readRuntimeSupervisorRun(runDir, opts = {}) {
+	const journalPath = join(runDir, JOURNAL_FILE);
+	const rawJournal = opts.strict === true ? await readFile(journalPath, "utf8") : await readMaybe$1(journalPath);
+	const resultPath = join(runDir, RESULT_FILE);
+	const failurePath = join(runDir, FAILURE_FILE);
+	const resultText = await readMaybe$1(resultPath);
+	const failureText = await readMaybe$1(failurePath);
+	const failure = parseOptionalRecord(failureText, failurePath);
+	assertFailureRecord(failure, failurePath);
+	const result = parseOptionalRecord(resultText, resultPath);
+	if (rawJournal === null) return absentRuntimeSupervisorRun(runDir, resultText, failureText, recordedRunId(result, failure));
+	const normalized = parseEnvelopeJournal(rawJournal, journalPath);
+	assertResultMatchesJournal(normalized.root, result, resultPath);
+	const childSpawns = normalized.events.filter((event) => event.kind === "spawned" && nonEmptyString(event.id) !== null).filter((event) => event.id !== normalized.root);
+	const workerIds = new Set(childSpawns.map((event) => nonEmptyString(event.id)).filter((id) => id !== null));
+	const workers = childSpawns.map((event) => ({
+		workerId: nonEmptyString(event.id),
+		label: nonEmptyString(event.label) ?? String(event.id),
+		events: null,
+		inbox: null,
+		patchBytes: null,
+		transcriptRef: null,
+		patchPath: null
+	}));
+	return {
+		runRef: runDir,
+		instanceId: normalized.root,
+		arm: null,
+		supRunDir: runDir,
+		journal: normalized.journal,
+		brainLog: null,
+		brainLogMissingReason: "Runtime FileRunContext records spend but not model completion finish reasons",
+		state: runtimeBeginState(normalized.root, normalized.startedAt),
+		progress: null,
+		workers,
+		workersMissingReason: null,
+		result: resultText,
+		failure: failureText,
+		judge: null,
+		judgeSource: null,
+		patch: null,
+		driverLog: null,
+		harnessWorkerTokens: null,
+		harnessMissingReason: "Runtime FileRunContext has no external worker-token join",
+		limits: sourceLimits(normalized.root, normalized.events, workerIds),
+		rootTranscriptRef: null,
+		traceCommand: "unavailable — Runtime FileRunContext records no provider-session trace identity"
+	};
+}
+/** The agent-runtime file-backed layout as a `SupervisorRunReader`. */
+function runtimeSupervisorRunReader(runDir, opts = {}) {
+	return {
+		runRef: runDir,
+		read: () => readRuntimeSupervisorRun(runDir, opts)
+	};
+}
+/**
+* True when a directory holds any file only Runtime's durable layer writes:
+* the spawn journal, the observer journal, or the failure record. A run that
+* threw before its first spawn has no journal yet and is still a Runtime run.
+*/
+async function isRuntimeSupervisorRunDir(runDir) {
+	for (const marker of RUNTIME_RUN_DIR_MARKERS) if (await isFile(join(runDir, marker))) return true;
+	return false;
+}
+async function isFile(path) {
+	return stat(path).then((entry) => entry.isFile()).catch((error) => {
+		if (typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) return false;
+		throw error;
+	});
+}
+//#endregion
+//#region src/supervisor-run/loops-reader.ts
+/**
+* ONE implementation of `SupervisorRunReader`: the on-disk layout the loops
+* supervisor writes — `<runDir>/ws/.agent/supervisor/<id>/{journal.jsonl,
+* state.json, progress.ndjson, workers/*.ndjson}` alongside the run's
+* `result.json` / `judge.json` / `driver.log` / delivered patch. Runs written
+* before the `.agent` rename live under `<ws>/.loops/supervisor/<id>` and are
+* still found via fallback.
+*
+* Nothing in `analyze.ts` knows this layout exists. A different store (an
+* archive, an object bucket, a database) implements the same interface and
+* gets the same report.
+*
+* Worker token recovery reuses the rollout module's opencode reader rather
+* than opening a second sqlite path — one store client, one corruption policy.
+*/
+async function readMaybe(path) {
+	return readFile(path, "utf8").catch(() => null);
+}
+/**
+* Locate the (single) supervisor run dir under `<ws>/.agent/supervisor`, falling back to the
+* pre-rename `<ws>/.loops/supervisor` so runs written by older supervisors stay analyzable.
+*/
+async function findSupervisorRunDirIn(ws) {
+	for (const stateDir of [".agent", ".loops"]) {
+		const root = join(ws, stateDir, "supervisor");
+		const dirs = (await readdir(root, { withFileTypes: true }).catch(() => [])).filter((e) => e.isDirectory()).map((e) => join(root, e.name));
+		if (dirs[0] !== void 0) return dirs[0];
+	}
+	return null;
+}
+/**
+* Read a loops supervisor run directory into source bytes. Never throws on a
+* missing artifact — an absent file becomes a `null` field, which is what makes
+* the dependent metric `unavailable` instead of 0.
+*/
+async function readLoopsSupervisorRun(runDir, opts = {}) {
+	const ws = opts.ws ?? join(runDir, "ws");
+	const supRunDir = await findSupervisorRunDirIn(ws);
+	const result = await readMaybe(join(runDir, "result.json"));
+	const resultObj = parseJson(result);
+	const journal = supRunDir === null ? null : await readMaybe(join(supRunDir, "journal.jsonl"));
+	const journalWorkerSpawns = parseJsonl(journal).filter((event) => event.kind === "spawned" && typeof event.parent === "string" && event.role !== "supervisor").length;
+	let workers = null;
+	let workersMissingReason = null;
+	const workerCwds = [];
+	let workerStarts = 0;
+	if (supRunDir === null) workersMissingReason = `no supervisor run dir under ${join(ws, ".agent", "supervisor")} (or legacy ${join(ws, ".loops", "supervisor")})`;
+	else {
+		const workersDir = join(supRunDir, "workers");
+		const entries = await readdir(workersDir).catch(() => null);
+		if (entries === null) workersMissingReason = `workers/ directory absent under ${supRunDir}`;
+		else {
+			const labels = [...new Set(entries.filter((f) => f.endsWith(".ndjson")).map((f) => f.replace(/\.inbox\.ndjson$/, "").replace(/\.ndjson$/, "")))].sort();
+			workers = [];
+			for (const label of labels) {
+				const events = await readMaybe(join(workersDir, `${label}.ndjson`));
+				const inbox = await readMaybe(join(workersDir, `${label}.inbox.ndjson`));
+				const patch = await readMaybe(join(workersDir, `${label}.patch`));
+				const startedRows = parseJsonl(events).filter((event) => event.kind === "started");
+				workerStarts += startedRows.length;
+				const startedIds = startedRows.map((event) => typeof event.workerId === "string" ? event.workerId : typeof event.agentId === "string" ? event.agentId : null).filter((id) => id !== null);
+				const distinctStartedIds = new Set(startedIds);
+				const workerId = startedRows.length > 0 && startedIds.length === startedRows.length && distinctStartedIds.size === 1 ? startedIds[0] : void 0;
+				workers.push({
+					...workerId === void 0 ? {} : { workerId },
+					label,
+					events,
+					inbox,
+					patchBytes: patch === null ? null : Buffer.byteLength(patch)
+				});
+				for (const ev of startedRows) if (ev.kind === "started" && typeof ev.cwd === "string") workerCwds.push(ev.cwd);
+			}
+		}
+	}
+	let harnessWorkerTokens = null;
+	let harnessMissingReason = null;
+	let workerCwdsWithoutSessions = 0;
+	if (opts.opencodeDb === null) harnessMissingReason = "opencode join disabled";
+	else if (workerCwds.length === 0) harnessMissingReason = "no worker clone cwds in workers/*.ndjson (nothing to join)";
+	else {
+		const db = await openOpencodeDb(opts.opencodeDb ?? DEFAULT_OPENCODE_DB);
+		if (db === null) harnessMissingReason = `opencode session store unreadable at ${opts.opencodeDb ?? DEFAULT_OPENCODE_DB}`;
+		else try {
+			const seen = /* @__PURE__ */ new Set();
+			let sessions = 0;
+			let input = 0;
+			let output = 0;
+			const distinctWorkerCwds = new Set(workerCwds);
+			for (const cwd of distinctWorkerCwds) {
+				const rows = findOpencodeSessionsByDirectory(db, cwd);
+				if (rows.length === 0) workerCwdsWithoutSessions += 1;
+				for (const row of rows) {
+					if (seen.has(row.id)) continue;
+					seen.add(row.id);
+					sessions += 1;
+					input += row.tokensInput;
+					output += row.tokensOutput + row.tokensReasoning;
+				}
+			}
+			harnessWorkerTokens = {
+				store: "opencode",
+				sessions,
+				input,
+				output
+			};
+			if (workerCwdsWithoutSessions > 0) harnessMissingReason = `${workerCwdsWithoutSessions}/${distinctWorkerCwds.size} worker clone cwds have no opencode session`;
+		} finally {
+			db.close();
+		}
+	}
+	const workerInvocations = Math.max(journalWorkerSpawns, workerStarts);
+	const workerTokenGaps = [];
+	if (workerCwds.length < workerInvocations) workerTokenGaps.push(`${workerInvocations - workerCwds.length}/${workerInvocations} worker invocations have no clone cwd for the opencode token join`);
+	if (workerInvocations > 0 && harnessWorkerTokens === null) workerTokenGaps.push(harnessMissingReason ?? "worker harness token join unavailable");
+	else if (workerCwdsWithoutSessions > 0 && harnessMissingReason !== null) workerTokenGaps.push(harnessMissingReason);
+	const workerTokenLimit = workerTokenGaps.length === 0 ? null : workerTokenGaps.join("; ");
+	const patchPath = opts.patchPath ?? (typeof resultObj?.patchPath === "string" ? resultObj.patchPath : null);
+	let judge = await readMaybe(join(runDir, "judge.json"));
+	let judgeSource = judge === null ? null : join(runDir, "judge.json");
+	if (judge === null && opts.ledgerPath !== void 0) {
+		const row = await findLedgerRow(opts.ledgerPath, runDir);
+		if (row !== null) {
+			judge = JSON.stringify(row);
+			judgeSource = `${opts.ledgerPath} (ledger row)`;
+		}
+	}
+	return {
+		runRef: runDir,
+		instanceId: typeof resultObj?.iid === "string" ? resultObj.iid : instanceIdFromPath(runDir),
+		arm: typeof resultObj?.arm === "string" ? resultObj.arm : basename(runDir),
+		supRunDir,
+		journal,
+		brainLog: supRunDir === null ? null : await readMaybe(join(supRunDir, "brain.jsonl")),
+		state: supRunDir === null ? null : await readMaybe(join(supRunDir, "state.json")),
+		progress: supRunDir === null ? null : await readMaybe(join(supRunDir, "progress.ndjson")),
+		workers,
+		workersMissingReason,
+		result,
+		judge,
+		judgeSource,
+		patch: patchPath === null ? null : await readMaybe(patchPath),
+		driverLog: await readMaybe(join(runDir, "driver.log")),
+		harnessWorkerTokens,
+		harnessMissingReason,
+		limits: {
+			...NO_SOURCE_LIMITS,
+			workerTokens: workerTokenLimit
+		},
+		traceCommand: null
+	};
+}
+/** The loops on-disk layout, as a `SupervisorRunReader`. */
+function loopsSupervisorRunReader(runDir, opts = {}) {
+	return {
+		runRef: runDir,
+		read: () => readLoopsSupervisorRun(runDir, opts)
+	};
+}
+/** The ledger row whose `runDir` is this run (falling back to iid + arm match). */
+async function findLedgerRow(ledgerPath, runDir) {
+	const rows = parseJsonl(await readMaybe(ledgerPath));
+	const exact = rows.find((r) => r.runDir === runDir);
+	if (exact !== void 0) return exact;
+	const iid = instanceIdFromPath(runDir);
+	const arm = basename(runDir);
+	return rows.find((r) => r.iid === iid && r.arm === arm) ?? null;
+}
+/** `<outDir>/runs/<iid>/<arm>` → `<iid>`. */
+function instanceIdFromPath(runDir) {
+	const parts = runDir.split("/").filter(Boolean);
+	const armIdx = parts.length - 1;
+	const iid = parts[armIdx - 1];
+	return parts[armIdx - 2] === "runs" && iid !== void 0 ? iid : null;
+}
+/**
+* Analyze a supervisor run. Accepts a run directory (read through the loops
+* reader), any `SupervisorRunReader`, or already-read source bytes — so a
+* caller with its own store never has to touch the filesystem layout.
+*/
+async function analyzeSupervisorRun(input, opts = {}) {
+	if (typeof input === "string") return analyzeSupervisorRunSources(await isRuntimeSupervisorRunDir(input) ? await readRuntimeSupervisorRun(input) : await readLoopsSupervisorRun(input, opts));
+	if (isReader(input)) return analyzeSupervisorRunSources(await input.read());
+	return analyzeSupervisorRunSources(input);
+}
+function isReader(input) {
+	return typeof input.read === "function";
+}
+/**
+* Read a completed run, write `run-report.json` + `run-report.md` beside its
+* artifacts, and append the headline block to the run log. Never throws on a
+* missing artifact — a run that produced nothing still yields a report whose
+* every metric says why.
+*/
+async function writeSupervisorRunReport(runDir, opts = {}) {
+	const report = analyzeSupervisorRunSources(await isRuntimeSupervisorRunDir(runDir) ? await readRuntimeSupervisorRun(runDir) : await readLoopsSupervisorRun(runDir, opts));
+	const md = renderSupervisorRunMarkdown(report);
+	const dest = opts.reportDir ?? runDir;
+	const stem = opts.reportDir === void 0 ? "run-report" : supervisorReportStem(runDir);
+	if (opts.reportDir !== void 0) await mkdir(opts.reportDir, { recursive: true }).catch(() => {});
+	await writeFile(join(dest, `${stem}.json`), JSON.stringify(report, null, 1)).catch(() => {});
+	await writeFile(join(dest, `${stem}.md`), md).catch(() => {});
+	const headline = renderSupervisorRunHeadline(report);
+	if (opts.appendHeadlineTo !== void 0) await appendFile(opts.appendHeadlineTo, `${headline}\n`).catch(() => {});
+	if (opts.echo !== false) console.log(headline);
+	return report;
+}
+/**
+* File stem for out-of-tree reports. Built from the run path's identifying
+* segments — candidate tag (the segment under `arm-runs/`), rep, instance, arm
+* — so two runs of the same instance from different candidates/reps never
+* overwrite each other.
+*/
+function supervisorReportStem(runDir) {
+	const parts = runDir.split("/").filter(Boolean);
+	const arm = parts[parts.length - 1] ?? "cell";
+	const iid = parts[parts.length - 2] ?? "instance";
+	const rep = parts.find((p) => /^rep-\d+$/.test(p));
+	const armRunsIdx = parts.indexOf("arm-runs");
+	return [
+		armRunsIdx >= 0 ? parts[armRunsIdx + 1] : void 0,
+		rep,
+		iid,
+		arm
+	].filter((s) => s !== void 0 && s !== "runs").join(".").replace(/[^A-Za-z0-9._-]/g, "_");
+}
+/**
+* Best-effort wrapper for a hot path: a reporting failure must never kill a run
+* that already produced real work. Returns null and logs the reason instead.
+*/
+async function writeSupervisorRunReportSafe(runDir, opts = {}) {
+	try {
+		return await writeSupervisorRunReport(runDir, opts);
+	} catch (err) {
+		console.log(`RUN-REPORT failed for ${runDir}: ${err instanceof Error ? err.message : String(err)}`);
+		return null;
+	}
+}
+/**
+* Report every run under an experiment `outDir` (any depth of
+* `runs/<iid>/<arm>`), write each run's report, and write the rollup at
+* `<outDir>/run-report-round.{json,md}`.
+*/
+async function reportSupervisorRound(outDir, opts = {}) {
+	const runDirs = await findSupervisorRunDirs(outDir);
+	const reports = [];
+	for (const runDir of runDirs) {
+		const r = await writeSupervisorRunReportSafe(runDir, {
+			...opts,
+			echo: opts.echo ?? false
+		});
+		if (r !== null) reports.push(r);
+	}
+	const rollup = rollupSupervisorRuns(reports);
+	const md = renderSupervisorRollupMarkdown(rollup, opts.title ?? `Round rollup — ${basename(outDir)}`);
+	const dest = opts.reportDir ?? outDir;
+	if (opts.reportDir !== void 0) await mkdir(opts.reportDir, { recursive: true }).catch(() => {});
+	await writeFile(join(dest, "run-report-round.json"), JSON.stringify(rollup, null, 1)).catch(() => {});
+	await writeFile(join(dest, "run-report-round.md"), md).catch(() => {});
+	if (opts.appendHeadlineTo !== void 0) await appendFile(opts.appendHeadlineTo, `${md}\n`).catch(() => {});
+	if (opts.echo !== false) console.log(md);
+	return rollup;
+}
+/**
+* Every loops or Runtime supervisor run below `root`.
+*
+* When `root` itself is one run, return no children so callers can distinguish
+* a single report from a parent-directory rollup.
+*/
+async function findSupervisorRunDirs(root) {
+	if (await isRuntimeSupervisorRunDir(root) || await findSupervisorRunDirIn(join(root, "ws")) !== null) return [];
+	const found = [];
+	const walk = async (dir, depth) => {
+		if (depth > 8) return;
+		const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+		for (const e of entries) {
+			if (!e.isDirectory()) continue;
+			if (e.name === "node_modules" || e.name === ".git") continue;
+			const full = join(dir, e.name);
+			if (await isRuntimeSupervisorRunDir(full) || await findSupervisorRunDirIn(join(full, "ws")) !== null) {
+				found.push(full);
+				continue;
+			}
+			await walk(full, depth + 1);
+		}
+	};
+	await walk(root, 0);
+	return found.sort();
+}
+//#endregion
+//#region src/supervisor-run/report-command.ts
+/**
+* `agent-eval supervisor-run report <runDir>` takes one run directory and
+* prints the report the module already renders. The command reads through
+* `analyzeSupervisorRun`, so a Runtime run dir and a loops run dir take the
+* same path and the status comes from the record `terminal-record.ts` names.
+*
+* Exit codes follow the other self-parsing subcommands: 2 for a usage error,
+* 1 when the directory cannot be read (missing, not a directory, or a corrupt
+* journal or terminal record), 0 after the report was written to stdout.
+*/
+const FORMATS = [
+	"headline",
+	"markdown",
+	"json"
+];
+const SUPERVISOR_RUN_USAGE = "usage: agent-eval supervisor-run report <runDir> [--format headline|markdown|json]";
+const PROCESS_IO = {
+	stdout: (text) => {
+		process.stdout.write(text);
+	},
+	stderr: (text) => {
+		process.stderr.write(text);
+	}
+};
+function isFormat(value) {
+	return FORMATS.includes(value);
+}
+function parseReportArgs(argv) {
+	let runDir = null;
+	let format = "headline";
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--format") {
+			const raw = argv[++i];
+			if (raw === void 0 || !isFormat(raw)) throw new Error(`--format expects one of ${FORMATS.join("|")}, got ${JSON.stringify(raw ?? "")}`);
+			format = raw;
+		} else if (arg.startsWith("--format=")) {
+			const raw = arg.slice(9);
+			if (!isFormat(raw)) throw new Error(`--format expects one of ${FORMATS.join("|")}, got ${JSON.stringify(raw)}`);
+			format = raw;
+		} else if (arg.startsWith("--")) throw new Error(`unknown flag "${arg}"`);
+		else if (runDir === null) runDir = arg;
+		else throw new Error(`unexpected argument "${arg}"`);
+	}
+	if (runDir === null) throw new Error(SUPERVISOR_RUN_USAGE);
+	return {
+		runDir,
+		format
+	};
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* CLI driver for `agent-eval supervisor-run`. `argv` is everything after the
+* command name, so `['report', runDir, ...flags]`. Returns the process exit code.
+*/
+async function runSupervisorRunCommand(argv, io = PROCESS_IO) {
+	const [verb, ...rest] = argv;
+	if (verb === void 0 || verb === "--help" || verb === "-h" || verb === "help") {
+		io.stdout(`${SUPERVISOR_RUN_USAGE}\n`);
+		return verb === void 0 ? 2 : 0;
+	}
+	if (verb !== "report") {
+		io.stderr(`unknown supervisor-run subcommand "${verb}"\n${SUPERVISOR_RUN_USAGE}\n`);
+		return 2;
+	}
+	if (rest.includes("--help") || rest.includes("-h")) {
+		io.stdout(`${SUPERVISOR_RUN_USAGE}\n`);
+		return 0;
+	}
+	let args;
+	try {
+		args = parseReportArgs(rest);
+	} catch (error) {
+		io.stderr(`${errorMessage(error)}\n`);
+		return 2;
+	}
+	const runDir = resolve(args.runDir);
+	const entry = await stat(runDir).catch(() => null);
+	if (entry === null || !entry.isDirectory()) {
+		io.stderr(`[agent-eval] supervisor-run report: ${runDir} is not a directory\n`);
+		return 1;
+	}
+	try {
+		const report = await analyzeSupervisorRun(runDir);
+		switch (args.format) {
+			case "headline":
+				io.stdout(`${renderSupervisorRunHeadline(report)}\n`);
+				break;
+			case "markdown":
+				io.stdout(renderSupervisorRunMarkdown(report));
+				break;
+			case "json":
+				io.stdout(`${JSON.stringify(report, null, 2)}\n`);
+				break;
+		}
+		return 0;
+	} catch (error) {
+		io.stderr(`[agent-eval] supervisor-run report failed for ${runDir}: ${errorMessage(error)}\n`);
+		return 1;
+	}
+}
+//#endregion
+export { parsePatch as _, loopsSupervisorRunReader as a, writeSupervisorRunReport as c, readRuntimeSupervisorRun as d, runtimeSupervisorRunReader as f, analyzeSupervisorRunSources as g, renderSupervisorRunMarkdown as h, findSupervisorRunDirs as i, writeSupervisorRunReportSafe as l, renderSupervisorRunHeadline as m, analyzeSupervisorRun as n, readLoopsSupervisorRun as o, renderSupervisorRollupMarkdown as p, findSupervisorRunDirIn as r, reportSupervisorRound as s, runSupervisorRunCommand as t, isRuntimeSupervisorRunDir as u, rollupSupervisorRuns as v };
+
+//# sourceMappingURL=report-command-DKlXfU5r.js.map