@krapht/ork 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/attach-CEGbRg1D.mjs

@@ -0,0 +1,1230 @@
+import { Er as TOOL_INPUT_KEYS, L as isNodeEvent, Nt as lockWaitLine, Or as maskReplacer, at as followRunTree, ft as DETACHED_ENV, ir as END_KINDS, kr as maskSecrets, mt as followEvents, nr as outcomeEnd, ot as answerDecision, st as pendingDecisions, tr as endOf, zt as slotWaitLine } from "./src-8cOPOgrT.mjs";
+import { t as applyFilters } from "./apply-Mb0fNpCX.mjs";
+import { t as outputsText } from "./outputs-text-CNTJ7Qq_.mjs";
+import { C as termOf, D as wrap, E as widthOf, O as readKeys, _ as interrupt, a as plain, b as canKey, g as createRegion, h as paint, m as bold, n as cost, p as apply, r as costOf, s as style, u as confirmOrStop, v as readLine, w as cut, x as plainEnv, y as withdrawn } from "./output-B1kwo0YU.mjs";
+import { n as chip, r as nodeChip, t as CHIP_LABELS } from "./chips-BqcT58qr.mjs";
+import { a as createView, i as formatBusEvent, n as nodeVerdict, o as styler, r as firstLine, t as hasConflict } from "./verdict-CMvPCpWC.mjs";
+import { z } from "zod";
+import { createInterface } from "node:readline/promises";
+// 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.workflow,
+				place.path
+			].filter((part) => part !== void 0).join(" · ")} · 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.workflow,
+		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, at once if it already has. */
+const parked = (signal) => new Promise((_, reject) => {
+	if (signal?.aborted === true) {
+		reject(withdrawn(signal));
+		return;
+	}
+	signal?.addEventListener("abort", () => {
+		reject(withdrawn(signal));
+	}, { once: true });
+});
+/**
+* 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,
+* but a gate's question (`waits`) waits for `ork decide` or the UI. 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);
+	};
+	/**
+	* Says where a waiting question is answered, and waits until withdrawn. A
+	* foreground run has no one at `ork decide` yet, so it says to start over
+	* detached.
+	*/
+	const waitElsewhere = (q) => {
+		const detached = (io.env ?? process.env)[DETACHED_ENV] === "1";
+		say(paint(term(), "muted", `  no terminal; ${plain(q.nodeId)} waits for ork decide or ork ui` + (detached ? "" : ": use --detach and answer with ork decide")));
+		return parked(q.signal);
+	};
+	const oneAtATime = (work) => {
+		const result = turn.then(work);
+		turn = result.catch(() => null);
+		return result;
+	};
+	const asking = (q, place) => !io.interactive && q.waits === true ? waitElsewhere(q) : 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, the last line of a failed
+*   tool's own stderr, 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 longest a script's last stderr line is shown on the log line. */
+const LAST_LINE_LIMIT = 200;
+/** The last non-empty line of a scrubbed detail, cut; "" when there is none. */
+const lastLine = (detail) => (detail ?? "").split("\n").map((line) => line.trim()).findLast((line) => line !== "")?.slice(0, LAST_LINE_LIMIT) ?? "";
+/**
+* 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. A failed tool (`command_failed`)
+* also shows the last line of its detail without `full`: a script's stderr is
+* the workflow's own message, not the provider's.
+*/
+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}`)));
+	else if (end.kind === "command_failed") {
+		const last = lastLine(end.detail);
+		if (last !== "") lines.push(`  ${style("dim", last)}`);
+	}
+	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-machine.ts
+/**
+* @file How a node's waits for the machine read in `ork logs`: a slot for a
+*   heavy command (ADR-080) and a lock (RFC-016), each naming who holds it.
+*/
+/** Whether `event` is a slot's or a lock's. */
+const isMachineEvent = (event) => event.type.startsWith("slot.") || event.type.startsWith("lock.");
+/** A slot or lock event's line, after its node's tag. */
+const machineLine = (event, style) => {
+	if (event.type === "slot.waiting") return style("yellow", `‖ ${slotWaitLine(event.holders)}`);
+	if (event.type === "slot.taken") return style("dim", "▸ got a check slot");
+	if (event.type === "lock.waiting") return style("yellow", `‖ ${lockWaitLine(event.lock, event.holders)}`);
+	if (event.type === "lock.taken") return style("dim", `▸ holds ${event.lock}`);
+	return style("dim", `▸ let ${event.lock} go`);
+};
+// 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
+/**
+* @file The run summary on the terminal: status, cost, what ran, what a resume
+*   kept, what was skipped and which failures an edge handled (G8, L42),
+*   branches to look at, why it did not succeed, and mail to nodes that never
+*   ran (L91).
+*/
+/** 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 workflow's declared outputs, one per key: a one-line value on the key's
+* line, a longer one under it; a cut value points at the stored full one.
+*/
+const outputLines = (result, style) => outputsText(result.outputs).flatMap(({ name, text, cut }) => {
+	const key = style("bold", `${name}:`);
+	const tail = cut ? [style("dim", `    … cut; full value: ork logs ${result.runId} --json`)] : [];
+	if (text === "") return [`  ${key} ${style("dim", "(empty)")}`];
+	if (!text.includes("\n")) return [`  ${key} ${text}`].concat(tail);
+	const body = text.split("\n").map((line) => `    ${line}`);
+	return [`  ${key}`].concat(body, tail);
+});
+/**
+* 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 keptCount = result.kept ?? 0;
+	const ran = result.nodes.filter((n) => n.runs > 0).length - keptCount;
+	const skipped = result.skipped ?? result.nodes.length - ran - keptCount;
+	const handled = result.failuresHandled ?? 0;
+	const lines = [
+		"",
+		`${mark} run ${result.runId} ${result.status.replace("_", " ")} ${style("dim", `· ${costOf(result.costUsd, result.partial, result.tokens)} · ${String(ran)} ran, ${keptCount === 0 ? "" : `${String(keptCount)} kept, `}${String(skipped)} skipped${handled === 0 ? "" : `, ${failuresHandled(handled)}`}`)}`,
+		...outputLines(result, style)
+	];
+	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}`);
+};
+/** Ork's `delegate` tool, as each driver names it (`mcp__ork__…`, `ork_…`). */
+const DELEGATE = /(?:^|_)delegate$/u;
+/** The input with every string in it masked. */
+const maskedInput = (input) => z.record(z.string(), z.unknown()).parse(JSON.parse(JSON.stringify(input, maskReplacer)));
+/** 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, raw, view, room, verbose, node) => {
+	const input = DELEGATE.test(name) ? maskedInput(raw) : raw;
+	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"}`;
+/** A `once: true` check that did not run, and the pass it stands on. */
+const skippedLine = ({ check, at, who }) => `${check}: already passed on these files · ${at} · ${who}`;
+/** 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}`;
+		const named = event.description === void 0 ? "" : ` · ${maskSecrets(event.description)}`;
+		return [`${tag(event.id)} ${style("dim", `${event.nodeType}${round}${owner}${named}`)}`];
+	}
+	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 (isMachineEvent(event)) return [`${tag(event.id)} ${machineLine(event, style)}`];
+	if (event.type === "verify.skipped") return [`${tag(event.id)} ${style("dim", `✓ ${skippedLine(event)}`)}`];
+	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 = options.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}.`;
+};
+/** `ork logs`'s filter flags (RFC-017): an event's time; no ids. */
+const logListTable = { fields: [{
+	name: "since",
+	description: "Only events since an age (24h, 30d, 12w), a day (2026-11-01), or all",
+	type: "since",
+	all: true,
+	get: (stored) => stored.at
+}, {
+	name: "until",
+	description: "Only events on or before this day (2026-11-01)",
+	type: "until",
+	get: (stored) => stored.at
+}] };
+/** Whether an event is one `--since`, `--until` and `--node` let through. */
+const matcher = (options) => (stored) => applyFilters(logListTable, [stored], options.filter ?? {}).length > 0 && (options.node === void 0 || isNodeEvent(stored.event, options.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);
+	const matches = matcher(options);
+	const replayed = options.limit === void 0 ? [] : store.events(run.id, options.after ?? 0).filter((stored) => matches(stored)).slice(0, -options.limit);
+	const dropped = new Set(replayed.map((stored) => stored.seq));
+	if (await followEvents(store, run.id, (stored) => {
+		const lines = print(stored);
+		if (!matches(stored) || dropped.has(stored.seq)) return;
+		for (const line of lines) 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/gutter.ts
+/**
+* @file The gutter before a called run's log lines (its call path, then `›`)
+*   and a log printer laid out in the columns the gutter leaves. Shared by `ork
+*   attach` and the commands that print several runs.
+*/
+/** A call path for reading: `plan › build`. */
+const callPathOf = (path) => path.join(" › ");
+/** The gutter before a called run's lines: its call path, then ` › `. */
+const gutterOf = (path) => path.length === 0 ? "" : `${callPathOf(path)} › `;
+/**
+* A run's printer, laid out in the columns its gutter leaves, so a line fits
+* the terminal with the gutter before it and a wrapped line goes on under its
+* own text, not at the terminal's first column.
+*/
+const printerFor = (term, path, options = {}) => createLogPrinter({
+	...options,
+	json: false,
+	view: {
+		term: {
+			...term,
+			width: Math.max(20, term.width - widthOf(gutterOf(path)))
+		},
+		roots: /* @__PURE__ */ new Map()
+	}
+});
+/** Prints `lines` through `out`, each (not blank) behind `path`'s muted gutter. */
+const printUnder = (out, term, path, lines) => {
+	const gutter = gutterOf(path);
+	const prefix = gutter === "" ? "" : paint(term, "muted", gutter);
+	for (const line of lines) out(line === "" ? line : `${prefix}${line}`);
+};
+// 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/prompts.ts
+const closedLine = (id, closed) => {
+	if (closed.type === "decision.withdrawn") return `${id} withdrawn`;
+	const by = closed.by === "owner" ? closed.owner ?? ANSWERED_BY.owner : ANSWERED_BY[closed.by];
+	return `${id} answered elsewhere: ${closed.answer} (${by})`;
+};
+/** Creates the prompts a command owns over `store`, asked on `human`. */
+const createPrompts = (store, human, options) => {
+	const { term, out } = options;
+	const say = styler(term);
+	const prompts = /* @__PURE__ */ new Map();
+	/** Decisions answered here: their `decision.answered` line is the card's. */
+	const mine = /* @__PURE__ */ new Set();
+	const asks = [];
+	const state = {};
+	const show = (path, lines) => {
+		printUnder(out, term, path, lines);
+	};
+	const ask = ({ run, path = [], workflow }, id) => {
+		const decision = store.decision(id);
+		if (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: options.by ?? "terminal",
+					signal: prompt.controller.signal,
+					place: {
+						run,
+						decision: id,
+						...workflow === void 0 ? {} : { workflow },
+						...path.length === 0 ? {} : { path: callPathOf(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) show(path, [say("dim", closedLine(id, closed))]);
+			} catch (error) {
+				prompts.delete(id);
+				state.failure ??= { error };
+			}
+		};
+		asks.push(settle());
+	};
+	return {
+		ask,
+		has: (id) => prompts.has(id) || mine.has(id),
+		seen: (event) => {
+			if (event.type !== "decision.answered" && event.type !== "decision.withdrawn") return false;
+			const prompt = prompts.get(event.decision);
+			if (prompt !== void 0) {
+				prompt.closed = event;
+				prompt.controller.abort();
+				return true;
+			}
+			return event.type === "decision.answered" && mine.has(event.decision);
+		},
+		open: () => prompts.size,
+		abort: () => {
+			for (const prompt of prompts.values()) prompt.controller.abort();
+		},
+		settled: async () => {
+			await Promise.all(asks);
+			if (state.failure !== void 0) throw state.failure.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.
+*/
+/**
+* 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 } = options.view ?? createView();
+	const say = styler(term);
+	const printers = /* @__PURE__ */ new Map();
+	const seen = {
+		hinted: false,
+		succeeded: false
+	};
+	const show = (path, lines) => {
+		printUnder(out, term, path, lines);
+	};
+	const prompts = human === void 0 ? void 0 : createPrompts(store, human, {
+		out,
+		term,
+		...options.home === void 0 ? {} : { home: options.home }
+	});
+	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 (prompts?.seen(event) === true) return;
+		if (event.type === "decision.opened" && event.owner === void 0 && pendingDecisions(store, { runId: run }).some((d) => d.id === event.decision)) {
+			if (prompts !== void 0) {
+				prompts.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 = printerFor(term, path);
+			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 }
+	});
+	prompts?.abort();
+	await prompts?.settled();
+	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
+	};
+};
+export { printerFor as a, logListTable as c, formatEvent as d, formatRunEvent as f, readText as h, printUnder as i, matcher as l, createTerminalHuman as m, createPrompts as n, createLogPrinter as o, callsShown as p, askStored as r, followRun as s, attachRun as t, unknownNode as u };