@krapht/ork 1.0.0-alpha.11 → 1.0.0-alpha.12

package/dist/store-B2OaE4ID.mjs

@@ -0,0 +1,1356 @@
+import { $t as endOf, C as openStore, En as maskSecrets, S as isNodeEvent, en as outcomeEnd, nn as END_KINDS, tt as followEvents, xt as liveStatus, zt as slotWaitLine } from "./src-CdDTQLdQ.mjs";
+import { n as pendingDecisions, t as answerDecision } from "./decide-DlbyctOE.mjs";
+import { E as readKeys, S as cut, T as wrap, _ as withdrawn, a as style, c as confirmOrStop, d as apply, f as bold, g as readLine, h as interrupt, i as plain, m as createRegion, n as cost, p as paint, v as canKey, w as widthOf, x as termOf, y as plainEnv } from "./output-CnRzrbUM.mjs";
+import { n as chip, r as nodeChip, t as CHIP_LABELS } from "./chips-CyeB_rhR.mjs";
+import { a as createView, i as formatBusEvent, n as nodeVerdict, o as styler, r as firstLine, t as hasConflict } from "./verdict-CIy8tAyX.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;
+	const earlier = store.decisions({ runId });
+	let count = Math.max(0, ...earlier.map(({ id }) => Number(id.slice(runId.length + 1)) || 0));
+	for (const { id, node, status } of earlier) {
+		if (status !== "open") continue;
+		store.withdrawDecision(id);
+		emit({
+			type: "decision.withdrawn",
+			node,
+			decision: id
+		});
+	}
+	/** 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
+					};
+				});
+			}, request.signal);
+			if (note !== void 0) request.onNote?.(note);
+			return answer === "allow" ? { allow: true } : {
+				allow: false,
+				message: note === void 0 ? localMessage : deniedMessage(note)
+			};
+		}
+	};
+};
+// ../core/src/remote/follow-tree.ts
+/**
+* Calls `onEvent` for each event of `root` and of the runs it called, once
+* each. A called run's stored events come right after the `call.started` that
+* started it; live events as they arrive. Ends when the root ends or `signal`
+* aborts.
+*/
+const followRunTree = async (store, root, onEvent, options = {}) => {
+	/** Every run followed, with its call path, in the order found. */
+	const paths = /* @__PURE__ */ new Map([[root, []]]);
+	/** Each run's last event seen, for the catch-up once the root ends. */
+	const seqs = /* @__PURE__ */ new Map();
+	const followers = [];
+	/** Ends the called runs' following once the root's has ended. */
+	const halt = new AbortController();
+	const signal = options.signal === void 0 ? halt.signal : AbortSignal.any([options.signal, halt.signal]);
+	const handle = (run, path) => (stored) => {
+		seqs.set(run, stored.seq);
+		onEvent({
+			run,
+			path,
+			stored
+		});
+		const { event } = stored;
+		if (event.type === "call.started" && !paths.has(event.run)) follow(event.run, [...path, event.node]);
+	};
+	const follow = (run, path) => {
+		paths.set(run, path);
+		followers.push(followEvents(store, run, handle(run, path), {
+			...options,
+			follow: true,
+			after: seqs.get(run) ?? 0,
+			signal
+		}));
+	};
+	/** Waits for every follower, including those started while waiting. */
+	const settle = async () => {
+		while (followers.length > 0) await Promise.all(followers.splice(0));
+	};
+	const end = await followEvents(store, root, handle(root, []), {
+		...options,
+		follow: true
+	});
+	halt.abort();
+	await settle();
+	if (end !== "aborted") {
+		for (const [run, path] of [...paths].slice(1)) followers.push(followEvents(store, run, handle(run, path), {
+			follow: false,
+			after: seqs.get(run) ?? 0
+		}));
+		await settle();
+	}
+	return {
+		end,
+		stillRunning: [...paths.keys()].slice(1).filter((id) => {
+			const [run] = store.lookup(id);
+			return run !== void 0 && liveStatus(run) === "running";
+		})
+	};
+};
+// src/human-card.ts
+/** Lines of context a card shows before `d` (or `--verbose`) shows the rest. */
+const CONTEXT_LINES = 6;
+/** Text from outside with its escapes gone and its line breaks kept. */
+const clean = (text) => text.split("\n").map((line) => plain(line)).join("\n");
+/** The card above the options, in the rich look or the plain lines. */
+const cardLines = (t, q, place, verbose, document) => {
+	const context = q.context === void 0 ? void 0 : clean(q.context);
+	if (!t.rich) return {
+		lines: [
+			...place === void 0 ? [] : [`run ${place.run}${place.path === void 0 ? "" : ` · ${place.path}`} · decision ${place.decision}`],
+			...document === void 0 ? [] : [document],
+			`? ${plain(q.nodeId)} asks: ${clean(q.question)}`,
+			...context === void 0 ? [] : [`  ${context.replaceAll("\n", "\n  ")}`]
+		],
+		moreContext: false
+	};
+	const shown = context === void 0 ? [] : wrap(context, t.width - 3);
+	const cutShort = !verbose && shown.length > CONTEXT_LINES;
+	const body = cutShort ? shown.slice(0, CONTEXT_LINES) : shown;
+	const where = place === void 0 ? "" : `  ${paint(t, "muted", [
+		`run ${place.run}`,
+		place.path,
+		place.index === void 0 || place.total === void 0 ? void 0 : `${String(place.index)} of ${String(place.total)}`
+	].filter((part) => part !== void 0).join(" · "))}`;
+	return {
+		lines: [
+			"",
+			` ${chip(t, CHIP_LABELS.ask, "accent")} ${nodeChip(t, plain(q.nodeId))}${where}`,
+			...wrap(clean(q.question), t.width - 1).map((l) => ` ${bold(t, l)}`),
+			...body.map((l) => paint(t, "muted", `   ${l}`)),
+			...cutShort ? [paint(t, "muted", `   … ${String(shown.length - CONTEXT_LINES)} more lines (d)`)] : []
+		],
+		moreContext: cutShort
+	};
+};
+/** The line above a permission prompt: who wants to run what. */
+const permitLine = (t, nodeId, preview) => {
+	const node = plain(nodeId);
+	const what = plain(preview);
+	if (!t.rich) return `? ${node} wants to run ${what}`;
+	const room = Math.max(20, t.width - node.length - 24);
+	return ` ${chip(t, CHIP_LABELS.ask, "accent")} ${nodeChip(t, node)} wants to run ${cut(what, room)}`;
+};
+/**
+* The line a card collapses to once answered: `✓ 509da722-1 · add-invalid-node`
+* (the decision, or the node when there is none, and the choice), or a note
+* that it was left for later.
+*/
+const doneLine = (t, place, nodeId, answer) => {
+	const who = place?.decision ?? plain(nodeId);
+	if (answer.kind === "later") return ` ${paint(t, "muted", "·")} ${cut(`${who} left for later`, t.width - 3)}`;
+	const said = answer.note === void 0 ? "" : ` · said: ${plain(answer.note)}`;
+	return ` ${paint(t, "ok", "✓")} ${cut(`${who} · ${answer.id}${said}`, t.width - 3)}`;
+};
+// src/term/text.ts
+/**
+* @file The text prompt: one line of text, edited in place on a terminal
+*   (arrows, Home/End, Backspace, Delete, Ctrl-U to clear), collapsing to one
+*   line when answered; Enter sends, Esc (or Ctrl-D on an empty line) leaves
+*   it. Plain mode asks `message: ` and reads a line, as the prompts always
+*   did. `editLine` is the editing itself, which the select prompt reuses for
+*   its note.
+*/
+const at = (next, to) => ({
+	value: next.join(""),
+	pos: to
+});
+/** `state` after `key`; keys that do not edit leave it as it is. */
+const editLine = (state, key) => {
+	const { value, pos } = state;
+	const chars = Array.from(value);
+	if (key.name === "char") return at(chars.toSpliced(pos, 0, key.text), pos + 1);
+	if (key.name === "backspace") return pos === 0 ? state : at(chars.toSpliced(pos - 1, 1), pos - 1);
+	if (key.name === "delete") return at(chars.toSpliced(pos, 1), pos);
+	if (key.name === "left") return {
+		value,
+		pos: Math.max(0, pos - 1)
+	};
+	if (key.name === "right") return {
+		value,
+		pos: Math.min(chars.length, pos + 1)
+	};
+	if (key.name === "home" || key.name === "ctrl-a") return {
+		value,
+		pos: 0
+	};
+	if (key.name === "end" || key.name === "ctrl-e") return {
+		value,
+		pos: chars.length
+	};
+	if (key.name === "ctrl-u") return at(chars.slice(pos), 0);
+	return state;
+};
+/**
+* The line to draw for `state` after `lead`, within `width`, and the column of
+* the cursor in it. A value too long for the room scrolls to keep the cursor in
+* view.
+*/
+const showLine = (lead, state, width, leadWidth) => {
+	const chars = Array.from(state.value);
+	const room = Math.max(1, width - leadWidth - 1);
+	const start = Math.max(0, state.pos - room + 1);
+	return {
+		line: `${lead}${chars.slice(start, start + room).join("")}`,
+		column: leadWidth + state.pos - start
+	};
+};
+const defaultDone$1 = (io, message) => (value) => {
+	const term = termOf(io.output, io.env);
+	const mark = paint(term, "ok", "✓");
+	return cut(` ${mark} ${message} · ${value === void 0 || value === "" ? "skipped" : value}`, term.width);
+};
+/** Asks for one line of text. */
+const readText = async (io, options) => {
+	const { message, signal } = options;
+	if (signal?.aborted === true) throw withdrawn(signal);
+	if (!canKey(io.input, io.output, io.env)) {
+		const answer = await readLine(io, `  ${message}: `, signal);
+		return answer === void 0 ? { kind: "cancelled" } : {
+			kind: "text",
+			value: answer.trim()
+		};
+	}
+	const done = options.done ?? defaultDone$1(io, message);
+	const term = () => termOf(io.output, io.env);
+	const region = createRegion(io.output, term);
+	const initial = options.initial ?? "";
+	return new Promise((resolve, reject) => {
+		let state = {
+			value: initial,
+			pos: Array.from(initial).length
+		};
+		const lead = ` ${paint(term(), "accent", "?")} ${bold(term(), message)} › `;
+		const leadWidth = Array.from(` ? ${message} › `).length;
+		const render = () => {
+			const { line, column } = showLine(lead, state, term().width, leadWidth);
+			region.draw([line], column);
+		};
+		const finish = (result, line) => {
+			stop();
+			io.output.off("resize", render);
+			signal?.removeEventListener("abort", onAbort);
+			region.finish(line);
+			resolve(result);
+		};
+		const onAbort = () => {
+			stop();
+			io.output.off("resize", render);
+			region.finish();
+			reject(withdrawn(signal));
+		};
+		const stop = readKeys(io.input, (key) => {
+			if (key.name === "enter") {
+				const value = state.value.trim();
+				finish({
+					kind: "text",
+					value
+				}, done(value));
+			} else if (key.name === "escape" || key.name === "ctrl-d" && state.value === "") finish({ kind: "cancelled" }, done());
+			else if (key.name === "ctrl-c") {
+				finish({ kind: "interrupted" });
+				interrupt(io);
+			} else {
+				state = editLine(state, key);
+				render();
+			}
+		});
+		io.output.on("resize", render);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		render();
+	});
+};
+// src/term/select.ts
+/**
+* @file The select prompt: a list of options moved with ↑/↓ (or `j`/`k`),
+*   Home/End and `1`–`9`, chosen with Enter. `n` adds a note (one line, edited
+*   in place), `d` shows or hides the details (a document), `q` or Esc leaves
+*   the question for later, Ctrl-C stops. It redraws only its own lines,
+*   follows a resize, and collapses to one line once answered. Plain mode
+*   prints the options as `1) id label - description` and asks `Choose [n]: `,
+*   as `ork decide` always did; there a note is asked for after the choice when
+*   the prompt takes one.
+*/
+const NOTE_PROMPT = "Note for the run (optional, Enter to skip)";
+/** The option an answer names: its number, or its id; empty is `recommended`. */
+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 label = (option) => option.label === void 0 ? option.id : `${option.id} ${option.label}`;
+const defaultDone = (options) => (result, term) => {
+	if (result.kind === "later") return ` ${paint(term, "muted", "·")} left for later`;
+	const option = options.find((o) => o.id === result.id);
+	return cut(` ${paint(term, "ok", "✓")} ${option === void 0 ? result.id : label(option)}`, term.width);
+};
+/** The numbered option lines of a plain prompt: ` 1) id label - description`. */
+const plainOptions = (options, recommended) => options.map((option, i) => {
+	const description = option.description === void 0 ? "" : ` - ${option.description}`;
+	const mark = option.id === recommended ? " (recommended)" : "";
+	const name = option.label === void 0 ? "" : ` ${option.label}`;
+	return `  ${String(i + 1)}) ${option.id}${name}${description}${mark}`;
+});
+/** The plain prompt: numbered options, then `Choose [n]: ` until one fits. */
+const selectPlain = (io, o) => {
+	const term = termOf(io.output, io.env);
+	const say = (text) => {
+		io.output.write(`${text}\n`);
+	};
+	for (const line of o.header?.(term) ?? []) say(line);
+	for (const line of plainOptions(o.options, o.recommended)) say(line);
+	for (const line of o.footer ?? []) say(line);
+	const at = o.options.findIndex((opt) => opt.id === o.recommended);
+	const hint = at === -1 ? "" : ` [${String(at + 1)}]`;
+	const ask = async () => {
+		const answer = await readLine(io, `  Choose${hint}: `, o.signal);
+		if (answer === void 0) throw new Error("input ended");
+		const id = pickOption(answer, o.options, o.recommended);
+		if (id === void 0) {
+			if (o.details !== void 0 && answer.trim() === "d") say(o.details);
+			else say("  Type an option's number or id.");
+			return ask();
+		}
+		if (o.note !== true) return {
+			kind: "chosen",
+			id
+		};
+		const noted = await readText(io, {
+			message: o.notePrompt ?? NOTE_PROMPT,
+			...o.signal === void 0 ? {} : { signal: o.signal }
+		});
+		return noted.kind === "text" && noted.value !== "" ? {
+			kind: "chosen",
+			id,
+			note: noted.value
+		} : {
+			kind: "chosen",
+			id
+		};
+	};
+	return ask();
+};
+/** Asks for one of `options`. */
+const select = (io, o) => {
+	if (o.signal?.aborted === true) return Promise.reject(withdrawn(o.signal));
+	if (!canKey(io.input, io.output, io.env)) return selectPlain(io, o);
+	const term = () => termOf(io.output, io.env);
+	const region = createRegion(io.output, term);
+	const done = o.done ?? defaultDone(o.options);
+	return new Promise((resolve, reject) => {
+		const start = o.options.findIndex((opt) => opt.id === o.recommended);
+		let cursor = Math.max(0, start);
+		let showDetails = false;
+		let note;
+		let editing;
+		const optionLines = (t) => o.options.flatMap((option, i) => {
+			const selected = i === cursor;
+			const number = i < 9 ? `${String(i + 1)}.` : "  ";
+			const mark = option.id === o.recommended ? " (recommended)" : "";
+			const head = cut(`${number} ${label(option)}`, t.width - 4 - mark.length);
+			const text = selected ? apply(t, ["bold", "cyan"], head) : head;
+			const lines = [` ${selected ? paint(t, "accent", "❯") : " "} ${text}${mark === "" ? "" : paint(t, "ok", mark)}`];
+			for (const line of wrap(option.description ?? "", t.width - 7)) if (line !== "") lines.push(paint(t, "muted", `      ${line}`));
+			return lines;
+		});
+		const keyLine = (t) => {
+			const keys = editing === void 0 ? [
+				"↑/↓ move",
+				"Enter choose",
+				...o.note === true ? ["n note"] : [],
+				...o.details === void 0 ? [] : [`d ${showDetails ? "hide" : "show"} details`],
+				...o.later === true ? ["q later"] : []
+			] : ["Enter save", "Esc cancel"];
+			return paint(t, "muted", cut(` ${keys.join(" · ")}`, t.width));
+		};
+		const render = () => {
+			const t = term();
+			const head = o.header?.(t) ?? [];
+			const body = optionLines(t);
+			const noteLine = note === void 0 ? [] : [paint(t, "muted", cut(` note: ${note}`, t.width))];
+			const above = [
+				...head,
+				...body,
+				...noteLine
+			];
+			const room = Math.max(3, t.rows - above.length - 3);
+			const all = showDetails && o.details !== void 0 ? wrap(o.details.trimEnd(), t.width - 3) : [];
+			const detail = (all.length > room ? [...all.slice(0, room - 1), `… ${String(all.length - room + 1)} more lines`] : all).map((line) => paint(t, "muted", `   ${line}`));
+			const lines = [
+				...above,
+				...detail,
+				keyLine(t)
+			];
+			if (editing === void 0) {
+				region.draw(lines);
+				return;
+			}
+			const lead = ` ${paint(t, "accent", "✎")} Note › `;
+			const { line, column } = showLine(lead, editing, t.width, 10);
+			region.draw([...lines, line], column);
+		};
+		const finish = (result) => {
+			stop();
+			cleanup();
+			region.finish(done(result, term()));
+			resolve(result);
+		};
+		const cleanup = () => {
+			io.output.off("resize", render);
+			o.signal?.removeEventListener("abort", onAbort);
+		};
+		const onAbort = () => {
+			stop();
+			cleanup();
+			region.finish();
+			reject(withdrawn(o.signal));
+		};
+		const edit = (key) => {
+			if (editing === void 0) return;
+			if (key.name === "enter") {
+				const value = editing.value.trim();
+				note = value === "" ? void 0 : value;
+				editing = void 0;
+			} else if (key.name === "escape") editing = void 0;
+			else editing = editLine(editing, key);
+			render();
+		};
+		const move = (to) => {
+			cursor = Math.min(o.options.length - 1, Math.max(0, to));
+			render();
+		};
+		const stop = readKeys(io.input, (key) => {
+			if (key.name === "ctrl-c") {
+				stop();
+				cleanup();
+				region.finish();
+				resolve({ kind: "interrupted" });
+				interrupt(io);
+			} else if (editing !== void 0) edit(key);
+			else if (key.name === "enter") {
+				const id = o.options[cursor]?.id;
+				if (id === void 0) return;
+				finish(note === void 0 ? {
+					kind: "chosen",
+					id
+				} : {
+					kind: "chosen",
+					id,
+					note
+				});
+			} else if (key.name === "up") move(cursor - 1);
+			else if (key.name === "down") move(cursor + 1);
+			else if (key.name === "home") move(0);
+			else if (key.name === "end") move(o.options.length - 1);
+			else if (key.name === "escape" && o.later === true) finish({ kind: "later" });
+			else if (key.name === "char") {
+				const c = key.text;
+				if (c === "k") move(cursor - 1);
+				else if (c === "j") move(cursor + 1);
+				else if (c >= "1" && c <= "9") {
+					if (Number(c) <= o.options.length) move(Number(c) - 1);
+				} else if (c === "n" && o.note === true) {
+					const value = note ?? "";
+					editing = {
+						value,
+						pos: Array.from(value).length
+					};
+					render();
+				} else if (c === "d" && o.details !== void 0) {
+					showDetails = !showDetails;
+					render();
+				} else if (c === "q" && o.later === true) finish({ kind: "later" });
+			}
+		});
+		io.output.on("resize", render);
+		o.signal?.addEventListener("abort", onAbort, { once: true });
+		render();
+	});
+};
+// 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. It draws through the terminal kit (`term/`): a card
+*   with an ASK chip and a list moved with the arrow keys, a yes-or-no for a
+*   permission, and one optional line for a note after a choice. Plain (not a
+*   terminal, `NO_COLOR`, `--plain`) it keeps the numbered prompts. 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_MESSAGE = "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)";
+/**
+* What a foreground caller shows of the runs it calls: their lines always, and
+* their questions only when stdin is a terminal, so no one is answered for.
+*/
+const callsShown = (human, stdinIsTty) => stdinIsTty === true ? { ask: human } : {};
+/** 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}`;
+};
+/** Never answers, until `signal` withdraws it: what a stopped prompt leaves. */
+const parked = (signal) => new Promise((_, reject) => {
+	signal?.addEventListener("abort", () => {
+		reject(withdrawn(signal));
+	});
+});
+/**
+* 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 closed;
+	let turn = Promise.resolve();
+	const say = (text) => {
+		io.output.write(`${text}\n`);
+	};
+	/** The one `readline` the plain prompts share; a rich prompt never opens it. */
+	const readLine = (text, signal) => {
+		if (rl === void 0) {
+			const opened = createInterface({
+				input: io.input,
+				output: io.output,
+				...plainEnv(io.env) ? { terminal: false } : {}
+			});
+			if (io.interrupt !== void 0) opened.on("SIGINT", io.interrupt);
+			closed = new Promise((resolve) => {
+				opened.once("close", () => {
+					resolve(void 0);
+				});
+			});
+			rl = opened;
+		}
+		const answer = signal === void 0 ? rl.question(text) : rl.question(text, { signal });
+		return closed === void 0 ? answer : Promise.race([answer, closed]);
+	};
+	const kit = {
+		input: io.input,
+		output: io.output,
+		readLine,
+		...io.env === void 0 ? {} : { env: io.env },
+		...io.interrupt === void 0 ? {} : { interrupt: io.interrupt }
+	};
+	const term = () => termOf(io.output, io.env);
+	/** The optional line after a choice, when the asker takes a note. */
+	const takeNote = async (onNote, signal) => {
+		if (onNote === void 0) return;
+		const noted = await readText(kit, {
+			message: NOTE_MESSAGE,
+			...signal === void 0 ? {} : { signal }
+		});
+		if (noted.kind === "interrupted") await parked(signal);
+		if (noted.kind === "text" && noted.value !== "") onNote(noted.value);
+	};
+	const oneAtATime = (work) => {
+		const result = turn.then(work);
+		turn = result.catch(() => null);
+		return result;
+	};
+	const asking = (q, place) => oneAtATime(async () => {
+		const { signal } = q;
+		if (signal?.aborted === true) throw new Error("the question was withdrawn");
+		const t = term();
+		const documentLines = q.document?.trimEnd().split("\n").length ?? 0;
+		const document = q.document === void 0 ? void 0 : clean(q.document);
+		const printed = document !== void 0 && documentLines <= SHORT_DOCUMENT_LINES;
+		const shownDocument = t.rich || !printed ? void 0 : document;
+		const header = (tt) => cardLines(tt, q, place, io.verbose === true, shownDocument).lines;
+		const options = q.options.map((o) => ({
+			id: o.id,
+			...o.label === void 0 ? {} : { label: plain(o.label) },
+			...o.description === void 0 ? {} : { description: plain(o.description) }
+		}));
+		const { moreContext } = cardLines(t, q, place, io.verbose === true);
+		const details = t.rich ? [moreContext ? clean(q.context ?? "") : void 0, document].filter((part) => part !== void 0).join("\n\n") || void 0 : printed ? void 0 : document;
+		if (!io.interactive) {
+			for (const line of header(t)) say(line);
+			for (const line of plainOptions(options, q.recommended)) say(line);
+			const answer = q.recommended ?? NO_ONE_TO_ASK;
+			say(paint(t, "muted", `  no terminal; answered ${answer}`));
+			return answer;
+		}
+		const result = await select(kit, {
+			header,
+			options,
+			...q.recommended === void 0 ? {} : { recommended: q.recommended },
+			...details === void 0 ? {} : { details },
+			...!t.rich && details !== void 0 ? { footer: [`  Document: ${String(documentLines)} lines. Type d to read it.`] } : {},
+			note: q.onNote !== void 0,
+			notePrompt: NOTE_MESSAGE,
+			later: place !== void 0,
+			done: (answer, tt) => doneLine(tt, place, q.nodeId, answer),
+			...signal === void 0 ? {} : { signal }
+		});
+		if (result.kind === "interrupted") return parked(signal);
+		if (result.kind === "later") return null;
+		if (result.note !== void 0) q.onNote?.(result.note);
+		return result.id;
+	});
+	return {
+		permit: ({ nodeId, toolName, input, signal, onNote }) => oneAtATime(async () => {
+			if (signal?.aborted === true) throw new Error("the prompt was withdrawn");
+			const t = term();
+			if (t.rich) say("");
+			say(permitLine(t, nodeId, previewInput(toolName, input)));
+			if (!io.interactive) {
+				say(paint(t, "muted", `  denied: ${NO_ONE_TO_PERMIT}`));
+				return {
+					allow: false,
+					message: NO_ONE_TO_PERMIT
+				};
+			}
+			const allowed = await confirmOrStop(kit, {
+				question: "Allow?",
+				...signal === void 0 ? {} : { signal }
+			});
+			if (allowed === null) return parked(signal);
+			if (allowed) return { allow: true };
+			await takeNote(onNote, signal);
+			return {
+				allow: false,
+				message: "The user did not allow this tool."
+			};
+		}),
+		ask: async (q) => await asking(q) ?? NO_ONE_TO_ASK,
+		askAt: (q, place) => asking(q, place),
+		close: () => {
+			rl?.close();
+		}
+	};
+};
+// src/run/format-end.ts
+/**
+* @file How a node's end reads on the terminal (specs/runtime/session-ends.md):
+*   its kind's label and Ork's own message, a note for a kind that may pass,
+*   the setup hint for an account or provider end, and the scrubbed raw detail
+*   only when asked for. Never the provider's own words first.
+*/
+/** What a transient kind says in place of its hint on the log line. */
+const MAY_PASS = "(may pass; ork resume retries)";
+/** `Turn limit: reached its turn limit (8)`, with a note when it may pass. */
+const endHeadline = (end) => {
+	const { label, transient } = END_KINDS[end.kind];
+	return `${label}: ${end.message}${transient ? ` ${MAY_PASS}` : ""}`;
+};
+/**
+* The lines under a headline: the hint for an account or provider end (what to
+* set up) or whenever `full` (`--verbose`, one node's log), and the detail only
+* when `full`. A transient kind's hint is its retry wording, which the headline
+* already says, so it is not printed twice.
+*/
+const endLines = (end, full, term = createView().term) => {
+	const style = styler(term);
+	const { actor, hint, transient } = END_KINDS[end.kind];
+	const setup = actor === "account" || actor === "provider";
+	const lines = [];
+	if (hint !== "" && !transient && (full || setup)) lines.push(`  ${style("dim", hint)}`);
+	if (full && end.detail !== void 0) lines.push(style("dim", "  details:"), ...end.detail.split("\n").map((line) => style("dim", `    ${line}`)));
+	return lines;
+};
+/**
+* A finished node's line under `tag`: its verdict, or for a failure its kind
+* and message (and the lines under it). The agent's own summary stays for a
+* `fail` it reported, and an old run's text no rule reads stays as stored.
+*/
+const formatFinished = (event, tag, verbose, term = createView().term, rest = tag) => {
+	const style = styler(term);
+	const conflict = hasConflict(event.output);
+	const mark = event.ok ? style(conflict ? "yellow" : "green", conflict ? "!" : "✓") : style("red", "✗");
+	const spent = event.usage === void 0 ? "" : style("dim", ` · ${cost(event.usage.costUsd)}`);
+	const end = endOf(event);
+	if (!(!event.ok && end.kind !== "reported_failure" && (event.end !== void 0 || end.kind !== "unknown"))) return [`${tag} ${mark} ${nodeVerdict(event.output, event.ok, event.error)}${spent}`];
+	return [`${tag} ${mark} ${endHeadline(end)}${spent}`, ...endLines(end, verbose, term).map((line) => `${rest} ${line}`)];
+};
+// src/run/format-outcome.ts
+/**
+* @file How a finished session reads on the terminal: its report or its end,
+*   the branch, artifacts and fields, and the usage line.
+*/
+const STATUS_MARK = {
+	pass: {
+		mark: "✓",
+		color: "green"
+	},
+	done: {
+		mark: "✓",
+		color: "green"
+	},
+	changes_requested: {
+		mark: "!",
+		color: "yellow"
+	},
+	fail: {
+		mark: "✗",
+		color: "red"
+	}
+};
+const seconds = (ms) => `${(ms / 1e3).toFixed(1)}s`;
+/** The usage line: cost, tokens, turns and time. */
+const formatUsage = ({ usage }, term = createView().term) => styler(term)("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, verbose = false, term = createView().term) => {
+	const style = styler(term);
+	const { report } = outcome;
+	if (report === null) {
+		const end = outcomeEnd(outcome);
+		return [
+			`${style("red", "✗")} ${style("bold", nodeId)} ${endHeadline(end)}`,
+			...endLines(end, verbose, term),
+			`  ${formatUsage(outcome, term)}`
+		];
+	}
+	const shown = STATUS_MARK[report.status];
+	const lines = [`${shown === void 0 ? "-" : style(shown.color, shown.mark)} ${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, term)}`);
+	return lines;
+};
+// src/run/format-result.ts
+/** How a run ended: its mark, and its chip's word and role when rich. */
+const RUN_END = {
+	succeeded: {
+		mark: "✓",
+		ok: "ok",
+		label: CHIP_LABELS.ok
+	},
+	failed: {
+		mark: "✗",
+		ok: "danger",
+		label: CHIP_LABELS.fail
+	},
+	budget_exhausted: {
+		mark: "!",
+		ok: "warn",
+		label: CHIP_LABELS.wait
+	},
+	quota_exhausted: {
+		mark: "!",
+		ok: "warn",
+		label: CHIP_LABELS.wait
+	},
+	timed_out: {
+		mark: "!",
+		ok: "warn",
+		label: CHIP_LABELS.wait
+	},
+	interrupted: {
+		mark: "!",
+		ok: "warn",
+		label: CHIP_LABELS.wait
+	}
+};
+const MARK_COLOR = {
+	ok: "green",
+	danger: "red",
+	warn: "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, term = createView().term) => {
+	const style = styler(term);
+	const end = RUN_END[result.status];
+	const mark = term.rich ? chip(term, end.label, end.ok) : style(MARK_COLOR[end.ok], end.mark);
+	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 = ["", `${mark} 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-tool.ts
+/**
+* @file How a session's own words and tool calls read in the transcript: the
+*   agent's text (indented plain, wrapped rich), and a tool call as `Tool first
+*   line` cut to the screen with `+N lines`, a path inside the node's worktree
+*   relative to it, or whole with `--verbose`. Untrusted text goes through
+*   `plain()` first.
+*/
+const indent = (text) => text.trimEnd().split("\n").map((line) => `  ${plain(line)}`);
+/** Agent text under a 2-column indent, its long lines wrapped to `room`. */
+const wrapped = (text, room) => {
+	const width = Math.max(1, room - 2);
+	return text.trimEnd().split("\n").flatMap((line) => {
+		const safe = plain(line).trimEnd();
+		return widthOf(safe) <= width ? [safe] : wrap(safe, width);
+	}).map((line) => `  ${line}`);
+};
+/** A tool's input as the call says it: the key that names its target, whole. */
+const toolText = (input, root) => {
+	const key = TOOL_INPUT_KEYS.find((k) => typeof input[k] === "string");
+	const text = key === void 0 ? JSON.stringify(input) : String(input[key]);
+	if (root === void 0) return text;
+	const base = root.replace(/\/+$/u, "");
+	return text === base ? "." : text.replaceAll(`${base}/`, "");
+};
+/**
+* A tool call: rich, `Tool first line` cut to `room` with `+N lines` when it
+* had more; plain, today's one dim line. `verbose` shows the call whole.
+*/
+const toolLines = (name, input, view, room, verbose, node) => {
+	const { term } = view;
+	const style = styler(term);
+	if (!term.rich && !verbose) return [style("dim", `  · ${plain(previewInput(name, input))}`)];
+	const label = plain(name);
+	const [first = "", ...rest] = toolText(input, view.roots.get(node)).trimEnd().split("\n").map((line) => plain(line));
+	const lead = term.rich ? "  " : "  · ";
+	const sep = term.rich ? "  " : " ";
+	const headWidth = widthOf(lead) + widthOf(label) + sep.length;
+	const styledHead = `${style("dim", lead)}${style("bold", label)}${style("dim", sep)}`;
+	if (verbose) {
+		const pad = " ".repeat(headWidth);
+		return [`${styledHead}${style("dim", first)}`, ...rest.map((line) => style("dim", `${pad}${line}`))];
+	}
+	const more = rest.length === 0 ? "" : ` +${String(rest.length)} ${rest.length === 1 ? "line" : "lines"}`;
+	return [`${styledHead}${style("dim", cut(first.trim(), Math.max(1, room - headWidth - more.length)))}${style("dim", more)}`];
+};
+// src/run/format.ts
+/**
+* @file How runs read on the terminal: session events and run events with node
+*   chips or prefixes; the node result is `format-outcome.ts`'s, a tool call
+*   `format-tool.ts`'s and the run summary `format-result.ts`'s.
+*/
+/** A line's 2-column indent, after any style codes that open it. */
+const INDENT = /^((?:\u001B\[[0-9;]*m)*) {2}/u;
+/** Who answered a decision, as the log says it. */
+const ANSWERED_BY = {
+	terminal: "terminal",
+	decide: "ork decide",
+	ui: "ork ui",
+	owner: "its owner"
+};
+/** The transcript lines for one event; tool names come from `tools`. */
+const formatEvent = (nodeId, event, tools, verbose = false, view = createView(), room = view.term.width - 1) => {
+	const { term } = view;
+	const style = styler(term);
+	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 term.rich ? wrapped(event.text, room) : indent(event.text);
+	if (event.type === "session.waiting") return indent(event.reason);
+	if (event.type === "tool.called") {
+		tools.set(event.id, event.name);
+		return toolLines(event.name, event.input, view, room, verbose, nodeId);
+	}
+	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, verbose, term);
+};
+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, terminal = false, verbose = false, view = createView()) => {
+	const { term } = view;
+	const style = styler(term);
+	const tag = (id) => term.rich ? `${nodeChip(term, id)}${" ".repeat(Math.max(0, width - id.length))}` : style("cyan", `${id.padEnd(width)} │`);
+	const blank = (id) => term.rich ? " ".repeat(widthOf(tag(id))) : tag(id);
+	const under = (id, lines) => lines.map((line, i) => `${i === 0 ? tag(id) : blank(id)} ${line}`);
+	if (event.type === "run.started") {
+		const starts = `starts at ${event.entries.join(", ")}`;
+		return [
+			term.rich ? `${chip(term, CHIP_LABELS.run, "accent")} run ${style("bold", event.runId)} of ${event.workflow} ${style("dim", starts)}` : style("dim", `▸ run ${event.runId} of ${event.workflow} (${starts})`),
+			...event.settings?.trigger === void 0 ? [] : [style("dim", `  started by trigger ${event.settings.trigger}; untrusted inputs: ${(event.settings.untrusted ?? []).join(", ") || "none"}`)],
+			...term.rich ? [""] : []
+		];
+	}
+	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}`)}`];
+		}
+		const room = term.width - widthOf(tag(event.id)) - 1 + 2 - (inner.fork === true ? 7 : 0);
+		return under(event.id, formatEvent(event.id, event.event, tools, verbose, view, room).map((line) => `${fork}${line.replace(INDENT, "$1")}`));
+	}
+	if (event.type === "node.finished") return formatFinished(event, tag(event.id), verbose, term, blank(event.id));
+	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") {
+		if (event.action !== "removed") view.roots.set(event.id, event.path);
+		const detail = event.detail === void 0 ? "" : ` (${event.detail})`;
+		const what = event.action === "removed" && event.branch !== void 0 ? `worktree of ${event.branch} (branch kept)` : `${event.branch ?? event.path}${detail}`;
+		const line = `${event.action} ${what}`;
+		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}; ${terminal ? "answer here or with ork decide" : "ork decide"}` : `decision ${event.decision}, via ${event.owner}`;
+		return [`${tag(event.node)} ${term.rich ? chip(term, CHIP_LABELS.ask, "accent") : 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 === "slot.waiting") return [`${tag(event.id)} ${style("yellow", `‖ ${slotWaitLine(event.holders)}`)}`];
+	if (event.type === "slot.taken") return [`${tag(event.id)} ${style("dim", "▸ got a check slot")}`];
+	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, term);
+	if (event.type === "run.resumed") {
+		const [one] = event.kept;
+		return ["", style("dim", `▸ resumed: ${one === void 0 ? "every node runs again" : event.kept.length === 1 ? `${one} keeps its result` : `${event.kept.join(", ")} keep their results`}`)];
+	}
+	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 under(event.node, formatBusEvent(event, term));
+};
+// src/runs/logs.ts
+/**
+* @file `ork logs`: replays a stored run's events as the transcript `ork run`
+*   printed, for the whole run or one node, and tails a live run until it
+*   ends.
+*/
+/** Turns stored events into lines, keeping the state a transcript needs. */
+const createLogPrinter = (options) => {
+	const tools = /* @__PURE__ */ new Map();
+	const view = createView();
+	let width = 8;
+	return (stored) => {
+		const { event } = stored;
+		if (event.type === "run.started") width = Math.max(...event.nodes.map((n) => n.id.length), 1);
+		if (options.node !== void 0 && !isNodeEvent(event, options.node)) return [];
+		if (options.json) return [JSON.stringify(stored)];
+		return formatRunEvent(event, width, tools, false, options.verbose === true || options.node !== void 0, view);
+	};
+};
+/**
+* Why `--node` names nothing in this run, or `null`: no event names it and the
+* run didn't declare it. A live run may still start it, so that is not
+* refused.
+*/
+const unknownNode = (stored, node, live) => {
+	const named = stored.some(({ event }) => isNodeEvent(event, node));
+	const declared = stored.some(({ event }) => event.type === "run.started" && event.nodes.some((n) => n.id === node));
+	return named || declared || live ? null : `Run has no node ${node}.`;
+};
+/**
+* Prints a run's events; with `follow`, then each new one as it is stored:
+* pushed over the run's socket, or polled from the store when there is none.
+* Returns when `run.finished` is stored, the run's process is gone, or `signal`
+* aborts.
+*/
+const followRun = async (store, run, out, options) => {
+	const print = createLogPrinter(options);
+	if (await followEvents(store, run.id, (stored) => {
+		for (const line of print(stored)) out(line);
+	}, {
+		follow: options.follow,
+		...options.after === void 0 ? {} : { after: options.after },
+		...options.intervalMs === void 0 ? {} : { intervalMs: options.intervalMs },
+		...options.home === void 0 ? {} : { home: options.home },
+		...options.signal === void 0 ? {} : { signal: options.signal }
+	}) === "crashed") out(style("red", `run ${run.id} stopped without finishing (its process is gone)`));
+};
+// src/runs/ask-stored.ts
+/**
+* @file Asks one stored decision on a terminal and stores the answer: the
+*   shared step of `ork decide`'s prompts and of `ork attach` (specs/cli.md).
+*   The question goes through the `TerminalHuman`, so prompts keep their order;
+*   a `signal` withdraws the prompt when the decision closes elsewhere; the
+*   answer goes through `answerDecision`, whose first answer wins.
+*/
+/** Asks `decision` on `human`, then stores the answer unless it was withdrawn. */
+const askStored = async (store, human, decision, { place, by, signal, home }) => {
+	let note;
+	const question = {
+		nodeId: decision.node,
+		question: decision.question,
+		options: decision.options,
+		onNote: (given) => {
+			note = given;
+		},
+		...decision.recommended === void 0 ? {} : { recommended: decision.recommended },
+		...decision.context === void 0 ? {} : { context: decision.context },
+		...decision.document === void 0 ? {} : { document: decision.document },
+		...signal === void 0 ? {} : { signal }
+	};
+	let choice;
+	try {
+		choice = await human.askAt(question, place);
+	} catch (error) {
+		if (signal?.aborted === true) return { kind: "withdrawn" };
+		throw error;
+	}
+	if (choice === null) return { kind: "later" };
+	const answered = await answerDecision(store, decision.id, choice, home, by, note);
+	return answered.ok ? {
+		kind: "answered",
+		choice
+	} : {
+		kind: "refused",
+		message: answered.error
+	};
+};
+// src/runs/attach.ts
+/**
+* @file Following a run and every run it called on a terminal, and answering
+*   their open decisions there (`ork attach`, and a foreground `ork run` that
+*   calls workflows; specs/cli.md, specs/scheduler/calls.md). Each run has its
+*   own log printer behind its call path; a decision opened in any of them is
+*   asked through one `TerminalHuman`, withdrawn when it closes elsewhere.
+*/
+const where = (path) => path.join(" › ");
+/**
+* Prints the events of `root` and of the runs it called until the root ends or
+* `signal` aborts, and asks each open decision with `options.human`.
+*/
+const attachRun = async (store, root, out, options = {}) => {
+	const { human, basePath = [] } = options;
+	const { term } = createView();
+	const say = styler(term);
+	const printers = /* @__PURE__ */ new Map();
+	const prompts = /* @__PURE__ */ new Map();
+	/** Decisions answered here: their `decision.answered` line is the card's. */
+	const mine = /* @__PURE__ */ new Set();
+	const asks = [];
+	const seen = {
+		hinted: false,
+		succeeded: false
+	};
+	const show = (path, lines) => {
+		const prefix = path.length === 0 ? "" : paint(term, "muted", `${where(path)} › `);
+		for (const line of lines) out(line === "" ? line : `${prefix}${line}`);
+	};
+	const ask = (run, path, id) => {
+		const decision = store.decision(id);
+		if (human === void 0 || decision === void 0) return;
+		const prompt = { controller: new AbortController() };
+		prompts.set(id, prompt);
+		const settle = async () => {
+			try {
+				const asked = await askStored(store, human, decision, {
+					by: "terminal",
+					signal: prompt.controller.signal,
+					place: {
+						run,
+						decision: id,
+						...path.length === 0 ? {} : { path: where(path) }
+					},
+					...options.home === void 0 ? {} : { home: options.home }
+				});
+				prompts.delete(id);
+				const { closed } = prompt;
+				if (asked.kind === "answered") {
+					mine.add(id);
+					if (!term.rich) show(path, [`${say("green", "✓")} ${id}: ${asked.choice}`]);
+				} else if (asked.kind === "refused") show(path, [paint(term, "warn", `! ${asked.message}`)]);
+				else if (asked.kind === "withdrawn" && closed !== void 0) {
+					const by = closed.type === "decision.answered" ? closed.by === "owner" ? closed.owner ?? ANSWERED_BY.owner : ANSWERED_BY[closed.by] : "";
+					show(path, [say("dim", closed.type === "decision.answered" ? `${id} answered elsewhere: ${closed.answer} (${by})` : `${id} withdrawn`)]);
+				}
+			} catch (error) {
+				prompts.delete(id);
+				seen.failure ??= { error };
+			}
+		};
+		asks.push(settle());
+	};
+	const { end, stillRunning } = await followRunTree(store, root, ({ run, path: below, stored }) => {
+		const path = [...basePath, ...below];
+		const { event } = stored;
+		if (event.type === "run.finished" && below.length === 0) seen.succeeded = event.result.status === "succeeded";
+		if (event.type === "decision.answered" || event.type === "decision.withdrawn") {
+			const prompt = prompts.get(event.decision);
+			if (prompt !== void 0) {
+				prompt.closed = event;
+				prompt.controller.abort();
+				return;
+			}
+			if (event.type === "decision.answered" && mine.has(event.decision)) return;
+		}
+		if (event.type === "decision.opened" && event.owner === void 0 && pendingDecisions(store, { runId: run }).some((d) => d.id === event.decision)) {
+			if (human !== void 0) {
+				ask(run, path, event.decision);
+				return;
+			}
+			if (options.hintNoTerminal === true && !seen.hinted) {
+				seen.hinted = true;
+				show(path, [say("dim", "no terminal: answer with ork decide")]);
+			}
+		}
+		let print = printers.get(run);
+		if (print === void 0) {
+			print = createLogPrinter({ json: false });
+			printers.set(run, print);
+		}
+		show(path, print(stored));
+	}, {
+		...options.home === void 0 ? {} : { home: options.home },
+		...options.intervalMs === void 0 ? {} : { intervalMs: options.intervalMs },
+		...options.signal === void 0 ? {} : { signal: options.signal }
+	});
+	for (const prompt of prompts.values()) prompt.controller.abort();
+	await Promise.all(asks);
+	if (seen.failure !== void 0) throw seen.failure.error;
+	if (end === "crashed") show(basePath, [say("red", `run ${root} stopped without finishing (its process is gone)`)]);
+	for (const id of stillRunning) out(say("dim", `↳ run ${id} still running · ork attach ${id}`));
+	return {
+		stillRunning,
+		exitCode: end === "aborted" || seen.succeeded ? 0 : 1
+	};
+};
+// src/store.ts
+/**
+* @file Opening the user's store (`~/.ork/state.db`) for the length of one
+*   command, and closing it after, whatever happens.
+*/
+/** Runs `body` with the user's store open, and closes it after. */
+const withStore = async (body) => {
+	const store = openStore();
+	try {
+		await body(store);
+	} finally {
+		store.close();
+	}
+};
+export { unknownNode as a, callsShown as c, createDecisionQueue as d, followRun as i, createTerminalHuman as l, attachRun as n, formatEvent as o, askStored as r, formatRunEvent as s, withStore as t, readText as u };