@tangle-network/agent-runtime 0.353.3 → 2.0.1

package/dist/top-web-CkXPPXjI.js

@@ -0,0 +1,1114 @@
+import { i as FileResultBlobStore, r as spawnJournalRecordEvents, t as FileSpawnJournal, u as FileObserverJournal } from "./journal-store-BpCOCDoO.js";
+import { o as readCommittedJsonLines, r as parseCommittedJsonLines } from "./jsonl-file-BBP9Dz9w.js";
+import { _ as safeWorkerFile, b as supervisorWorkersDir, f as legacySupervisorRunsRoot, y as supervisorRunsRoot } from "./run-cancellation-Cpm-BIUu.js";
+import { n as projectPursuit, t as discoverDurableSupervisionRun } from "./supervision-discovery-C3t0Xw-T.js";
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync, watch } from "node:fs";
+import { basename, dirname, extname, join, resolve, sep } from "node:path";
+import { readFile, realpath, stat } from "node:fs/promises";
+import { createServer } from "node:http";
+// src/tui/top-transcript.ts
+/** Read selected history on demand, leaving the live topology snapshot bounded and fast. */
+async function transcriptHistory(worker, runDir, node) {
+	const rows = [];
+	const identity = node?.identity;
+	if (runDir && typeof identity?.taskDigest === "string" && worker.startedAt) {
+		const task = await new FileResultBlobStore(join(runDir, "blobs")).get(identity.taskDigest);
+		if (task !== void 0) rows.unshift({
+			at: worker.startedAt,
+			event: {
+				kind: "notice",
+				provenance: "delegated-input",
+				source: `parent ${node?.parentId ?? "run caller"}; task ${identity.taskDigest}${typeof identity.profileDigest === "string" ? `; profile ${identity.profileDigest}` : ""}; Runtime FileResultBlobStore`,
+				text: typeof task === "string" ? task : JSON.stringify(task, null, 2)
+			}
+		});
+	}
+	if (!worker.eventFile) {
+		const native = transcriptRows(worker);
+		if (!native.length && worker.startedAt) rows.push({
+			at: worker.startedAt,
+			event: {
+				kind: "notice",
+				provenance: "capture-unavailable",
+				text: "Native conversation was not captured for this agent.",
+				source: "Runtime recorded capture"
+			}
+		});
+		return [...rows, ...native];
+	}
+	const lines = [];
+	for await (const row of readCommittedJsonLines(worker.eventFile)) {
+		lines.push(JSON.stringify(row));
+		if (lines.length > 200) lines.shift();
+	}
+	return [...rows, ...transcriptRows({
+		...worker,
+		liveTail: lines
+	})];
+}
+/** Present the recorded tail through sandbox-ui's existing agent-stream contract. */
+function transcriptRows(worker) {
+	const rows = [];
+	for (const line of worker.liveTail) {
+		let value;
+		try {
+			value = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		const at = typeof value.timestamp === "string" ? value.timestamp : typeof value.at === "string" ? value.at : void 0;
+		if (!at || !Number.isFinite(Date.parse(at))) continue;
+		const event = value.event;
+		if (event?.kind) {
+			const kind = {
+				text_delta: "text",
+				reasoning_delta: "reasoning",
+				tool_call: "tool-call",
+				tool_result: "tool-result"
+			}[event.kind] ?? event.kind;
+			rows.push({
+				at,
+				event: {
+					...event,
+					kind
+				}
+			});
+			continue;
+		}
+		const message = value.message;
+		if (!message) continue;
+		const parts = typeof message.content === "string" ? [{
+			type: "text",
+			text: message.content
+		}] : message.content ?? [];
+		for (const part of parts) if (part.type === "text" && typeof part.text === "string") rows.push({
+			at,
+			event: {
+				kind: message.role === "user" ? "user" : "text",
+				text: part.text
+			}
+		});
+		else if (part.type === "thinking" && typeof part.thinking === "string") rows.push({
+			at,
+			event: {
+				kind: "reasoning",
+				text: part.thinking
+			}
+		});
+		else if (part.type === "tool_use") rows.push({
+			at,
+			event: {
+				kind: "tool-call",
+				toolCallId: String(part.id),
+				toolName: String(part.name),
+				args: part.input
+			}
+		});
+		else if (part.type === "tool_result") rows.push({
+			at,
+			event: {
+				kind: "tool-result",
+				toolCallId: String(part.tool_use_id),
+				result: part.content
+			}
+		});
+	}
+	return rows;
+}
+/** The bounded native/normalized tail shared by snapshot adapters and selected streams. */
+function readTranscriptTail(file) {
+	const fd = openSync(file, "r");
+	try {
+		const size = statSync(file).size;
+		const buffer = Buffer.alloc(Math.min(size, 65536));
+		readSync(fd, buffer, 0, buffer.length, Math.max(0, size - buffer.length));
+		const lines = buffer.toString().split("\n");
+		lines.pop();
+		if (size > buffer.length) lines.shift();
+		return lines.filter(Boolean).slice(-200);
+	} finally {
+		closeSync(fd);
+	}
+}
+function transcriptTail(worker) {
+	return transcriptRows(worker.eventFile ? {
+		...worker,
+		liveTail: readTranscriptTail(worker.eventFile)
+	} : worker);
+}
+// src/tui/workflow-journal.ts
+/** Native workflows have no Runtime accounting. Translate recorded lifecycle only. */
+function workflowJournal(runDir, text) {
+	const rows = parseCommittedJsonLines(text, "journal.jsonl");
+	const events = [];
+	const tails = /* @__PURE__ */ new Map();
+	let first;
+	let last;
+	for (const row of rows) {
+		if (typeof row.agentId !== "string" || !/^[\w-]+$/.test(row.agentId)) continue;
+		const id = row.agentId;
+		if (row.type === "started") {
+			const file = join(runDir, `agent-${id}.jsonl`);
+			let start;
+			let end;
+			try {
+				const fd = openSync(file, "r");
+				try {
+					const size = statSync(file).size;
+					const prefix = Buffer.alloc(Math.min(size, 16384));
+					readSync(fd, prefix, 0, prefix.length, 0);
+					start = /"timestamp":"([^"]+)"/.exec(prefix.toString())?.[1];
+					const lines = readTranscriptTail(file).slice(-8);
+					end = [...lines.join("\n").matchAll(/"timestamp":"([^"]+)"/g)].at(-1)?.[1];
+					tails.set(id, {
+						file,
+						lines
+					});
+				} finally {
+					closeSync(fd);
+				}
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+			if (start && (!first || start < first)) first = start;
+			if (end && (!last || end > last)) last = end;
+			events.push({
+				kind: "spawned",
+				id,
+				label: typeof row.label === "string" ? row.label : id,
+				runtime: "claude-code",
+				...start ? { at: start } : {}
+			});
+			events.push({
+				kind: "metered",
+				id,
+				spend: {
+					usdKnown: false,
+					tokensKnown: false
+				}
+			});
+		} else if (row.type === "result" || row.type === "error" || row.type === "cancelled") {
+			const line = tails.get(id)?.lines.at(-1);
+			const at = line ? /"timestamp":"([^"]+)"/.exec(line)?.[1] : void 0;
+			events.push(row.type === "cancelled" ? {
+				kind: "cancelled",
+				id,
+				...at ? { at } : {}
+			} : {
+				kind: "settled",
+				id,
+				status: row.type === "error" ? "down" : "done",
+				...at ? { at } : {},
+				spent: {
+					usdKnown: false,
+					tokensKnown: false
+				}
+			});
+		}
+	}
+	return {
+		id: basename(runDir),
+		events,
+		tails,
+		first,
+		last
+	};
+}
+// src/tui/top-snapshot.ts
+/**
+* Read-only operator snapshots over the writer-owned supervisor layout and explicit durable runs.
+* Workspace reads preserve legacy files; durable reads use discovery, journals and the canonical
+* pursuit projection for model identity, failure and accounting evidence. Run totals count once.
+* ANSI presentation lives in `./top-frame`.
+*
+* @experimental
+*/
+const emptySpend = {
+	iterations: 0,
+	tokensInput: 0,
+	tokensOutput: 0,
+	usd: 0,
+	ms: 0
+};
+function loadTopSnapshot(rootDir, input = Date.now()) {
+	if (typeof input !== "number" && input.format === "journal") return loadJournalTopSnapshot(rootDir, input.runDir, input.now ?? Date.now());
+	if (typeof input !== "number" && input.format === "workflow") {
+		const root = resolve(rootDir), dir = resolve(input.runDir), now = input.now ?? Date.now();
+		const read = readSourceFile(join(dir, "journal.jsonl"), "journal", "journal.jsonl");
+		if (read.value === void 0) return Promise.resolve(topSnapshot(root, now, [], read.diagnostics.length ? [...read.diagnostics] : [{
+			source: "journal",
+			path: "journal.jsonl",
+			reason: "missing"
+		}]));
+		try {
+			const journal = workflowJournal(dir, read.value);
+			const supervisor = buildSupervisorView({
+				id: journal.id,
+				task: journal.id,
+				status: "unobserved",
+				workspaceDir: root,
+				budget: 0,
+				budgetKnown: false,
+				...journal.first ? { startedAt: journal.first } : {}
+			}, dir, journal.events, [], now, journal.tails);
+			return Promise.resolve(topSnapshot(root, now, [{
+				...supervisor,
+				driverSpend: {
+					...supervisor.driverSpend,
+					usdKnown: false,
+					tokensKnown: false
+				},
+				totals: {
+					...supervisor.totals,
+					usdKnown: false,
+					tokensKnown: false
+				}
+			}]));
+		} catch {
+			return Promise.resolve(topSnapshot(root, now, [], [{
+				source: "journal",
+				path: "journal.jsonl",
+				reason: "invalid-state"
+			}]));
+		}
+	}
+	if (typeof input !== "number") return loadDurableTopSnapshot(rootDir, input.runDir, input.now ?? Date.now());
+	const now = input;
+	const root = resolve(rootDir);
+	const supervisors = [];
+	const diagnostics = [];
+	let discovered = 0;
+	const report = (runId, sources) => {
+		for (const source of sources) diagnostics.push({
+			...source,
+			runId
+		});
+	};
+	for (const runsRoot of [supervisorRunsRoot(root), legacySupervisorRunsRoot(root)]) {
+		if (!existsSync(runsRoot)) continue;
+		for (const entry of readdirSync(runsRoot)) {
+			const dir = join(runsRoot, entry);
+			if (!isDirectory(dir)) continue;
+			discovered += 1;
+			const state = readSupervisorState(dir);
+			report(entry, state.diagnostics);
+			if (!state.value) continue;
+			const journal = readJournal(dir);
+			const progress = readSourceFile(join(dir, "progress.ndjson"), "progress", "progress.ndjson");
+			const workerEvents = readWorkerEventTails(supervisorWorkersDir(dir), 8);
+			report(entry, [
+				...journal.diagnostics,
+				...progress.diagnostics,
+				...workerEvents.diagnostics
+			]);
+			supervisors.push(buildSupervisorView(state.value, dir, journal.value, tailLines(progress.value, 8), now, workerEvents.value));
+		}
+	}
+	supervisors.sort((a, b) => String(b.startedAt ?? "").localeCompare(String(a.startedAt ?? "")));
+	return topSnapshot(root, now, supervisors, diagnostics, discovered);
+}
+function topSnapshot(root, now, supervisors, diagnostics = [], discovered = 1, pursuit) {
+	return {
+		root,
+		generatedAt: now,
+		supervisors,
+		completeness: diagnostics.length ? "partial" : "complete",
+		diagnostics,
+		discovered,
+		loaded: supervisors.length,
+		...pursuit ? { pursuit } : {}
+	};
+}
+async function loadDurableTopSnapshot(rootDir, runDir, now) {
+	const root = resolve(rootDir);
+	let pursuit;
+	let source = "observer-journal";
+	let path = "observer.jsonl";
+	try {
+		if (typeof runDir !== "string" || !runDir.trim()) throw new TypeError("runDir must be non-empty");
+		const journal = await FileObserverJournal.open(join(resolve(runDir), path));
+		if (!journal) return topSnapshot(root, now, [], [{
+			source,
+			path,
+			reason: "missing"
+		}]);
+		pursuit = projectPursuit(await journal.read());
+		source = "journal";
+		path = ".";
+		const discovery = await discoverDurableSupervisionRun(runDir);
+		const latest = new Map(pursuit.runs.map((run) => [run.runId, run]));
+		path = "spawn-journal.jsonl";
+		const spawnJournal = new FileSpawnJournal(discovery.spawnJournalPath);
+		return topSnapshot(root, now, await Promise.all([...latest.values()].map(async (run) => {
+			const binding = discovery.roots.find((id) => id === run.runId);
+			if (!binding && existsSync(discovery.spawnJournalPath)) throw new Error("observer run has no discovered spawn root");
+			const events = binding ? await spawnJournal.loadTree(binding) ?? [] : [];
+			const rootSpawn = events.find((event) => event.kind === "spawned" && event.id === binding);
+			const budget = rootSpawn?.kind === "spawned" ? rootSpawn.budget?.maxTokens : void 0;
+			return buildSupervisorView({
+				id: run.runId,
+				status: run.status,
+				task: run.runId,
+				workspaceDir: root,
+				budget: budget ?? 0,
+				budgetKnown: budget !== void 0,
+				startedAt: new Date(run.firstObservedAt).toISOString(),
+				...run.settledAt === void 0 ? {} : { completedAt: new Date(run.settledAt).toISOString() }
+			}, discovery.runDir, events.filter(isSpawnEvent), run.error ? [run.error] : [], now, void 0, run);
+		})), [], 1, pursuit);
+	} catch (error) {
+		const reason = isRecord(error) && typeof error.code === "string" ? "unreadable" : "invalid-state";
+		return topSnapshot(root, now, [], [{
+			source,
+			path,
+			reason
+		}], 1, pursuit);
+	}
+}
+/** Old Discovery and factory roots may predate observer.jsonl; absence never establishes known totals. */
+async function loadJournalTopSnapshot(rootDir, runDir, now) {
+	const root = resolve(rootDir), dir = resolve(runDir);
+	try {
+		const discovery = await discoverDurableSupervisionRun(dir);
+		const journal = new FileSpawnJournal(discovery.spawnJournalPath);
+		return topSnapshot(root, now, await Promise.all(discovery.roots.map(async (id, i) => {
+			const events = await journal.loadTree(id) ?? [];
+			const terminal = events.filter((event) => event.id === id && (event.kind === "settled" || event.kind === "cancelled")).at(-1);
+			const first = events.find((event) => event.kind === "spawned" && event.id === id);
+			const budget = first?.kind === "spawned" ? first.budget?.maxTokens : void 0;
+			const tails = readWorkerEventTails(supervisorWorkersDir(dir), 8);
+			const view = buildSupervisorView({
+				id,
+				task: id,
+				workspaceDir: root,
+				status: terminal?.kind === "settled" ? terminal.status : terminal?.kind === "cancelled" ? "cancelled" : "running",
+				budget: budget ?? 0,
+				budgetKnown: budget !== void 0,
+				...discovery.rootsBegunAt[i] ? { startedAt: discovery.rootsBegunAt[i] } : {},
+				...terminal?.at ? { completedAt: terminal.at } : {}
+			}, dir, events.filter(isSpawnEvent), [], now, tails.value);
+			return {
+				...view,
+				totals: {
+					...view.totals,
+					usdKnown: false,
+					tokensKnown: false
+				}
+			};
+		})), [{
+			source: "observer-journal",
+			path: "observer.jsonl",
+			reason: "missing"
+		}], discovery.roots.length);
+	} catch {
+		return topSnapshot(root, now, [], [{
+			source: "journal",
+			path: "spawn-journal.jsonl",
+			reason: "invalid-state"
+		}]);
+	}
+}
+function observerSpend(spend, gaps = []) {
+	const parsed = parseSpend(spend);
+	return {
+		...parsed,
+		usdKnown: spend !== void 0 && parsed.usdKnown !== false && !gaps.includes("usd"),
+		tokensKnown: spend !== void 0 && parsed.tokensKnown !== false && !gaps.includes("tokens")
+	};
+}
+/**
+* The journal file a run dir actually carries. `createFileRunContext` — this repo's own durable
+* writer — names it `spawn-journal.jsonl`; `journal.jsonl` is the retired bare-event file older
+* runs left behind. First existing name wins; a reader that knew only the retired name would show
+* zero workers for every current run.
+*/
+const journalFileNames = ["spawn-journal.jsonl", "journal.jsonl"];
+function readJournal(eventDir) {
+	const path = journalFileNames.find((candidate) => existsSync(join(eventDir, candidate)));
+	if (!path) return {
+		value: [],
+		diagnostics: []
+	};
+	const read = readSourceFile(join(eventDir, path), "journal", path);
+	if (read.value === void 0) return {
+		value: [],
+		diagnostics: read.diagnostics
+	};
+	const out = [];
+	let partial = false;
+	for (const line of read.value.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const parsed = JSON.parse(trimmed);
+			const events = parsed.kind === "event" || parsed.kind === "events" ? spawnJournalRecordEvents(parsed) : [parsed];
+			for (const event of events) if (isSpawnEvent(event)) out.push(event);
+		} catch {
+			partial = true;
+		}
+	}
+	return {
+		value: out,
+		diagnostics: partial ? [{
+			source: "journal",
+			path,
+			reason: "partial-json"
+		}] : []
+	};
+}
+function buildSupervisorView(state, stateDir, events, progressTail, now, workerEventTails = /* @__PURE__ */ new Map(), accounting) {
+	const workers = /* @__PURE__ */ new Map();
+	let driverSpend = emptySpend;
+	const journalRootId = events.find((event) => event.kind === "spawned" && !event.parent && event.label === "root")?.id;
+	const isRoot = (id) => id === state.id || id === journalRootId;
+	for (const event of events) {
+		if (isRoot(event.id) || event.kind === "spawned" && !event.parent && event.label === "root") {
+			if (event.kind === "metered" && event.accountingOnly !== true) driverSpend = addSpend(driverSpend, parseSpend(event.spend));
+			continue;
+		}
+		const worker = ensureWorker(workers, event.id);
+		if (event.kind === "spawned") {
+			worker.label = event.label ?? worker.label;
+			if (event.parent) worker.parent = event.parent;
+			if (event.runtime) worker.runtime = event.runtime;
+			worker.status = "running";
+			if (event.at) worker.startedAt = event.at;
+			const budget = parseBudget(event.budget);
+			if (budget) worker.budget = budget;
+		} else if (event.kind === "settled" || event.kind === "cancelled") {
+			if (event.at) worker.endedAt = event.at;
+			if (event.kind === "settled") {
+				worker.status = event.status === "down" ? "down" : "done";
+				if (event.outRef) worker.outRef = event.outRef;
+				if (event.infra !== void 0) worker.infra = event.infra;
+				const verdict = describeVerdict(event.verdict);
+				if (verdict) worker.verdict = verdict;
+			} else {
+				worker.status = "cancelled";
+				if (event.reason) worker.reason = event.reason;
+			}
+			if (event.kind === "settled" || event.spent !== void 0) {
+				worker.spend = addSpend(worker.spend, parseSpend(event.spent));
+				worker.metered = emptySpend;
+			}
+		} else if (event.kind === "progress") worker.metered = parseSpend(event.spend);
+		else if (event.accountingOnly !== true) worker.metered = addSpend(worker.metered, parseSpend(event.spend));
+	}
+	if (accounting) {
+		driverSpend = observerSpend(accounting.totals.exclusiveByNode[accounting.runId]);
+		for (const worker of workers.values()) {
+			worker.spend = observerSpend(accounting.totals.exclusiveByNode[worker.id], accounting.spendGaps?.find((gap) => gap.id === worker.id)?.channels);
+			worker.metered = emptySpend;
+		}
+	}
+	const workerViews = [...workers.values()].map((worker) => {
+		const tail = workerEventTails.get(worker.label) ?? workerEventTails.get(safeWorkerFile(worker.label)) ?? workerEventTails.get(safeWorkerFile(worker.id)) ?? workerEventTails.get(worker.id);
+		worker.liveTail = tail?.lines ?? [];
+		if (tail?.file) worker.eventFile = tail.file;
+		return finalizeWorker(worker, now);
+	}).sort((a, b) => compareWorker(a, b));
+	const totals = supervisorTotals(state, workerViews, driverSpend, now);
+	if (accounting) {
+		const spend = observerSpend(accounting.totals.inclusive, accounting.spendGaps?.flatMap((gap) => gap.channels));
+		Object.assign(totals, spend, { tokensTotal: spend.tokensInput + spend.tokensOutput });
+	}
+	return {
+		id: state.id,
+		stateDir,
+		status: state.status,
+		task: state.task,
+		workspaceDir: state.workspaceDir,
+		budget: state.budget,
+		...state.budgetKnown === void 0 ? {} : { budgetKnown: state.budgetKnown },
+		...selectFields(state, [
+			"verifyCmd",
+			"workerModel",
+			"driverModel",
+			"verdict",
+			"progress",
+			"startedAt",
+			"completedAt"
+		], Boolean),
+		...selectFields(state, [
+			"maxSandboxes",
+			"maxLifetimeSeconds",
+			"idleTimeoutSeconds",
+			"maxUsd",
+			"maxDepth"
+		], (value) => value !== void 0),
+		...state.result?.spentUsd !== void 0 ? { resultSpentUsd: state.result.spentUsd } : {},
+		...state.result?.spentTokens !== void 0 ? { resultSpentTokens: state.result.spentTokens } : {},
+		workers: workerViews,
+		progressTail: [...progressTail],
+		journalTail: events.slice(-12),
+		driverSpend,
+		totals
+	};
+}
+function selectFields(value, keys, include) {
+	const selected = {};
+	for (const key of keys) if (include(value[key])) selected[key] = value[key];
+	return selected;
+}
+function ensureWorker(workers, id) {
+	const existing = workers.get(id);
+	if (existing) return existing;
+	const created = {
+		id,
+		label: id,
+		status: "running",
+		spend: emptySpend,
+		metered: emptySpend,
+		liveTail: []
+	};
+	workers.set(id, created);
+	return created;
+}
+function finalizeWorker(worker, now) {
+	const startMs = parseTime(worker.startedAt);
+	const endMs = parseTime(worker.endedAt) ?? (worker.status === "running" ? now : startMs);
+	const latencyMs = startMs !== void 0 && endMs !== void 0 ? Math.max(0, endMs - startMs) : 0;
+	return {
+		...worker,
+		latencyMs
+	};
+}
+function supervisorTotals(state, workers, driverSpend, now) {
+	const spend = workers.map(totalSpend).reduce(addSpend, driverSpend);
+	const counts = {
+		running: 0,
+		done: 0,
+		down: 0,
+		cancelled: 0
+	};
+	for (const worker of workers) counts[worker.status] += 1;
+	const started = parseTime(state.startedAt);
+	const completed = parseTime(state.completedAt);
+	const latencyMs = started !== void 0 ? Math.max(0, (completed ?? now) - started) : 0;
+	const latencies = workers.map((worker) => worker.latencyMs).filter((ms) => ms > 0);
+	return {
+		workers: workers.length,
+		...counts,
+		...spend.usdKnown === false ? { usdKnown: false } : {},
+		...spend.tokensKnown === false ? { tokensKnown: false } : {},
+		inFlight: counts.running,
+		settled: workers.length - counts.running,
+		tokensInput: spend.tokensInput,
+		tokensOutput: spend.tokensOutput,
+		tokensTotal: spend.tokensInput + spend.tokensOutput,
+		usd: spend.usd > 0 ? spend.usd : state.result?.spentUsd ?? 0,
+		latencyMs,
+		workerLatency: distribution(latencies)
+	};
+}
+function aggregateSnapshot(snapshot) {
+	const complete = snapshot.completeness === "complete";
+	return {
+		usdKnown: complete && snapshot.supervisors.every((row) => row.totals.usdKnown !== false),
+		tokensKnown: complete && snapshot.supervisors.every((row) => row.totals.tokensKnown !== false),
+		supervisors: snapshot.supervisors.length,
+		workers: sum(snapshot.supervisors.map((supervisor) => supervisor.totals.workers)),
+		running: sum(snapshot.supervisors.map((supervisor) => supervisor.totals.running)),
+		done: sum(snapshot.supervisors.map((supervisor) => supervisor.totals.done)),
+		down: sum(snapshot.supervisors.map((supervisor) => supervisor.totals.down)),
+		usd: sum(snapshot.supervisors.map((supervisor) => supervisor.totals.usd)),
+		tokensInput: sum(snapshot.supervisors.map((supervisor) => supervisor.totals.tokensInput)),
+		tokensOutput: sum(snapshot.supervisors.map((supervisor) => supervisor.totals.tokensOutput))
+	};
+}
+function compareWorker(a, b) {
+	const aStart = parseTime(a.startedAt) ?? 0;
+	const bStart = parseTime(b.startedAt) ?? 0;
+	if (a.status === "running" && b.status !== "running") return -1;
+	if (b.status === "running" && a.status !== "running") return 1;
+	return aStart - bStart || a.label.localeCompare(b.label);
+}
+function totalSpend(worker) {
+	return addSpend(worker.spend, worker.metered);
+}
+function addSpend(a, b) {
+	return {
+		iterations: a.iterations + b.iterations,
+		tokensInput: a.tokensInput + b.tokensInput,
+		tokensOutput: a.tokensOutput + b.tokensOutput,
+		usd: a.usd + b.usd,
+		ms: a.ms + b.ms,
+		...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
+		...a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {}
+	};
+}
+function parseSpend(value) {
+	if (!isRecord(value)) return emptySpend;
+	const tokens = isRecord(value.tokens) ? value.tokens : {};
+	return {
+		...value.usdKnown === false ? { usdKnown: false } : {},
+		...value.tokensKnown === false || tokens.tokensKnown === false ? { tokensKnown: false } : {},
+		iterations: numberValue(value.iterations),
+		tokensInput: numberValue(tokens.input),
+		tokensOutput: numberValue(tokens.output),
+		usd: numberValue(value.usd),
+		ms: numberValue(value.ms)
+	};
+}
+function parseBudget(value) {
+	if (!isRecord(value)) return void 0;
+	const budget = {
+		...typeof value.maxIterations === "number" ? { maxIterations: value.maxIterations } : {},
+		...typeof value.maxTokens === "number" ? { maxTokens: value.maxTokens } : {},
+		...typeof value.maxUsd === "number" ? { maxUsd: value.maxUsd } : {}
+	};
+	return Object.keys(budget).length ? budget : void 0;
+}
+function describeVerdict(value) {
+	if (!isRecord(value)) return void 0;
+	if (typeof value.valid === "boolean") return value.valid ? "valid" : "invalid";
+	if (typeof value.score === "number") return `score ${value.score.toFixed(2)}`;
+}
+function distribution(values) {
+	const sorted = [...values].sort((a, b) => a - b);
+	return {
+		n: sorted.length,
+		min: sorted[0] ?? 0,
+		median: percentile(sorted, .5),
+		p90: percentile(sorted, .9),
+		max: sorted[sorted.length - 1] ?? 0
+	};
+}
+function percentile(sorted, p) {
+	if (sorted.length === 0) return 0;
+	return sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * p) - 1))] ?? 0;
+}
+/**
+* Read one source file under a run directory. An absent file is not a defect on its own — the
+* writer may not have reached it yet — so it reads as `undefined` with no diagnostic; only a
+* failed read raises one. `path` stays run-relative and never carries file contents.
+*/
+function readSourceFile(file, source, path) {
+	if (!existsSync(file)) return {
+		value: void 0,
+		diagnostics: []
+	};
+	try {
+		return {
+			value: readFileSync(file, "utf8"),
+			diagnostics: []
+		};
+	} catch {
+		return {
+			value: void 0,
+			diagnostics: [{
+				source,
+				path,
+				reason: "unreadable"
+			}]
+		};
+	}
+}
+function tailLines(raw, maxLines) {
+	if (raw === void 0) return [];
+	return raw.trim().split("\n").filter(Boolean).slice(-maxLines);
+}
+function readWorkerEventTails(dir, maxLines) {
+	const out = /* @__PURE__ */ new Map();
+	if (!existsSync(dir)) return {
+		value: out,
+		diagnostics: []
+	};
+	const workersDir = basename(dir);
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return {
+			value: out,
+			diagnostics: [{
+				source: "worker-tail",
+				path: workersDir,
+				reason: "unreadable"
+			}]
+		};
+	}
+	const diagnostics = [];
+	for (const entry of entries) {
+		if (!entry.endsWith(".ndjson") || entry.endsWith(".inbox.ndjson")) continue;
+		const file = join(dir, entry);
+		const read = readSourceFile(file, "worker-tail", join(workersDir, entry));
+		diagnostics.push(...read.diagnostics);
+		const lines = tailLines(read.value, maxLines);
+		out.set(entry.slice(0, -7), {
+			file,
+			lines
+		});
+	}
+	return {
+		value: out,
+		diagnostics
+	};
+}
+function readSupervisorState(dir) {
+	const path = "state.json";
+	const read = readSourceFile(join(dir, path), "supervisor-state", path);
+	if (read.diagnostics.length > 0) return {
+		value: void 0,
+		diagnostics: read.diagnostics
+	};
+	const failed = (reason) => ({
+		value: void 0,
+		diagnostics: [{
+			source: "supervisor-state",
+			path,
+			reason
+		}]
+	});
+	if (read.value === void 0) return failed("missing");
+	try {
+		const parsed = JSON.parse(read.value);
+		return isSupervisorState(parsed) ? {
+			value: parsed,
+			diagnostics: []
+		} : failed("invalid-state");
+	} catch {
+		return failed("partial-json");
+	}
+}
+function isSupervisorState(value) {
+	return isRecord(value) && Object.entries({
+		id: "string",
+		status: "string",
+		task: "string",
+		workspaceDir: "string",
+		budget: "number"
+	}).every(([key, type]) => typeof value[key] === type);
+}
+function isSpawnEvent(value) {
+	return isRecord(value) && typeof value.id === "string" && typeof value.kind === "string" && [
+		"spawned",
+		"settled",
+		"cancelled",
+		"metered",
+		"progress"
+	].includes(value.kind);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isDirectory(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function numberValue(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function parseTime(value) {
+	if (!value) return void 0;
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function sum(values) {
+	return values.reduce((total, value) => total + value, 0);
+}
+// src/tui/top-web.ts
+/** Read-only web transport over the same snapshots as the terminal. No execution or writes. */
+async function serveTopWeb(options) {
+	if (!options.roots.length) throw new Error("At least one --root is required");
+	const roots = [...new Set(await Promise.all(options.roots.map((root) => realpath(root))))];
+	const assets = await realpath(options.assets ?? dirname(createRequire(import.meta.url).resolve("@drewstone/agent-record/workspace-viewer.js")));
+	for (const file of ["workspace-viewer.js", "styles.css"]) await stat(resolve(assets, file));
+	const host = options.host ?? "127.0.0.1";
+	const clients = /* @__PURE__ */ new Set();
+	const transcripts = /* @__PURE__ */ new Set();
+	const snapshots = /* @__PURE__ */ new Map();
+	const digests = /* @__PURE__ */ new Map();
+	const watchers = [];
+	let sequence = 0;
+	let reading = false;
+	let dirty = true;
+	let closed = false;
+	let scheduled;
+	const send = (client, frame) => {
+		if (client.writableLength > 1048576) return client.destroy();
+		client.write(`id: ${frame.sequence}\nevent: snapshot\ndata: ${JSON.stringify(frame)}\n\n`);
+	};
+	const refresh = async () => {
+		if (reading || closed) return;
+		reading = true;
+		dirty = false;
+		try {
+			const changed = [];
+			for (const root of roots) {
+				const snapshot = existsSync(resolve(root, "observer.jsonl")) ? await loadTopSnapshot(root, { runDir: root }) : existsSync(resolve(root, "spawn-journal.jsonl")) ? await loadTopSnapshot(root, {
+					runDir: root,
+					format: "journal"
+				}) : existsSync(resolve(root, "journal.jsonl")) ? await loadTopSnapshot(root, {
+					runDir: root,
+					format: "workflow"
+				}) : await loadRunsRoot(root);
+				const digest = createHash("sha256").update(JSON.stringify(snapshot, (key, value) => key === "generatedAt" || key === "latencyMs" ? void 0 : value)).digest("hex");
+				snapshots.set(root, snapshot);
+				if (digests.get(root) !== digest) {
+					changed.push(snapshot);
+					digests.set(root, digest);
+				}
+			}
+			if (changed.length) {
+				const frame = {
+					sequence: ++sequence,
+					observedAt: Date.now(),
+					reset: false,
+					snapshots: changed
+				};
+				for (const client of clients) send(client, frame);
+			}
+			for (const update of transcripts) update();
+		} finally {
+			reading = false;
+			if (dirty && !closed) schedule();
+		}
+	};
+	const schedule = () => {
+		dirty = true;
+		if (!scheduled && !closed) scheduled = setTimeout(() => {
+			scheduled = void 0;
+			refresh().catch((error) => {
+				for (const client of clients) client.write(`event: unavailable\ndata: ${JSON.stringify({ message: String(error) })}\n\n`);
+			});
+		}, 16);
+	};
+	await refresh();
+	for (const root of roots) watchers.push(watch(root, { recursive: true }, schedule));
+	const reconcile = setInterval(schedule, 500);
+	const heartbeat = setInterval(() => {
+		for (const client of clients) client.write(": alive\n\n");
+	}, 15e3);
+	const server = createServer((request, response) => {
+		(async () => {
+			const base = `http://${request.headers.host}`;
+			const incomingHost = new URL(base).hostname.replace(/^\[|\]$/g, "");
+			if (!request.headers.host || ![
+				host,
+				"127.0.0.1",
+				"localhost",
+				"::1"
+			].includes(incomingHost) || request.headers.origin && request.headers.origin !== base) {
+				response.writeHead(403).end();
+				return;
+			}
+			if (request.method !== "GET" && request.method !== "HEAD") {
+				response.writeHead(405, { Allow: "GET, HEAD" }).end();
+				return;
+			}
+			const path = new URL(request.url ?? "/", base).pathname;
+			response.setHeader("Cache-Control", "no-store");
+			response.setHeader("X-Content-Type-Options", "nosniff");
+			if (path === "/api/top/events") {
+				if (request.method === "HEAD") {
+					response.writeHead(200, { "Content-Type": "text/event-stream" }).end();
+					return;
+				}
+				response.writeHead(200, {
+					"Content-Type": "text/event-stream",
+					"X-Accel-Buffering": "no"
+				});
+				response.flushHeaders();
+				clients.add(response);
+				send(response, {
+					sequence,
+					observedAt: Date.now(),
+					reset: true,
+					snapshots: [...snapshots.values()]
+				});
+				response.on("close", () => clients.delete(response));
+			} else if (/^\/api\/top\/agents\/\d+\/[^/]+\/[^/]+\/stream$/.test(path)) {
+				const [, , , , rootIndex, runId, workerId] = path.split("/").map(decodeURIComponent);
+				const root = roots[Number(rootIndex)];
+				const worker = () => {
+					const run = root ? snapshots.get(root)?.supervisors.find((run) => run.id === runId) : void 0;
+					const node = run?.workers.find((node) => node.id === workerId);
+					if (node || !run || run.id !== workerId) return node;
+					return {
+						id: run.id,
+						label: "root",
+						...root && existsSync(resolve(root, "root-stream.jsonl")) ? { eventFile: resolve(root, "root-stream.jsonl") } : {},
+						status: run.status === "cancelled" ? "cancelled" : run.status === "done" ? "done" : run.status === "down" ? "down" : "running",
+						startedAt: run.startedAt,
+						endedAt: run.completedAt,
+						latencyMs: run.totals.latencyMs,
+						spend: run.driverSpend,
+						metered: {
+							iterations: 0,
+							tokensInput: 0,
+							tokensOutput: 0,
+							usd: 0,
+							ms: 0
+						},
+						liveTail: run.progressTail
+					};
+				};
+				if (!worker()) {
+					response.writeHead(404).end();
+					return;
+				}
+				let history = await transcriptHistory(worker(), root, snapshots.get(root)?.pursuit?.nodes.find((node) => node.runId === runId && node.id === workerId));
+				response.writeHead(200, {
+					"Content-Type": "text/event-stream",
+					"X-Accel-Buffering": "no"
+				});
+				response.flushHeaders();
+				if (request.method === "HEAD") {
+					response.end();
+					return;
+				}
+				const generation = Date.now();
+				response.write(`event: reset\ndata: ${JSON.stringify({ generation })}\n\n`);
+				const seen = /* @__PURE__ */ new Set();
+				let lastSeq = 0;
+				const update = () => {
+					const node = worker();
+					if (!node || response.writableLength > 1048576) {
+						response.destroy();
+						return;
+					}
+					const events = (history ?? transcriptTail(node)).flatMap((row) => {
+						const key = createHash("sha256").update(JSON.stringify(row)).digest("hex");
+						if (seen.has(key)) return [];
+						seen.add(key);
+						if (seen.size > 2e3) seen.delete(seen.values().next().value);
+						return [{
+							...row,
+							seq: ++lastSeq
+						}];
+					});
+					history = void 0;
+					const alive = node.status === "running";
+					response.write(`event: rows\ndata: ${JSON.stringify({
+						generation,
+						events,
+						lastSeq,
+						alive,
+						window: "recorded-tail"
+					})}\n\n`);
+					if (!alive) {
+						response.write("event: end\ndata: {}\n\n");
+						response.end();
+					}
+				};
+				transcripts.add(update);
+				response.on("close", () => transcripts.delete(update));
+				update();
+			} else if (path === "/api/top") {
+				response.writeHead(200, { "Content-Type": "application/json" });
+				response.end(JSON.stringify({
+					sequence,
+					observedAt: Date.now(),
+					reset: true,
+					snapshots: [...snapshots.values()]
+				}));
+			} else if (path === "/") {
+				response.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+				response.end("<!doctype html><html><head><meta name=\"viewport\" content=\"width=device-width,initial-scale=1\"><title>Live agents</title><link rel=\"stylesheet\" href=\"/assets/styles.css\"></head><body><div id=\"agent-workspace\" data-mode=\"live\" data-api=\"/api/top\" data-theme=\"dark\"></div><script type=\"module\" src=\"/assets/workspace-viewer.js\"><\/script></body></html>");
+			} else if (path.startsWith("/assets/")) {
+				const file = await realpath(resolve(assets, decodeURIComponent(path.slice(8))));
+				if (!file.startsWith(assets + sep)) {
+					response.writeHead(403).end();
+					return;
+				}
+				const kind = {
+					".js": "text/javascript",
+					".css": "text/css",
+					".woff2": "font/woff2"
+				}[extname(file)];
+				if (!kind) {
+					response.writeHead(404).end();
+					return;
+				}
+				response.writeHead(200, { "Content-Type": kind });
+				response.end(request.method === "HEAD" ? void 0 : await readFile(file));
+			} else response.writeHead(404).end();
+		})().catch((error) => {
+			if (!response.headersSent) response.writeHead(500, { "Content-Type": "application/json" });
+			response.end(JSON.stringify({ error: String(error) }));
+		});
+	});
+	let closing;
+	const close = () => closing ??= (async () => {
+		closed = true;
+		if (scheduled) clearTimeout(scheduled);
+		clearInterval(reconcile);
+		clearInterval(heartbeat);
+		for (const watcher of watchers) watcher.close();
+		for (const client of clients) client.end();
+		transcripts.clear();
+		server.closeAllConnections();
+		await new Promise((done, reject) => server.close((error) => error && (!("code" in error) || error.code !== "ERR_SERVER_NOT_RUNNING") ? reject(error) : done()));
+	})();
+	try {
+		await new Promise((done, reject) => {
+			server.once("error", reject);
+			server.listen(options.port ?? 0, host, done);
+		});
+	} catch (error) {
+		await close();
+		throw error;
+	}
+	const address = server.address();
+	if (!address || typeof address === "string") throw new Error("Web server has no TCP address");
+	return {
+		url: `http://${host.includes(":") ? `[${host}]` : host}:${address.port}/`,
+		close
+	};
+}
+/** CLI options stay on agent-runtime-top; the renderer is supplied by its installed owner. */
+async function runTopWeb(argv) {
+	const values = (flag) => argv.flatMap((arg, i) => arg === flag ? [argv[i + 1] ?? ""] : []);
+	const roots = values("--root");
+	const port = Number(values("--port")[0] ?? 0);
+	if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error("Invalid --port");
+	const web = await serveTopWeb({
+		roots: roots.length ? roots : [process.cwd()],
+		...values("--assets")[0] ? { assets: values("--assets")[0] } : {},
+		port,
+		...values("--host")[0] ? { host: values("--host")[0] } : {}
+	});
+	process.stdout.write(`${JSON.stringify({
+		event: "ready",
+		url: web.url,
+		pid: process.pid
+	})}\n`);
+	const stop = () => {
+		web.close().catch((error) => {
+			process.stderr.write(`${String(error)}\n`);
+			process.exitCode = 1;
+		});
+	};
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
+	return web;
+}
+/** A journal root holds one `<runId>/observer.jsonl` per retained run beside any workspace runs. */
+async function loadRunsRoot(root) {
+	const workspace = loadTopSnapshot(root);
+	const runIds = readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync(resolve(root, entry.name, "observer.jsonl"))).map((entry) => entry.name);
+	if (!runIds.length) return workspace;
+	const runs = await Promise.all(runIds.map((runId) => loadTopSnapshot(root, { runDir: resolve(root, runId) })));
+	const diagnostics = [...workspace.diagnostics, ...runs.flatMap((run, i) => run.diagnostics.map((d) => ({
+		...d,
+		runId: runIds[i]
+	})))];
+	const supervisors = [...workspace.supervisors, ...runs.flatMap((run) => run.supervisors)];
+	return {
+		...workspace,
+		supervisors,
+		diagnostics,
+		completeness: diagnostics.length ? "partial" : "complete",
+		discovered: workspace.discovered + runIds.length,
+		loaded: supervisors.length
+	};
+}
+export { numberValue as a, totalSpend as c, loadTopSnapshot as i, serveTopWeb as n, parseSpend as o, aggregateSnapshot as r, parseTime as s, runTopWeb as t };
+
+//# sourceMappingURL=top-web-CkXPPXjI.js.map