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

package/dist/bin.mjs

@@ -1,58 +1,28 @@
 #!/usr/bin/env node
-import { Bn as serializeWorkflow, Bt as FEEDBACK_TARGETS, Cn as runDirOf, D as inspectProject, Dn as projectRootOf, Dt as userMessageText, En as inside, Ft as PROJECT_FILE, H as tellNode, Ht as planPost, I as createCalls, It as gitRulesOf, J as tellLiveRun, Jn as beforeOf, Jt as normalizeTitle, Kn as settingsOf, Kt as createFeedback, L as addressOf, Lt as loadProject, M as clearGitLocalEnv, N as parseInputPairs, P as resolveInputs, R as endLink, Rt as FEEDBACK_KINDS, Sn as projectsHome, Tt as startRun, Un as WorkflowSchema, V as peerOf, W as flattenTree, Wt as sendPost, Xt as maskReplacer, Yn as isClaudeNode, _ as lateTriggers, _n as hasInRepoFiles, _t as runStatus, an as wakeRun, ar as CLAUDE_DRIVERS, bn as placeFiles, cn as planMoveInto, d as runningRunIds, dn as toolsInUse, dt as namingNoDriver, er as INTEGRATIONS, et as adoptedCalls, f as runningScript, fn as createAgent, ft as sessionDriver, h as isNewer, hn as loadAgents, ht as liveStatus, i as NOT_STARTED, in as socketRoom, ir as ORK_LAYOUT, it as replayLoopAnswers, l as planUpgrade, ln as linkTools, mn as catalogAgent, n as resolveBase, nn as serveRun, nt as resumable, on as planAgentMigration, or as firstLine, ot as detachRun, pn as deleteAgent, q as requestStop, qt as fingerprint, rn as socketPath, rr as AGENT_TOOL_LAYOUTS, rt as createReplay, sn as applySteps, st as followEvents, t as createWorkspace, tt as detachResume, u as releaseNotes, un as toolLinks, ut as planNodeSession, v as triggersReport, vn as inRepoPlace, vt as runTree, wn as shownPath, wt as walkSummary, xn as placeFor, yn as newProjectId, z as endLinksOf, zt as FEEDBACK_SEVERITIES } from "./src-hrj2h0IZ.mjs";
-import { C as feedbackActions, S as placeOf, _ as previewPost, b as acceptItem, c as checkDue, d as pendingNotice, f as readUpdateCache, g as nodeSession, h as writeUpdateCache, i as registryOf, l as fetchLatest, m as updateCachePath, n as ORK_VERSION, o as updateSwitchOff, p as refreshUpdateCache, r as isSwitchedOn, s as runInstall, t as ORK_NAME, u as newerVersion$1, v as checkNote, w as openFixRun, y as recordNote } from "./__build_info__-D9lSlMFy.mjs";
-import { i as builtinWorkflowFile, n as pendingDecisions, r as builtinProblem, t as answerDecision } from "./decide-CoIJh34e.mjs";
-import { n as newRunId, t as findRun } from "./find-rBBk7Jui.mjs";
-import { a as write, c as openStore, i as style, l as storePath, n as cost, o as writeErr, s as nodeOf, t as confirm } from "./output-TV_j7Ni0.mjs";
-import { n as listOrkWorktrees, t as createdWorktrees } from "./list-Bv5Lxu7z.mjs";
-import { a as planClean, t as applyClean } from "./clean-CA_Oi2Wl.mjs";
+import { $ as DETACHED_ENV, $t as endOf, An as linkTools, Ar as AGENT_DRIVERS, At as nestItems, Bn as placeFiles, C as openStore, Cn as wakeRun, Ct as runStatus, Dn as planAgentMigration, Dr as readyDriver, E as inspectProject, En as maskSecrets, Er as driverChecks, Et as templateOf, Fn as catalogAgent, Gt as PROJECT_FILE, H as tellNode, Hn as projectsHome, I as createCalls, In as loadAgents, J as tellLiveRun, Jt as machineRulesOf, Kn as inside, Kt as gitRulesOf, L as addressOf, Ln as hasInRepoFiles, M as parseInputPairs, Mn as toolsInUse, N as resolveInputs, Nn as createAgent, On as applySteps, Or as AGENT_TOOL_LAYOUTS, Pn as deleteAgent, Q as listKey, Qt as createSignals, R as endLink, Rn as inRepoPlace, S as isNodeEvent, Tn as maskReplacer, Un as runDirOf, V as peerOf, Vn as placeFor, W as flattenTree, Wn as shownPath, X as detachResume, Y as adoptedCalls, Z as resumable, _t as startRun, a as releaseNotes, an as FEEDBACK_SEVERITIES, bn as serveRun, br as retiredDriverHint, cn as planPost, cr as serializeWorkflow, dr as WorkflowSchema, dt as sessionDriver, en as outcomeEnd, et as detachRun, fn as createFeedback, gr as isClaudeNode, gt as walkSummary, i as planUpgrade, in as FEEDBACK_KINDS, ir as beforeOf, j as clearGitLocalEnv, jn as toolLinks, kn as planMoveInto, kr as ORK_LAYOUT, lt as planNodeSession, mn as normalizeTitle, mr as settingsOf, n as resolveBase, nn as END_KINDS, nt as NOT_STARTED, o as runningRunIds, on as FEEDBACK_TARGETS, q as requestStop, qn as projectRootOf, qt as loadProject, s as runningScript, t as createWorkspace, tt as followEvents, u as isNewer, un as sendPost, wt as runTree, x as activeTree, xn as socketPath, xt as liveStatus, yt as userMessageText, z as endLinksOf, zn as newProjectId, zt as slotWaitLine } from "./src-D6_xjm-x.mjs";
+import { C as feedbackActions, S as placeOf, _ as previewPost, b as acceptItem, f as readUpdateCache, g as nodeSession, h as writeUpdateCache, i as registryOf, l as fetchLatest, m as updateCachePath, n as ORK_VERSION, s as runInstall, t as ORK_NAME, v as checkNote, w as openFixRun, y as recordNote } from "./__build_info__-CIchF6nr.mjs";
+import { i as builtinWorkflowFile, n as pendingDecisions, r as builtinProblem, t as answerDecision } from "./decide-B6PnKeqo.mjs";
+import { n as newRunId, t as findRun } from "./find-BicBbGMg.mjs";
+import { n as listOrkWorktrees, t as createdWorktrees } from "./list-CEaJ07jd.mjs";
+import { a as planClean, t as applyClean } from "./clean-Di-KT7Mf.mjs";
 import { c as subcommandsOf, i as argsOf, n as groupedEntries, o as publicArgs, s as resolved, t as groupOf } from "./help-groups-BwYoAWsh.mjs";
-import { a as formatRunEvent, i as formatEvent, n as formatRuns, o as createTerminalHuman, r as formatTree, t as ago } from "./format-zMmhqyLE.mjs";
-import { c as registeredProjects, i as refusedBuiltin, n as WORKFLOW_SUFFIX, o as workflowArg, s as projectAt, t as WORKFLOW_DIR } from "./workflows-vsEohqa7.mjs";
-import { a as validate, c as warningLines, i as loadWorkflow, o as validateFile, r as formatReport, s as walkLoaded, t as context } from "./context-6x3kXREO.mjs";
-import { i as runLimits, r as limitsRefusal, t as chatNotice } from "./limits-BPM9wUlV.mjs";
-import { _ as resultOf, a as builtinExecutors, d as maskedEnv, f as maskedNamesOfRun, g as clearOutputFiles, h as sessionEnv, i as onPath, l as clearStateFiles, m as runScrubber, n as missingProgramMessage, r as missingPrograms, t as envProblems } from "./src-BxUJPGa5.mjs";
-import { i as decideRefusal, n as chatRefusal } from "./in-a-run-DdAakpRR.mjs";
+import { C as widthOf, S as hang, T as readKeys, _ as canKey, a as write, b as termOf, d as bold, f as paint, g as withdrawn, h as readLine, i as style, m as interrupt, n as cost, o as writeErr, p as createRegion, r as plain, s as confirmOrStop, t as confirm, u as apply$1, v as plainEnv, w as wrap, x as cut, y as takePlainFlag } from "./output-CM95njYt.mjs";
+import { n as chip, r as nodeChip, t as CHIP_LABELS } from "./chips-BA7SrrH5.mjs";
+import { _ as namedMcpEntries, a as builtinExecutors, d as maskedEnv, f as maskedNamesOfRun, g as clearOutputFiles, h as sessionEnv, i as onPath, l as clearStateFiles, m as runScrubber, n as missingProgramMessage, r as missingPrograms, t as envProblems, v as resultOf } from "./src-9iGkjnsy.mjs";
+import { c as registeredProjects, i as refusedBuiltin, n as WORKFLOW_SUFFIX, o as workflowArg, s as projectAt, t as WORKFLOW_DIR } from "./workflows-DZvW3i1e.mjs";
+import { C as startUpdateCheck, S as showUpdateNotice, _ as runChecks, a as validateFile, c as warningLines, d as runReadyDriver, f as unfitLines, g as orkCheck, h as headWarning, i as validate, l as checksHere, m as experimentsCheck, o as walkLoaded, p as exec, r as loadWorkflow, s as formatReport, t as context, u as chooseReadyDriver, v as socketCheck, w as updateCheckOff, x as runUpdateChild, y as triggerChecks } from "./context-BaNshWr9.mjs";
+import { c as nodeVerdict, d as createView, f as styler, i as listedStatus, l as firstLine, n as formatRuns, r as formatTree, s as hasConflict, t as ago, u as formatBusEvent } from "./format-lWhN-jYR.mjs";
+import { i as runLimits, r as limitsRefusal, t as chatNotice } from "./limits-jZQp9ZJC.mjs";
+import { i as decideRefusal, n as chatRefusal } from "./in-a-run-CgkVouyG.mjs";
 import path from "node:path";
 import { stringify } from "yaml";
 import { z } from "zod";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
-import { createHash } from "node:crypto";
+import { appendFileSync, existsSync, linkSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
-import { execFile, spawn } from "node:child_process";
 import { setTimeout } from "node:timers/promises";
 import { defineCommand, renderUsage, runMain } from "citty";
 import { createInterface } from "node:readline/promises";
-import { styleText } from "node:util";
-// ../integrations/src/ready.ts
-/**
-* @file Which Claude driver is ready on this machine: each driver's own check
-*   (what `ork doctor` shows), and the one a run takes for the nodes that name
-*   no driver, so a committed workflow never carries one person's login.
-*/
-/** Each registered Claude driver's own check, in registry order. */
-const driverChecks = (run, env) => Promise.all(CLAUDE_DRIVERS.map(async (driver) => ({
-	id: driver.id,
-	result: await driver.doctor(run, env)
-})));
-/**
-* The driver ready here: the one whose check passes; with more than one,
-* {@link PREFERRED_DRIVER}; with none, each driver's hint.
-*/
-const readyDriver = (checks) => {
-	const ready = checks.filter(({ result }) => result.status === "ok");
-	const pick = ready.find(({ id }) => id === "cli") ?? ready.at(0);
-	if (pick === void 0) return {
-		ok: false,
-		hints: checks.flatMap(({ result }) => result.hint === void 0 ? [] : [result.hint])
-	};
-	return {
-		ok: true,
-		driver: pick.id,
-		detail: pick.result.detail,
-		ready: ready.length
-	};
-};
 // ../core/src/control/queue.ts
 const PERMISSION_OPTIONS = [{
 	id: "allow",
@@ -64,14 +34,33 @@ const PERMISSION_OPTIONS = [{
 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}`;
-/** At most `max` characters of a tool's input, for the decision's context. */
-const inputPreview = (input, max = 400) => {
-	const json = JSON.stringify(input);
-	return json.length > max ? `${json.slice(0, max - 1)}…` : json;
+/** The input fields that say what a tool will do, the first one present. */
+const TOOL_INPUT_KEYS = [
+	"command",
+	"file_path",
+	"path",
+	"url",
+	"pattern"
+];
+/** A tool's input for the decision's context: as written, cut at `max`. */
+const inputContext = (input, max = 4e3) => {
+	const key = TOOL_INPUT_KEYS.find((k) => typeof input[k] === "string");
+	const text = key === void 0 ? JSON.stringify(input, void 0, 2) : String(input[key]);
+	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
 };
 const createDecisionQueue = (options) => {
 	const { store, runId, emit } = options;
-	let count = 0;
+	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;
@@ -155,12 +144,16 @@ const createDecisionQueue = (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;
@@ -219,7 +212,7 @@ const createDecisionQueue = (options) => {
 				kind: "permission",
 				question: `Allow ${request.toolName}?`,
 				options: PERMISSION_OPTIONS,
-				context: inputPreview(request.input)
+				context: inputContext(request.input)
 			}, local === void 0 ? void 0 : (signal) => {
 				let said;
 				return local.permit({
@@ -236,7 +229,7 @@ const createDecisionQueue = (options) => {
 						note: said
 					};
 				});
-			});
+			}, request.signal);
 			if (note !== void 0) request.onNote?.(note);
 			return answer === "allow" ? { allow: true } : {
 				allow: false,
@@ -314,165 +307,6 @@ const startControl = async (options) => {
 		}
 	};
 };
-// ../core/src/feedback/signals.ts
-const ORK_TOOL = "mcp__ork__";
-/**
-* An observer for one run's events: give it each event, and record what it
-* returns, in order (the event, its origin filled in when it is feedback, then
-* any feedback it signals).
-*/
-const createSignals = (options = {}) => {
-	let workflow;
-	const nodeTypes = /* @__PURE__ */ new Map();
-	const sessions = /* @__PURE__ */ new Map();
-	const tools = /* @__PURE__ */ new Map();
-	const asked = /* @__PURE__ */ new Map();
-	const seen = /* @__PURE__ */ new Set();
-	const originOf = (node) => {
-		const origin = {};
-		if (workflow !== void 0) origin.workflow = workflow;
-		if (options.workflowHash !== void 0) origin.workflowHash = options.workflowHash;
-		const type = node === void 0 ? void 0 : nodeTypes.get(node);
-		if (type !== void 0) origin.nodeType = type;
-		const session = node === void 0 ? void 0 : sessions.get(node);
-		if (session !== void 0) origin.model = session.model;
-		if (session?.driver !== void 0) origin.driver = session.driver;
-		if (options.version !== void 0) origin.version = options.version;
-		return origin;
-	};
-	const record = (node, signal) => {
-		const print = fingerprint(signal);
-		if (seen.has(print)) return [];
-		seen.add(print);
-		return [{
-			type: "feedback.recorded",
-			...node === void 0 ? {} : { node },
-			feedback: {
-				source: "system",
-				kind: signal.kind,
-				target: signal.target,
-				severity: signal.severity,
-				title: signal.title,
-				body: signal.body,
-				evidence: signal.evidence ?? [],
-				code: signal.code,
-				fingerprint: print,
-				origin: originOf(node)
-			}
-		}];
-	};
-	const answered = (question, answer) => {
-		if (question.kind === "permission") {
-			if (answer !== "deny") return null;
-			const tool = question.question.replace(/^Allow /u, "").replace(/\?$/u, "");
-			return [question.node, {
-				code: "permission.denied",
-				kind: "friction",
-				target: "workflow",
-				severity: "low",
-				title: `${question.node} was denied ${tool}`,
-				body: "Allow it in the node's `tools.allow` if it needs it, or tell it in its prompt not to use it.",
-				evidence: [tool]
-			}];
-		}
-		if (question.recommended === void 0 || answer === question.recommended) return null;
-		return [question.node, {
-			code: "recommendation.overridden",
-			kind: "context-gap",
-			target: "workflow",
-			severity: "low",
-			title: `The answer to ${question.node}'s question was not the one it recommended`,
-			body: `Asked: ${question.question} Recommended: ${question.recommended}. Answered: ${answer}.`
-		}];
-	};
-	/** The feedback an event signals, if any, and the node it is about. */
-	const signalOf = (event) => {
-		if (event.type === "loop.exhausted") return [event.from, {
-			code: "loop.exhausted",
-			kind: "workflow",
-			target: "workflow",
-			severity: "medium",
-			title: `The loop ${event.from} -> ${event.to} ran out of its ${String(event.maxRounds)} rounds`,
-			body: "Raise `maxRounds`, or make what the loop's nodes are asked to fix clearer so it settles sooner."
-		}];
-		if (event.type === "run.finished" && event.result.status === "budget_exhausted") return [void 0, {
-			code: "budget.exhausted",
-			kind: "workflow",
-			target: "workflow",
-			severity: "medium",
-			title: "The run's budget ran out",
-			body: `The run stopped after spending $${event.result.costUsd.toFixed(4)}. Raise \`limits.budgetUsd\`, or give nodes cheaper models or smaller budgets.`
-		}];
-		if (event.type === "decision.answered") {
-			const question = asked.get(event.decision);
-			return question === void 0 ? null : answered(question, event.answer);
-		}
-		if (event.type === "node.event" && event.event.type === "tool.result") {
-			const name = tools.get(`${event.id}\0${event.event.id}`);
-			if (!event.event.isError || name?.startsWith(ORK_TOOL) !== true) return null;
-			const tool = name.slice(10);
-			return [event.id, {
-				code: "tool.error",
-				kind: "bug",
-				target: "ork",
-				severity: "medium",
-				title: `Ork's ${tool} tool returned an error`,
-				body: `A call to \`${tool}\` failed; the node's events show the call.`,
-				evidence: [name]
-			}];
-		}
-		if (event.type === "node.finished" && nodeTypes.get(event.id) === "human.gate" && event.output["answeredBy"] === "timeout") return [event.id, {
-			code: "gate.timeout",
-			kind: "workflow",
-			target: "workflow",
-			severity: "low",
-			title: `The gate ${event.id} timed out and took its default`,
-			body: "No one answered in time. Lengthen its `timeout`, or keep it if the default was right."
-		}];
-		return null;
-	};
-	/** Keeps what later events and origins need. */
-	const observe = (event) => {
-		if (event.type === "run.started") workflow = event.workflow;
-		if (event.type === "node.started") nodeTypes.set(event.id, event.nodeType);
-		if (event.type === "decision.opened") {
-			const question = {
-				node: event.node,
-				kind: event.kind,
-				question: event.question
-			};
-			if (event.recommended !== void 0) question.recommended = event.recommended;
-			asked.set(event.decision, question);
-		}
-		if (event.type !== "node.event") return;
-		const inner = event.event;
-		if (inner.type === "session.started" && inner.fork !== true) sessions.set(event.id, {
-			model: inner.model,
-			...inner.driver === void 0 ? {} : { driver: inner.driver }
-		});
-		if (inner.type === "tool.called") tools.set(`${event.id}\0${inner.id}`, inner.name);
-	};
-	return (event) => {
-		observe(event);
-		if (event.type === "feedback.recorded") {
-			if (seen.has(event.feedback.fingerprint)) return [];
-			seen.add(event.feedback.fingerprint);
-			const origin = {
-				...originOf(event.node),
-				...event.feedback.origin
-			};
-			return [{
-				...event,
-				feedback: {
-					...event.feedback,
-					origin
-				}
-			}];
-		}
-		const signal = signalOf(event);
-		return signal === null ? [event] : [event, ...record(...signal)];
-	};
-};
 /** A title's words, as fingerprints compare them. */
 const titleWords = (title) => new Set(normalizeTitle(title).split(" ").filter((word) => word !== ""));
 /** The share of two titles' words they have in common (Jaccard). */
@@ -514,6 +348,140 @@ const proposeMerges = (items) => {
 		};
 	}).filter((merge) => merge !== void 0).toSorted((a, b) => firstSeen(a.into, b.into));
 };
+/** `ORK_HEAVY_SLOTS` as a count; anything but a positive integer is the default. */
+const heavySlots = (env = process.env) => {
+	const count = Number(env["ORK_HEAVY_SLOTS"]);
+	return Number.isInteger(count) && count > 0 ? count : 2;
+};
+const codeOf = (error) => error instanceof Error && "code" in error ? error.code : void 0;
+const alive = (pid) => {
+	if (pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return codeOf(error) === "EPERM";
+	}
+};
+const read = (file) => {
+	try {
+		const value = JSON.parse(readFileSync(file, "utf8"));
+		if (typeof value !== "object" || value === null || !("id" in value && "run" in value && "node" in value && "pid" in value)) return;
+		const { id, run, node, pid } = value;
+		return typeof id === "string" && typeof run === "string" && typeof node === "string" && typeof pid === "number" ? {
+			id,
+			run,
+			node,
+			pid
+		} : void 0;
+	} catch {
+		return;
+	}
+};
+const listed = (dir) => {
+	try {
+		return readdirSync(dir).filter((name) => name.endsWith(".json")).toSorted();
+	} catch {
+		return [];
+	}
+};
+/** Written whole (a rename), so no reader sees half a record. */
+const writeWhole = (file, record) => {
+	const draft = `${file}.${record.id}.tmp`;
+	writeFileSync(draft, JSON.stringify(record), { mode: 384 });
+	renameSync(draft, file);
+};
+/** Deletes a record if it is still `id`'s. */
+const dropIf = (file, id) => {
+	if (read(file)?.id === id) rmSync(file, { force: true });
+};
+let tickets = 0;
+/** A ticket's name: sorted by when it was queued. */
+const ticketName = (id) => `${String(Date.now()).padStart(15, "0")}-${String(process.pid).padStart(8, "0")}-${String(tickets += 1).padStart(6, "0")}-${id}.json`;
+/** The ledger in `dir`, with `slots` slots. */
+const fileSlotLedger = (options) => {
+	const { dir, slots } = options;
+	const queue = path.join(dir, "queue");
+	const slotFile = (index) => path.join(dir, `slot-${String(index)}.json`);
+	const records = () => Array.from({ length: slots }, (_, index) => {
+		const file = slotFile(index);
+		return {
+			file,
+			held: read(file)
+		};
+	});
+	const holders = () => records().flatMap(({ held }) => held === void 0 ? [] : [held]);
+	const sweep = () => {
+		const gone = [];
+		for (const file of [...records().map((record) => record.file), ...listed(queue).map((name) => path.join(queue, name))]) {
+			const held = read(file);
+			if (held === void 0 || alive(held.pid)) continue;
+			dropIf(file, held.id);
+			gone.push(held);
+		}
+		return gone;
+	};
+	/** Links `draft` into a free slot; true when it got one. */
+	const tryTake = (draft) => {
+		for (const { file, held } of records()) {
+			if (held !== void 0) continue;
+			try {
+				linkSync(draft, file);
+				return true;
+			} catch (error) {
+				if (codeOf(error) !== "EEXIST") throw error;
+			}
+		}
+		return false;
+	};
+	const take = async (holder, { signal, onWait }) => {
+		mkdirSync(queue, {
+			recursive: true,
+			mode: 448
+		});
+		const record = {
+			id: randomUUID(),
+			...holder
+		};
+		const ticket = path.join(queue, ticketName(record.id));
+		writeWhole(ticket, record);
+		let told = false;
+		try {
+			for (;;) {
+				if (signal.aborted) return null;
+				sweep();
+				const free = records().filter(({ held }) => held === void 0).length;
+				if (listed(queue).indexOf(path.basename(ticket)) < free && tryTake(ticket)) {
+					const release = () => {
+						for (const { file, held } of records()) if (held?.id === record.id) dropIf(file, record.id);
+					};
+					return release;
+				}
+				if (!told) {
+					told = true;
+					onWait?.(holders());
+				}
+				try {
+					await setTimeout(options.pollMs ?? 500, void 0, { signal });
+				} catch {
+					return null;
+				}
+			}
+		} finally {
+			rmSync(ticket, { force: true });
+		}
+	};
+	return {
+		take,
+		holders,
+		sweep
+	};
+};
+/** The machine's ledger: `~/.ork/slots`, `ORK_HEAVY_SLOTS` slots. */
+const machineSlotLedger = (options = {}) => fileSlotLedger({
+	dir: path.join(options.home ?? homedir(), ".ork", "slots"),
+	slots: heavySlots(options.env)
+});
 // ../core/src/remote/relay.ts
 /**
 * @file A run's side of the relay (RFC-003): its nodes' links, read from the
@@ -613,6 +581,89 @@ const createRelay = (options) => {
 		}
 	};
 };
+// ../core/src/run/replay.ts
+const NO_FAN_OUTS = {
+	lists: /* @__PURE__ */ new Map(),
+	items: /* @__PURE__ */ new Map()
+};
+/** Whether an activation's input carries a result this run made anew. */
+const carries = (fresh, input) => {
+	if (input === void 0) return false;
+	if (fresh.has(input)) return true;
+	const results = input["results"];
+	if (results === null || typeof results !== "object") return false;
+	return Object.values(results).some((value) => value !== null && typeof value === "object" && fresh.has(value));
+};
+/**
+* Hands each node's recorded results back in order, until the node runs anew
+* once (it failed or never finished last time, or its input is new); from then
+* on it always runs. A node cut off mid-session continues that session, once.
+*/
+const createReplay = (history, cutOff = /* @__PURE__ */ new Map(), mail, earlier, fanOuts = NO_FAN_OUTS) => {
+	const sessions = new Map(cutOff);
+	const used = /* @__PURE__ */ new Map();
+	const anew = /* @__PURE__ */ new Set();
+	const fresh = /* @__PURE__ */ new WeakSet();
+	/** Fanned nodes whose list was resolved anew: their items can't be replayed. */
+	const renewed = /* @__PURE__ */ new Set();
+	const takeItem = (activation, of) => {
+		const recorded = fanOuts.items.get(activation.id)?.get(activation.round ?? 0);
+		if (recorded !== void 0 && !renewed.has(of) && !carries(fresh, activation.input)) return recorded;
+		anew.add(activation.id);
+		return null;
+	};
+	return {
+		take: (activation) => {
+			const { id } = activation;
+			if (activation.brief !== void 0 || anew.has(id)) return null;
+			if (activation.item !== void 0) return takeItem(activation, activation.item.of);
+			const index = used.get(id) ?? 0;
+			const recorded = history.get(id)?.[index];
+			if (recorded === void 0 || carries(fresh, activation.input)) {
+				anew.add(id);
+				return null;
+			}
+			used.set(id, index + 1);
+			return recorded;
+		},
+		ran: (result) => {
+			fresh.add(result.output);
+		},
+		cutOff: (activation) => {
+			const session = activation.brief === void 0 && (activation.item === void 0 || !renewed.has(activation.item.of)) ? sessions.get(activation.id) : void 0;
+			sessions.delete(activation.id);
+			return session;
+		},
+		listed: (id, round, source) => {
+			const list = fanOuts.lists.get(listKey(id, round));
+			const ranAnew = typeof source === "object" && source !== null && fresh.has(source);
+			if (list !== void 0 && !ranAnew) return list;
+			renewed.add(id);
+			return null;
+		},
+		previousSession: ({ id, item, round = 0 }) => item === void 0 || renewed.has(item.of) ? void 0 : [...fanOuts.items.get(id) ?? []].findLast(([before]) => before < round)?.[1].sessionId,
+		lastOutput: (id) => history.get(id)?.at(-1)?.output,
+		kept: () => [...history.keys(), ...fanOuts.items.keys()],
+		...mail === void 0 ? {} : { mail },
+		...earlier === void 0 ? {} : { earlier }
+	};
+};
+/**
+* The run's `HumanChannel`, answering questions about loops out of rounds as
+* they were answered last time, in order; anything else goes to `human`.
+*/
+const replayLoopAnswers = (human, answers) => {
+	const left = [...answers];
+	return {
+		permit: (request) => human.permit(request),
+		...human.settled === void 0 ? {} : { settled: human.settled },
+		ask: (question) => {
+			const index = left.findIndex((a) => a.question === question.question);
+			const [given] = index === -1 ? [] : left.splice(index, 1);
+			return given === void 0 ? human.ask(question) : Promise.resolve(given.answer);
+		}
+	};
+};
 // ../core/src/store/recorder.ts
 /**
 * @file Records a run as it happens: each event appended to the store and
@@ -641,6 +692,11 @@ const createRecorder = (store, run, runDir) => {
 // src/help-root.ts
 /** Where the user docs start. */
 const DOCS_URL = "https://github.com/mimshins/ork/blob/main/docs/README.md";
+/** The flags every command takes, which `bin.ts` handles before citty. */
+const GLOBAL_FLAGS = [{
+	name: "--plain",
+	description: "Plain output: no color, no redrawn prompts (also ORK_PLAIN=1, NO_COLOR)"
+}];
 const rowOf = (entry) => {
 	const short = groupOf(entry.name)?.short ?? entry.description;
 	const alias = entry.aliases.length === 0 ? "" : ` (alias: ${entry.aliases.join(", ")})`;
@@ -668,6 +724,9 @@ const renderRootHelp = async (cmd) => {
 		...groups.flatMap((group) => groupLines(group, width)),
 		`Usage: ${name} <command> [flags]`,
 		"",
+		"Flags for every command:",
+		...GLOBAL_FLAGS.map((f) => `  ${f.name}  ${f.description}`),
+		"",
 		`Use "${name} <command> --help" for more about a command.`,
 		`${name} v${meta.version ?? ""}`
 	].join("\n");
@@ -691,299 +750,870 @@ const renderHelp = async (cmd, parent) => {
 	if (cmd.subCommands !== void 0 && parent === void 0) return renderRootHelp(shown);
 	const above = parent?.meta === void 0 ? void 0 : { meta: parent.meta };
 	const usage = await renderUsage(shown, above);
-	if (cmd.subCommands === void 0) return usage;
+	const globals = `GLOBAL OPTIONS\n\n${GLOBAL_FLAGS.map((f) => `  ${f.name}  ${f.description}`).join("\n")}`;
+	if (cmd.subCommands === void 0) return `${usage}\n\n${globals}`;
 	const choices = await choicesOf(shown);
-	return usage.replace(` [OPTIONS] ${choices}`, ` <command> [flags]`).replace(` ${choices}`, ` <command> [flags]`);
+	return `${usage.replace(` [OPTIONS] ${choices}`, ` <command> [flags]`).replace(` ${choices}`, ` <command> [flags]`)}\n\n${globals}`;
 };
 /** Prints {@link renderHelp}'s usage, as citty prints its own. */
 const showHelp = async (cmd, parent) => {
 	process.stdout.write(`${await renderHelp(cmd, parent)}\n\n`);
 };
-// src/update/notify.ts
+// 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} · 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} · ${String(place.index)} of ${String(place.total)}`)}`;
+	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)}`;
+};
 /**
-* @file The new-version notice (ADR-038). At most once a day a command starts a
-*   detached copy of `ork` that asks the npm registry for the latest version
-*   and records it in `~/.ork/update-check.json`, so no command waits on the
-*   network; a later command, when a newer version is known, ends with one line
-*   on stderr (once a day). Off in CI, without a terminal, with `--json`, and
-*   with `ORK_NO_UPDATE_CHECK=1` or `NO_UPDATE_NOTIFIER=1`.
+* 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.
 */
-/** Set in the background copy of `ork` that only runs the check. */
-const UPDATE_CHILD_ENV = "ORK_UPDATE_CHECK_CHILD";
+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
 /**
-* Why the automatic check is off for this command, or `null` when it is on: the
-* environment's switches (core's, which `ork ui` reads too), then where a
-* notice on stderr would go.
+* @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 updateCheckOff = (env, argv, terminal) => {
-	const switched = updateSwitchOff(env);
-	if (switched !== null) return switched === "CI" ? "in CI" : "turned off";
-	if (isSwitchedOn(env["ORK_DETACHED"]) || !terminal) return "no terminal";
-	if (argv.includes("--json")) return "JSON output";
-	if (argv[0] === "upgrade") return "ork upgrade checks for itself";
-	if (argv[0] === "ui" && argv.includes("--serve")) return "ork ui's server checks for itself";
-	return null;
-};
-/** The notice's text. */
-const updateNotice = (latest, current) => `Ork ${latest} is out (you have ${current}). Upgrade with: ork upgrade`;
+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;
+};
 /**
-* Starts the background check when one is due. Records the attempt first, so
-* commands started in the next moments do not start one too.
+* 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 startUpdateCheck = (file = updateCachePath(), now = /* @__PURE__ */ new Date()) => {
-	try {
-		const cache = readUpdateCache(file);
-		if (!checkDue(cache, now)) return;
-		writeUpdateCache(file, {
-			...cache,
-			checkedAt: now.toISOString()
-		});
-		const child = spawn(process.execPath, [...process.execArgv, process.argv[1] ?? ""], {
-			detached: true,
-			stdio: "ignore",
-			env: {
-				...process.env,
-				[UPDATE_CHILD_ENV]: "1"
-			}
-		});
-		child.on("error", () => {});
-		child.unref();
-	} catch {}
+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
+	};
 };
-/** The background copy's whole job: ask the registry, record the answer. */
-const runUpdateChild = async () => {
-	const registry = registryOf(process.env);
-	await refreshUpdateCache(updateCachePath(), ORK_NAME, /* @__PURE__ */ new Date(), {
-		current: ORK_VERSION,
-		...registry === void 0 ? {} : { registry }
-	});
+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);
 };
-/** Prints the notice when a newer version is known and not told today. */
-const showUpdateNotice = (file = updateCachePath(), now = /* @__PURE__ */ new Date()) => {
-	try {
-		const cache = readUpdateCache(file);
-		const latest = pendingNotice(cache, ORK_VERSION, now);
-		if (cache === null || latest === null) return;
-		const text = updateNotice(latest, ORK_VERSION);
-		process.stderr.write(`\n${styleText("yellow", text, { stream: process.stderr })}\n`);
-		writeUpdateCache(file, {
-			...cache,
-			notified: {
-				version: latest,
-				at: now.toISOString()
+/** 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();
 			}
 		});
-	} catch {}
+		io.output.on("resize", render);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		render();
+	});
 };
-// src/update/upgrade.ts
+// src/term/select.ts
 /**
-* @file `ork doctor`'s line for Ork itself (ADR-038): the running version
-*   against the last update check, read from the record without asking the
-*   network. What `ork upgrade` does is core's (`planUpgrade`, `runInstall`),
-*   shared with the server behind `ork ui`.
+* @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.
 */
-/** `ork doctor`'s line for Ork itself, from the last check. */
-const versionCheck = (current, cache, checksOff) => {
-	const newer = newerVersion$1(cache, current);
-	if (newer !== null) return {
-		name: "ork",
-		status: "warn",
-		detail: `${current}; ${newer} is out`,
-		hint: "Run ork upgrade."
+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`);
 	};
-	return {
-		name: "ork",
-		status: "ok",
-		detail: `${current} (${cache?.latest === void 0 ? checksOff ? "update check off" : "not checked for updates yet" : `the latest as of ${cache.checkedAt.slice(0, 10)}`})`
+	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$1(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/doctor/checks.ts
+// src/human.ts
 /**
-* @file The checks behind `ork doctor`: Ork's own version against the last
-*   update check, each tool's presence and login status (the drivers' own
-*   checks, which `ork run` also reads to pick the one ready), and whether a
-*   run's socket path fits, through an injectable `exec` so tests need no real
-*   tools. Never prints a token or an account.
+* @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 TIMEOUT_MS = 15e3;
-const exec = (program, args) => new Promise((resolve) => {
-	execFile(program, args, {
-		timeout: TIMEOUT_MS,
-		encoding: "utf8"
-	}, (error, stdout) => {
-		resolve({
-			ok: error === null,
-			stdout
-		});
+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)";
+/** 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));
 	});
 });
-/** Ork's own version, against the last update check (no network). */
-const orkCheck = () => versionCheck(ORK_VERSION, readUpdateCache(updateCachePath()), updateCheckOff(process.env, [], true) !== null);
-const MIN_NODE = [24, 20];
-const checkNode = (version) => {
-	const [major = 0, minor = 0] = version.split(".").map(Number);
-	const [minMajor, minMinor] = MIN_NODE;
-	return major > minMajor || major === minMajor && minor >= minMinor ? {
-		name: "node",
-		status: "ok",
-		detail: `v${version}`
-	} : {
-		name: "node",
-		status: "fail",
-		detail: `v${version}`,
-		hint: `Ork needs Node ${MIN_NODE.join(".")} or later.`
+/**
+* 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();
+		}
 	};
 };
-const checkGit = async (run) => {
-	const version = await run("git", ["--version"]);
-	if (!version.ok) return [{
-		name: "git",
-		status: "fail",
-		detail: "not found",
-		hint: "Install git; Ork gives each writing node its own worktree."
-	}];
-	const inside = await run("git", ["rev-parse", "--is-inside-work-tree"]);
-	return [{
-		name: "git",
-		status: "ok",
-		detail: firstLine(version.stdout)
-	}, inside.ok ? {
-		name: "git repo",
-		status: "ok",
-		detail: "inside a work tree"
-	} : {
-		name: "git repo",
-		status: "warn",
-		detail: "not a git repository",
-		hint: "Run Ork inside a git repository so nodes can use worktrees."
-	}];
+// 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}` : ""}`;
 };
 /**
-* Runs every check: Node and git, then every registered Claude driver and
-* integration (ADR-022). Node, git, and at least one driver are required;
-* integrations are optional.
+* 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 runChecks = async (run, env, nodeVersion) => {
-	const [git, checked, tools] = await Promise.all([
-		checkGit(run),
-		driverChecks(run, env),
-		Promise.all(INTEGRATIONS.flatMap((i) => i.doctor === void 0 ? [] : [i.doctor(run, env)]))
-	]);
-	const drivers = checked.map(({ result }) => result);
-	const results = [
-		checkNode(nodeVersion),
-		...git,
-		...drivers,
-		...tools
-	];
-	return {
-		results,
-		ok: drivers.some((d) => d.status === "ok") && !results.some((r) => r.status === "fail")
-	};
+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;
 };
 /**
-* Whether a run's socket fits under `~` (L38). Past the limit a run can't
-* listen, and nothing else says so: answers, commands and followers fall back
-* to the store, a second at a time. `home` is the user's `~`.
+* 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 socketCheck = (home, platform) => {
-	const { bytes, max } = socketRoom(home, platform);
-	if (max === void 0 || bytes <= max) return {
-		name: "sockets",
-		status: "ok",
-		detail: max === void 0 ? "not Unix sockets here" : `${String(bytes)} of ${String(max)} bytes`
-	};
-	return {
-		name: "sockets",
-		status: "warn",
-		detail: `a run's socket path is ${String(bytes)} bytes, past the ${String(max)} this system allows`,
-		hint: "Runs still work, but answers, commands and `ork logs --follow` wait up to a second for each, as they read the store instead. A shorter home folder path fixes it."
-	};
+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
 /**
-* What it says of triggers (RFC-011): a long-lived process can die quietly, so
-* a live trigger that hasn't looked when it should have is worth saying. `home`
-* is the user's `~` (tests pass a folder).
+* @file How a finished session reads on the terminal: its report or its end,
+*   the branch, artifacts and fields, and the usage line.
 */
-const triggerChecks = (home) => {
-	const store = openStore(storePath(home));
-	try {
-		const report = triggersReport(store, store.projects(), home);
-		const broken = report.broken.map(({ file, message }) => ({
-			name: "triggers",
-			status: "warn",
-			detail: `${file}: ${message}`,
-			hint: "Its triggers are off until it can be read."
-		}));
-		const live = report.triggers.filter(({ standing }) => standing === "live");
-		if (live.length === 0) return broken;
-		const late = lateTriggers(report, /* @__PURE__ */ new Date());
-		if (late.length === 0) return [...broken, {
-			name: "ork watch",
-			status: "ok",
-			detail: `${String(live.length)} trigger(s) looking`
-		}];
-		return [...broken, {
-			name: "ork watch",
-			status: "warn",
-			detail: `not looking: ${late.map(({ trigger }) => trigger).join(", ")}`,
-			hint: report.pid === void 0 ? "Start it with `ork watch --detach`." : "See `ork watch --status`."
-		}];
-	} finally {
-		store.close();
+const STATUS_MARK = {
+	pass: {
+		mark: "✓",
+		color: "green"
+	},
+	done: {
+		mark: "✓",
+		color: "green"
+	},
+	changes_requested: {
+		mark: "!",
+		color: "yellow"
+	},
+	fail: {
+		mark: "✗",
+		color: "red"
 	}
 };
-// src/run/ready-driver.ts
+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`;
 /**
-* @file The driver a run takes for the session nodes that name none (core's
-*   `driver.ts` has the whole rule): the one `ork doctor`'s own checks find
-*   ready on this machine, said in one line. With none ready, the run stops
-*   before any session starts, with the hints `ork doctor` gives. A resumed run
-*   keeps the driver it recorded.
+* 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.
 */
-/** The real checks: the tools on this machine and its environment. */
-const checksHere = () => driverChecks(exec, process.env);
-const subject = (names, all) => {
-	if (all) return "No driver is named, so the run uses";
-	const [only] = names;
-	return names.length === 1 && only !== void 0 ? `${only} names no driver, so it uses` : `${names.join(", ")} name no driver, so they use`;
+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
 /**
-* The driver for `names`, the session nodes that name none, from `checks`.
-* `all` says whether they are every session node of the run.
+* @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 chooseReadyDriver = (names, all, checks) => {
-	const ready = readyDriver(checks);
-	if (!ready.ok) return {
-		ok: false,
-		lines: [
-			`No Claude driver is ready here, and ${names.join(", ")} ${names.length === 1 ? "names" : "name"} none.`,
-			...ready.hints,
-			"See `ork doctor`."
-		]
-	};
-	const why = ready.ready === 1 ? `the one ready here (${ready.detail})` : `more than one is ready, and a run takes ${ready.driver} first`;
-	return {
-		ok: true,
-		driver: ready.driver,
-		line: `${subject(names, all)} the ${ready.driver} driver: ${why}.`
-	};
+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}/`, "");
 };
 /**
-* What a run takes for its session nodes that name no driver: nothing when
-* `--driver` overrides them all or each names one; the driver a resumed run
-* recorded; otherwise the one ready here.
+* 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 runReadyDriver = async (workflow, options) => {
-	if (options.override !== void 0) return { ok: true };
-	const names = namingNoDriver(workflow);
-	if (names.length === 0) return { ok: true };
-	if (options.recorded !== void 0) return {
-		ok: true,
-		driver: options.recorded
-	};
-	const sessions = Object.values(workflow.nodes).filter((node) => node.type === "claude.leader" || node.type === "claude.worker").length;
-	return chooseReadyDriver(names, names.length === sessions, await (options.checks ?? checksHere)());
+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/chat.ts
 /**
@@ -994,12 +1624,11 @@ const runReadyDriver = async (workflow, options) => {
 *   where it ran, as the run's sessions were set up (ADR-065), and the exchange
 *   is added to the run's record.
 */
-/** The declared node a spawned worker (`<template>-<n>`) is an instance of. */
-const templateOf = (nodes, id) => {
-	if (id in nodes) return void 0;
-	const template = id.replace(/-\d+$/u, "");
-	return template in nodes ? template : void 0;
-};
+/**
+* The declared node a spawned worker or an item of a fanned node is an instance
+* of.
+*/
+const instanceOf = (nodes, id) => id in nodes ? void 0 : templateOf(id, new Set(Object.keys(nodes)));
 /** The run's sessions loaded the machine's Claude setup, so this one does. */
 const machineClaudeOf = (events) => events.some(({ event }) => event.type === "run.started" && event.settings?.machineClaude === true) ? { machineClaude: true } : {};
 /**
@@ -1020,7 +1649,7 @@ const resumeChat = async (options) => {
 	const notice = chatNotice(store, place, options.home);
 	if (notice !== null) options.out(notice);
 	const runDir = runDirOf(place, run.id);
-	const template = templateOf(workflow.nodes, node);
+	const template = instanceOf(workflow.nodes, node);
 	const plan = planNodeSession(workflow, node, {
 		cwd,
 		inputs: {},
@@ -1035,10 +1664,12 @@ const resumeChat = async (options) => {
 		...template === void 0 ? {} : { template }
 	});
 	if (!plan.ok) return plan.error;
+	const servers = namedMcpEntries(run.project, plan.mcp);
+	if (!servers.ok) return servers.error;
 	let driver = options.driver ?? session.driver ?? plan.driver;
 	if (driver === void 0) {
 		const ready = readyDriver(await (options.driverChecks ?? checksHere)());
-		if (!ready.ok) return ["No Claude driver is ready here.", ...ready.hints].join(" ");
+		if (!ready.ok) return ["No agent driver is ready here.", ...ready.hints].join(" ");
 		driver = ready.driver;
 	}
 	const record = appendRecorder(store, run.id, runDir);
@@ -1048,8 +1679,9 @@ const resumeChat = async (options) => {
 		body: options.body,
 		delivered: "resumed"
 	});
-	const started = (await options.runtime(driver)).start({
+	const started = (await options.runtime(driver, placeFiles(place).runs)).start({
 		...plan.spec,
+		...servers.value,
 		resume: session.sessionId,
 		prompt: options.body,
 		...machineClaudeOf(events)
@@ -1080,16 +1712,27 @@ const resumeChat = async (options) => {
 /** 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 && nodeOf(event) !== options.node) return [];
+		if (options.node !== void 0 && !isNodeEvent(event, options.node)) return [];
 		if (options.json) return [JSON.stringify(stored)];
-		return formatRunEvent(event, width, tools);
+		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`
@@ -1107,6 +1750,59 @@ const followRun = async (store, run, out, options) => {
 		...options.signal === void 0 ? {} : { signal: options.signal }
 	}) === "crashed") out(style("red", `run ${run.id} stopped without finishing (its process is gone)`));
 };
+// src/run/node-notes.ts
+/**
+* @file What a run of one node (`ork run --node`) leaves out, said before its
+*   session starts: the messages, steps and `forEach` it does not run. A node
+*   with `forEach` (RFC-013) runs once with no item when it has `items`, and is
+*   refused when it has `from`, as the node that reports its list is not run.
+*   And, after it, its run summary: how the node ended
+*   (specs/runtime/session-ends.md).
+*/
+/** A warning line, as the run prints it. */
+const noteLines = (lines) => lines.map((line) => `${style(["yellow", "bold"], "warning")} ${line}`);
+/** Why a node can't run alone, or what a run of it leaves out. */
+const oneNodeNotes = (workflow, id) => {
+	const node = workflow.nodes[id];
+	if (node === void 0) return { warnings: [] };
+	const each = "forEach" in node ? node.forEach : void 0;
+	if (each !== void 0 && "from" in each) return {
+		error: `\`${id}\` runs once for each item of ${each.from}, a list another node reports, and a run of one node does not run that node; run the whole workflow, or give it \`items\` of its own`,
+		warnings: []
+	};
+	const steps = [...beforeOf(node, workflow.defaults) === void 0 ? [] : ["before"], ..."verify" in node && node.verify !== void 0 ? ["verify"] : []];
+	return { warnings: [
+		..."notify" in node && node.notify ? [`${id}'s notify: does nothing here: a run of one node has no message bus.`] : [],
+		...each === void 0 ? [] : [`${id}'s forEach: does not fan out in a run of one node: it runs once, with no item.`],
+		...steps.map((step) => `${id}'s ${step}: does not run in a run of one node.`)
+	] };
+};
+/** The `node.finished` fields that say how it ended: its error and its end. */
+const endedFields = (result) => ({
+	...result.error === void 0 ? {} : { error: result.error },
+	end: endOf(result)
+});
+/** The one-node run's result, its reason the node's message. */
+const oneNodeResult = (runId, id, result, ok) => {
+	const costUsd = result.usage?.costUsd ?? 0;
+	return {
+		runId,
+		status: ok ? "succeeded" : "failed",
+		costUsd,
+		nodes: [{
+			id,
+			runs: 1,
+			ok: result.ok,
+			output: result.output,
+			costUsd,
+			...endedFields(result)
+		}],
+		reasons: result.error === void 0 ? [] : [`${id}: ${result.error}`],
+		worktrees: [],
+		skipped: 0,
+		failuresHandled: 0
+	};
+};
 // src/run/origin.ts
 /**
 * @file Where a run's feedback comes from, beyond what its events say: Ork's
@@ -1114,6 +1810,8 @@ const followRun = async (store, run, out, options) => {
 *   content hash.
 */
 /** Ork's version and the workflow's hash, for the run's feedback records. */
+/** The Ork version a run records in `run.started` and `run.resumed`. */
+const ORK_RUN_VERSION = ORK_VERSION;
 const feedbackOrigin = (workflowFile) => {
 	const origin = { version: ORK_VERSION };
 	try {
@@ -1147,6 +1845,8 @@ const runNode = async (options) => {
 	if (!pairs.ok) return failed([`--input: ${pairs.error}`]);
 	const inputs = resolveInputs(workflow, pairs.raw);
 	if (!inputs.ok) return failed(inputs.errors);
+	const notes = oneNodeNotes(workflow, options.nodeId);
+	if (notes.error !== void 0) return failed([notes.error]);
 	const limits = runLimits(options.store, place, options.home);
 	const refused = limitsRefusal(limits, workflow);
 	if (refused.length > 0) return failed(refused);
@@ -1166,6 +1866,8 @@ const runNode = async (options) => {
 		pluginDir: path.join(runDir, "plugins", options.nodeId)
 	});
 	if (!plan.ok) return failed([plan.error]);
+	const servers = namedMcpEntries(projectRoot, plan.mcp);
+	if (!servers.ok) return failed([servers.error]);
 	const named = sessionDriver({
 		override: options.driver,
 		named: plan.driver
@@ -1174,12 +1876,13 @@ const runNode = async (options) => {
 	if (ready?.ok === false) return failed(ready.lines);
 	if (ready?.line !== void 0) options.err(ready.line);
 	const driver = named ?? ready?.driver;
-	if (driver === void 0) return failed(["No Claude driver is ready here."]);
-	const planned = workflow.nodes[options.nodeId];
-	if (planned !== void 0 && "notify" in planned && planned.notify) options.err(`${style(["yellow", "bold"], "warning")} ${options.nodeId}'s notify: does nothing here: a run of one node has no message bus.`);
-	const skipped = planned === void 0 ? [] : [...beforeOf(planned, workflow.defaults) === void 0 ? [] : ["before"], ..."verify" in planned && planned.verify !== void 0 ? ["verify"] : []];
-	for (const step of skipped) options.err(`${style(["yellow", "bold"], "warning")} ${options.nodeId}'s ${step}: does not run in a run of one node.`);
-	for (const warning of plan.warnings) options.err(`${style(["yellow", "bold"], "warning")} ${warning}`);
+	if (driver === void 0) return failed(["No agent driver is ready here."]);
+	const unfit = unfitLines(workflow, options.drivers, {
+		override: driver,
+		only: options.nodeId
+	});
+	if (unfit.length > 0) return failed(unfit);
+	for (const line of noteLines([...notes.warnings, ...plan.warnings])) options.err(line);
 	const id = options.nodeId;
 	const recorder = createRecorder(options.store, {
 		id: runId,
@@ -1213,10 +1916,11 @@ const runNode = async (options) => {
 		...options.home === void 0 ? {} : { home: options.home }
 	});
 	const signals = createSignals(feedbackOrigin(path.resolve(options.cwd, options.file)));
+	const view = createView();
 	const record = (raw) => {
 		for (const event of signals(raw)) {
 			control.publish(recorder(event));
-			if (event.type === "feedback.recorded" && !options.json) for (const line of formatRunEvent(event, id.length, /* @__PURE__ */ new Map())) options.out(line);
+			if (event.type === "feedback.recorded" && !options.json) for (const line of formatRunEvent(event, id.length, /* @__PURE__ */ new Map(), false, options.verbose, view)) options.out(line);
 		}
 	};
 	const nodeType = workflow.nodes[id]?.type ?? "claude.worker";
@@ -1237,9 +1941,12 @@ const runNode = async (options) => {
 		nodeType,
 		round: 1
 	});
-	const runtime = await options.runtime(driver);
+	const runtime = await options.runtime(driver, placeFiles(place).runs);
 	if (options.machineClaude === true) plan.spec.machineClaude = true;
-	const session = runtime.start(plan.spec, {
+	const session = runtime.start({
+		...plan.spec,
+		...servers.value
+	}, {
 		human: control.human,
 		...graph === null ? {} : { feedback: createFeedback({
 			graph,
@@ -1258,10 +1965,9 @@ const runNode = async (options) => {
 		});
 		if (event.type === "session.finished") outcome = event.outcome;
 		if (options.json) options.out(JSON.stringify(event));
-		else for (const line of formatEvent(options.nodeId, event, tools)) options.out(line);
+		else for (const line of formatEvent(options.nodeId, event, tools, options.verbose, view)) options.out(line);
 	}
 	const result = resultOf(outcome);
-	const costUsd = result.usage?.costUsd ?? 0;
 	record({
 		type: "node.finished",
 		id,
@@ -1269,27 +1975,11 @@ const runNode = async (options) => {
 		ok: result.ok,
 		output: result.output,
 		...result.usage === void 0 ? {} : { usage: result.usage },
-		...result.error === void 0 ? {} : { error: result.error }
+		...endedFields(result)
 	});
 	record({
 		type: "run.finished",
-		result: {
-			runId,
-			status: succeeded(outcome) ? "succeeded" : "failed",
-			costUsd,
-			nodes: [{
-				id,
-				runs: 1,
-				ok: result.ok,
-				output: result.output,
-				costUsd,
-				...result.error === void 0 ? {} : { error: result.error }
-			}],
-			reasons: result.error === void 0 ? [] : [`${id}: ${result.error}`],
-			worktrees: [],
-			skipped: 0,
-			failuresHandled: 0
-		}
+		result: oneNodeResult(runId, id, result, succeeded(outcome))
 	});
 	await control.close();
 	return {
@@ -1498,6 +2188,14 @@ const preflight = async (options, given) => {
 		lines: driver.lines
 	};
 	if (driver.line !== void 0) options.err(driver.line);
+	const unfit = unfitLines(given.effective, options.drivers, {
+		override: options.driver,
+		ready: driver.driver ?? options.resume?.settings.readyDriver
+	});
+	if (unfit.length > 0) return {
+		ok: false,
+		lines: unfit
+	};
 	const checkout = await prepareCheckout(workflow, {
 		...options,
 		cwd: place.root
@@ -1569,6 +2267,7 @@ const runWorkflowFile = async (options) => {
 	}, runDir) : appendRecorder(options.store, runId, runDir);
 	const width = Math.max(...Object.keys(workflow.nodes).map((id) => id.length));
 	const tools = /* @__PURE__ */ new Map();
+	const view = createView();
 	const started = Promise.withResolvers();
 	const live = {};
 	const control = await startControl({
@@ -1588,7 +2287,7 @@ const runWorkflowFile = async (options) => {
 		for (const event of signals(raw)) {
 			control.publish(record(event));
 			if (options.json) options.out(JSON.stringify(event));
-			else for (const line of formatRunEvent(event, width, tools)) options.out(line);
+			else for (const line of formatRunEvent(event, width, tools, options.human !== void 0, options.verbose, view)) options.out(line);
 		}
 	};
 	const workspace = root === void 0 ? void 0 : createWorkspace({
@@ -1605,7 +2304,7 @@ const runWorkflowFile = async (options) => {
 	});
 	const maskedNames = maskedNamesOfRun(workflow, place, projects);
 	const executorOptions = {
-		runtimeFor: options.runtime,
+		runtimeFor: (driver) => options.runtime(driver, placeFiles(place).runs),
 		inPlace: options.inPlace,
 		maskedNames
 	};
@@ -1614,10 +2313,11 @@ const runWorkflowFile = async (options) => {
 	if (options.tools !== void 0) executorOptions.tools = options.tools;
 	const script = process.argv[1];
 	if (script !== void 0 && onPath(script)) executorOptions.orkBin = script;
-	const replay = options.resume === void 0 ? void 0 : createReplay(options.resume.history, options.resume.cutOff, options.resume.mail, options.resume.earlier);
+	const replay = options.resume === void 0 ? void 0 : createReplay(options.resume.history, options.resume.cutOff, options.resume.mail, options.resume.earlier, options.resume.fanOuts);
 	if (replay !== void 0) onEvent({
 		type: "run.resumed",
-		kept: replay.kept()
+		kept: replay.kept(),
+		ork: ORK_RUN_VERSION
 	});
 	const ports = callPorts({
 		...options,
@@ -1639,6 +2339,7 @@ const runWorkflowFile = async (options) => {
 		executors: builtinExecutors(executorOptions),
 		human: options.resume === void 0 ? control.human : replayLoopAnswers(control.human, options.resume.loopAnswers),
 		onEvent,
+		orkVersion: ORK_RUN_VERSION,
 		settings: {
 			inPlace: options.inPlace,
 			...options.driver === void 0 ? {} : { driver: options.driver },
@@ -1653,6 +2354,10 @@ const runWorkflowFile = async (options) => {
 		...workspace === void 0 ? {} : { workspace },
 		scrub: runScrubber(maskedNames, process.env),
 		limits: ready.limits,
+		machine: {
+			rules: machineRulesOf(loadProject(place.root, placeFiles(place).rules).project),
+			ledger: machineSlotLedger(options.home === void 0 ? {} : { home: options.home })
+		},
 		beforeFinish: takeLastCommands(control, started.promise)
 	});
 	live.handle = handle;
@@ -1683,9 +2388,11 @@ const flagValues = (rawArgs, flag) => {
 	}
 	return values;
 };
-const isDriver = (value) => CLAUDE_DRIVERS.some((d) => d.id === value);
+const isDriver = (value) => AGENT_DRIVERS.some((d) => d.id === value);
+/** Why `--driver` refuses a value: a retired id names its replacement. */
+const badDriver = (value) => `--${retiredDriverHint(value) ?? `driver must be one of ${AGENT_DRIVERS.map((d) => d.id).join(", ")}, got \`${value}\``}`;
 /** Loads the drivers only when a run starts, so other commands stay fast. */
-const loadRuntime = async (driver) => (await import("./src-B9v0lDc6.mjs")).createRuntime(driver, sessionEnv(process.env));
+const loadRuntime = async (driver, runs) => (await import("./src-BnZgZGrf.mjs")).createRuntime(driver, sessionEnv(process.env), runs);
 /**
 * Ctrl-C asks the run to stop, and so does a terminal closing or a polite kill,
 * so that the run ends tidily and leaves no result unscrubbed.
@@ -1703,11 +2410,18 @@ const onInterrupt = (stop) => {
 	process.once("SIGHUP", interrupt);
 };
 /** The terminal that answers a run's questions; none in a detached run. */
-const terminalHuman = () => process.env["ORK_DETACHED"] === "1" ? void 0 : createTerminalHuman({
-	input: process.stdin,
-	output: process.stderr,
-	interactive: process.stdin.isTTY
-});
+const terminalHuman = () => {
+	const detached = process.env[DETACHED_ENV] === "1";
+	if (detached) writeErr(style("dim", "detached run: no terminal asks; answer with ork decide"));
+	return detached ? void 0 : createTerminalHuman({
+		input: process.stdin,
+		output: process.stderr,
+		interactive: process.stdin.isTTY,
+		interrupt: () => {
+			process.kill(process.pid, "SIGINT");
+		}
+	});
+};
 const run = defineCommand({
 	meta: {
 		name: "run",
@@ -1729,7 +2443,7 @@ const run = defineCommand({
 		},
 		driver: {
 			type: "string",
-			description: "sdk (API key or cloud provider) or cli (your claude login)"
+			description: "claude-code (default: the driver ready here)"
 		},
 		"in-place": {
 			type: "boolean",
@@ -1751,6 +2465,11 @@ const run = defineCommand({
 			description: "Print the events as JSON lines",
 			default: false
 		},
+		verbose: {
+			type: "boolean",
+			description: "Show each tool call whole, and why each failed node stopped, with its scrubbed details",
+			default: false
+		},
 		detach: {
 			type: "boolean",
 			description: "Run in the background; follow it with ork logs -f, answer with ork decide",
@@ -1787,7 +2506,7 @@ const run = defineCommand({
 	},
 	run: async ({ args, rawArgs }) => {
 		if (args.driver !== void 0 && !isDriver(args.driver)) {
-			writeErr(`--driver must be ${CLAUDE_DRIVERS.map((d) => d.id).join(" or ")}, got \`${args.driver}\``);
+			writeErr(badDriver(args.driver));
 			process.exitCode = 1;
 			return;
 		}
@@ -1832,6 +2551,7 @@ const run = defineCommand({
 			inPlace: args["in-place"],
 			...args["machine-claude"] ? { machineClaude: true } : {},
 			json: args.json,
+			verbose: args.verbose,
 			runtime: loadRuntime,
 			store,
 			...human === void 0 ? {} : { human },
@@ -1877,22 +2597,25 @@ const run = defineCommand({
 *   each message at its session's next step, and its replies stream here; a
 *   node of a finished run is answered by resuming its last session.
 */
-/** Asks for one line; `null` once the input ends (Ctrl-D). */
-const askLine = async () => {
-	const rl = createInterface({
+/**
+* Asks for one line; `null` once the input ends (Ctrl-D), Esc leaves, or
+* `signal` withdraws it. A live chat prints replies while it waits, which a
+* redrawn prompt can't share the screen with, so it asks line by line.
+*/
+const askLine = async (live = false, signal) => {
+	const asked = await readText({
 		input: process.stdin,
-		output: process.stdout
-	});
-	const closed = new Promise((resolve) => {
-		rl.once("close", () => {
-			resolve(null);
-		});
-	});
-	try {
-		return await Promise.race([rl.question(style("bold", "you › ")), closed]);
-	} finally {
-		rl.close();
-	}
+		output: process.stdout,
+		...live ? { env: {
+			...process.env,
+			ORK_PLAIN: "1"
+		} } : {}
+	}, {
+		message: "you",
+		done: (value) => ` you › ${value ?? ""}`,
+		...signal === void 0 ? {} : { signal }
+	}).catch(() => ({ kind: "cancelled" }));
+	return asked.kind === "text" ? asked.value : null;
 };
 /** Chats with a node of a live run until the input ends or the run does. */
 const chatLive = async (store, run, node, message) => {
@@ -1914,7 +2637,7 @@ const chatLive = async (store, run, node, message) => {
 		abort.abort();
 	});
 	for (;;) {
-		const line = await Promise.race([askLine(), following.then(() => null)]);
+		const line = await Promise.race([askLine(true, abort.signal), following.then(() => null)]);
 		if (line === null || abort.signal.aborted) break;
 		if (line.trim() !== "") await tellLiveRun(store, run, node, line);
 	}
@@ -1945,7 +2668,7 @@ const chat = defineCommand({
 		},
 		driver: {
 			type: "string",
-			description: "For a finished run: sdk or cli (default: the one it ran with)"
+			description: "For a finished run: claude-code (default: the one it ran with)"
 		}
 	},
 	run: async ({ args }) => {
@@ -1971,7 +2694,7 @@ const chat = defineCommand({
 				return;
 			}
 			if (args.driver !== void 0 && !isDriver(args.driver)) {
-				writeErr(`--driver must be sdk or cli, not \`${args.driver}\`.`);
+				writeErr(`${badDriver(args.driver)}.`);
 				process.exitCode = 1;
 				return;
 			}
@@ -2010,13 +2733,35 @@ const chat = defineCommand({
 		}
 	}
 });
+// src/commands/decide-list.ts
+/**
+* One line per open decision, for `--list`: on a terminal an ASK chip and the
+* node's chip with the id and the question after, cut to the screen; plain, the
+* id, the node and the question.
+*/
+const formatDecisions = (decisions, workflow, t = termOf(process.stdout)) => {
+	if (decisions.length === 0) return [workflow === void 0 ? "No open decisions." : `No open decisions in workflow ${workflow}.`];
+	const idWidth = Math.max(...decisions.map((d) => d.id.length));
+	const nodeWidth = Math.max(...decisions.map((d) => plain(d.node).length));
+	return decisions.map((d) => {
+		const node = plain(d.node);
+		const options = `[${d.options.map((o) => o.id === d.recommended ? `${o.id}*` : o.id).join(", ")}]`;
+		const document = d.document === void 0 ? "" : " +document";
+		const via = d.owner === void 0 ? "" : ` via ${plain(d.owner)}`;
+		if (!t.rich) return `${d.id}  ${node}${via}  ${plain(d.question)}${document} ${options}`;
+		const lead = `${chip(t, CHIP_LABELS.ask, "accent")} ${nodeChip(t, node)}${" ".repeat(nodeWidth - node.length)} ${bold(t, d.id.padEnd(idWidth))}  `;
+		const room = Math.max(20, t.width - (7 + nodeWidth + 2 + idWidth + 2));
+		return `${lead}${cut(`${plain(d.question)}${document} ${options}${via}`, room)}`;
+	});
+};
 // src/commands/decide.ts
 /**
 * @file `ork decide`: answer a live run's open decisions from any terminal (it
 *   writes to the store, then wakes the run on its socket; specs/messaging.md).
 *   `--say` gives the answer a note, which goes to the run with it. With `--id`
 *   and `--choose`, `--note` and `--rating` instead note how the decision's
-*   node went, as the run's feedback (specs/feedback.md).
+*   node went, as the run's feedback (specs/feedback.md). `--document` prints
+*   what a gate gave to read beside its question.
 */
 const failed$2 = (message) => {
 	writeErr(message);
@@ -2054,8 +2799,6 @@ const saidLine = (store, id) => {
 	const note = store.decision(id)?.note;
 	return note === void 0 ? "" : style("dim", ` · said: ${note}`);
 };
-/** One line per open decision, for `--list`. */
-const formatDecisions = (decisions) => decisions.length === 0 ? ["No open decisions."] : decisions.map((d) => `${style("bold", d.id)}  ${style("cyan", d.node)}${d.owner === void 0 ? "" : style("dim", ` via ${d.owner}`)}  ${d.question} ${style("dim", `[${d.options.map((o) => o.id === d.recommended ? `${o.id}*` : o.id).join(", ")}]`)}`);
 const decide = defineCommand({
 	meta: {
 		name: "decide",
@@ -2082,6 +2825,15 @@ const decide = defineCommand({
 			description: "List them as JSON",
 			default: false
 		},
+		workflow: {
+			type: "string",
+			description: "Only the decisions of this workflow's runs"
+		},
+		document: {
+			type: "boolean",
+			description: "Print the document of the decision --id names",
+			default: false
+		},
 		id: {
 			type: "string",
 			description: "Answer this decision…"
@@ -2101,10 +2853,15 @@ const decide = defineCommand({
 		rating: {
 			type: "string",
 			description: "…rating it good or bad"
+		},
+		verbose: {
+			type: "boolean",
+			description: "Show each question's whole context, not its first lines",
+			default: false
 		}
 	},
 	run: async ({ args }) => {
-		const refusal = args.id !== void 0 || args.choose !== void 0 || process.stdin.isTTY && !args.list && !args.json ? decideRefusal() : null;
+		const refusal = !args.document && (args.id !== void 0 || args.choose !== void 0 || process.stdin.isTTY && !args.list && !args.json) ? decideRefusal() : null;
 		if (refusal !== null) {
 			failed$2(refusal);
 			return;
@@ -2113,9 +2870,20 @@ const decide = defineCommand({
 		const human = createTerminalHuman({
 			input: process.stdin,
 			output: process.stdout,
-			interactive: process.stdin.isTTY
+			interactive: process.stdin.isTTY,
+			verbose: args.verbose
 		});
 		try {
+			if (args.document) {
+				if (args.id === void 0 || args.choose !== void 0) {
+					failed$2("--document goes with --id, without --choose.");
+					return;
+				}
+				const { document } = store.decision(args.id) ?? {};
+				if (document === void 0) failed$2(`${args.id} has no document.`);
+				else write(document);
+				return;
+			}
 			if (args.id !== void 0 || args.choose !== void 0) {
 				if (args.id === void 0 || args.choose === void 0) {
 					failed$2("--id and --choose go together.");
@@ -2143,10 +2911,11 @@ const decide = defineCommand({
 				return;
 			}
 			if (args.say !== void 0) {
-				failed$2("--say goes with --id and --choose; answering here asks for a note after each choice.");
+				failed$2("--say goes with --id and --choose; answering here, press n to add a note (plain: it asks for one after each choice).");
 				return;
 			}
 			const filter = {};
+			if (args.workflow !== void 0) filter.workflow = args.workflow;
 			if (args.run !== void 0 && args.run !== "") {
 				const found = findRun(store, args.run, process.cwd());
 				if (!found.ok) {
@@ -2161,11 +2930,11 @@ const decide = defineCommand({
 				return;
 			}
 			if (args.list || !process.stdin.isTTY || open.length === 0) {
-				for (const line of formatDecisions(open)) write(line);
+				for (const line of formatDecisions(open, args.workflow)) write(line);
 				return;
 			}
-			for (const d of open) {
-				write(style("dim", `run ${d.runId} · decision ${d.id}`));
+			const collapses = canKey(process.stdin, process.stdout);
+			for (const [index, d] of open.entries()) {
 				const question = {
 					nodeId: d.node,
 					question: d.question,
@@ -2173,13 +2942,21 @@ const decide = defineCommand({
 				};
 				if (d.recommended !== void 0) question.recommended = d.recommended;
 				if (d.context !== void 0) question.context = d.context;
+				if (d.document !== void 0) question.document = d.document;
 				let note;
 				question.onNote = (given) => {
 					note = given;
 				};
-				const choice = await human.ask(question);
+				const choice = await human.askAt(question, {
+					run: d.runId,
+					decision: d.id,
+					index: index + 1,
+					total: open.length
+				});
+				if (choice === null) continue;
 				const answered = await answerDecision(store, d.id, choice, void 0, "decide", note);
-				write(answered.ok ? `${style("green", "✓")} ${d.id}: ${choice}${saidLine(store, d.id)}\n` : `${style("yellow", "!")} ${answered.error}\n`);
+				if (!answered.ok) write(`${style("yellow", "!")} ${answered.error}\n`);
+				else if (!collapses) write(`${style("green", "✓")} ${d.id}: ${choice}${saidLine(store, d.id)}\n`);
 			}
 		} finally {
 			human?.close();
@@ -2264,7 +3041,7 @@ const resume = defineCommand({
 		},
 		driver: {
 			type: "string",
-			description: "sdk or cli (default: the one the run used)"
+			description: "claude-code (default: the one the run used)"
 		},
 		"in-place": {
 			type: "boolean",
@@ -2288,7 +3065,7 @@ const resume = defineCommand({
 	},
 	run: async ({ args, rawArgs }) => {
 		if (args.driver !== void 0 && !isDriver(args.driver)) {
-			failed$1(`--driver must be sdk or cli, got \`${args.driver}\``);
+			failed$1(badDriver(args.driver));
 			return;
 		}
 		const store = openStore();
@@ -2339,6 +3116,76 @@ const resume = defineCommand({
 		}
 	}
 });
+// src/doctor/format.ts
+/** Marks are made when used, so `--plain` (set after load) is read. */
+const MARK = {
+	ok: () => style("green", "✓"),
+	warn: () => style("yellow", "!"),
+	fail: () => style("red", "✗"),
+	skip: () => style("dim", "-")
+};
+const CHECK_CHIP = {
+	ok: {
+		label: CHIP_LABELS.ok,
+		role: "ok"
+	},
+	warn: {
+		label: CHIP_LABELS.warn,
+		role: "warn"
+	},
+	fail: {
+		label: CHIP_LABELS.fail,
+		role: "danger"
+	},
+	skip: {
+		label: CHIP_LABELS.skip,
+		role: "muted"
+	}
+};
+/**
+* A check's lines. Rich: a chip (its words padded to line the details up), the
+* detail wrapped under its column, the hint dimmed and indented; plain: a mark
+* and the lines as they always were.
+*/
+const formatCheck = (result, term = termOf(process.stdout)) => {
+	if (!term.rich) {
+		const line = `${MARK[result.status]()} ${result.name.padEnd(20)} ${result.detail}`;
+		return result.hint === void 0 ? [line] : [line, `  ${style("dim", result.hint)}`];
+	}
+	const { label, role } = CHECK_CHIP[result.status];
+	const lead = `${chip(term, label.padEnd(4), role)} ${result.name.padEnd(20)} `;
+	return [...hang(lead, result.detail, term.width), ...result.hint === void 0 ? [] : wrap(result.hint, term.width - 2).map((line) => `  ${paint(term, "muted", line)}`)];
+};
+// src/doctor/lease-checks.ts
+/**
+* @file What `ork doctor` says of Command Code leases (RFC-014): it removes the
+*   `ork` MCP entries a crashed session left in its checkout's local scope, and
+*   says where. Never prints a token.
+*/
+/**
+* Removes the `ork` MCP entries a crashed Command Code session left in its
+* checkout's local scope (RFC-014), from the leases in the project's runs
+* folder. Says nothing when there were none. `bin` is the `cmd` program.
+*/
+const leaseChecks = async (place, env = process.env, bin = "cmd") => {
+	const { cleanStaleLeases, leaseLedger } = await import("./src-BnZgZGrf.mjs");
+	const { cleaned, failed } = await cleanStaleLeases({
+		bin,
+		ledger: leaseLedger(placeFiles(place).runs),
+		env
+	});
+	const name = "command-code";
+	return [...cleaned.length === 0 ? [] : [{
+		name,
+		status: "ok",
+		detail: `removed the \`ork\` MCP entry a stopped session left in ${cleaned.join(", ")}`
+	}], ...failed.length === 0 ? [] : [{
+		name,
+		status: "warn",
+		detail: `could not remove the \`ork\` MCP entry a stopped session left in ${failed.join(", ")}`,
+		hint: "Run `cmd mcp remove --scope local ork` in each of those folders."
+	}]];
+};
 // src/project/ork-skills.ts
 /**
 * @file The Claude Code plugin's skills (`plugins/ork/skills/`) as text, by
@@ -2349,8 +3196,8 @@ const resume = defineCommand({
 const ORK_SKILLS = {
 	principles: "---\nname: principles\ndescription: Use when deciding how to split work into an Ork workflow - which steps are programs, which are Claude sessions, where a person decides - so it costs less than doing it by hand and can't go wrong quietly.\n---\n\n# How Ork splits work\n\nOrk exists to do long jobs for less than doing them by hand, and safely. Four\nrules decide the shape of a workflow.\n\n## 1. A program for what a program can do\n\nA model turn is for judgment. Anything a program can decide, it should: run the\ntests, read a pull request's state, count what changed, wait for CI.\n\n- **A tool node** (`tool.shell`, `tool.git`, `tool.gh`, `tool.aws`) or an\n  **`mcp.call`** does it with no session. With `output: { format: json }`, its\n  answer routes the run: `when: \"json.state == 'OPEN'\"`.\n- **`verify:`** on a session runs a check before its report counts, so a session\n  can't claim success past failing tests. **`before:`** hands it what a program\n  found, so it doesn't spend turns finding it.\n- **`watch:`** waits on CI or a review with a program that looks every few\n  seconds; hours of waiting cost nothing.\n- **`notify:`** lets a program tell a running session what it found, with no\n  model turn to carry the news.\n\n## 2. Spend where it pays\n\n- A small model and low effort for a narrow task (`model: haiku`,\n  `effort: low`); the large ones where thinking pays.\n- `budgetUsd` on each session and on the run (`limits.budgetUsd`). A loop of\n  sessions without a budget or `limits.timeout` gets a warning, for good reason.\n- Give a session what it needs in its `prompt` and `before:`, rather than\n  letting it search; and `isolation: readonly` for a reviewer that only reads.\n\n## 3. Make a mistake impossible before checking for it\n\n- Declare what a node says: `output.schema` lists on tool JSON and Claude\n  reports (`verdict: [approve, escalate]`). Conditions then compare against a\n  closed list, and a run fails a value off it rather than matching nothing.\n- A verdict is a declared field, never words to search a summary for.\n- Give each condition its opposite, and each failure a handler (`when: \"!ok\"`).\n- Check every draft with Ork's `check` tool until it's clean.\n\n## 4. A person decides what can't be undone\n\nMerging, deploying, publishing, spending a lot: put a `human.gate` before it,\nwith the safe option `recommended`. For a run nobody watches, give it a\n`timeout` and the safe `default`. You never answer a gate yourself.\n\n## An example\n\nA review that a program checks first, and a person signs off:\n\n```yaml\nschemaVersion: 1\nname: careful-review\ndescription: Lint with a program, review with a small model, and ask before merging.\ninputs:\n  pr:\n    type: string\n    required: true\nlimits:\n  budgetUsd: 3\nnodes:\n  lint:\n    type: tool.shell\n    command: pnpm lint\n    allow: [pnpm lint]\n  review:\n    type: claude.worker\n    prompt: \"Review pull request {{inputs.pr}}. The linter passed.\"\n    model: haiku\n    effort: low\n    isolation: readonly\n    budgetUsd: 1\n    output:\n      schema:\n        verdict: [approve, escalate]\n  ask:\n    type: human.gate\n    question: \"Merge pull request {{inputs.pr}}? The review says {{nodes.review.output.verdict}}.\"\n    options: [merge, wait]\n    recommended: wait\n  merge:\n    type: tool.gh\n    command: pr merge {{inputs.pr}} --squash\n    allow: [pr merge]\nedges:\n  - lint -> review\n  - review -> ask\n  - from: ask\n    to: merge\n    when: \"choice == 'merge'\"\n```\n\n`lint` costs nothing, `review` is a small model with a cap, and nothing merges\nwithout a person.\n",
 	run: "---\nname: run\ndescription: Use when starting, following or explaining an Ork run - what it's doing, why it failed, what it cost, and what waits on the person - and when the person asks about their Ork runs.\n---\n\n# Running and following Ork workflows\n\nOrk runs workflows on the person's machine with their accounts, so a run spends\ntheir money and can push, merge or deploy. Start one only when they ask, and\nnever answer a decision for them.\n\n## Starting\n\n1. Find it: Ork's `workflows` tool gives each workflow's name and inputs.\n2. Check it first with `check` (`workflow: <name>`). Don't start one with an\n   error.\n3. Start it with `start_run`, giving every required input. Claude Code asks the\n   person first, unless they've allowed it. It answers with the run's id; the run goes on in the\n   background, whatever happens to this conversation.\n\nWithout Ork's tools: `ork run <workflow> --detach --input name=value`.\n\n## Following\n\n- `run` gives a run's status, what it waits on, its cost so far, and each\n  node's state. `runs` lists the newest runs.\n- `run_events` gives its newest events; `node` narrows them, and `last` or\n  `after` widens them. A `node.finished` event with `ok: false` says why a node\n  failed.\n- `explain_context` says what a node's session was given: its agent,\n  instructions, skills and files. Use it when a node didn't know something.\n- `usage` says what runs spent, by workflow and model, and how close the limits\n  are.\n\nSay what you found plainly: which node, what it said, and what it cost. Quote a\nnode's own words rather than retelling them.\n\n## What only the person does\n\n- **Decisions.** `decisions` lists the questions waiting on them: a gate, a loop\n  that ran out of rounds, a permission. Tell them what each asks, the options,\n  and the recommended one, and that they answer in `ork ui` or with\n  `ork decide` in their own terminal. Don't answer one: never run\n  `ork decide --id … --choose …`; with Ork's plugin, a hook stops it.\n- **Stopping, pausing, resuming.** Tell them the command: `ork stop <run>`,\n  `ork pause <run>`, `ork continue <run>`, `ork resume <run>`. A node can be\n  stopped alone with `--node <id>`.\n\n## Without Ork's tools\n\n| Want                   | Command                        |\n| ---------------------- | ------------------------------ |\n| Runs, newest first     | `ork ps`                       |\n| A run's transcript     | `ork logs <run>` (`--follow`)  |\n| Its nodes and cost     | `ork tree <run>`               |\n| What runs spent        | `ork usage`                    |\n| What waits on a person | `ork decide --list`            |\n| A node's context       | `ork context explain <wf> <n>` |\n",
-	setup: "---\nname: setup\ndescription: Use when the person asks you to set up Ork, install it, or get started with it in a repository - checking it's installed, setting up the project, making Ork's tools available to you, and a first workflow.\n---\n\n# Setting up Ork\n\nOrk runs workflows on the person's machine with their own accounts. Setting it\nup changes their machine and their repository, so say what each step does and\nask before it. Work through these in order, and stop where they say no.\n\n## 1. Check\n\n```sh\nork --version\nork doctor\n```\n\n- **No `ork`:** it needs Node 24.20 or later (`node --version`). The install is\n  `npm install --global @krapht/ork`; show it and run it only when they say\n  yes. The guide:\n  https://github.com/mimshins/ork/blob/main/docs/getting-started/installation.md\n- **Read `ork doctor` to them.** It needs git, a git repository with a commit,\n  and one Claude driver. Don't run `git init` or a commit without asking.\n- **A driver not ready:** they log in themselves, with `claude` (the CLI\n  driver), or by setting `ANTHROPIC_API_KEY` or a cloud provider in their own\n  shell (the SDK driver). Never ask for a key, never take one pasted to you, and\n  never write one into a file or a command. `gh` and `aws` are optional, and\n  their logins are their own too (`gh auth login`, `aws sso login`).\n\n## 2. The project\n\n- **`ork init`** keeps Ork's files in the repository, in `.ork/`, committed with\n  the code. It adds `.ork/runs/` to `.gitignore`, links `.claude/` and similar\n  folders to `.ork/`, and writes a starter workflow, `hello`.\n- **`ork register`** keeps them beside it, in `~/.ork/projects/<id>/`, and\n  writes nothing into the repository. For a repository whose process isn't\n  theirs to change, or to try Ork first.\n\nExplain both and ask which. Skip the question when the repository decides it: a\n`.ork/` folder means `ork init` has run (`ork projects` lists what's\nregistered). Neither overwrites a file.\n\n## 3. Make Ork available to you\n\nIf Ork's tools (`workflows`, `check`) already answer you, skip this. Otherwise,\nby where you run, and asking before each change to a config:\n\n- **Claude Code:** Ork's plugin brings the skills and the tools. The person\n  types these themselves:\n\n  ```\n  /plugin marketplace add mimshins/ork\n  /plugin install ork@ork\n  ```\n\n  Or, in a project set up with `ork init`, the skills in the repository for\n  everyone who clones it, then the tools:\n\n  ```sh\n  ork init --skills\n  claude mcp add ork -- ork mcp\n  ```\n\n  New tools start when they restart Claude Code or reconnect `ork` in `/mcp`;\n  so does the plugin's, once `ork` is installed.\n\n- **Another MCP client:** add a server named `ork` with command `ork` and args\n  `[\"mcp\"]` to its MCP config, where its own docs say. Its tools find the\n  project by its id, from `ork projects`.\n- **A shell only:** use the CLI. `ork --help` and each command's `--help` say\n  what it takes.\n\n## 4. A first workflow\n\nOffer to write one for a task they name. Follow `/ork:write`, check each draft\n(the `check` tool, or `ork validate <file>`) until it has no error, then save\nit. Don't start it: a run spends their money. Start it only when they say so,\nin the background with its inputs (`start_run`, or\n`ork run <name> --detach --input name=value`), and follow it with `/ork:run`.\n\n## 5. Show them `ork ui`\n\nTell them to run `ork ui` in their own terminal: their runs, graphs and logs in\nthe browser, and where they answer what a run asks.\n\n## Never\n\n- Ask for, store or pass on a password, key or token.\n- Answer a run's decision: they answer in `ork ui` or with `ork decide` in\n  their own terminal.\n- Install, edit a config, or start a run without a yes.\n",
-	write: "---\nname: write\ndescription: Use when writing or changing an Ork workflow (a `.ork/workflows/*.ork.yaml` file) - its nodes, edges, conditions and loops - and checking each draft until Ork accepts it.\n---\n\n# Writing an Ork workflow\n\nAn Ork workflow is one YAML file in the project, `.ork/workflows/<name>.ork.yaml`.\nIt names the nodes (Claude sessions, programs, a person's decisions) and the\nedges that carry work between them. Ork runs it on the person's machine with\ntheir own accounts.\n\n## How to work\n\n1. **Look first.** Ork's `workflows` tool lists the project's workflows; read\n   one that's close. `agents` lists the agents a node can use. Before you split\n   the work, read `/ork:principles`: a program where a program will do, a\n   session only for judgment.\n2. **Don't guess a field.** `workflow_format` gives the format; ask it for one\n   node type (`nodeType: \"human.gate\"`) to see that type's fields.\n3. **Check every draft** with Ork's `check` tool (`text`, or `workflow` for a\n   file), and fix what it says until it has no error. Read its warnings: they\n   mean something. Without Ork's tools, run `ork validate <file>`.\n4. **Then save the file**, beginning with the schema line below, so editors can\n   check it too.\n\n## The shape of a file\n\n```yaml\n# yaml-language-server: $schema=https://raw.githubusercontent.com/mimshins/ork/main/packages/schema/workflow.schema.json\nschemaVersion: 1\nname: fix-and-ship\ndescription: Fix a failing test, check it with the test suite, and ask before opening a pull request.\ninputs:\n  issue:\n    type: string\n    required: true\n    description: What fails.\ndefaults:\n  model: sonnet\n  budgetUsd: 2\nlimits:\n  budgetUsd: 10\nnodes:\n  fix:\n    type: claude.worker\n    prompt: \"Fix this, and keep the change small: {{inputs.issue}}\"\n  tests:\n    type: tool.shell\n    command: pnpm test\n    allow: [pnpm test]\n  ask:\n    type: human.gate\n    question: \"Open a pull request for {{nodes.fix.output.branch}}?\"\n    options: [open, hold]\n    recommended: hold\n  pr:\n    type: tool.gh\n    command: pr create --fill --head {{nodes.fix.output.branch}}\n    allow: [pr create]\nedges:\n  - fix -> tests\n  - from: tests\n    to: fix\n    when: \"!ok\"\n    maxRounds: 2\n  - from: tests\n    to: ask\n    when: ok\n  - from: ask\n    to: pr\n    when: \"choice == 'open'\"\n```\n\nNode ids are lowercase: letters, digits, `-` and `_`. Secrets never go in the\nfile: a tool reads one with `env:` and `{{env.NAME}}`.\n\n## Nodes\n\n| Type                              | Does                                                                |\n| --------------------------------- | ------------------------------------------------------------------- |\n| `claude.worker`                   | A Claude session that does one task and reports                     |\n| `claude.leader`                   | A session that plans and delegates to the nodes it owns (`parent:`) |\n| `claude.subagent`                 | A subagent inside its parent's session; it takes no edges           |\n| `tool.shell`                      | Any program, run without a shell; `allow:` lists command prefixes   |\n| `tool.git`, `tool.gh`, `tool.aws` | The person's own `git`, `gh`, `aws`, with an allow list             |\n| `mcp.call`                        | One tool call on an MCP server, with no session                     |\n| `human.gate`                      | A question with options and a recommended one                       |\n| `control.join`                    | Waits for its inputs: `all` (default), `any`, or `n` of them        |\n| `control.router`, `control.split` | Pass their input on; a router takes its first matching edge         |\n| `workflow.call`                   | Starts another workflow as its own run                              |\n\n- **A Claude node reports** `status` (`pass`, `changes_requested`, `done` or\n  `fail`), `summary`, `artifacts`, `branch`, and any field its `output.schema`\n  declares, such as `verdict: [approve, escalate]`. For another verdict, declare\n  a field: `status` can't take other values.\n- **A tool node reports** `exitCode`, `stdout`, `stderr`, and with\n  `output: { format: json, schema: { state: [OPEN, CLOSED] } }` its JSON as\n  `json`. Declare the fields you read: a run then checks them, and a typo can't\n  pass.\n- **A gate reports** `choice` and `answeredBy`. A `timeout` needs a `default`.\n\n## Edges and conditions\n\n- `a -> b`, `a -> b, c`, `b, c -> j` are plain edges, taken when the source\n  succeeded. A failed node takes no plain edge: handle a failure with\n  `when: \"!ok\"`, or `status == 'fail'` on a Claude node.\n- `{ from: a, to: b, when: \"...\" }` is taken when the condition holds. A bare\n  name reads the source's output: `when: \"verdict == 'approve'\"`. Quote any\n  condition that starts with `!`, or YAML reads it as a tag.\n- Conditions have `==`, `!=`, `<`, `>`, `&&`, `||`, `!`, and `any`, `all`,\n  `count`, `len`, `contains`. A join's `statuses` suits `any(statuses, 'fail')`.\n- A node runs when any edge into it is taken; only a join waits. A node with no\n  way in taken is skipped, and so is what follows it.\n- Templates, `{{inputs.x}}`, `{{nodes.a.output.field}}`, `{{run.id}}`, go in\n  `prompt`, `instructions`, `command`, `cwd` and `question`. Each value stays\n  one argument of a command, so it can't inject one.\n\n## Loops\n\nEvery cycle needs an edge with `maxRounds`. Give the way back a condition and\nthe way out its opposite, as `!ok` and `ok` above; a plain edge beside a loop\nfires every round. When a loop runs out, Ork asks a person what to do.\n\n## What `check` refuses, and why\n\n- **A value the source can't have** (`when.value`): `status == 'failed'` (it's\n  `fail`), a gate's `choice == 'aprove'` for `approve`, a value outside a\n  declared list. The message names the values it can have.\n- **A loop no condition ends**, a plain edge beside a loop, a loop of sessions\n  with no `limits.budgetUsd` or `limits.timeout`: warnings, each worth fixing.\n- **`no way the walk tried reaches x`**: Ork tried every way through, and none\n  got to `x`. A join waiting on a branch a first-match router never takes is\n  the usual cause.\n"
+	setup: "---\nname: setup\ndescription: Use when the person asks you to set up Ork, install it, or get started with it in a repository - checking it's installed, setting up the project, making Ork's tools available to you, and a first workflow.\n---\n\n# Setting up Ork\n\nOrk runs workflows on the person's machine with their own accounts. Setting it\nup changes their machine and their repository, so say what each step does and\nask before it. Work through these in order, and stop where they say no.\n\n## 1. Check\n\n```sh\nork --version\nork doctor\n```\n\n- **No `ork`:** it needs Node 24.20 or later (`node --version`). The install is\n  `npm install --global @krapht/ork`; show it and run it only when they say\n  yes. The guide:\n  https://github.com/mimshins/ork/blob/main/docs/getting-started/installation.md\n- **Read `ork doctor` to them.** It needs git, a git repository with a commit,\n  and one agent driver. Don't run `git init` or a commit without asking.\n- **A driver not ready:** they log in themselves, with `claude auth login`, or\n  by setting `ANTHROPIC_API_KEY` or a cloud provider in their own shell (either\n  makes the claude-code driver ready). Never ask for a key, never take one pasted to you, and\n  never write one into a file or a command. `gh` and `aws` are optional, and\n  their logins are their own too (`gh auth login`, `aws sso login`).\n\n## 2. The project\n\n- **`ork init`** keeps Ork's files in the repository, in `.ork/`, committed with\n  the code. It adds `.ork/runs/` to `.gitignore`, links `.claude/` and similar\n  folders to `.ork/`, and writes a starter workflow, `hello`.\n- **`ork register`** keeps them beside it, in `~/.ork/projects/<id>/`, and\n  writes nothing into the repository. For a repository whose process isn't\n  theirs to change, or to try Ork first.\n\nExplain both and ask which. Skip the question when the repository decides it: a\n`.ork/` folder means `ork init` has run (`ork projects` lists what's\nregistered). Neither overwrites a file.\n\n## 3. Make Ork available to you\n\nIf Ork's tools (`workflows`, `check`) already answer you, skip this. Otherwise,\nby where you run, and asking before each change to a config:\n\n- **Claude Code:** Ork's plugin brings the skills and the tools. The person\n  types these themselves:\n\n  ```\n  /plugin marketplace add mimshins/ork\n  /plugin install ork@ork\n  ```\n\n  Or, in a project set up with `ork init`, the skills in the repository for\n  everyone who clones it, then the tools:\n\n  ```sh\n  ork init --skills\n  claude mcp add ork -- ork mcp\n  ```\n\n  New tools start when they restart Claude Code or reconnect `ork` in `/mcp`;\n  so does the plugin's, once `ork` is installed.\n\n- **Another MCP client:** add a server named `ork` with command `ork` and args\n  `[\"mcp\"]` to its MCP config, where its own docs say. Its tools find the\n  project by its id, from `ork projects`.\n- **A shell only:** use the CLI. `ork --help` and each command's `--help` say\n  what it takes.\n\n## 4. A first workflow\n\nOffer to write one for a task they name. Follow `/ork:write`, check each draft\n(the `check` tool, or `ork validate <file>`) until it has no error, then save\nit. Don't start it: a run spends their money. Start it only when they say so,\nin the background with its inputs (`start_run`, or\n`ork run <name> --detach --input name=value`), and follow it with `/ork:run`.\n\n## 5. Show them `ork ui`\n\nTell them to run `ork ui` in their own terminal: their runs, graphs and logs in\nthe browser, and where they answer what a run asks.\n\n## Never\n\n- Ask for, store or pass on a password, key or token.\n- Answer a run's decision: they answer in `ork ui` or with `ork decide` in\n  their own terminal.\n- Install, edit a config, or start a run without a yes.\n",
+	write: "---\nname: write\ndescription: Use when writing or changing an Ork workflow (a `.ork/workflows/*.ork.yaml` file) - its nodes, edges, conditions and loops - and checking each draft until Ork accepts it.\n---\n\n# Writing an Ork workflow\n\nAn Ork workflow is one YAML file in the project, `.ork/workflows/<name>.ork.yaml`.\nIt names the nodes (Claude sessions, programs, a person's decisions) and the\nedges that carry work between them. Ork runs it on the person's machine with\ntheir own accounts.\n\n## How to work\n\n1. **Look first.** Ork's `workflows` tool lists the project's workflows; read\n   one that's close. `agents` lists the agents a node can use. Before you split\n   the work, read `/ork:principles`: a program where a program will do, a\n   session only for judgment.\n2. **Don't guess a field.** `workflow_format` gives the format; ask it for one\n   node type (`nodeType: \"human.gate\"`) to see that type's fields.\n3. **Check every draft** with Ork's `check` tool (`text`, or `workflow` for a\n   file), and fix what it says until it has no error. Read its warnings: they\n   mean something. Without Ork's tools, run `ork validate <file>`.\n4. **Then save the file**, beginning with the schema line below, so editors can\n   check it too.\n\n## The shape of a file\n\n```yaml\n# yaml-language-server: $schema=https://raw.githubusercontent.com/mimshins/ork/main/packages/schema/workflow.schema.json\nschemaVersion: 1\nname: fix-and-ship\ndescription: Fix a failing test, check it with the test suite, and ask before opening a pull request.\ninputs:\n  issue:\n    type: string\n    required: true\n    description: What fails.\ndefaults:\n  model: sonnet\n  budgetUsd: 2\nlimits:\n  budgetUsd: 10\nnodes:\n  fix:\n    type: claude.worker\n    prompt: \"Fix this, and keep the change small: {{inputs.issue}}\"\n  tests:\n    type: tool.shell\n    command: pnpm test\n    allow: [pnpm test]\n  ask:\n    type: human.gate\n    question: \"Open a pull request for {{nodes.fix.output.branch}}?\"\n    options: [open, hold]\n    recommended: hold\n  pr:\n    type: tool.gh\n    command: pr create --fill --head {{nodes.fix.output.branch}}\n    allow: [pr create]\nedges:\n  - fix -> tests\n  - from: tests\n    to: fix\n    when: \"!ok\"\n    maxRounds: 2\n  - from: tests\n    to: ask\n    when: ok\n  - from: ask\n    to: pr\n    when: \"choice == 'open'\"\n```\n\nNode ids are lowercase: letters, digits, `-` and `_`. Secrets never go in the\nfile: a tool reads one with `env:` and `{{env.NAME}}`.\n\n## Nodes\n\n| Type                              | Does                                                                |\n| --------------------------------- | ------------------------------------------------------------------- |\n| `claude.worker`                   | A Claude session that does one task and reports                     |\n| `claude.leader`                   | A session that plans and delegates to the nodes it owns (`parent:`) |\n| `claude.subagent`                 | A subagent inside its parent's session; it takes no edges           |\n| `tool.shell`                      | Any program, run without a shell; `allow:` lists command prefixes   |\n| `tool.git`, `tool.gh`, `tool.aws` | The person's own `git`, `gh`, `aws`, with an allow list             |\n| `mcp.call`                        | One tool call on an MCP server, with no session                     |\n| `human.gate`                      | A question with options and a recommended one                       |\n| `control.join`                    | Waits for its inputs: `all` (default), `any`, or `n` of them        |\n| `control.router`, `control.split` | Pass their input on; a router takes its first matching edge         |\n| `workflow.call`                   | Starts another workflow as its own run                              |\n\nA worker, tool node, `mcp.call` or `workflow.call` can run once per entry of a\nlist: see [One node per item](#one-node-per-item).\n\n- **A Claude node reports** `status` (`pass`, `changes_requested`, `done` or\n  `fail`), `summary`, `artifacts`, `branch`, and any field its `output.schema`\n  declares, such as `verdict: [approve, escalate]`. For another verdict, declare\n  a field: `status` can't take other values.\n- **A tool node reports** `exitCode`, `stdout`, `stderr`, and with\n  `output: { format: json, schema: { state: [OPEN, CLOSED] } }` its JSON as\n  `json`. Declare the fields you read: a run then checks them, and a typo can't\n  pass.\n- **A gate reports** `choice` and `answeredBy`. A `timeout` needs a `default`.\n\n## Edges and conditions\n\n- `a -> b`, `a -> b, c`, `b, c -> j` are plain edges, taken when the source\n  succeeded. A failed node takes no plain edge: handle a failure with\n  `when: \"!ok\"`, or `status == 'fail'` on a Claude node.\n- `{ from: a, to: b, when: \"...\" }` is taken when the condition holds. A bare\n  name reads the source's output: `when: \"verdict == 'approve'\"`. Quote any\n  condition that starts with `!`, or YAML reads it as a tag.\n- Conditions have `==`, `!=`, `<`, `>`, `&&`, `||`, `!`, and `any`, `all`,\n  `count`, `len`, `contains`. A join's `statuses` suits `any(statuses, 'fail')`.\n- A node runs when any edge into it is taken; only a join waits. A node with no\n  way in taken is skipped, and so is what follows it.\n- Templates, `{{inputs.x}}`, `{{nodes.a.output.field}}`, `{{run.id}}`, go in\n  `prompt`, `instructions`, `command`, `cwd` and `question`. Each value stays\n  one argument of a command, so it can't inject one.\n\n## One node per item\n\n`forEach` runs a worker, a tool node, an `mcp.call` or a `workflow.call` once\nper entry of a list, with no model turn to fan out or gather. Not a leader, a\ngate, a subagent or a control node.\n\n```yaml\nplan:\n  type: claude.worker\n  prompt: \"Split this into at most 6 independent tasks: {{inputs.goal}}\"\n  isolation: readonly\n  output:\n    schema:\n      tasks:\n        list: { title: string, detail: string } # declare the list and its shape\nbuild:\n  type: claude.worker\n  prompt: \"Task {{index}}: {{item.title}}. {{item.detail}}\"\n  isolation: worktree\n  forEach:\n    from: \"{{nodes.plan.output.tasks}}\" # exactly one path to a declared list\n    maxItems: 6 # required with `from`: the cap on sessions started\n    maxParallel: 3\n```\n\n- `forEach: { items: [a, b] }` takes a list written in the file instead.\n- `{{item}}` and `{{index}}` work only in a node with `forEach`, in `prompt`,\n  `command`, `arguments`, `inputs`, `env` and `ref`. A program also gets\n  `ORK_ITEM` and `ORK_INDEX`.\n- The next node reads `items`, `results` (each item's output, `summary`,\n  `branch`), `statuses` and `count`: `{{nodes.build.output.results}}`,\n  `when: \"all(statuses, 'pass')\"`. Items follow no edges; the node does.\n- `onFailure: finish` (default) runs every item; `stop` starts no more after a\n  failure. A list over `maxItems` makes Ork ask a person.\n- Declare the source's `list`, or `check` warns `forEach.undeclared`. Fix\n  `forEach.not-list`, `forEach.order` and `item.field` errors; they name the\n  field or node.\n\n## Loops\n\nEvery cycle needs an edge with `maxRounds`. Give the way back a condition and\nthe way out its opposite, as `!ok` and `ok` above; a plain edge beside a loop\nfires every round. When a loop runs out, Ork asks a person what to do.\n\n## What `check` refuses, and why\n\n- **A value the source can't have** (`when.value`): `status == 'failed'` (it's\n  `fail`), a gate's `choice == 'aprove'` for `approve`, a value outside a\n  declared list. The message names the values it can have.\n- **A loop no condition ends**, a plain edge beside a loop, a loop of sessions\n  with no `limits.budgetUsd` or `limits.timeout`: warnings, each worth fixing.\n- **`no way the walk tried reaches x`**: Ork tried every way through, and none\n  got to `x`. A join waiting on a branch a first-match router never takes is\n  the usual cause.\n"
 };
 // src/project/init-skills.ts
 /**
@@ -2450,16 +3297,17 @@ const DESCRIBE = {
 	folder: (link) => `${link.path} is a real folder, left as it is`
 };
 const describe = (link) => DESCRIBE[link.state](link);
+/** Labels are made when used, so `--plain` (set after load) is read. */
 const LABEL = {
-	linked: style("dim", "ok     "),
-	missing: style("yellow", "missing"),
-	broken: style("red", "broken "),
-	elsewhere: style("yellow", "kept   "),
-	folder: style("yellow", "kept   ")
+	linked: () => style("dim", "ok     "),
+	missing: () => style("yellow", "missing"),
+	broken: () => style("red", "broken "),
+	elsewhere: () => style("yellow", "kept   "),
+	folder: () => style("yellow", "kept   ")
 };
 /** One line per folder; `created` marks the links this call made. */
 const formatLinks = (links, created = []) => links.map((link) => {
-	return `${created.includes(link.path) ? style("green", "linked ") : LABEL[link.state]} ${describe(link)}`;
+	return `${created.includes(link.path) ? style("green", "linked ") : LABEL[link.state]()} ${describe(link)}`;
 });
 const checkOf = (tool, links) => {
 	const name = `${AGENT_TOOL_LAYOUTS.find((l) => l.id === tool)?.name ?? tool} links`;
@@ -2498,7 +3346,7 @@ const projectChecks = (root) => [...linkChecks(root), ...skillChecks(root, ORK_V
 * @file This installation of Ork: its name and version for the root command;
 *   `ork doctor`, which prints Ork's version against the last update check and
 *   the environment checks (Node, git, the user's own claude, gh and aws
-*   logins, the project's links) and fails when no Claude driver can run; and
+*   logins, the project's links) and fails when no agent driver can run; and
 *   `ork upgrade`, which asks the npm registry for the latest version and, when
 *   it is newer, upgrades Ork the way it was installed after the user agrees
 *   (`--yes` skips the question; `--check` only reports). A clone or `npx` gets
@@ -2511,16 +3359,6 @@ const ORK_META = {
 	version: ORK_VERSION,
 	description: "Orchestrate Claude agents on your machine"
 };
-const MARK = {
-	ok: style("green", "✓"),
-	warn: style("yellow", "!"),
-	fail: style("red", "✗"),
-	skip: style("dim", "-")
-};
-const formatCheck = (result) => {
-	const line = `${MARK[result.status]} ${result.name.padEnd(20)} ${result.detail}`;
-	return result.hint === void 0 ? [line] : [line, `  ${style("dim", result.hint)}`];
-};
 const doctor = defineCommand({
 	meta: {
 		name: "doctor",
@@ -2529,17 +3367,21 @@ const doctor = defineCommand({
 	run: async () => {
 		const { results, ok } = await runChecks(exec, process.env, process.versions.node);
 		const place = projectAt(process.cwd());
+		const experiments = experimentsCheck(place);
 		for (const result of [
 			orkCheck(),
 			...results,
 			...place.mode === "attached" ? [] : projectChecks(place.root),
 			socketCheck(),
-			...triggerChecks()
+			...triggerChecks(),
+			...await leaseChecks(place),
+			experiments
 		]) for (const line of formatCheck(result)) write(line);
 		if (!ok) {
-			write(`\n${style("red", "Not ready:")} Ork needs Node, git, and at least one Claude driver.`);
+			write(`\n${style("red", "Not ready:")} Ork needs Node, git, and at least one agent driver.`);
 			process.exitCode = 1;
 		}
+		if (experiments.status === "fail") process.exitCode = 1;
 	}
 });
 /** The ids of runs still running anywhere on this machine. */
@@ -2574,7 +3416,7 @@ const agreed = (yes, command) => {
 		write(`Run it yourself: ${command}\nor run ork upgrade --yes.`);
 		return Promise.resolve(false);
 	}
-	return confirm(`Run ${style("bold", command)}? [y/N] `);
+	return confirm(`Run ${command}?`);
 };
 const upgrade = defineCommand({
 	meta: {
@@ -2955,10 +3797,25 @@ const relocateProject = (store, id, target) => {
 		created: false
 	};
 };
-/** One project's lines for `ork projects`. */
-const formatProject = (project) => {
-	const gone = existsSync(project.root) ? "" : style("yellow", " (missing)");
-	return [`${style("bold", project.id)}  ${style("dim", project.mode)}  ${project.root}${gone}`, style("dim", `  files: ${shownPath(project.dir, project.root)}`)];
+/**
+* One project's lines for `ork projects`; rich, its mode and a missing clone
+* are chips, its id is padded to `idWidth` and its root is cut to the screen.
+*/
+const formatProject = (project, term = termOf(process.stdout), idWidth = 0) => {
+	const missing = !existsSync(project.root);
+	if (!term.rich) {
+		const gone = missing ? style("yellow", " (missing)") : "";
+		return [`${style("bold", project.id)}  ${style("dim", project.mode)}  ${project.root}${gone}`, style("dim", `  files: ${shownPath(project.dir, project.root)}`)];
+	}
+	const mode = chip(term, project.mode.toUpperCase(), "muted");
+	const gone = missing ? ` ${chip(term, "MISSING", "warn")}` : "";
+	const room = term.width - (idWidth + 2 + project.mode.length + 2 + 2) - (missing ? 10 : 0);
+	return [`${style("bold", project.id.padEnd(idWidth))}  ${mode}  ${cut(project.root, Math.max(8, room))}${gone}`, style("dim", cut(`  files: ${shownPath(project.dir, project.root)}`, term.width))];
+};
+/** Every project's lines, their ids aligned when rich. */
+const formatProjects = (projects, term = termOf(process.stdout)) => {
+	const idWidth = term.rich ? Math.max(0, ...projects.map((p) => p.id.length)) : 0;
+	return projects.flatMap((p) => formatProject(p, term, idWidth));
 };
 /** What `ork register` prints: the project, and where its files go. */
 const formatRegistered = (project, created) => {
@@ -3034,7 +3891,7 @@ const driverLine = (checks, projectDefault) => {
 		const why = ready.ready === 1 ? ready.detail : `more than one is ready, and ${ready.driver} comes first`;
 		return `Runs use the driver that's ready when they start: ${ready.driver} here (${why}).`;
 	}
-	return `Runs use the driver that's ready when they start, and none is ready here yet: ${checks.find(({ id }) => id === "cli")?.result.hint ?? "see `ork doctor`."}`;
+	return `Runs use the driver that's ready when they start, and none is ready here yet: ${checks.find(({ id }) => id === "claude-code")?.result.hint ?? "see `ork doctor`."}`;
 };
 /**
 * The line for the project at `root`: `ork doctor`'s driver checks through
@@ -3187,7 +4044,7 @@ const migrateHere = async (cwd, options) => {
 			fail("Pass --yes to migrate without a terminal.");
 			return;
 		}
-		if (!options.yes && !await confirm("Go ahead? [y/N] ")) return;
+		if (!options.yes && !await confirm("Go ahead?")) return;
 		applyMigration(plan, store);
 		write(`${style("green", "✓")} migrated. ${afterMigration(plan)}`);
 	} finally {
@@ -3307,7 +4164,7 @@ const projects = defineCommand({
 		const all = withStore$1((store) => store.projects());
 		if (args.json) write(JSON.stringify(all, void 0, 2));
 		else if (all.length === 0) write("No projects registered yet: ork init (in-repo) or ork register (attached).");
-		else for (const project of all) for (const line of formatProject(project)) write(line);
+		else for (const line of formatProjects(all)) write(line);
 	}
 });
 const migrate = defineCommand({
@@ -3401,13 +4258,16 @@ const SEVERITY_STYLE = {
 };
 const about = (item) => `${item.target}/${item.kind}`;
 /** One line per item, most recently seen first. */
-const formatFeedbackItems = (items, now = Date.now()) => {
+const formatFeedbackItems = (items, now = Date.now(), term = termOf(process.stdout)) => {
 	if (items.length === 0) return ["No feedback yet."];
 	const width = Math.max(...items.map((i) => about(i).length));
 	return items.map((item) => {
-		const status = item.status === "new" ? "" : ` ${style("dim", `[${item.status}]`)}`;
+		const mark = item.status === "new" ? "" : term.rich ? ` ${chip(term, item.status.toUpperCase(), item.status === "dismissed" ? "muted" : "accent")}` : ` ${style("dim", `[${item.status}]`)}`;
 		const times = `${String(item.count)}×`.padStart(4);
-		return `${style("dim", item.id)} ${times} ${style(SEVERITY_STYLE[item.severity], about(item).padEnd(width))}  ${item.title}${status} ${style("dim", `· ${ago(item.lastSeen, now)}`)}`;
+		const when = ` ${style("dim", `· ${ago(item.lastSeen, now)}`)}`;
+		const room = term.width - (item.id.length + 1 + times.length + 1 + width + 2) - widthOf(mark) - widthOf(when);
+		const title = term.rich ? cut(item.title, Math.max(8, room)) : item.title;
+		return `${style("dim", item.id)} ${times} ${style(SEVERITY_STYLE[item.severity], about(item).padEnd(width))}  ${title}${mark}${when}`;
 	});
 };
 const plural = (n, word) => `${String(n)} ${word}${n === 1 ? "" : "s"}`;
@@ -3635,7 +4495,7 @@ const apply = defineCommand({
 		item: itemArg$1,
 		driver: {
 			type: "string",
-			description: "sdk (API key or cloud provider) or cli (your claude login)"
+			description: "claude-code (default: the driver ready here)"
 		},
 		"run-id": {
 			type: "string",
@@ -3644,7 +4504,7 @@ const apply = defineCommand({
 	},
 	run: async ({ args }) => {
 		if (args.driver !== void 0 && !isDriver(args.driver)) {
-			writeErr(`--driver must be sdk or cli, got \`${args.driver}\``);
+			writeErr(badDriver(args.driver));
 			process.exitCode = 1;
 			return;
 		}
@@ -4174,7 +5034,7 @@ const ps = defineCommand({
 			limit: Number.isInteger(limit) && limit > 0 ? limit : 20,
 			...args.all ? {} : { project: placeFor(process.cwd(), store.projects()).root }
 		});
-		const statusOf = (run) => runStatus(run, run.status === "running" ? store.events(run.id).map((s) => s.event) : []);
+		const statusOf = (run) => listedStatus(run, run.status === "running" ? store.events(run.id).map((s) => s.event) : []);
 		if (args.json) write(JSON.stringify(runs, void 0, 2));
 		else for (const line of formatRuns(runs, args.all, Date.now(), statusOf)) write(line);
 	})
@@ -4205,6 +5065,11 @@ const logs = defineCommand({
 			type: "boolean",
 			description: "Print the stored events as JSON lines",
 			default: false
+		},
+		verbose: {
+			type: "boolean",
+			description: "Show each tool call whole, and why each failed node stopped, with its scrubbed details (always on with --node)",
+			default: false
 		}
 	},
 	run: ({ args }) => withStore(async (store) => {
@@ -4214,6 +5079,12 @@ const logs = defineCommand({
 			process.exitCode = 1;
 			return;
 		}
+		const problem = args.node === void 0 ? null : unknownNode(store.events(found.run.id), args.node, args.follow && found.run.status === "running");
+		if (problem !== null) {
+			writeErr(problem);
+			process.exitCode = 1;
+			return;
+		}
 		const abort = new AbortController();
 		process.once("SIGINT", () => {
 			abort.abort();
@@ -4221,6 +5092,7 @@ const logs = defineCommand({
 		await followRun(store, found.run, write, {
 			follow: args.follow,
 			json: args.json,
+			verbose: args.verbose,
 			signal: abort.signal,
 			...args.node === void 0 ? {} : { node: args.node }
 		});
@@ -4247,8 +5119,9 @@ const tree = defineCommand({
 			return;
 		}
 		const { run } = found;
-		const events = store.events(run.id).map((s) => s.event);
-		const roots = runTree(events);
+		const stored = store.events(run.id);
+		const events = stored.map((s) => s.event);
+		const roots = nestItems(activeTree(stored));
 		if (args.json) {
 			write(JSON.stringify(roots, void 0, 2));
 			return;
@@ -4306,7 +5179,7 @@ const addAgent = (options) => {
 *   doesn't, and otherwise it asks on a terminal, once, saying the plugin has
 *   them too, or says how to add them later.
 */
-const QUESTION = "Add Ork's skills for Claude Code to .ork/skills/, so it writes workflows Ork accepts? Ork's Claude Code plugin has them too. [y/N] ";
+const QUESTION = "Add Ork's skills for Claude Code to .ork/skills/, so it writes workflows Ork accepts? Ork's Claude Code plugin has them too.";
 const HINT = "Ork's skills for Claude Code: add them here with `ork init --skills`, or install Ork's plugin in Claude Code (/plugin marketplace add mimshins/ork, then /plugin install ork@ork).";
 /** Whether to write the skills: as asked, or the person's answer. */
 const wanted = (root, asked) => {
@@ -4377,6 +5250,8 @@ const init = defineCommand({
 			skills: args.skills,
 			link: args.link
 		});
+		const noCommit = await headWarning(exec);
+		if (noCommit !== null) write(style("yellow", `\n! git: ${noCommit}`));
 		write(`\nNext: edit ${WORKFLOW_DIR}/, then run ${style("bold", "ork validate")}.`);
 	}
 });
@@ -4575,27 +5450,27 @@ const main = defineCommand({
 		ps,
 		logs,
 		tree,
-		usage: () => import("./usage-EW7DI6Z7.mjs").then((module) => module.usage),
-		prune: () => import("./usage-EW7DI6Z7.mjs").then((module) => module.prune),
+		usage: () => import("./usage-GceBGMjU.mjs").then((module) => module.usage),
+		prune: () => import("./usage-GceBGMjU.mjs").then((module) => module.prune),
 		decide,
-		relay: () => import("./relay-BipJYszF.mjs").then((module) => module.relay),
-		pause: () => import("./pause-C7lJkSma.mjs").then((module) => module.pause),
-		continue: () => import("./pause-C7lJkSma.mjs").then((module) => module.continueRun),
+		relay: () => import("./relay-DNx7be9k.mjs").then((module) => module.relay),
+		pause: () => import("./pause-D6PuSlNl.mjs").then((module) => module.pause),
+		continue: () => import("./pause-D6PuSlNl.mjs").then((module) => module.continueRun),
 		stop,
 		chat,
-		send: () => import("./send-nbkjf3sc.mjs").then((module) => module.send),
+		send: () => import("./send-CLs_fyg7.mjs").then((module) => module.send),
 		resume,
 		feedback,
 		context,
-		worktrees: () => import("./worktrees-Ahj9rdWK.mjs").then((module) => module.worktrees),
-		wt: () => import("./worktrees-Ahj9rdWK.mjs").then((module) => module.worktrees),
-		watch: () => import("./watch-BAkSGaOp.mjs").then((module) => module.watch),
-		mcp: () => import("./mcp-DM30MFBw.mjs").then((module) => module.mcp),
-		ui: () => import("./ui-B98FSboa.mjs").then((module) => module.ui),
+		worktrees: () => import("./worktrees-Be51E2rB.mjs").then((module) => module.worktrees),
+		wt: () => import("./worktrees-Be51E2rB.mjs").then((module) => module.worktrees),
+		watch: () => import("./watch-BmoybMQg.mjs").then((module) => module.watch),
+		mcp: () => import("./mcp-DYgVA9f5.mjs").then((module) => module.mcp),
+		ui: () => import("./ui-CIci4UBW.mjs").then((module) => module.ui),
 		doctor,
 		upgrade,
-		completion: () => import("./completion-DBGfL-gN.mjs").then((module) => module.completion),
-		__complete: () => import("./completion-DBGfL-gN.mjs").then((module) => module.completeCommand(main))
+		completion: () => import("./completion-C5D0sEs5.mjs").then((module) => module.completion),
+		__complete: () => import("./completion-C5D0sEs5.mjs").then((module) => module.completeCommand(main))
 	}
 });
 // src/bin.ts
@@ -4605,15 +5480,16 @@ const main = defineCommand({
 *   starts the daily background check and ends with the notice (ADR-038); the
 *   background copy it starts only runs the check. It first clears git's local
 *   variables (a hook's `GIT_DIR`, `GIT_INDEX_FILE`, …), so nothing Ork starts
-*   acts on the hook's repository (specs/worktrees.md). `--help` leaves out the
-*   flags only Ork passes to itself. `ork __complete`, which tab completion
-*   runs on every Tab, goes first: no update check, and no citty, so a typed
-*   `--help` is a word to complete.
+*   acts on the hook's repository (specs/worktrees.md). The global `--plain`
+*   flag is taken out of the arguments and set as `ORK_PLAIN=1`. `--help`
+*   leaves out the flags only Ork passes to itself. `ork __complete`, which tab
+*   completion runs on every Tab, goes first: no update check, and no citty, so
+*   a typed `--help` is a word to complete.
 */
 clearGitLocalEnv();
-const argv = process.argv.slice(2);
+const argv = takePlainFlag(process.argv.slice(2));
 if (argv[0] === "__complete") {
-	const { printCompletions } = await import("./completion-DBGfL-gN.mjs");
+	const { printCompletions } = await import("./completion-C5D0sEs5.mjs");
 	await printCompletions(main, argv.slice(1));
 } else if (process.env["ORK_UPDATE_CHECK_CHILD"] === "1") await runUpdateChild();
 else {
@@ -4623,6 +5499,9 @@ else {
 			showUpdateNotice();
 		});
 	}
-	await runMain(main, { showUsage: showHelp });
+	await runMain(main, {
+		rawArgs: argv,
+		showUsage: showHelp
+	});
 }
 export {};