@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/supervisor-run-D_sokXcO.js

@@ -1,1690 +0,0 @@
-import { a as parseJsonl, i as parseJson, o as parseSupervisorTree, r as asRecord, s as workerSourceKey } from "./integrity-DY6tIbl0.js";
-import { d as transcriptFromEntries, i as openOpencodeDb, l as parseClaudeEntries, r as findOpencodeSessionsByDirectory, t as DEFAULT_OPENCODE_DB } from "./opencode-sqlite-8r6WUfHc.js";
-import { basename, dirname, join } from "node:path";
-import { appendFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-//#region src/supervisor-run/types.ts
-function unavailable(reason) {
-	return { unavailable: reason };
-}
-function isUnavailable(v) {
-	return typeof v === "object" && v !== null && typeof v.unavailable === "string";
-}
-/** Render a measured scalar for the markdown/headline: `0` and `unavailable` stay distinct. */
-function showMeasured(v) {
-	if (isUnavailable(v)) return `unavailable — ${v.unavailable}`;
-	if (v === null) return "null";
-	return String(v);
-}
-/** A source that carries every fact the analyzer can use. */
-const NO_SOURCE_LIMITS = {
-	managerTokens: null,
-	workerTokens: null,
-	spendUsd: null,
-	workerVerdicts: null,
-	deliverables: null
-};
-const SUPERVISOR_RUN_SCHEMA = "tangle.supervisor-run@1";
-const SUPERVISOR_RUN_ROLLUP_SCHEMA = "tangle.supervisor-run-rollup@1";
-//#endregion
-//#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";
-/**
-* 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.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 { 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 supervisorWallMs = startedAt !== null && completedAt !== null && completedAt >= startedAt ? completedAt - startedAt : !haveJournal ? gap("supervisorWallMs", journalMissing) : gap("supervisorWallMs", "no parseable start/complete timestamps in state.json or journal");
-	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 && completedAt !== null && completedAt >= prev) {
-		const span = completedAt - 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,
-		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 acceptedLimit = verdictLimit ?? 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 ((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: acceptedLimit !== null ? gap("accepted", acceptedLimit) : src.workers === null ? unavailable(workersGapReason) : accepted,
-		rejected: rejectedLimit === null ? rejected : unavailable(rejectedLimit),
-		emptyPass: acceptedLimit !== null ? gap("emptyPass", acceptedLimit) : 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 journalWorkerIn = rootChildCloses.reduce((a, c) => a + c.spend.tokens.input, 0);
-	const journalWorkerOut = rootChildCloses.reduce((a, c) => a + c.spend.tokens.output, 0);
-	const journalWorkerUsd = rootChildCloses.reduce((a, c) => a + c.spend.usd, 0);
-	const workerUsdById = /* @__PURE__ */ new Map();
-	for (const c of workerCloses) workerUsdById.set(c.id, (workerUsdById.get(c.id) ?? 0) + c.spend.usd);
-	const labelById = new Map(workerSpawns.map((spawn) => [spawn.id, spawn.label]));
-	const workerUsdByLabel = /* @__PURE__ */ new Map();
-	for (const close of workerCloses) {
-		const label = labelById.get(close.id);
-		if (label === void 0) continue;
-		workerUsdByLabel.set(label, (workerUsdByLabel.get(label) ?? 0) + close.spend.usd);
-	}
-	const sq = src.harnessWorkerTokens;
-	const harnessGapReason = src.harnessMissingReason ?? "harness session store unavailable and journal settled spend is 0";
-	const workerTokenLimit = src.limits.workerTokens;
-	const workerIn = workerTokenLimit !== null ? gap("workers.tokensIn", workerTokenLimit) : sq !== null ? journalWorkerIn + sq.input : haveJournal ? journalWorkerIn : gap("workers.tokensIn", harnessGapReason);
-	const workerOut = workerTokenLimit !== null ? unavailable(workerTokenLimit) : sq !== null ? journalWorkerOut + sq.output : haveJournal ? journalWorkerOut : unavailable(harnessGapReason);
-	const stateResult = asRecord(state?.result);
-	const stateUsd = typeof stateResult.spentUsd === "number" ? stateResult.spentUsd : null;
-	const usdLimit = src.limits.spendUsd;
-	const totalUsd = usdLimit !== null ? gap("totalUsd", usdLimit) : stateUsd !== null ? round(stateUsd, 6) : haveJournal ? round(tree.brain.usd + journalWorkerUsd, 6) : gap("totalUsd", journalMissing);
-	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 ? close.spend.tokens.input : null),
-			tokensOut: w.tokensOut ?? (close?.hasSpend ? 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 walls = perWorker.map((w) => w.wallMs).filter((w) => w !== null).sort((a, b) => a - b);
-	const brainCalls = parseJsonl(src.brainLog);
-	const managerTokenLimit = src.limits.managerTokens;
-	const economics = {
-		brain: {
-			tokensIn: managerTokenLimit !== null ? gap("brain.tokensIn", managerTokenLimit) : haveJournal ? tree.brain.tokensIn : gap("brain.tokensIn", journalMissing),
-			tokensOut: managerTokenLimit !== null ? unavailable(managerTokenLimit) : haveJournal ? tree.brain.tokensOut : unavailable(journalMissing),
-			usd: usdLimit !== null ? unavailable(usdLimit) : haveJournal ? round(tree.brain.usd, 6) : unavailable(journalMissing),
-			cacheRead: managerTokenLimit !== null ? unavailable(managerTokenLimit) : !haveJournal ? unavailable(journalMissing) : tree.brain.hasCache ? tree.brain.cacheRead : unavailable(NO_CACHE_COUNTERS),
-			cacheWrite: managerTokenLimit !== null ? unavailable(managerTokenLimit) : !haveJournal ? unavailable(journalMissing) : tree.brain.hasCache ? tree.brain.cacheWrite : unavailable(NO_CACHE_COUNTERS),
-			source: managerTokenLimit ?? (haveJournal ? `journal metered events (n=${tree.brain.meteredCount})` : 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 ? round(journalWorkerUsd, 6) : unavailable(journalMissing),
-			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"}`
-		},
-		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 ? "journal metered + settled usd" : journalMissing,
-		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: walls.length === 0 ? unavailable(src.workers === null ? workersGapReason : "no worker start/finish pairs captured") : {
-			n: walls.length,
-			min: walls[0],
-			p50: quantile(walls, .5),
-			p90: quantile(walls, .9),
-			max: walls[walls.length - 1],
-			sum: walls.reduce((a, b) => a + b, 0)
-		},
-		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: pickString(state, "status") ?? pickString(result, "sup_status") ?? gap("supStatus", "no state.json / result.json status"),
-		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;
-}
-function quantile(sorted, q) {
-	if (sorted.length === 0) return 0;
-	return sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(q * sorted.length) - 1))];
-}
-/** 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 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),
-		resolvedCount: resolvedVals.length === 0 ? unavailable("no cell reported a judge verdict") : resolvedVals.filter((v) => v === true).length,
-		perCell
-	};
-}
-//#endregion
-//#region src/supervisor-run/claude-code-reader.ts
-/**
-* Supervision-tree reader over a THIRD-PARTY harness: Claude Code.
-*
-* `loops-reader.ts` reads a supervisor we wrote, whose journal was designed
-* for this analysis. This reader reads a harness we do not control, whose
-* transcript was designed for replaying a chat — and recovers the same tree
-* from it. If both produce a `SupervisorRunSources`, the tree model is a
-* property of multi-agent runs, not of our journal format.
-*
-* ## Where the tree hides in a Claude Code transcript
-*
-* | Tree fact | Claude Code evidence |
-* |---|---|
-* | spawn      | assistant `tool_use` (`Agent` / `Task`), answered by a `tool_result` whose `toolUseResult.agentId` names the child |
-* | settle     | a `<task-notification>` block in a later user line: `<task-id>` = agentId, `<status>` |
-* | steer      | assistant `tool_use` (`SendMessage`) with `input.to` = agentId — mid-task, to a LIVE child |
-* | delivered  | that steer's `tool_result` carrying `success` / `resumedAgentId` |
-* | cancel     | assistant `tool_use` (`TaskStop`) targeting an agentId |
-* | brain spend| `message.usage` on the main thread's assistant lines |
-* | worker spend| `message.usage` inside `<session>/subagents/agent-<id>.jsonl` |
-* | depth      | a child transcript that itself contains `Agent` tool_use lines |
-*
-* Every one of those is read through `parseClaudeEntries` — the SAME line
-* parser `src/rollout/readers/claude-jsonl.ts` uses for solo rollouts. There
-* is no second transcript parser.
-*
-* ## What Claude Code cannot say
-*
-* It records tokens but never a price, runs no per-worker verify, and keeps no
-* per-worker patch. Those are declared once in `limits`, so the analyzer
-* reports `unavailable — <reason>` instead of the $0 / 0-accepted that summing
-* an empty field would produce. See `SourceLimits`.
-*
-* ## Metric coverage vs the loops journal
-*
-* Measured on a real 52-agent session (fixture:
-* `tests/fixtures/supervisor-run/claude-code-session-*`).
-*
-* | Metric | loops | Claude Code | Why |
-* |---|---|---|---|
-* | workersSpawned / Settled / Cancelled | full | full | spawn tool_use + task-notification + TaskStop |
-* | steers / steersDelivered / steersByWorker | full | full | `SendMessage`; delivery from its tool_result |
-* | waves / waveSizes / maxConcurrency | full | full | derived from spawn/settle instants |
-* | respawns / repeatedLabels | full | full | same derivation |
-* | delegationDepth | full | full | a child transcript's own spawn calls |
-* | timeToFirstSpawn / supervisorWall | full | full | transcript instants |
-* | idleMs / idlePct / workerUtilization | full | PARTIAL | an agent that never notifies is counted live to the end of the transcript |
-* | observeThenRespawn / respawnWithoutEvidence | full | full | ordering of spawn vs settle instants |
-* | workerEvidenceBytes | full | PARTIAL | the child's closing message; 0 for pruned transcripts |
-* | brain tokens in/out + cache | full | full | main-thread `message.usage` |
-* | worker tokens in/out + cache | via harness join | full or unavailable | totals are refused if any spawned transcript was pruned; retained per-worker rows remain available |
-* | perWorker wall | full | full | spawn → settle instants |
-* | accepted / rejected / emptyPass / settledVerdicts | full | NONE | no per-worker verify step exists |
-* | brain/worker/total usd, costPerAcceptedPatch | full | NONE | transcripts carry no price |
-* | patch stats, delivered, verifyPass/Rc | full | NONE | no diff is handed back |
-* | judgeResolved / Score / Passed / Total | full | NONE | no judge in the loop |
-* | driverSteerCalls, brainTruncations | full | NONE | no outer driver log, no per-call finish_reason tap |
-*/
-/** Tool names that spawn a child agent. `Task` is the older name for `Agent`. */
-const DEFAULT_SPAWN_TOOLS = ["Agent", "Task"];
-/** Tool names that deliver a message to an ALREADY-RUNNING child agent. */
-const DEFAULT_STEER_TOOLS = ["SendMessage"];
-/** Tool names that stop a running child agent. */
-const DEFAULT_CANCEL_TOOLS = ["TaskStop", "KillAgent"];
-const SPEND_UNPRICED = "Claude Code transcripts record token usage but never a price — usd is not in the store";
-const NO_VERDICTS = "Claude Code runs no per-worker verify step — a subagent reports prose, not pass/fail";
-const NO_DELIVERABLES = "Claude Code retains no per-worker patch — subagents commit to git, they do not hand back a diff";
-const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-const str = (v) => typeof v === "string" ? v : null;
-function blockText(content) {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return "";
-	const parts = [];
-	for (const b of content) if (isRecord(b) && b.type === "text" && typeof b.text === "string") parts.push(b.text);
-	return parts.join("\n");
-}
-const tag = (xml, name) => {
-	const m = xml.match(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`));
-	return m === null ? null : m[1];
-};
-/**
-* Task notifications are the settle instants. A notification fires each time an
-* agent stops, so a resumed agent produces several — they are kept in order and
-* the LAST one is the settle the analyzer sees, with the earlier ones acting as
-* the intermediate stops they actually were.
-*/
-function parseNotifications(text, at) {
-	const out = [];
-	for (const m of text.matchAll(/<task-notification>[\s\S]*?<\/task-notification>/g)) {
-		const xml = m[0];
-		const taskId = tag(xml, "task-id");
-		if (taskId === null) continue;
-		out.push({
-			taskId: taskId.trim(),
-			toolUseId: tag(xml, "tool-use-id")?.trim() ?? null,
-			status: tag(xml, "status")?.trim() ?? "unknown",
-			summary: tag(xml, "summary")?.trim() ?? null,
-			at
-		});
-	}
-	return out;
-}
-/** Project entries of ONE thread (main or a single sidechain) into tool traffic. */
-function threadCalls(entries) {
-	const uses = [];
-	const results = /* @__PURE__ */ new Map();
-	const notifications = [];
-	let firstAt = null;
-	let lastAt = null;
-	for (const entry of entries) {
-		if (entry.timestamp !== null) {
-			if (firstAt === null) firstAt = entry.timestamp;
-			lastAt = entry.timestamp;
-		}
-		const content = entry.message.content;
-		if (entry.type === "assistant") {
-			if (!Array.isArray(content)) continue;
-			for (const block of content) {
-				if (!isRecord(block) || block.type !== "tool_use") continue;
-				const id = str(block.id);
-				const name = str(block.name);
-				if (id === null || name === null) continue;
-				uses.push({
-					id,
-					name,
-					input: isRecord(block.input) ? block.input : {},
-					at: entry.timestamp
-				});
-			}
-			continue;
-		}
-		if (typeof content === "string") {
-			notifications.push(...parseNotifications(content, entry.timestamp));
-			continue;
-		}
-		if (!Array.isArray(content)) continue;
-		for (const block of content) {
-			if (!isRecord(block)) continue;
-			if (block.type === "tool_result" && typeof block.tool_use_id === "string") results.set(block.tool_use_id, {
-				id: block.tool_use_id,
-				at: entry.timestamp,
-				structured: entry.toolUseResult,
-				text: blockText(block.content)
-			});
-			else if (block.type === "text" && typeof block.text === "string") notifications.push(...parseNotifications(block.text, entry.timestamp));
-		}
-	}
-	return {
-		uses,
-		results,
-		notifications,
-		firstAt,
-		lastAt
-	};
-}
-/**
-* The agent id a spawn produced. Claude Code puts it in the structured
-* `toolUseResult`; the same id is echoed in the result text for transcripts
-* written before that field existed, so both are tried before giving up.
-*/
-function spawnedAgentId(result) {
-	if (result === void 0) return null;
-	if (isRecord(result.structured)) {
-		const id = str(result.structured.agentId);
-		if (id !== null) return id;
-	}
-	return result.text.match(/agentId:\s*([A-Za-z0-9_-]+)/)?.[1] ?? null;
-}
-async function readChildren(dir) {
-	const names = await readdir(dir).catch(() => null);
-	if (names === null) return [];
-	const out = [];
-	for (const name of names.filter((n) => n.endsWith(".jsonl")).sort()) {
-		const path = join(dir, name);
-		const raw = await readFile(path, "utf8").catch(() => null);
-		if (raw === null) continue;
-		const entries = parseClaudeEntries(raw);
-		const projected = transcriptFromEntries(entries, { includeSidechain: true });
-		const metaRaw = await readFile(path.replace(/\.jsonl$/, ".meta.json"), "utf8").catch(() => null);
-		let meta = {};
-		if (metaRaw !== null) try {
-			const parsed = JSON.parse(metaRaw);
-			if (isRecord(parsed)) meta = parsed;
-		} catch {
-			meta = {};
-		}
-		const agentId = entries.find((e) => e.agentId !== null)?.agentId ?? name.replace(/^agent-/, "").replace(/\.jsonl$/, "");
-		out.push({
-			agentId,
-			path,
-			description: str(meta.description),
-			spawnToolUseId: str(meta.toolUseId),
-			spawnDepth: typeof meta.spawnDepth === "number" ? meta.spawnDepth : null,
-			entries,
-			tokensIn: projected.usage.tokensIn,
-			tokensOut: projected.usage.tokensOut,
-			cacheRead: projected.usage.cacheRead,
-			cacheWrite: projected.usage.cacheWrite,
-			firstAt: projected.startedAt,
-			lastAt: projected.endedAt,
-			model: projected.model,
-			finalReport: [...projected.messages].reverse().find((m) => m.role === "assistant" && typeof m.content === "string")?.content ?? null
-		});
-	}
-	return out;
-}
-/** A journal line in the dialect `parseSupervisorTree` reads. */
-const line = (obj) => JSON.stringify(obj);
-/**
-* Read a Claude Code session (plus its subagent transcripts) as supervision-tree
-* source bytes. Never throws on a missing artifact.
-*/
-async function readClaudeCodeSupervisorRun(opts) {
-	const spawnTools = new Set(opts.spawnTools ?? DEFAULT_SPAWN_TOOLS);
-	const steerTools = new Set(opts.steerTools ?? DEFAULT_STEER_TOOLS);
-	const cancelTools = new Set(opts.cancelTools ?? DEFAULT_CANCEL_TOOLS);
-	const raw = await readFile(opts.transcriptPath, "utf8").catch(() => null);
-	const sessionId = basename(opts.transcriptPath).replace(/\.jsonl$/, "");
-	const runRef = opts.runRef ?? opts.transcriptPath;
-	const limits = {
-		managerTokens: null,
-		workerTokens: null,
-		spendUsd: SPEND_UNPRICED,
-		workerVerdicts: NO_VERDICTS,
-		deliverables: null
-	};
-	const traceCommand = `npx --yes @tangle-network/traces@latest analyze --harness claude-code --session ${sessionId}`;
-	if (raw === null) return {
-		runRef,
-		instanceId: opts.instanceId ?? sessionId,
-		arm: opts.arm ?? null,
-		supRunDir: null,
-		journal: null,
-		brainLog: null,
-		state: null,
-		progress: null,
-		workers: null,
-		workersMissingReason: `session transcript unreadable at ${opts.transcriptPath}`,
-		result: null,
-		judge: null,
-		judgeSource: null,
-		patch: null,
-		driverLog: null,
-		harnessWorkerTokens: null,
-		harnessMissingReason: `session transcript unreadable at ${opts.transcriptPath}`,
-		limits: {
-			...limits,
-			managerTokens: `session transcript unreadable at ${opts.transcriptPath}`,
-			workerTokens: `session transcript unreadable at ${opts.transcriptPath}`,
-			deliverables: NO_DELIVERABLES
-		},
-		traceCommand
-	};
-	const allEntries = parseClaudeEntries(raw);
-	const main = threadCalls(allEntries.filter((e) => !e.isSidechain));
-	const mainTranscript = transcriptFromEntries(allEntries);
-	const subagentsDir = opts.subagentsDir === void 0 ? join(dirname(opts.transcriptPath), sessionId, "subagents") : opts.subagentsDir;
-	const children = subagentsDir === null ? [] : await readChildren(subagentsDir);
-	const childByAgentId = new Map(children.map((c) => [c.agentId, c]));
-	const childBySpawnToolUseId = new Map(children.filter((c) => c.spawnToolUseId !== null).map((c) => [c.spawnToolUseId, c]));
-	const threads = [{
-		id: sessionId,
-		calls: main
-	}];
-	for (const child of children) threads.push({
-		id: child.agentId,
-		calls: threadCalls(child.entries)
-	});
-	const spawns = [];
-	const steersByTarget = /* @__PURE__ */ new Map();
-	const cancels = [];
-	const settles = [];
-	for (const thread of threads) {
-		for (const use of thread.calls.uses) {
-			if (spawnTools.has(use.name)) {
-				const result = thread.calls.results.get(use.id);
-				const agentId = spawnedAgentId(result) ?? childBySpawnToolUseId.get(use.id)?.agentId ?? null;
-				if (agentId === null) continue;
-				const label = str(use.input.description) ?? childByAgentId.get(agentId)?.description ?? agentId;
-				spawns.push({
-					agentId,
-					parentId: thread.id,
-					label,
-					at: result?.at ?? use.at,
-					model: isRecord(result?.structured) ? str(result.structured.resolvedModel) : null
-				});
-				continue;
-			}
-			if (steerTools.has(use.name)) {
-				const target = str(use.input.to) ?? str(use.input.recipient);
-				if (target === null) continue;
-				const result = thread.calls.results.get(use.id);
-				const structured = isRecord(result?.structured) ? result.structured : null;
-				const delivered = structured?.success === true || str(structured?.resumedAgentId) === target;
-				const rows = steersByTarget.get(target) ?? [];
-				rows.push({
-					requestId: use.id,
-					at: use.at,
-					delivered
-				});
-				steersByTarget.set(target, rows);
-				continue;
-			}
-			if (cancelTools.has(use.name)) {
-				const target = str(use.input.agentId) ?? str(use.input.to) ?? str(use.input.taskId);
-				if (target !== null) cancels.push({
-					agentId: target,
-					at: use.at
-				});
-			}
-		}
-		settles.push(...thread.calls.notifications);
-	}
-	const spawnedIds = new Set(spawns.map((s) => s.agentId));
-	const cancelledIds = new Set(cancels.filter((c) => spawnedIds.has(c.agentId)).map((c) => c.agentId));
-	const startedAt = main.firstAt;
-	const completedAt = main.lastAt;
-	const journalLines = [line({
-		kind: "spawned",
-		id: sessionId,
-		parent: null,
-		label: `session:${sessionId}`,
-		role: "supervisor",
-		at: startedAt
-	})];
-	for (const s of spawns) journalLines.push(line({
-		kind: "spawned",
-		id: s.agentId,
-		parent: s.parentId,
-		label: s.label,
-		role: "worker",
-		at: s.at
-	}));
-	const lastNotification = /* @__PURE__ */ new Map();
-	for (const n of settles) {
-		if (!spawnedIds.has(n.taskId)) continue;
-		lastNotification.set(n.taskId, n);
-	}
-	for (const [agentId, n] of lastNotification) {
-		if (cancelledIds.has(agentId)) continue;
-		journalLines.push(line({
-			kind: "settled",
-			id: agentId,
-			status: n.status,
-			verdict: n.summary,
-			at: n.at
-		}));
-	}
-	const lastCancel = /* @__PURE__ */ new Map();
-	for (const c of cancels) {
-		if (!spawnedIds.has(c.agentId)) continue;
-		lastCancel.set(c.agentId, c);
-	}
-	for (const c of lastCancel.values()) journalLines.push(line({
-		kind: "cancelled",
-		id: c.agentId,
-		reason: "stopped by supervisor",
-		at: c.at
-	}));
-	journalLines.push(line({
-		kind: "metered",
-		id: sessionId,
-		spend: { tokens: {
-			input: mainTranscript.usage.tokensIn,
-			output: mainTranscript.usage.tokensOut,
-			cacheRead: mainTranscript.usage.cacheRead,
-			cacheWrite: mainTranscript.usage.cacheWrite
-		} },
-		at: completedAt
-	}));
-	const settleAtByAgent = new Map([...lastNotification.entries()].map(([id, n]) => [id, n.at]));
-	const spawnAtByAgent = new Map(spawns.map((s) => [s.agentId, s.at]));
-	const workers = [];
-	for (const spawn of spawns) {
-		const { agentId, label } = spawn;
-		const events = [];
-		const inbox = [];
-		const child = childByAgentId.get(agentId) ?? null;
-		const startAt = child?.firstAt ?? spawnAtByAgent.get(agentId) ?? null;
-		const endAt = settleAtByAgent.get(agentId) ?? child?.lastAt ?? null;
-		if (startAt !== null) events.push(line({
-			kind: "started",
-			label,
-			at: startAt,
-			agentId
-		}));
-		for (const steer of steersByTarget.get(agentId) ?? []) {
-			inbox.push(line({
-				id: steer.requestId,
-				at: steer.at,
-				worker: label,
-				message: "steer"
-			}));
-			events.push(line({
-				kind: "message",
-				label,
-				direction: "down",
-				at: steer.at,
-				requestId: steer.requestId,
-				delivered: steer.delivered
-			}));
-		}
-		if (endAt !== null) events.push(line({
-			kind: "finished",
-			label,
-			at: endAt,
-			agentId,
-			...child?.finalReport === null || child?.finalReport === void 0 ? {} : { evidence: child.finalReport }
-		}));
-		workers.push({
-			workerId: agentId,
-			label,
-			events: events.length === 0 ? "" : `${events.join("\n")}\n`,
-			inbox: inbox.length === 0 ? "" : `${inbox.join("\n")}\n`,
-			patchBytes: null,
-			transcriptRef: child?.path ?? null,
-			patchPath: null,
-			tokensIn: child?.tokensIn ?? null,
-			tokensOut: child?.tokensOut ?? null,
-			cacheRead: child?.cacheRead ?? null,
-			cacheWrite: child?.cacheWrite ?? null
-		});
-	}
-	const joined = children.length;
-	const harnessWorkerTokens = joined === 0 ? null : {
-		store: "claude-code subagent transcripts",
-		sessions: joined,
-		input: children.reduce((a, c) => a + c.tokensIn, 0),
-		output: children.reduce((a, c) => a + c.tokensOut, 0),
-		cacheRead: children.reduce((a, c) => a + c.cacheRead, 0),
-		cacheWrite: children.reduce((a, c) => a + c.cacheWrite, 0)
-	};
-	const missingChildren = spawns.filter((s) => !childByAgentId.has(s.agentId)).length;
-	const harnessMissingReason = subagentsDir === null ? "subagent transcript join disabled" : joined === 0 ? `no subagent transcripts under ${subagentsDir}` : missingChildren === 0 ? null : `${missingChildren}/${spawns.length} spawned agents have no retained transcript under ${subagentsDir} (Claude Code prunes them; their tokens are unrecoverable)`;
-	const liveWorkers = spawns.filter((s) => !lastNotification.has(s.agentId) && !cancelledIds.has(s.agentId)).length;
-	const state = JSON.stringify({
-		id: sessionId,
-		status: liveWorkers > 0 ? "running" : "idle",
-		startedAt,
-		completedAt,
-		result: { delivered: null }
-	});
-	return {
-		runRef,
-		instanceId: opts.instanceId ?? sessionId,
-		arm: opts.arm ?? null,
-		supRunDir: subagentsDir,
-		journal: `${journalLines.join("\n")}\n`,
-		brainLog: null,
-		state,
-		progress: null,
-		workers,
-		workersMissingReason: null,
-		result: null,
-		judge: null,
-		judgeSource: null,
-		patch: null,
-		driverLog: null,
-		harnessWorkerTokens,
-		harnessMissingReason,
-		limits: {
-			...limits,
-			workerTokens: spawns.length === 0 ? null : harnessMissingReason,
-			deliverables: NO_DELIVERABLES
-		},
-		rootTranscriptRef: opts.transcriptPath,
-		traceCommand
-	};
-}
-/** A `SupervisorRunReader` over a Claude Code session — the same contract loops implements. */
-function claudeCodeSupervisorRunReader(opts) {
-	return {
-		runRef: opts.runRef ?? opts.transcriptPath,
-		read: () => readClaudeCodeSupervisorRun(opts)
-	};
-}
-//#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 ?? "?"}]`,
-		`  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)}`,
-		`  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");
-}
-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)} |`);
-	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(`- 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(`| 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("");
-	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 nested
-* driver is represented twice: once as a child spawn in its parent's tree and
-* once as the parentless root marker of its own tree. This reader removes only
-* that duplicate root marker and preserves the remaining envelopes for the
-* supervisor-run analyzer. Runtime stores profile identity below `identity`
-* and does not emit Eval's role field, so this boundary projects those fields
-* without changing Runtime's journal dialect.
-*/
-const JOURNAL_FILE = "spawn-journal.jsonl";
-const RESULT_FILE = "result.json";
-const TRAJECTORY_FILE = "trajectory.json";
-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 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 matches = parentSpawnsById.get(id) ?? [];
-			matches.push(entry);
-			parentSpawnsById.set(id, matches);
-		}
-		if (entry.root === id && entry.event.parent === void 0) {
-			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 = (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 marker = rootMarkersByTree.get(nestedRoot) ?? [];
-		if (marker.length !== 1) throw formatError(path, begun.get(nestedRoot)?.line ?? 1, `nested tree ${JSON.stringify(nestedRoot)} must contain one root marker`);
-		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(marker[0]?.event ?? {});
-		const parentDigest = profileDigest(parentSpawn.event);
-		if (markerDigest !== null && parentDigest !== null && markerDigest !== parentDigest) throw formatError(path, marker[0]?.line ?? 1, `nested tree ${JSON.stringify(nestedRoot)} disagrees with its parent profile digest`);
-		if (parentDigest === null && markerDigest !== null) parentSpawn.event.profileDigest = markerDigest;
-	}
-	const supervisorIds = /* @__PURE__ */ new Set([top.root, ...nestedRoots]);
-	const normalized = events.filter((entry) => !(nestedRoots.has(entry.root) && entry.event.kind === "spawned" && entry.event.id === entry.root && entry.event.parent === void 0)).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 unknownUsd = [...rootMeters.map((event) => spendRecord(event.spend)), ...closes.filter((event) => event.kind === "settled").map((event) => spendRecord(event.spent))].filter((spend) => spend !== null).some((spend) => spend.usdKnown === false);
-	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 : unknownUsd ? "Runtime recorded usdKnown:false for at least one spend" : 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"
-	};
-}
-function runtimeState(root, startedAt, result, trajectory, resultPath, trajectoryPath) {
-	const resultKind = result?.kind === "completed" || result?.kind === "interrupted" ? result.kind : null;
-	if (resultKind !== null && result !== null) {
-		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)}`);
-	}
-	if (trajectory !== null && nonEmptyString(trajectory.root) === null) throw new Error(`${trajectoryPath}: Runtime trajectory has no root`);
-	if (typeof trajectory?.root === "string" && trajectory.root !== root) throw new Error(`${trajectoryPath}: root ${JSON.stringify(trajectory.root)} does not match journal root ${JSON.stringify(root)}`);
-	if (trajectory !== null && !Array.isArray(trajectory.nodes)) throw new Error(`${trajectoryPath}: Runtime trajectory nodes must be an array`);
-	let status = null;
-	if (resultKind === "completed") status = "completed";
-	else if (resultKind === "interrupted") status = "interrupted";
-	else if (Array.isArray(trajectory?.nodes)) {
-		const rootNodes = trajectory.nodes.map((node) => record(node)).filter((node) => node?.id === root);
-		if (rootNodes.length > 1) throw new Error(`${trajectoryPath}: Runtime trajectory contains duplicate root nodes`);
-		status = nonEmptyString(rootNodes[0]?.status);
-	}
-	return JSON.stringify({
-		id: root,
-		startedAt,
-		...status === null ? {} : { status }
-	});
-}
-/**
-* Read one agent-runtime `createFileRunContext(dir)` directory.
-*
-* 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) {
-	const journalPath = join(runDir, JOURNAL_FILE);
-	const normalized = parseEnvelopeJournal(await readFile(journalPath, "utf8"), journalPath);
-	const resultText = await readMaybe$1(join(runDir, RESULT_FILE));
-	const trajectoryText = await readMaybe$1(join(runDir, TRAJECTORY_FILE));
-	const result = parseOptionalRecord(resultText, join(runDir, RESULT_FILE));
-	const trajectory = parseOptionalRecord(trajectoryText, join(runDir, TRAJECTORY_FILE));
-	const resultPath = join(runDir, RESULT_FILE);
-	const trajectoryPath = join(runDir, TRAJECTORY_FILE);
-	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: runtimeState(normalized.root, normalized.startedAt, result, trajectory, resultPath, trajectoryPath),
-		progress: null,
-		workers,
-		workersMissingReason: null,
-		result: resultText,
-		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) {
-	return {
-		runRef: runDir,
-		read: () => readRuntimeSupervisorRun(runDir)
-	};
-}
-/** True when a directory contains Runtime's canonical file-backed journal. */
-async function isRuntimeSupervisorRunDir(runDir) {
-	return stat(join(runDir, JOURNAL_FILE)).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
-export { rollupSupervisorRuns as C, isUnavailable as D, SUPERVISOR_RUN_SCHEMA as E, showMeasured as O, parsePatch as S, SUPERVISOR_RUN_ROLLUP_SCHEMA as T, DEFAULT_SPAWN_TOOLS as _, readLoopsSupervisorRun as a, readClaudeCodeSupervisorRun as b, writeSupervisorRunReport as c, readRuntimeSupervisorRun as d, runtimeSupervisorRunReader as f, DEFAULT_CANCEL_TOOLS as g, renderSupervisorRunMarkdown as h, loopsSupervisorRunReader as i, unavailable as k, writeSupervisorRunReportSafe as l, renderSupervisorRunHeadline as m, findSupervisorRunDirIn as n, reportSupervisorRound as o, renderSupervisorRollupMarkdown as p, findSupervisorRunDirs as r, supervisorReportStem as s, analyzeSupervisorRun as t, isRuntimeSupervisorRunDir as u, DEFAULT_STEER_TOOLS as v, NO_SOURCE_LIMITS as w, analyzeSupervisorRunSources as x, claudeCodeSupervisorRunReader as y };
-
-//# sourceMappingURL=supervisor-run-D_sokXcO.js.map