@krapht/ork 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/format-DaROJUgG.mjs

@@ -1,662 +0,0 @@
-import { bt as liveStatus, cn as maskSecrets } from "./src-BsLHKQRc.mjs";
-import { i as style, n as cost } from "./output-CwqlG1Le.mjs";
-import { createInterface } from "node:readline/promises";
-// ../core/src/control/queue.ts
-const PERMISSION_OPTIONS = [{
-	id: "allow",
-	label: "Allow"
-}, {
-	id: "deny",
-	label: "Deny"
-}];
-const DENIED = "The user did not allow this tool.";
-/** The deny message a session gets, with the person's words when given. */
-const deniedMessage = (note) => note === void 0 ? DENIED : `${DENIED} They said: ${note}`;
-/** The input fields that say what a tool will do, the first one present. */
-const TOOL_INPUT_KEYS = [
-	"command",
-	"file_path",
-	"path",
-	"url",
-	"pattern"
-];
-/** A tool's input for the decision's context: as written, cut at `max`. */
-const inputContext = (input, max = 4e3) => {
-	const key = TOOL_INPUT_KEYS.find((k) => typeof input[k] === "string");
-	const text = key === void 0 ? JSON.stringify(input, void 0, 2) : String(input[key]);
-	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
-};
-const createDecisionQueue = (options) => {
-	const { store, runId, emit } = options;
-	let count = 0;
-	/** Opens a decision and settles it with the first answer. */
-	const decide = (open, local, withdrawn) => {
-		count += 1;
-		const id = `${runId}-${String(count)}`;
-		const record = store.openDecision({
-			...open,
-			id,
-			runId
-		});
-		const event = {
-			type: "decision.opened",
-			node: record.node,
-			decision: id,
-			kind: record.kind,
-			question: record.question,
-			options: record.options
-		};
-		if (record.recommended !== void 0) event.recommended = record.recommended;
-		if (record.owner !== void 0) event.owner = record.owner;
-		emit(event);
-		const { promise, resolve, reject } = Promise.withResolvers();
-		const settled = new AbortController();
-		/** `note` is the stored one: masked, and absent when blank. */
-		const finish = (answer, by, note) => {
-			if (settled.signal.aborted) return;
-			settled.abort();
-			const answered = {
-				type: "decision.answered",
-				node: open.node,
-				decision: id,
-				answer,
-				by
-			};
-			if (note !== void 0) answered.note = note;
-			emit(answered);
-			resolve(note === void 0 ? {
-				answer,
-				by
-			} : {
-				answer,
-				by,
-				note
-			});
-		};
-		const withdraw = () => {
-			if (settled.signal.aborted) return;
-			settled.abort();
-			store.withdrawDecision(id);
-			emit({
-				type: "decision.withdrawn",
-				node: open.node,
-				decision: id
-			});
-			reject(/* @__PURE__ */ new Error("the question was withdrawn"));
-		};
-		if (withdrawn?.aborted === true) withdraw();
-		withdrawn?.addEventListener("abort", withdraw, { once: true });
-		const fromStore = async () => {
-			try {
-				const closed = await options.waitFor(id, settled.signal);
-				if (closed.status === "answered" && closed.answer !== void 0) finish(closed.answer, closed.answeredBy ?? "decide", closed.note);
-			} catch {}
-		};
-		const fromTerminal = async (ask) => {
-			try {
-				const { answer, note } = await ask(settled.signal);
-				if (store.answerDecision(id, answer, "terminal", note)) finish(answer, "terminal", store.decision(id)?.note);
-			} catch {}
-		};
-		fromStore();
-		if (local !== void 0) fromTerminal(local);
-		return promise;
-	};
-	return {
-		ask: (question) => {
-			const open = {
-				node: question.nodeId,
-				kind: "question",
-				question: question.question,
-				options: question.options
-			};
-			if (question.recommended !== void 0) open.recommended = question.recommended;
-			if (question.context !== void 0) open.context = question.context;
-			if (question.document !== void 0) open.document = question.document;
-			if (question.owner !== void 0) open.owner = question.owner;
-			const { local } = options;
-			return decide(open, local === void 0 ? void 0 : (signal) => {
-				let note;
-				return local.ask({
-					...question,
-					question: maskSecrets(question.question),
-					...question.context === void 0 ? {} : { context: maskSecrets(question.context) },
-					...question.document === void 0 ? {} : { document: maskSecrets(question.document) },
-					signal,
-					onNote: (given) => {
-						note = given;
-					}
-				}).then((answer) => note === void 0 ? { answer } : {
-					answer,
-					note
-				});
-			}, question.signal).then(({ answer, note }) => {
-				if (note !== void 0) question.onNote?.(note);
-				return answer;
-			});
-		},
-		settled: (question) => {
-			count += 1;
-			const id = `${runId}-${String(count)}`;
-			const { owner } = question;
-			const record = store.openDecision({
-				id,
-				runId,
-				node: question.nodeId,
-				kind: "question",
-				question: question.question,
-				options: question.options,
-				owner,
-				...question.recommended === void 0 ? {} : { recommended: question.recommended },
-				...question.context === void 0 ? {} : { context: question.context }
-			});
-			emit({
-				type: "decision.opened",
-				node: record.node,
-				decision: id,
-				kind: "question",
-				question: record.question,
-				options: record.options,
-				owner,
-				...record.recommended === void 0 ? {} : { recommended: record.recommended }
-			});
-			store.answerDecision(id, question.answer, "owner", question.note);
-			const note = store.decision(id)?.note;
-			emit({
-				type: "decision.answered",
-				node: record.node,
-				decision: id,
-				answer: question.answer,
-				by: "owner",
-				owner,
-				...note === void 0 ? {} : { note }
-			});
-		},
-		permit: async (request) => {
-			const { local } = options;
-			let localMessage = DENIED;
-			const { answer, note } = await decide({
-				node: request.nodeId,
-				kind: "permission",
-				question: `Allow ${request.toolName}?`,
-				options: PERMISSION_OPTIONS,
-				context: inputContext(request.input)
-			}, local === void 0 ? void 0 : (signal) => {
-				let said;
-				return local.permit({
-					...request,
-					signal,
-					onNote: (given) => {
-						said = given;
-					}
-				}).then((result) => {
-					if (!result.allow) localMessage = result.message;
-					const choice = result.allow ? "allow" : "deny";
-					return said === void 0 ? { answer: choice } : {
-						answer: choice,
-						note: said
-					};
-				});
-			});
-			if (note !== void 0) request.onNote?.(note);
-			return answer === "allow" ? { allow: true } : {
-				allow: false,
-				message: note === void 0 ? localMessage : deniedMessage(note)
-			};
-		}
-	};
-};
-// src/human.ts
-/**
-* @file The terminal `HumanChannel`: answers `ask_user` questions, gates and
-*   permission prompts on the terminal, one at a time, and denies or defers
-*   when no one is there. After a choice it offers one optional line for a
-*   note, which Enter skips. In a run it is the decision queue's local
-*   answerer, racing `ork decide`.
-*/
-const PREVIEW = 160;
-/** A document longer than this is offered (`d`) rather than printed. */
-const SHORT_DOCUMENT_LINES = 40;
-const NO_ONE_TO_PERMIT = "No one is at the terminal to approve this tool, so it is not allowed in this run.";
-const NOTE_PROMPT = "  Note for the run (optional, Enter to skip): ";
-const NO_ONE_TO_ASK = "no one (nobody is at the terminal; use your best judgment and say so in your report)";
-/** One line that shows what a tool is about to do. */
-const previewInput = (toolName, input) => {
-	const key = TOOL_INPUT_KEYS.find((k) => typeof input[k] === "string");
-	const line = (key === void 0 ? JSON.stringify(input) : `${key}: ${String(input[key])}`).replaceAll(/\s+/gu, " ").trim();
-	return line.length > PREVIEW ? `${toolName} ${line.slice(0, 159)}…` : `${toolName} ${line}`;
-};
-/** The option an answer names: its number, or its id. */
-const pickOption = (answer, options, recommended) => {
-	const value = answer.trim();
-	if (value === "") return recommended;
-	const index = Number(value);
-	if (Number.isInteger(index) && index >= 1 && index <= options.length) return options[index - 1]?.id;
-	return options.find((o) => o.id === value)?.id;
-};
-const optionLine = (option, index, recommended) => {
-	const label = option.label === void 0 ? "" : ` ${option.label}`;
-	const description = option.description === void 0 ? "" : style("dim", ` - ${option.description}`);
-	const mark = option.id === recommended ? style("green", " (recommended)") : "";
-	return `  ${String(index + 1)}) ${style("bold", option.id)}${label}${description}${mark}`;
-};
-/**
-* Answers permission prompts and `ask_user` questions on the terminal, one at a
-* time. Without a terminal it denies tools and leaves questions to the node. A
-* withdrawn prompt (answered elsewhere) rejects, which frees the turn.
-*/
-const createTerminalHuman = (io) => {
-	let rl;
-	let turn = Promise.resolve();
-	const say = (text) => {
-		io.output.write(`${text}\n`);
-	};
-	const prompt = (text, signal) => {
-		rl ??= createInterface({
-			input: io.input,
-			output: io.output
-		});
-		return signal === void 0 ? rl.question(text) : rl.question(text, { signal });
-	};
-	/** The optional line after a choice, when the asker takes a note. */
-	const takeNote = async (onNote, signal) => {
-		if (onNote === void 0) return;
-		const note = (await prompt(NOTE_PROMPT, signal)).trim();
-		if (note !== "") onNote(note);
-	};
-	const choose = async (hint, options, recommended, signal, document) => {
-		const answer = await prompt(`  Choose${hint}: `, signal);
-		const picked = pickOption(answer, options, recommended);
-		if (picked !== void 0) return picked;
-		if (document !== void 0 && answer.trim() === "d") say(document);
-		else say(style("dim", "  Type an option's number or id."));
-		return choose(hint, options, recommended, signal, document);
-	};
-	const oneAtATime = (work) => {
-		const result = turn.then(work);
-		turn = result.catch(() => null);
-		return result;
-	};
-	return {
-		permit: ({ nodeId, toolName, input, signal, onNote }) => oneAtATime(async () => {
-			if (signal?.aborted === true) throw new Error("the prompt was withdrawn");
-			say(`${style(["yellow", "bold"], "?")} ${style("bold", nodeId)} wants to run ${previewInput(toolName, input)}`);
-			if (!io.interactive) {
-				say(style("dim", `  denied: ${NO_ONE_TO_PERMIT}`));
-				return {
-					allow: false,
-					message: NO_ONE_TO_PERMIT
-				};
-			}
-			const answer = (await prompt("  Allow? [y/N] ", signal)).trim().toLowerCase();
-			if (answer === "y" || answer === "yes") return { allow: true };
-			await takeNote(onNote, signal);
-			return {
-				allow: false,
-				message: "The user did not allow this tool."
-			};
-		}),
-		ask: ({ nodeId, question, options, recommended, context, document, signal, onNote }) => oneAtATime(async () => {
-			if (signal?.aborted === true) throw new Error("the question was withdrawn");
-			const documentLines = document?.trimEnd().split("\n").length ?? 0;
-			if (document !== void 0 && documentLines <= SHORT_DOCUMENT_LINES) say(document);
-			say(`${style(["yellow", "bold"], "?")} ${style("bold", nodeId)} asks: ${question}`);
-			if (context !== void 0) say(style("dim", `  ${context.replaceAll("\n", "\n  ")}`));
-			for (const [index, option] of options.entries()) say(optionLine(option, index, recommended));
-			if (!io.interactive) {
-				const answer = recommended ?? NO_ONE_TO_ASK;
-				say(style("dim", `  no terminal; answered ${answer}`));
-				return answer;
-			}
-			const fallback = options.findIndex((o) => o.id === recommended);
-			const hint = fallback === -1 ? "" : ` [${String(fallback + 1)}]`;
-			if (documentLines > SHORT_DOCUMENT_LINES) say(`  Document: ${String(documentLines)} lines. Type d to read it.`);
-			const picked = await choose(hint, options, recommended, signal, document);
-			await takeNote(onNote, signal);
-			return picked;
-		}),
-		close: () => {
-			rl?.close();
-		}
-	};
-};
-// src/run/format-bus.ts
-/** The first line of a message body, cut to fit one terminal line. */
-const firstLine = (body) => {
-	const [line = ""] = body.trim().split("\n");
-	return line.length > 100 ? `${line.slice(0, 99)}…` : line;
-};
-/** Messages, owner questions and claims, without the node prefix. */
-const formatBusEvent = (event) => {
-	if (event.type === "claim.taken") return [style("dim", `⚑ claimed ${event.resource}`)];
-	if (event.type === "claim.refused") {
-		const held = event.held === event.resource ? "" : ` (it holds ${event.held})`;
-		return [style("yellow", `⚑ ${event.resource} is ${event.holder}'s${held}`)];
-	}
-	if (event.type === "claim.released") return [style("dim", `⚑ released ${event.resource}`)];
-	if (event.type === "message.sent") {
-		const how = event.via === void 0 ? "" : ` (${event.via})`;
-		return [style("dim", `✉ to ${event.to}${how}: ${firstLine(event.body)}`)];
-	}
-	if (event.type === "message.received") {
-		const how = event.via === void 0 ? "" : ` (${event.via})`;
-		return [style("dim", `✉ from ${event.from}${how}: ${firstLine(event.body)}`)];
-	}
-	if (event.type === "call.started") return [style("dim", `↳ started ${event.workflow} as run ${event.run}`)];
-	if (event.type === "link.notice") return [style("dim", `↔ ${event.text}`)];
-	if (event.type === "message.read") return [];
-	if (event.type === "owner.asked") return [`${style(["yellow", "bold"], "?")} asked as the owner of ${event.about}: ${event.text} ${style("dim", `(${event.question})`)}`];
-	if (event.type === "owner.answered") return [style("dim", `→ ${event.answer} (owner)`)];
-	return [style("dim", "→ its session ended first; asking you")];
-};
-// src/run/format-result.ts
-const RUN_MARK = {
-	succeeded: style("green", "✓"),
-	failed: style("red", "✗"),
-	budget_exhausted: style("yellow", "!"),
-	quota_exhausted: style("yellow", "!"),
-	timed_out: style("yellow", "!"),
-	interrupted: style("yellow", "!")
-};
-/** `1 failure handled`, `2 failures handled`. */
-const failuresHandled = (count) => `${String(count)} ${count === 1 ? "failure" : "failures"} handled`;
-/**
-* The run summary: status, cost, what ran, what was skipped and which failures
-* an edge handled, branches to look at, why, and mail to nodes that never ran.
-*/
-const formatRunResult = (result) => {
-	const ran = result.nodes.filter((n) => n.runs > 0).length;
-	const skipped = result.skipped ?? result.nodes.length - ran;
-	const handled = result.failuresHandled ?? 0;
-	const lines = ["", `${RUN_MARK[result.status]} run ${result.runId} ${result.status.replace("_", " ")} ${style("dim", `· ${cost(result.costUsd)} · ${String(ran)} ran, ${String(skipped)} skipped${handled === 0 ? "" : `, ${failuresHandled(handled)}`}`)}`];
-	for (const kept of result.worktrees) lines.push(`  ${kept.id}: ${kept.branch ?? "detached"} ${style("dim", `at ${kept.path} (${kept.reason})`)}`);
-	for (const reason of result.reasons) lines.push(`  ${style("red", reason)}`);
-	for (const { node, messages } of result.unread ?? []) lines.push(`  ${style(["yellow", "bold"], "warning")} ${node} never ran, so ${messages === 1 ? "1 message" : `${String(messages)} messages`} to it went unread`);
-	return lines;
-};
-// src/run/format.ts
-/** Who answered a decision, as the log says it. */
-const ANSWERED_BY = {
-	terminal: "terminal",
-	decide: "ork decide",
-	ui: "ork ui",
-	owner: "its owner"
-};
-const STATUS_MARK = {
-	pass: style("green", "✓"),
-	done: style("green", "✓"),
-	changes_requested: style("yellow", "!"),
-	fail: style("red", "✗")
-};
-const seconds = (ms) => `${(ms / 1e3).toFixed(1)}s`;
-const indent = (text) => text.trimEnd().split("\n").map((line) => `  ${line}`);
-/** The usage line: cost, tokens, turns and time. */
-const formatUsage = ({ usage }) => style("dim", [
-	cost(usage.costUsd),
-	`${String(usage.inputTokens)} in / ${String(usage.outputTokens)} out (${String(usage.cacheReadTokens)} cached)`,
-	`${String(usage.turns)} turns`,
-	seconds(usage.durationMs)
-].join(" · "));
-/** How a finished session reads on the terminal. */
-const formatOutcome = (nodeId, outcome) => {
-	const { report } = outcome;
-	if (report === null) return [
-		`${style("red", "✗")} ${style("bold", nodeId)} ended without a report (${outcome.subtype})`,
-		...outcome.errors.map((e) => `  ${style("red", e)}`),
-		`  ${formatUsage(outcome)}`
-	];
-	const lines = [`${STATUS_MARK[report.status] ?? "-"} ${style("bold", nodeId)} ${report.status}: ${report.summary}`];
-	if (report.branch !== void 0) lines.push(`  branch: ${report.branch}`);
-	for (const [name, file] of Object.entries(report.artifacts)) lines.push(`  ${name}: ${file}`);
-	for (const [name, value] of Object.entries(report.fields)) lines.push(`  ${name}: ${JSON.stringify(value)}`);
-	lines.push(`  ${formatUsage(outcome)}`);
-	return lines;
-};
-/** The transcript lines for one event; tool names come from `tools`. */
-const formatEvent = (nodeId, event, tools) => {
-	if (event.type === "session.started") {
-		const fork = event.fork === true ? ", a fork to answer a question" : "";
-		return [style("dim", `▸ ${nodeId} (${event.model}, session ${event.sessionId}${fork})`)];
-	}
-	if (event.type === "assistant.text") return indent(event.text);
-	if (event.type === "tool.called") {
-		tools.set(event.id, event.name);
-		return [style("dim", `  · ${previewInput(event.name, event.input)}`)];
-	}
-	if (event.type === "tool.result") return event.isError ? [style("red", `  ✗ ${tools.get(event.id) ?? "tool"} failed`)] : [];
-	if (event.type === "plan.limit") return event.status === "allowed" ? [] : [style("yellow", `  ! plan: ${event.window.replaceAll("_", " ")} limit ${event.status === "rejected" ? "reached" : "is close"}`)];
-	return formatOutcome(nodeId, event.outcome);
-};
-/** A one-line verdict for a finished node, by what its type outputs. */
-const nodeVerdict = (output) => {
-	const { status, summary, exitCode, choice, answeredBy, count } = output;
-	if (typeof status === "string") return typeof summary === "string" && summary !== "" ? `${status}: ${summary}` : status;
-	if (typeof exitCode === "number") return `exit ${String(exitCode)}`;
-	if (typeof choice === "string") return `${choice} (${String(answeredBy)})`;
-	if (typeof count === "number") return `${String(count)} ran`;
-	return "done";
-};
-const items = (count) => `${String(count)} ${count === 1 ? "item" : "items"}`;
-/** Transcript lines for one run event, prefixed with the node they are from. */
-const formatRunEvent = (event, width, tools) => {
-	const tag = (id) => style("cyan", `${id.padEnd(width)} │`);
-	if (event.type === "run.started") return [style("dim", `▸ run ${event.runId} of ${event.workflow} (starts at ${event.entries.join(", ")})`), ...event.settings?.trigger === void 0 ? [] : [style("dim", `  started by trigger ${event.settings.trigger}; untrusted inputs: ${(event.settings.untrusted ?? []).join(", ") || "none"}`)]];
-	if (event.type === "node.started") {
-		const round = event.round > 1 ? ` (round ${String(event.round)})` : "";
-		const owner = event.owner === void 0 ? "" : `, for ${event.owner}`;
-		return [`${tag(event.id)} ${style("dim", `${event.nodeType}${round}${owner}`)}`];
-	}
-	if (event.type === "node.event") {
-		const inner = event.event;
-		if (inner.type === "session.finished") return [];
-		const fork = inner.fork === true ? style("dim", "fork · ") : "";
-		if (inner.type === "session.started") {
-			const why = inner.fork === true ? ", to answer a question" : "";
-			return [`${tag(event.id)} ${fork}${style("dim", `${inner.model}, session ${inner.sessionId}${why}`)}`];
-		}
-		return formatEvent(event.id, event.event, tools).map((line) => `${tag(event.id)} ${fork}${line.replace(/^ {2}/u, "")}`);
-	}
-	if (event.type === "node.finished") {
-		const mark = event.ok ? style("green", "✓") : style("red", "✗");
-		const spent = event.usage === void 0 ? "" : style("dim", ` · ${cost(event.usage.costUsd)}`);
-		return [`${tag(event.id)} ${mark} ${nodeVerdict(event.output)}${spent}`];
-	}
-	if (event.type === "node.skipped") return [`${tag(event.id)} ${style("dim", "- skipped")}`];
-	if (event.type === "loop.exhausted") return [`${style(["yellow", "bold"], "!")} the loop ${event.from} -> ${event.to} used all ${String(event.maxRounds)} rounds`];
-	if (event.type === "watch.started") return [`${tag(event.id)} ${style("dim", `watching until ${event.until}, every ${event.every}`)}`];
-	if (event.type === "watch.changed") return [`${tag(event.id)} ${style("dim", `look ${String(event.looks)}:`)} ${event.said}`];
-	if (event.type === "watch.ended") return [`${tag(event.id)} ${style("dim", `${event.outcome} after ${String(event.looks)} looks`)}`];
-	if (event.type === "edge.taken") return [];
-	if (event.type === "worktree") {
-		const detail = event.detail === void 0 ? "" : ` (${event.detail})`;
-		const line = `${event.action} ${event.branch ?? event.path}${detail}`;
-		return [`${tag(event.id)} ${event.action === "conflict" ? style("yellow", `! ${line}`) : style("dim", `⎇ ${line}`)}`];
-	}
-	if (event.type === "decision.opened") {
-		const what = event.kind === "permission" ? "asks to" : "asks:";
-		const question = event.kind === "permission" ? event.question.replace(/^Allow /u, "run ").replace(/\?$/u, "") : event.question;
-		const where = event.owner === void 0 ? `decision ${event.decision}; ork decide` : `decision ${event.decision}, via ${event.owner}`;
-		return [`${tag(event.node)} ${style(["yellow", "bold"], "?")} ${what} ${question} ${style("dim", `(${where})`)}`];
-	}
-	if (event.type === "decision.answered") {
-		const by = event.by === "owner" && event.owner !== void 0 ? event.owner : ANSWERED_BY[event.by];
-		const said = event.note === void 0 ? "" : ` · said: ${event.note.replaceAll(/\s+/gu, " ")}`;
-		return [`${tag(event.node)} ${style("dim", `→ ${event.answer} (${by})${said}`)}`];
-	}
-	if (event.type === "decision.withdrawn") return [`${tag(event.node)} ${style("dim", "→ question withdrawn")}`];
-	if (event.type === "run.command") {
-		const node = event.node === void 0 ? "" : ` --node ${event.node}`;
-		return [style(["yellow", "bold"], `! ork ${event.command}${node} received`)];
-	}
-	if (event.type === "node.held") {
-		const at = event.at === "tool" ? "its tool call waits for ork continue" : "it starts after ork continue";
-		return [`${tag(event.id)} ${style("yellow", `‖ paused: ${at}`)}`];
-	}
-	if (event.type === "node.released") return [`${tag(event.id)} ${style("dim", "▸ continues")}`];
-	if (event.type === "each.listed") {
-		const round = event.round > 1 ? ` (round ${String(event.round)})` : "";
-		return [`${tag(event.node)} ${style("dim", `${items(event.count)}${round}`)}`];
-	}
-	if (event.type === "each.exceeded") {
-		const over = `${items(event.count)}, over maxItems ${String(event.maxItems)}`;
-		return [`${tag(event.node)} ${style("yellow", `! ${over}`)}`];
-	}
-	if (event.type === "run.finished") return formatRunResult(event.result);
-	if (event.type === "run.resumed") {
-		const [one] = event.kept;
-		const kept = one === void 0 ? "every node runs again" : event.kept.length === 1 ? `${one} keeps its result` : `${event.kept.join(", ")} keep their results`;
-		return ["", style("dim", `▸ resumed: ${kept}`)];
-	}
-	if (event.type === "feedback.recorded") {
-		const { target, kind, title } = event.feedback;
-		const line = style("dim", `✎ feedback (${target}, ${kind}): ${title}`);
-		return [event.node === void 0 ? line : `${tag(event.node)} ${line}`];
-	}
-	if (event.type === "user.message") {
-		const note = event.delivered === "queued" ? " (for its next session)" : "";
-		return [`${tag(event.node)} ${style(["magenta", "bold"], "you:")} ${firstLine(event.body)}${style("dim", note)}`];
-	}
-	return formatBusEvent(event).map((line) => `${tag(event.node)} ${line}`);
-};
-// src/runs/format.ts
-/**
-* @file How stored runs read on the terminal: the `ork ps` table and the `ork
-*   tree` ownership tree with each node's state, tokens and cost, and what is
-*   paused (ADR-041).
-*/
-const STATUS_STYLE = {
-	running: "cyan",
-	paused: "yellow",
-	succeeded: "green",
-	failed: "red",
-	crashed: "red",
-	budget_exhausted: "yellow",
-	quota_exhausted: "yellow",
-	timed_out: "yellow",
-	interrupted: "yellow"
-};
-/** `just now`, `5m ago`, `3h ago`, `2d ago`, then the date. */
-const ago = (iso, now = Date.now()) => {
-	const minutes = Math.floor((now - Date.parse(iso)) / 6e4);
-	if (minutes < 1) return "just now";
-	if (minutes < 60) return `${String(minutes)}m ago`;
-	if (minutes < 1440) return `${String(Math.floor(minutes / 60))}h ago`;
-	if (minutes < 10080) return `${String(Math.floor(minutes / 1440))}d ago`;
-	return iso.slice(0, 10);
-};
-/** `42s`, `3m12s`, `1h05m`. */
-const duration = (ms) => {
-	const s = Math.max(0, Math.round(ms / 1e3));
-	if (s < 60) return `${String(s)}s`;
-	if (s < 3600) return `${String(Math.floor(s / 60))}m${String(s % 60).padStart(2, "0")}s`;
-	return `${String(Math.floor(s / 3600))}h${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}m`;
-};
-/**
-* The `ork ps` table; `withProject` adds each run's project. A called run's
-* cost is dimmed and says its caller's, whose cost already counts it.
-*/
-const formatRuns = (runs, withProject, now = Date.now(), statusOf = liveStatus) => {
-	if (runs.length === 0) return ["No runs."];
-	const rows = runs.map((run) => {
-		const status = statusOf(run);
-		const end = run.finishedAt === void 0 ? now : Date.parse(run.finishedAt);
-		return {
-			id: run.id,
-			workflow: run.workflow,
-			status,
-			when: `${ago(run.startedAt, now)} · ${duration(end - Date.parse(run.startedAt))}`,
-			cost: run.parent === void 0 ? cost(run.costUsd) : `${cost(run.costUsd)} in ${run.parent}`,
-			called: run.parent !== void 0,
-			project: run.project
-		};
-	});
-	const width = (pick, title) => Math.max(title.length, ...rows.map((r) => pick(r).length));
-	const w = {
-		id: width((r) => r.id, "RUN"),
-		workflow: width((r) => r.workflow, "WORKFLOW"),
-		status: width((r) => r.status, "STATUS"),
-		when: width((r) => r.when, "STARTED"),
-		cost: width((r) => r.cost, "COST")
-	};
-	const header = [
-		"RUN".padEnd(w.id),
-		"WORKFLOW".padEnd(w.workflow),
-		"STATUS".padEnd(w.status),
-		"STARTED".padEnd(w.when),
-		"COST".padStart(w.cost),
-		...withProject ? ["PROJECT"] : []
-	].join("  ");
-	return [style("dim", header), ...rows.map((r) => [
-		style("bold", r.id.padEnd(w.id)),
-		r.workflow.padEnd(w.workflow),
-		style(STATUS_STYLE[r.status] ?? "reset", r.status.padEnd(w.status)),
-		style("dim", r.when.padEnd(w.when)),
-		r.called ? style("dim", r.cost.padStart(w.cost)) : r.cost.padStart(w.cost),
-		...withProject ? [style("dim", r.project)] : []
-	].join("  "))];
-};
-const STATE_MARK = {
-	waiting: style("dim", "·"),
-	running: style("cyan", "●"),
-	ok: style("green", "✓"),
-	failed: style("red", "✗"),
-	skipped: style("dim", "-")
-};
-/** `950`, `12.3k`, `1.2M`. */
-const count = (n) => {
-	if (n < 1e3) return String(n);
-	if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`;
-	return `${(n / 1e6).toFixed(1)}M`;
-};
-const stateText = (node) => {
-	if (node.state === "running") return node.runs > 1 ? `running (round ${String(node.runs)})` : "running";
-	if (node.state === "ok" || node.state === "failed") {
-		const verdict = nodeVerdict(node.output ?? {});
-		const line = verdict.length > 60 ? `${verdict.slice(0, 59)}…` : verdict;
-		return node.runs > 1 ? `${line} (${String(node.runs)} runs)` : line;
-	}
-	return node.state;
-};
-const isItem = (node) => node.template !== void 0 && /\.\d+$/u.test(node.id);
-/**
-* Moves each item of a node with `forEach` (`build.2`) under its node, in list
-* order, from beside it or under its owner, where the events put it.
-*/
-const nestItems = (roots) => {
-	const all = [];
-	const collect = (node) => {
-		all.push(node);
-		for (const child of node.children) collect(child);
-	};
-	for (const root of roots) collect(root);
-	const items = all.filter((node) => isItem(node));
-	const home = new Map(all.map((node) => [node.id, node]));
-	const isMoved = (node) => items.includes(node) && home.has(node.template ?? "");
-	for (const node of all) node.children = node.children.filter((c) => !isMoved(c));
-	for (const item of items) home.get(item.template ?? "")?.children.push(item);
-	return roots.filter((root) => !isMoved(root));
-};
-/** The ownership tree, one line per node, children under their owner. */
-const formatTree = (roots, now = Date.now()) => {
-	const lines = [];
-	const walk = (node, lead, branch) => {
-		lines.push({
-			label: `${lead}${branch}${node.id}`,
-			node
-		});
-		const next = lead + (branch === "├─ " ? "│  " : branch === "" ? "" : "   ");
-		node.children.forEach((child, index) => {
-			walk(child, next, index === node.children.length - 1 ? "└─ " : "├─ ");
-		});
-	};
-	for (const root of roots) walk(root, "", "");
-	const label = Math.max(...lines.map((l) => l.label.length));
-	const type = Math.max(...lines.map((l) => l.node.type.length));
-	return lines.map(({ label: text, node }) => {
-		const usage = node.inputTokens + node.outputTokens === 0 ? "" : style("dim", `  ${count(node.inputTokens)} in / ${count(node.outputTokens)} out · ${cost(node.costUsd)}`);
-		const state = node.held === true ? `${style("yellow", "‖")} paused` : `${STATE_MARK[node.state]} ${stateText(node)}`;
-		const spent = isItem(node) && node.startedAt !== void 0 ? style("dim", `  ${duration((node.finishedAt === void 0 ? now : Date.parse(node.finishedAt)) - Date.parse(node.startedAt))}`) : "";
-		return `${text.padEnd(label)}  ${style("dim", node.type.padEnd(type))}  ${state}${spent}${usage}`;
-	});
-};
-export { formatEvent as a, createDecisionQueue as c, nestItems as i, formatRuns as n, formatRunEvent as o, formatTree as r, createTerminalHuman as s, ago as t };