@krapht/ork 0.2.0 → 0.3.0

package/dist/bin.mjs

@@ -1,18 +1,23 @@
 #!/usr/bin/env node
-import { A as contextDiagnostics, B as loadAgents, C as createFeedback, D as maskSecrets, E as maskReplacer, F as toolLinks, G as placeFiles, H as hasInRepoFiles, I as toolsInUse, J as runDirOf, K as placeFor, L as createAgent, M as applySteps, N as planMoveInto, O as parseTemplate, P as linkTools, Q as projectRootOf, R as deleteAgent, S as FEEDBACK_TARGETS, T as targetOf, U as inRepoPlace, V as PROJECT_MODES, W as newProjectId, X as workflowDirOf, Y as shownPath, Z as inside, _ as compileWorkflow, a as removeWorktree, at as isToolNode, b as FEEDBACK_KINDS, c as lines, ct as integrationFor, d as planNodeSession, dt as CLAUDE_DRIVERS, et as parseWorkflow, ft as firstLine$1, g as resolvePractices, h as practiceInstructions, i as inspectProject, it as isClaudeNode, j as planAgentMigration, k as renderTemplate, l as detectInstaller, lt as AGENT_TOOL_LAYOUTS, m as runScope, n as resolveBase, nt as WorkflowSchema, o as git, ot as INTEGRATIONS, p as userMessageText, q as projectsHome, rt as settingsOf, s as gitOk, st as TOOL_PREFIX, t as createWorkspace, tt as serializeWorkflow, u as startRun, ut as ORK_LAYOUT, v as gitRulesOf, w as fingerprint, x as FEEDBACK_SEVERITIES, y as loadProject, z as catalogAgent } from "./src-CJ_zF0Zj.mjs";
+import { $ as replayLoopAnswers, $t as projectsHome, Bt as linkTools, Cn as beforeOf, Ct as FEEDBACK_SEVERITIES, Dt as targetOf, E as planNodeSession, Et as fingerprint, Ft as socketPath, Gt as catalogAgent, H as requestStop, Ht as toolsInUse, I as peerOf, It as wakeRun, Jt as hasInRepoFiles, Kt as loadAgents, L as tellNode, Lt as planAgentMigration, M as addressOf, Mn as ORK_LAYOUT, N as endLink, Nn as CLAUDE_DRIVERS, O as parseInputPairs, On as INTEGRATIONS, Ot as maskReplacer, P as endLinksOf, Pn as firstLine, Pt as serveRun, Q as createReplay, Qt as placeFor, Rt as applySteps, St as FEEDBACK_KINDS, Tt as createFeedback, U as tellLiveRun, Ut as createAgent, Vt as toolLinks, Wt as deleteAgent, X as detachResume, Xt as newProjectId, Y as adoptedCalls, Yt as inRepoPlace, Z as resumable, Zt as placeFiles, b as inspectProject, d as triggersReport, dt as startRun, en as runDirOf, hn as serializeWorkflow, i as NOT_STARTED, in as projectRootOf, j as createCalls, jn as AGENT_TOOL_LAYOUTS, k as resolveInputs, kt as maskSecrets, l as detectInstaller, n as resolveBase, nt as followEvents, ot as runStatus, pt as userMessageText, rn as inside, rt as liveStatus, st as runTree, t as createWorkspace, tn as shownPath, tt as detachRun, u as lateTriggers, ut as walkSummary, wn as isClaudeNode, xn as settingsOf, xt as gitRulesOf, yn as WorkflowSchema, z as flattenTree, zt as planMoveInto } from "./src-Cz1yOUTg.mjs";
+import { a as pendingDecisions, i as answerDecision, n as ORK_VERSION, r as nodeSession, t as ORK_NAME } from "./__build_info__-CXXMLvjt.mjs";
+import { n as newRunId, t as findRun } from "./find-BcvhT6UN.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-Q2EdeVUt.mjs";
+import { a as formatRunEvent, c as createdWorktrees, i as formatEvent, l as listOrkWorktrees, n as formatRuns, o as createTerminalHuman, r as formatTree, s as applyClean, t as ago, u as planClean } from "./format-DqpObyMl.mjs";
+import { a as validate, c as warningLines, d as workflowArg, f as projectAt, i as loadWorkflow, l as WORKFLOW_DIR, o as validateFile, p as isNewer, r as formatReport, s as walkLoaded, t as context, u as WORKFLOW_SUFFIX } from "./context-BFGC_C02.mjs";
+import { i as runLimits, r as limitsRefusal, t as chatNotice } from "./limits-BKYAmqCR.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-DtN1k-B3.mjs";
+import { i as decideRefusal, n as chatRefusal } from "./in-a-run-BbLhZOFW.mjs";
 import { defineCommand, runMain } from "citty";
 import { createInterface } from "node:readline/promises";
 import path from "node:path";
 import { stringify } from "yaml";
-import { accessSync, appendFileSync, constants, existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { createHash, randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { homedir } from "node:os";
-import { createConnection, createServer } from "node:net";
-import { createInterface as createInterface$1 } from "node:readline";
-import { DatabaseSync } from "node:sqlite";
+import { setTimeout } from "node:timers/promises";
 import { execFile, spawn } from "node:child_process";
 import { styleText } from "node:util";
-import { setTimeout as setTimeout$1 } from "node:timers/promises";
 // ../core/src/control/queue.ts
 const PERMISSION_OPTIONS = [{
 	id: "allow",
@@ -134,123 +139,6 @@ const createDecisionQueue = (options) => {
 		}
 	};
 };
-// ../core/src/control/socket.ts
-/**
-* @file The per-run local socket (`~/.ork/sockets/<run>.sock`): the fast path
-*   beside the store (ADR-024). Other `ork` processes `wake` a run when they
-*   have written an answer or a command, and `follow` a run to get each event
-*   as it is stored. One JSON message per line; nothing is lost when the socket
-*   is gone, since the store has it all.
-*/
-/** Where a run's socket lives; `home` is `~` (tests pass a folder). */
-const socketPath = (runId, home = homedir()) => path.join(home, ".ork", "sockets", `${runId}.sock`);
-/** For errors another handler already settles. */
-const ignore = () => {};
-const messageOf = (line) => {
-	try {
-		const value = JSON.parse(line);
-		if (value === null || typeof value !== "object" || !("type" in value)) return;
-		if (value.type === "wake") return { type: "wake" };
-		if (value.type === "follow") {
-			const after = "after" in value ? Number(value.after) : 0;
-			return {
-				type: "follow",
-				after: Number.isFinite(after) ? after : 0
-			};
-		}
-	} catch {}
-};
-/** Listens on the run's socket; resolves once it is listening. */
-const serveRun = async (options) => {
-	mkdirSync(path.dirname(options.path), { recursive: true });
-	rmSync(options.path, { force: true });
-	const followers = /* @__PURE__ */ new Set();
-	const server = createServer((socket) => {
-		socket.on("error", () => {
-			followers.delete(socket);
-		});
-		socket.on("close", () => {
-			followers.delete(socket);
-		});
-		const lines = createInterface$1({ input: socket });
-		lines.on("error", ignore);
-		lines.on("line", (line) => {
-			const message = messageOf(line);
-			if (message?.type === "wake") options.onWake();
-			if (message?.type === "follow") {
-				for (const stored of options.backlog(message.after)) socket.write(`${JSON.stringify(stored)}\n`);
-				followers.add(socket);
-			}
-		});
-	});
-	const { promise, resolve, reject } = Promise.withResolvers();
-	server.once("error", reject);
-	server.listen(options.path, () => {
-		resolve();
-	});
-	await promise;
-	return {
-		publish: (stored) => {
-			const line = `${JSON.stringify(stored)}\n`;
-			for (const socket of followers) socket.write(line);
-		},
-		close: () => {
-			for (const socket of followers) socket.end();
-			const closed = Promise.withResolvers();
-			server.close(() => {
-				closed.resolve();
-			});
-			rmSync(options.path, { force: true });
-			return closed.promise;
-		}
-	};
-};
-/** Tells a live run to look at the store now; false when it is not listening. */
-const wakeRun = (file) => {
-	const { promise, resolve } = Promise.withResolvers();
-	const socket = createConnection(file, () => {
-		socket.end(`${JSON.stringify({ type: "wake" })}\n`, () => {
-			resolve(true);
-		});
-	});
-	socket.on("error", () => {
-		resolve(false);
-	});
-	return promise;
-};
-/**
-* Follows a live run over its socket: `onEvent` gets each event stored after
-* `after`. Resolves `"ended"` when the run closes the socket, or
-* `"unavailable"` when no run is listening.
-*/
-const followSocket = (file, after, onEvent, signal) => {
-	const { promise, resolve } = Promise.withResolvers();
-	let connected = false;
-	const socket = createConnection(file, () => {
-		connected = true;
-		socket.write(`${JSON.stringify({
-			type: "follow",
-			after
-		})}\n`);
-	});
-	const lines = createInterface$1({ input: socket });
-	lines.on("error", ignore);
-	lines.on("line", (line) => {
-		try {
-			onEvent(JSON.parse(line));
-		} catch {}
-	});
-	socket.on("error", () => {
-		resolve(connected ? "ended" : "unavailable");
-	});
-	socket.on("close", () => {
-		resolve(connected ? "ended" : "unavailable");
-	});
-	signal?.addEventListener("abort", () => {
-		socket.destroy();
-	});
-	return promise;
-};
 // ../core/src/control/control.ts
 const startControl = async (options) => {
 	const { store, runId } = options;
@@ -265,13 +153,23 @@ const startControl = async (options) => {
 			}
 		}
 		for (const command of store.takeCommands(runId)) if (command.kind === "message") options.onMessage(command.node, command.body);
-		else if (!stopped) {
+		else if (command.kind === "relay") options.onRelay?.(command.node, command.from, command.body);
+		else if (command.kind === "script") options.onScript?.(command.node, command.from, command.body);
+		else if (command.kind === "notice") options.onNotice?.(command.node, command.body);
+		else if (command.kind === "stop" && command.node === void 0) {
+			if (stopped) continue;
 			stopped = true;
 			options.emit({
 				type: "run.command",
 				command: "stop"
 			});
 			options.onStop();
+		} else if (!stopped) {
+			if (options.onControl?.(command.kind, command.node) ?? false) options.emit({
+				type: "run.command",
+				command: command.kind,
+				...command.node === void 0 ? {} : { node: command.node }
+			});
 		}
 	};
 	const timer = setInterval(check, options.intervalMs ?? 1e3);
@@ -504,267 +402,102 @@ const createSignals = (options = {}) => {
 		return signal === null ? [event] : [event, ...record(...signal)];
 	};
 };
-// ../core/src/run/inputs.ts
-const coerce = (name, type, raw) => {
-	if (type === "string") return { value: raw };
-	if (type === "number") {
-		const value = Number(raw);
-		return raw.trim() === "" || Number.isNaN(value) ? { error: `input "${name}" must be a number, got "${raw}"` } : { value };
-	}
-	if (raw === "true" || raw === "false") return { value: raw === "true" };
-	return { error: `input "${name}" must be true or false, got "${raw}"` };
-};
+// ../core/src/remote/relay.ts
 /**
-* Checks `--input name=value` pairs against the workflow's inputs: unknown
-* names, missing required inputs, and types. Defaults fill the rest.
+* @file A run's side of the relay (RFC-003): its nodes' links, read from the
+*   store, and sending to a node of another run. A message is a row in the
+*   store and a wake on that run's socket, so no process has to stay up for it,
+*   and the store has it if the socket is gone. Reaching a link's limit asks
+*   the user whether to go on, as a loop out of rounds does.
 */
-const resolveInputs = (workflow, raw) => {
-	const declared = workflow.inputs ?? {};
-	const errors = [];
-	const inputs = {};
-	for (const name of Object.keys(raw)) if (declared[name] === void 0) errors.push(`unknown input "${name}"`);
-	for (const [name, def] of Object.entries(declared)) {
-		const value = raw[name];
-		if (value === void 0) {
-			if (def.default !== void 0) inputs[name] = def.default;
-			else if (def.required === true) errors.push(`missing required input "${name}" (--input ${name}=…)`);
-			continue;
+/** For a refused or abandoned question: a stopped run has nothing to do. */
+const ignore = () => {};
+const createRelay = (options) => {
+	const { store, runId, home, human } = options;
+	/** Links with the question about their limit open. */
+	const asking = /* @__PURE__ */ new Set();
+	const askToGoOn = async (link, node) => {
+		if (asking.has(link.id)) return;
+		asking.add(link.id);
+		try {
+			if (await human.ask({
+				nodeId: node,
+				question: `${addressOf(link.a)} and ${addressOf(link.b)} have used all ${String(link.maxMessages)} messages of their link. Let them go on?`,
+				options: [{
+					id: "extend",
+					description: `${String(link.maxMessages)} more`
+				}, {
+					id: "end",
+					description: "End the link"
+				}],
+				recommended: "end"
+			}) === "extend") {
+				store.extendLink(link.id, link.maxMessages);
+				await Promise.all([link.a, link.b].map((end) => tellNode(store, end, "[ork] The user let this link go on; you can send again.", home)));
+			} else await endLink(store, link, "the user ended it", home);
+		} finally {
+			asking.delete(link.id);
 		}
-		const result = coerce(name, def.type ?? "string", value);
-		if ("error" in result) errors.push(result.error);
-		else inputs[name] = result.value;
-	}
-	return errors.length > 0 ? {
-		ok: false,
-		errors
-	} : {
-		ok: true,
-		inputs
 	};
-};
-/** Parses `name=value` strings, as given to `--input`. */
-const parseInputPairs = (pairs) => {
-	const raw = {};
-	for (const pair of pairs) {
-		const at = pair.indexOf("=");
-		if (at <= 0) return {
-			ok: false,
-			error: `expected name=value, got "${pair}"`
-		};
-		raw[pair.slice(0, at)] = pair.slice(at + 1);
-	}
-	return {
-		ok: true,
-		raw
+	/** Why `peer`'s run cannot take a message now, or null. */
+	const closed = (peer) => {
+		const [run] = store.lookup(peer.run);
+		if (run === void 0) return `run ${peer.run} is gone`;
+		const status = liveStatus(run);
+		return status === "running" ? null : `its run has finished (${status}). A finished run's session is not resumed by another agent; the user can resume it with \`ork chat\``;
 	};
-};
-// ../core/src/run/resume.ts
-/** How a run ended that cut its working nodes off, rather than failing them. */
-const CUTTING = /* @__PURE__ */ new Set(["interrupted", "budget_exhausted"]);
-/** Reads a run's events back into what `ork resume` needs. */
-const resumeState = (events) => {
-	const history = /* @__PURE__ */ new Map();
-	const closed = /* @__PURE__ */ new Set();
-	const open = /* @__PURE__ */ new Map();
-	const worktrees = /* @__PURE__ */ new Map();
-	const branches = /* @__PURE__ */ new Set();
-	const loopAnswers = [];
-	/** Decision or owner-question id -> its question, when it is about a loop. */
-	const loopQuestions = /* @__PURE__ */ new Map();
-	let loopPending = false;
-	let inputs = {};
-	let settings = {};
-	let succeeded = false;
-	let ended;
-	/** Nodes whose last activation did not finish well, and its session. */
-	const unfinished = /* @__PURE__ */ new Map();
-	const inboxes = /* @__PURE__ */ new Map();
-	const waiting = /* @__PURE__ */ new Map();
-	let last = 0;
-	for (const event of events) {
-		if (event.type === "run.started") {
-			inputs = event.inputs ?? inputs;
-			settings = event.settings ?? settings;
-			continue;
-		}
-		if (event.type === "message.sent") {
-			last = Math.max(last, event.message);
-			const unread = inboxes.get(event.to) ?? [];
-			unread.push({
-				id: event.message,
-				from: event.node,
-				body: event.body
+	const isRunning = (peer) => {
+		const events = store.events(peer.run).map((stored) => stored.event);
+		return flattenTree(runTree(events)).some((n) => n.id === peer.node && n.state === "running");
+	};
+	return {
+		peers: (node) => store.links({
+			run: runId,
+			live: true
+		}).flatMap((link) => {
+			const peer = peerOf(link, runId, node);
+			return peer === void 0 ? [] : [addressOf(peer)];
+		}),
+		send: (node, to, body) => {
+			const link = store.links({
+				run: runId,
+				live: true
+			}).find((candidate) => {
+				const peer = peerOf(candidate, runId, node);
+				return peer !== void 0 && addressOf(peer) === to;
 			});
-			inboxes.set(event.to, unread);
-			continue;
-		}
-		if (event.type === "message.read") {
-			const unread = inboxes.get(event.node) ?? [];
-			inboxes.set(event.node, unread.filter((m) => !event.ids.includes(m.id)));
-			continue;
-		}
-		if (event.type === "user.message" && event.delivered === "queued") {
-			waiting.set(event.node, [...waiting.get(event.node) ?? [], event.body]);
-			continue;
-		}
-		if (event.type === "node.started") {
-			waiting.delete(event.id);
-			if (event.owner === void 0) open.set(event.id, {});
-			continue;
-		}
-		if (event.type === "node.event") {
-			const inner = event.event;
-			const current = open.get(event.id);
-			if (current === void 0) continue;
-			if (inner.type === "session.started") current.sessionId = inner.sessionId;
-			if (inner.type === "session.finished" && inner.outcome.sessionId) current.sessionId = inner.outcome.sessionId;
-			continue;
-		}
-		if (event.type === "node.finished") {
-			const current = open.get(event.id);
-			open.delete(event.id);
-			if (current === void 0 || closed.has(event.id)) continue;
-			if (!event.ok) {
-				closed.add(event.id);
-				if (current.sessionId !== void 0) unfinished.set(event.id, current.sessionId);
-				continue;
+			const peer = link && peerOf(link, runId, node);
+			if (link === void 0 || peer === void 0) return {
+				ok: false,
+				error: `you have no live link to ${to}`
+			};
+			const why = closed(peer);
+			if (why !== null) {
+				endLink(store, link, why, home);
+				return {
+					ok: false,
+					error: `${to} cannot take it: ${why}`
+				};
 			}
-			const result = {
+			if (link.messages >= link.maxMessages) {
+				askToGoOn(link, node).catch(ignore);
+				return {
+					ok: false,
+					error: `this link has used all ${String(link.maxMessages)} of its messages, and the user has been asked whether to go on`
+				};
+			}
+			store.countMessage(link.id);
+			store.command(peer.run, {
+				kind: "relay",
+				node: peer.node,
+				from: `${runId}/${node}`,
+				body
+			});
+			wakeRun(socketPath(peer.run, home));
+			return {
 				ok: true,
-				output: event.output
+				delivered: isRunning(peer) ? "now" : "queued"
 			};
-			if (event.usage !== void 0) result.usage = event.usage;
-			if (current.sessionId !== void 0) result.sessionId = current.sessionId;
-			history.set(event.id, [...history.get(event.id) ?? [], result]);
-			continue;
-		}
-		if (event.type === "worktree") {
-			const known = worktrees.get(event.id);
-			if (event.action === "created" || known === void 0) worktrees.set(event.id, {
-				id: event.id,
-				path: event.path,
-				...event.branch === void 0 ? {} : { branch: event.branch },
-				merged: false,
-				removed: false
-			});
-			const entry = worktrees.get(event.id);
-			if (entry === void 0) continue;
-			if (event.branch !== void 0) branches.add(event.branch);
-			if (event.snapshot !== void 0) entry.snapshot = event.snapshot;
-			if (event.action === "merged") entry.merged = true;
-			if (event.action === "committed" || event.action === "conflict") entry.merged = false;
-			if (event.action === "removed") entry.removed = true;
-			continue;
-		}
-		if (event.type === "loop.exhausted") {
-			loopPending = true;
-			continue;
-		}
-		if (event.type === "decision.opened") {
-			if (loopPending) loopQuestions.set(event.decision, event.question);
-			loopPending = false;
-			continue;
-		}
-		if (event.type === "owner.asked") {
-			if (loopPending) loopQuestions.set(event.question, event.text);
-			loopPending = false;
-			continue;
-		}
-		if (event.type === "owner.unanswered") {
-			loopPending = true;
-			continue;
-		}
-		if (event.type === "decision.answered" || event.type === "owner.answered") {
-			const key = event.type === "owner.answered" ? event.question : event.decision;
-			const question = loopQuestions.get(key);
-			if (question !== void 0) loopAnswers.push({
-				question,
-				answer: event.answer
-			});
-			continue;
-		}
-		if (event.type === "run.finished") {
-			succeeded = event.result.status === "succeeded";
-			ended = event.result.status;
-			continue;
-		}
-	}
-	for (const [id, current] of open) {
-		closed.add(id);
-		if (current.sessionId !== void 0) unfinished.set(id, current.sessionId);
-	}
-	const cut = ended === void 0 || CUTTING.has(ended);
-	return {
-		history,
-		inputs,
-		settings,
-		worktrees: [...worktrees.values()].filter((w) => !w.removed).map(({ removed: _removed, ...w }) => w),
-		branches: [...branches],
-		loopAnswers,
-		succeeded,
-		cutOff: cut ? unfinished : /* @__PURE__ */ new Map(),
-		mail: {
-			inboxes,
-			waiting,
-			last
-		}
-	};
-};
-/** 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) => {
-	const sessions = new Map(cutOff);
-	const used = /* @__PURE__ */ new Map();
-	const anew = /* @__PURE__ */ new Set();
-	const fresh = /* @__PURE__ */ new WeakSet();
-	return {
-		take: (activation) => {
-			const { id } = activation;
-			if (activation.brief !== void 0 || anew.has(id)) return null;
-			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 ? sessions.get(activation.id) : void 0;
-			sessions.delete(activation.id);
-			return session;
-		},
-		kept: () => [...history.keys()],
-		...mail === void 0 ? {} : { mail }
-	};
-};
-/**
-* 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),
-		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);
 		}
 	};
 };
@@ -793,606 +526,6 @@ const createRecorder = (store, run, runDir) => {
 	store.begin(run);
 	return appendRecorder(store, run.id, runDir);
 };
-// ../core/src/store/schema.ts
-const MIGRATIONS = [
-	`CREATE TABLE runs (
-     id TEXT PRIMARY KEY,
-     workflow TEXT NOT NULL,
-     file TEXT NOT NULL,
-     project TEXT NOT NULL,
-     status TEXT NOT NULL,
-     pid INTEGER NOT NULL,
-     started_at TEXT NOT NULL,
-     finished_at TEXT,
-     cost_usd REAL NOT NULL DEFAULT 0
-   );
-   CREATE INDEX runs_by_project ON runs (project, started_at);
-   CREATE TABLE events (
-     run_id TEXT NOT NULL REFERENCES runs (id),
-     seq INTEGER NOT NULL,
-     at TEXT NOT NULL,
-     type TEXT NOT NULL,
-     node TEXT,
-     data TEXT NOT NULL,
-     PRIMARY KEY (run_id, seq)
-   ) WITHOUT ROWID;`,
-	`CREATE TABLE decisions (
-     id TEXT PRIMARY KEY,
-     run_id TEXT NOT NULL REFERENCES runs (id),
-     node TEXT NOT NULL,
-     kind TEXT NOT NULL,
-     question TEXT NOT NULL,
-     options TEXT NOT NULL,
-     recommended TEXT,
-     context TEXT,
-     opened_at TEXT NOT NULL,
-     status TEXT NOT NULL,
-     answer TEXT,
-     answered_by TEXT,
-     answered_at TEXT
-   );
-   CREATE INDEX decisions_by_status ON decisions (status, run_id);
-   CREATE TABLE commands (
-     id INTEGER PRIMARY KEY AUTOINCREMENT,
-     run_id TEXT NOT NULL REFERENCES runs (id),
-     kind TEXT NOT NULL,
-     at TEXT NOT NULL,
-     handled_at TEXT
-   );`,
-	`ALTER TABLE commands ADD COLUMN node TEXT;
-   ALTER TABLE commands ADD COLUMN body TEXT;`,
-	`CREATE TABLE feedback (
-     id INTEGER PRIMARY KEY AUTOINCREMENT,
-     run_id TEXT NOT NULL REFERENCES runs (id),
-     seq INTEGER NOT NULL,
-     at TEXT NOT NULL,
-     node TEXT,
-     source TEXT NOT NULL,
-     kind TEXT NOT NULL,
-     target TEXT NOT NULL,
-     severity TEXT NOT NULL,
-     title TEXT NOT NULL,
-     body TEXT NOT NULL,
-     evidence TEXT NOT NULL,
-     code TEXT,
-     fingerprint TEXT NOT NULL,
-     workflow TEXT,
-     workflow_hash TEXT,
-     node_type TEXT,
-     model TEXT,
-     driver TEXT,
-     version TEXT,
-     feedback_version INTEGER NOT NULL
-   );
-   CREATE INDEX feedback_by_fingerprint ON feedback (fingerprint, at);
-   CREATE TABLE feedback_items (
-     fingerprint TEXT PRIMARY KEY,
-     status TEXT NOT NULL,
-     updated_at TEXT NOT NULL
-   );`,
-	`CREATE TABLE projects (
-     id TEXT PRIMARY KEY,
-     root TEXT NOT NULL UNIQUE,
-     mode TEXT NOT NULL,
-     dir TEXT NOT NULL,
-     registered_at TEXT NOT NULL
-   );`
-];
-/** A text column, or `""` when it is null. */
-const text$1 = (row, key) => {
-	const value = row?.[key];
-	return typeof value === "string" ? value : "";
-};
-/** Applies the migrations the database has not had yet. */
-const migrate$1 = (db) => {
-	const version = Number(db.prepare("PRAGMA user_version").get()?.["user_version"] ?? 0);
-	for (const [index, sql] of MIGRATIONS.entries()) {
-		if (index < version) continue;
-		db.exec("BEGIN");
-		db.exec(sql);
-		db.exec(`PRAGMA user_version = ${String(index + 1)}`);
-		db.exec("COMMIT");
-	}
-};
-// ../core/src/store/decisions.ts
-const choicesOf = (json) => {
-	const parsed = JSON.parse(json);
-	if (!Array.isArray(parsed)) return [];
-	return parsed.flatMap((item) => {
-		if (item === null || typeof item !== "object" || !("id" in item)) return [];
-		const { id } = item;
-		if (typeof id !== "string") return [];
-		const choice = { id };
-		if ("label" in item && typeof item.label === "string") choice.label = item.label;
-		if ("description" in item && typeof item.description === "string") choice.description = item.description;
-		return [choice];
-	});
-};
-const kindOf = (value) => value === "permission" ? "permission" : "question";
-const statusOf$1 = (value) => value === "answered" || value === "withdrawn" ? value : "open";
-const decisionOf = (row) => {
-	const record = {
-		id: text$1(row, "id"),
-		runId: text$1(row, "run_id"),
-		node: text$1(row, "node"),
-		kind: kindOf(text$1(row, "kind")),
-		question: text$1(row, "question"),
-		options: choicesOf(text$1(row, "options") || "[]"),
-		openedAt: text$1(row, "opened_at"),
-		status: statusOf$1(text$1(row, "status"))
-	};
-	const optional = {
-		recommended: text$1(row, "recommended"),
-		context: text$1(row, "context"),
-		answer: text$1(row, "answer"),
-		answeredAt: text$1(row, "answered_at")
-	};
-	for (const [key, value] of Object.entries(optional)) if (value !== "") Object.assign(record, { [key]: value });
-	const by = text$1(row, "answered_by");
-	if (by === "terminal" || by === "decide") record.answeredBy = by;
-	return record;
-};
-const decisionQueries = (db) => {
-	const insert = db.prepare(`INSERT INTO decisions (id, run_id, node, kind, question, options, recommended, context, opened_at, status)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'open')`);
-	const answer = db.prepare(`UPDATE decisions SET status = 'answered', answer = ?, answered_by = ?, answered_at = ?
-     WHERE id = ? AND status = 'open'`);
-	const withdraw = db.prepare("UPDATE decisions SET status = 'withdrawn', answered_at = ? WHERE id = ? AND status = 'open'");
-	const byId = db.prepare("SELECT * FROM decisions WHERE id = ?");
-	const filtered = db.prepare(`SELECT d.* FROM decisions d JOIN runs r ON r.id = d.run_id
-     WHERE (?1 IS NULL OR d.run_id = ?1)
-       AND (?2 IS NULL OR r.project = ?2)
-       AND (?3 IS NULL OR d.status = ?3)
-     ORDER BY d.opened_at, d.rowid`);
-	const addCommand = db.prepare("INSERT INTO commands (run_id, kind, node, body, at) VALUES (?, ?, ?, ?, ?)");
-	const pending = db.prepare("SELECT id, kind, node, body FROM commands WHERE run_id = ? AND handled_at IS NULL ORDER BY id");
-	const handled = db.prepare("UPDATE commands SET handled_at = ? WHERE id = ?");
-	return {
-		openDecision: (decision) => {
-			const openedAt = (/* @__PURE__ */ new Date()).toISOString();
-			const masked = {
-				...decision,
-				question: maskSecrets(decision.question),
-				...decision.context === void 0 ? {} : { context: maskSecrets(decision.context) }
-			};
-			insert.run(masked.id, masked.runId, masked.node, masked.kind, masked.question, JSON.stringify(masked.options), masked.recommended ?? null, masked.context ?? null, openedAt);
-			return {
-				...masked,
-				openedAt,
-				status: "open"
-			};
-		},
-		answerDecision: (id, choice, by) => Number(answer.run(choice, by, (/* @__PURE__ */ new Date()).toISOString(), id).changes) === 1,
-		withdrawDecision: (id) => {
-			withdraw.run((/* @__PURE__ */ new Date()).toISOString(), id);
-		},
-		decision: (id) => {
-			const row = byId.get(id);
-			return row === void 0 ? void 0 : decisionOf(row);
-		},
-		decisions: (filter) => filtered.all(filter.runId ?? null, filter.project ?? null, filter.status ?? null).map((row) => decisionOf(row)),
-		command: (runId, command) => {
-			const at = (/* @__PURE__ */ new Date()).toISOString();
-			if (command.kind === "stop") addCommand.run(runId, "stop", null, null, at);
-			else addCommand.run(runId, "message", command.node, maskSecrets(command.body), at);
-		},
-		takeCommands: (runId) => {
-			const at = (/* @__PURE__ */ new Date()).toISOString();
-			return pending.all(runId).flatMap((row) => {
-				handled.run(at, Number(row["id"]));
-				const kind = text$1(row, "kind");
-				if (kind === "stop") return [{ kind }];
-				if (kind === "message") return [{
-					kind,
-					node: text$1(row, "node"),
-					body: text$1(row, "body")
-				}];
-				return [];
-			});
-		}
-	};
-};
-// ../core/src/store/feedback.ts
-const STATUSES$1 = [
-	"new",
-	"triaged",
-	"accepted",
-	"dismissed",
-	"published",
-	"resolved"
-];
-const SOURCES = [
-	"system",
-	"agent",
-	"human"
-];
-/** `value` if it is one of `values`, else `fallback`. */
-const oneOf$1 = (values, value, fallback) => values.find((v) => v === value) ?? fallback;
-/** A JSON array column of strings, without nulls. */
-const strings = (row, key) => {
-	const parsed = JSON.parse(text$1(row, key) || "[]");
-	return Array.isArray(parsed) ? parsed.filter((v) => typeof v === "string" && v !== "") : [];
-};
-const ORIGIN_COLUMNS = [
-	["workflow", "workflow"],
-	["workflowHash", "workflow_hash"],
-	["nodeType", "node_type"],
-	["model", "model"],
-	["driver", "driver"],
-	["version", "version"]
-];
-const recordOf$2 = (row) => {
-	const origin = {};
-	for (const [key, column] of ORIGIN_COLUMNS) {
-		const value = text$1(row, column);
-		if (value !== "") origin[key] = value;
-	}
-	const feedback = {
-		source: oneOf$1(SOURCES, text$1(row, "source"), "system"),
-		kind: oneOf$1(FEEDBACK_KINDS, text$1(row, "kind"), "idea"),
-		target: oneOf$1(FEEDBACK_TARGETS, text$1(row, "target"), "workflow"),
-		severity: oneOf$1(FEEDBACK_SEVERITIES, text$1(row, "severity"), "medium"),
-		title: text$1(row, "title"),
-		body: text$1(row, "body"),
-		evidence: strings(row, "evidence"),
-		fingerprint: text$1(row, "fingerprint"),
-		origin
-	};
-	const code = text$1(row, "code");
-	if (code !== "") feedback.code = code;
-	const record = {
-		id: Number(row?.["id"]),
-		runId: text$1(row, "run_id"),
-		seq: Number(row?.["seq"]),
-		at: text$1(row, "at"),
-		feedback
-	};
-	const node = text$1(row, "node");
-	if (node !== "") record.node = node;
-	return record;
-};
-const itemOf = (row) => {
-	const severities = strings(row, "severities");
-	return {
-		id: text$1(row, "fingerprint"),
-		status: oneOf$1(STATUSES$1, text$1(row, "status"), "new"),
-		title: text$1(row, "title"),
-		target: oneOf$1(FEEDBACK_TARGETS, text$1(row, "target"), "workflow"),
-		kind: oneOf$1(FEEDBACK_KINDS, text$1(row, "kind"), "idea"),
-		severity: FEEDBACK_SEVERITIES.toReversed().find((s) => severities.includes(s)) ?? "medium",
-		sources: strings(row, "sources").flatMap((s) => SOURCES.filter((known) => known === s)),
-		count: Number(row?.["count"]),
-		firstSeen: text$1(row, "first_seen"),
-		lastSeen: text$1(row, "last_seen"),
-		runs: strings(row, "runs"),
-		workflows: strings(row, "workflows"),
-		models: strings(row, "models")
-	};
-};
-const ITEMS = `SELECT f.fingerprint, i.status,
-     (SELECT title FROM feedback WHERE fingerprint = f.fingerprint ORDER BY id LIMIT 1) AS title,
-     MIN(f.target) AS target, MIN(f.kind) AS kind,
-     json_group_array(DISTINCT f.severity) AS severities,
-     json_group_array(DISTINCT f.source) AS sources,
-     COUNT(*) AS count, MIN(f.at) AS first_seen, MAX(f.at) AS last_seen,
-     json_group_array(DISTINCT f.run_id) AS runs,
-     json_group_array(DISTINCT f.workflow) AS workflows,
-     json_group_array(DISTINCT f.model) AS models
-   FROM feedback f JOIN feedback_items i ON i.fingerprint = f.fingerprint`;
-const feedbackQueries = (db) => {
-	const insert = db.prepare(`INSERT INTO feedback (run_id, seq, at, node, source, kind, target, severity,
-       title, body, evidence, code, fingerprint, workflow, workflow_hash,
-       node_type, model, driver, version, feedback_version)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-	const insertItem = db.prepare(`INSERT INTO feedback_items (fingerprint, status, updated_at)
-     VALUES (?, 'new', ?) ON CONFLICT (fingerprint) DO NOTHING`);
-	const shown = db.prepare(`${ITEMS} WHERE i.status != 'dismissed' GROUP BY f.fingerprint ORDER BY last_seen DESC`);
-	const every = db.prepare(`${ITEMS} GROUP BY f.fingerprint ORDER BY last_seen DESC`);
-	const byPrefix = db.prepare(`${ITEMS} WHERE substr(f.fingerprint, 1, ?) = ? GROUP BY f.fingerprint ORDER BY last_seen DESC`);
-	const records = db.prepare("SELECT * FROM feedback WHERE fingerprint = ? ORDER BY id");
-	const setStatus = db.prepare("UPDATE feedback_items SET status = ?, updated_at = ? WHERE fingerprint = ?");
-	return {
-		insertFeedback: (runId, seq, at, node, feedback) => {
-			const { origin } = feedback;
-			insert.run(runId, seq, at, node ?? null, feedback.source, feedback.kind, feedback.target, feedback.severity, maskSecrets(feedback.title), maskSecrets(feedback.body), JSON.stringify(feedback.evidence.map((e) => maskSecrets(e))), feedback.code ?? null, feedback.fingerprint, origin.workflow ?? null, origin.workflowHash ?? null, origin.nodeType ?? null, origin.model ?? null, origin.driver ?? null, origin.version ?? null, 1);
-			insertItem.run(feedback.fingerprint, at);
-		},
-		feedbackItems: (filter = {}) => (filter.all === true ? every : shown).all().map((r) => itemOf(r)),
-		findFeedback: (prefix) => byPrefix.all(prefix.length, prefix).map((r) => itemOf(r)),
-		feedbackRecords: (fingerprint) => records.all(fingerprint).map((r) => recordOf$2(r)),
-		setFeedbackStatus: (fingerprint, status) => Number(setStatus.run(status, (/* @__PURE__ */ new Date()).toISOString(), fingerprint).changes) > 0
-	};
-};
-// ../core/src/store/projects.ts
-/**
-* @file The store's registered projects (ADR-035): which repositories Ork
-*   knows, and where it keeps each one's files (in the repository, or in
-*   `~/.ork/projects/<id>/` when attached), and moving it from one to the other
-*   (`ork migrate`) with its runs' workflow files.
-*/
-const recordOf$1 = (row) => ({
-	id: text$1(row, "id"),
-	root: text$1(row, "root"),
-	mode: PROJECT_MODES.find((m) => m === text$1(row, "mode")) ?? "in-repo",
-	dir: text$1(row, "dir"),
-	registeredAt: text$1(row, "registered_at")
-});
-const projectQueries = (db) => {
-	const all = db.prepare("SELECT * FROM projects ORDER BY id");
-	const insert = db.prepare(`INSERT INTO projects (id, root, mode, dir, registered_at)
-     VALUES (?, ?, ?, ?, ?)`);
-	const remove = db.prepare("DELETE FROM projects WHERE id = ?");
-	const move = db.prepare("UPDATE projects SET root = ?, mode = ?, dir = ? WHERE id = ?");
-	const rehome = db.prepare("UPDATE runs SET project = ? WHERE project = ?");
-	const refile = db.prepare(`UPDATE runs SET file = ? || substr(file, ?)
-     WHERE project = ? AND substr(file, 1, ?) = ?`);
-	return {
-		projects: () => all.all().map((r) => recordOf$1(r)),
-		addProject: (project) => {
-			const record = {
-				...project,
-				registeredAt: (/* @__PURE__ */ new Date()).toISOString()
-			};
-			insert.run(record.id, record.root, record.mode, record.dir, record.registeredAt);
-			return record;
-		},
-		forgetProject: (id) => Number(remove.run(id).changes) > 0,
-		moveProject: (id, place) => {
-			const before = all.all().map((r) => recordOf$1(r)).find((p) => p.id === id);
-			if (before === void 0) return false;
-			const from = `${before.dir}${path.sep}`;
-			const root = place.root ?? before.root;
-			db.exec("BEGIN");
-			try {
-				move.run(root, place.mode, place.dir, id);
-				rehome.run(root, before.root);
-				refile.run(`${place.dir}${path.sep}`, from.length + 1, root, from.length, from);
-				db.exec("COMMIT");
-			} catch (error) {
-				db.exec("ROLLBACK");
-				throw error;
-			}
-			return true;
-		}
-	};
-};
-// ../core/src/store/queries.ts
-/** Every query set on `db`; `insertFeedback` is the store's own. */
-const storeQueries = (db) => ({
-	...decisionQueries(db),
-	...feedbackQueries(db),
-	...projectQueries(db)
-});
-// ../core/src/store/sqlite.ts
-/**
-* @file The event store on `node:sqlite` (ADR-024): one database for every
-*   project, `~/.ork/state.db`, in WAL mode so other `ork` processes read while
-*   a run writes. Events are stored with secrets masked, feedback records
-*   beside them, and the registered projects; the schema is versioned with
-*   `user_version`.
-*/
-/** `~/.ork/state.db`; `home` is `~` (tests pass a folder). */
-const storePath = (home = homedir()) => path.join(home, ".ork", "state.db");
-const STATUSES = [
-	"running",
-	"succeeded",
-	"failed",
-	"budget_exhausted",
-	"interrupted"
-];
-const statusOf = (value) => STATUSES.find((s) => s === value) ?? "failed";
-const recordOf = (row) => {
-	const record = {
-		id: text$1(row, "id"),
-		workflow: text$1(row, "workflow"),
-		file: text$1(row, "file"),
-		project: text$1(row, "project"),
-		status: statusOf(text$1(row, "status")),
-		pid: Number(row?.["pid"]),
-		startedAt: text$1(row, "started_at"),
-		costUsd: Number(row?.["cost_usd"])
-	};
-	const finished = text$1(row, "finished_at");
-	if (finished !== "") record.finishedAt = finished;
-	return record;
-};
-/** An event as the store wrote it. */
-const eventOf = (data) => JSON.parse(data);
-/** The node an event is about, for filtering. */
-const nodeOf = (event) => {
-	if ("id" in event && typeof event.id === "string") return event.id;
-	if ("node" in event && typeof event.node === "string") return event.node;
-	return null;
-};
-/** Opens (and creates) the store at `file`; `:memory:` for tests. */
-const openStore = (file = storePath()) => {
-	if (file !== ":memory:") mkdirSync(path.dirname(file), { recursive: true });
-	const db = new DatabaseSync(file);
-	db.exec("PRAGMA journal_mode = WAL");
-	db.exec("PRAGMA synchronous = NORMAL");
-	db.exec("PRAGMA busy_timeout = 5000");
-	db.exec("PRAGMA foreign_keys = ON");
-	migrate$1(db);
-	const insertRun = db.prepare(`INSERT INTO runs (id, workflow, file, project, status, pid, started_at)
-     VALUES (?, ?, ?, ?, 'running', ?, ?)`);
-	const lastSeq = db.prepare("SELECT COALESCE(MAX(seq), 0) AS seq FROM events WHERE run_id = ?");
-	const insertEvent = db.prepare("INSERT INTO events (run_id, seq, at, type, node, data) VALUES (?, ?, ?, ?, ?, ?)");
-	const finishRun = db.prepare("UPDATE runs SET status = ?, finished_at = ?, cost_usd = ? WHERE id = ?");
-	const reopenRun = db.prepare("UPDATE runs SET status = 'running', pid = ?, finished_at = NULL WHERE id = ?");
-	const addCost = db.prepare("UPDATE runs SET cost_usd = cost_usd + ? WHERE id = ?");
-	const byId = db.prepare("SELECT * FROM runs WHERE id = ?");
-	const byPrefix = db.prepare("SELECT * FROM runs WHERE substr(id, 1, ?) = ? ORDER BY started_at DESC, rowid DESC");
-	const allRuns = db.prepare("SELECT * FROM runs ORDER BY started_at DESC, rowid DESC LIMIT ?");
-	const projectRuns = db.prepare("SELECT * FROM runs WHERE project = ? ORDER BY started_at DESC, rowid DESC LIMIT ?");
-	const eventsAfter = db.prepare("SELECT seq, at, data FROM events WHERE run_id = ? AND seq > ? ORDER BY seq");
-	const { insertFeedback, ...queries } = storeQueries(db);
-	return {
-		...queries,
-		begin: (run) => {
-			const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-			insertRun.run(run.id, run.workflow, run.file, run.project, process.pid, startedAt);
-			return {
-				...run,
-				status: "running",
-				pid: process.pid,
-				startedAt,
-				costUsd: 0
-			};
-		},
-		reopen: (runId) => {
-			reopenRun.run(process.pid, runId);
-		},
-		append: (runId, event) => {
-			const at = (/* @__PURE__ */ new Date()).toISOString();
-			const seq = Number(lastSeq.get(runId)?.["seq"] ?? 0) + 1;
-			insertEvent.run(runId, seq, at, event.type, nodeOf(event), JSON.stringify(event, maskReplacer));
-			if (event.type === "node.finished" && event.usage !== void 0) addCost.run(event.usage.costUsd, runId);
-			if (event.type === "feedback.recorded") insertFeedback(runId, seq, at, event.node, event.feedback);
-			if (event.type === "run.finished") finishRun.run(event.result.status, at, event.result.costUsd, runId);
-			return {
-				runId,
-				seq,
-				at,
-				event
-			};
-		},
-		runs: (filter = {}) => {
-			const limit = filter.limit ?? -1;
-			return (filter.project === void 0 ? allRuns.all(limit) : projectRuns.all(filter.project, limit)).map((r) => recordOf(r));
-		},
-		lookup: (prefix) => {
-			const exact = byId.get(prefix);
-			if (exact !== void 0) return [recordOf(exact)];
-			return byPrefix.all(prefix.length, prefix).map((r) => recordOf(r));
-		},
-		events: (runId, after = 0) => eventsAfter.all(runId, after).map((r) => ({
-			runId,
-			seq: Number(r["seq"]),
-			at: text$1(r, "at"),
-			event: eventOf(text$1(r, "data"))
-		})),
-		close: () => {
-			db.close();
-		}
-	};
-};
-// ../core/src/store/view.ts
-const blank = (id, type, parent) => {
-	const node = {
-		id,
-		type,
-		state: "waiting",
-		runs: 0,
-		costUsd: 0,
-		inputTokens: 0,
-		outputTokens: 0,
-		children: []
-	};
-	if (parent !== void 0) node.parent = parent;
-	return node;
-};
-/** A spawned worker's template: `<template>-<n>` of a declared node. */
-const templateOf$1 = (id, declared) => {
-	const base = /^(?<base>.+)-\d+$/u.exec(id)?.groups?.["base"];
-	return base !== void 0 && declared.has(base) ? base : void 0;
-};
-/** Folds a run's events into its ownership tree; roots in declared order. */
-const runTree = (events) => {
-	const nodes = /* @__PURE__ */ new Map();
-	const declared = /* @__PURE__ */ new Map();
-	for (const event of events) if (event.type === "run.started") for (const info of event.nodes) {
-		if (nodes.has(info.id)) continue;
-		const node = blank(info.id, info.type, info.parent);
-		nodes.set(info.id, node);
-		declared.set(info.id, node);
-	}
-	else if (event.type === "node.started") {
-		let node = nodes.get(event.id);
-		if (node === void 0) {
-			node = blank(event.id, event.nodeType, event.owner);
-			const template = templateOf$1(event.id, declared);
-			if (template !== void 0) node.template = template;
-			nodes.set(event.id, node);
-		}
-		node.state = "running";
-		node.runs += 1;
-	} else if (event.type === "node.finished") {
-		const node = nodes.get(event.id);
-		if (node === void 0) continue;
-		node.state = event.ok ? "ok" : "failed";
-		node.output = event.output;
-		node.costUsd += event.usage?.costUsd ?? 0;
-		node.inputTokens += event.usage?.inputTokens ?? 0;
-		node.outputTokens += event.usage?.outputTokens ?? 0;
-	} else if (event.type === "node.skipped") {
-		const node = nodes.get(event.id);
-		if (node !== void 0) node.state = "skipped";
-	}
-	const roots = [];
-	for (const node of nodes.values()) {
-		const owner = node.parent === void 0 ? void 0 : nodes.get(node.parent);
-		if (owner === void 0) roots.push(node);
-		else owner.children.push(node);
-	}
-	return roots;
-};
-const alive = (pid) => {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		return error instanceof Error && "code" in error && error.code === "EPERM";
-	}
-};
-/** A run's status, with `crashed` for a `running` run whose process is gone. */
-const liveStatus = (run) => run.status === "running" && !alive(run.pid) ? "crashed" : run.status;
-// ../core/src/update/version.ts
-const VERSION = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/u;
-/** `1.2.3`, `v1.2.3-beta.1` and the like; `null` for anything else. */
-const parseVersion = (text) => {
-	const match = VERSION.exec(text.trim());
-	if (match === null) return null;
-	const [, major = "0", minor = "0", patch = "0", pre] = match;
-	return {
-		core: [
-			Number(major),
-			Number(minor),
-			Number(patch)
-		],
-		pre: pre === void 0 ? [] : pre.split(".")
-	};
-};
-const NUMERIC = /^\d+$/u;
-/** One pre-release identifier against another: numbers sort below words. */
-const compareIdentifier = (a, b) => {
-	const an = NUMERIC.test(a);
-	const bn = NUMERIC.test(b);
-	if (an && bn) return Number(a) - Number(b);
-	if (an !== bn) return an ? -1 : 1;
-	return a < b ? -1 : Number(a > b);
-};
-const comparePre = (a, b) => {
-	if (a.length === 0 || b.length === 0) return b.length - a.length;
-	for (let i = 0; i < Math.min(a.length, b.length); i += 1) {
-		const order = compareIdentifier(a[i] ?? "", b[i] ?? "");
-		if (order !== 0) return order;
-	}
-	return a.length - b.length;
-};
-/** Semver precedence: negative when `a` is older, 0 when equal. */
-const compareVersions = (a, b) => {
-	for (let i = 0; i < 3; i += 1) {
-		const order = (a.core[i] ?? 0) - (b.core[i] ?? 0);
-		if (order !== 0) return order;
-	}
-	return comparePre(a.pre, b.pre);
-};
-/** Whether `candidate` is newer than `current`; false when either is invalid. */
-const isNewer = (candidate, current) => {
-	const a = parseVersion(candidate);
-	const b = parseVersion(current);
-	return a !== null && b !== null && compareVersions(a, b) > 0;
-};
 const updateCachePath = (home = homedir()) => path.join(home, ".ork", "update-check.json");
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const text = (record, key) => {
@@ -1484,799 +617,80 @@ const pendingNotice = (cache, current, now) => {
 	const told = cache?.notified;
 	return told?.version === newer && age(told.at, now) < 864e5 ? null : newer;
 };
-// ../core/src/worktree/list.ts
+// src/runs/chat.ts
 /**
-* @file What `ork worktrees` shows and cleans: every worktree and branch Ork's
-*   runs recorded creating, whatever the project's git rules named them, and
-*   any `ork/*` branch besides, with their state read from git itself.
+* @file `ork chat`'s two paths. A node of a live run gets the message through
+*   the store and the run's socket, and the run's bus pushes it into the node's
+*   session (specs/messaging.md#chat; `tellLiveRun` and `nodeSession` are in
+*   core). A node of a finished run gets it by resuming its last Claude session
+*   where it ran, 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 worktrees the project's runs recorded creating, oldest run first; one
-* entry per branch or folder, from the latest run that created it.
+* Resumes a finished node's last session with the user's message, prints the
+* session, and adds it to the run's record. Returns why it could not.
 */
-const createdWorktrees = (store, project) => {
-	const byName = /* @__PURE__ */ new Map();
-	for (const run of store.runs({ project }).toReversed()) for (const { event } of store.events(run.id)) {
-		if (event.type !== "worktree" || event.action !== "created") continue;
-		byName.set(event.branch ?? event.path, {
-			runId: run.id,
-			nodeId: event.id,
-			path: event.path,
-			...event.branch === void 0 ? {} : { branch: event.branch }
+const resumeChat = async (options) => {
+	const { store, run, node } = options;
+	const { session, outputs } = nodeSession(store.events(run.id, 0), node);
+	if (!session.known) return `${node} is not a node of run ${run.id}.`;
+	if (!session.chattable) return `${node} is not a leader or worker; only they have sessions to talk to.`;
+	if (session.sessionId === void 0) return `${node} has no Claude session to resume in run ${run.id}.`;
+	const cwd = session.cwd ?? session.checkout?.path;
+	if (cwd === void 0 || !existsSync(cwd)) return `${node}'s session ran in ${cwd ?? "a folder Ork did not record"}, which is gone (a merged worktree is removed), so it cannot be resumed.`;
+	const { workflow, place, workflowDir } = loadWorkflow(run.file, path.dirname(run.file), void 0, store.projects());
+	if (workflow === null) return `The workflow ${run.file} is gone or no longer valid.`;
+	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 plan = planNodeSession(workflow, node, {
+		cwd,
+		inputs: {},
+		outputs,
+		inPlace: session.checkout === void 0,
+		workflowDir,
+		projectRoot: run.project,
+		orkDir: place.dir,
+		pluginDir: path.join(runDir, "plugins", node),
+		...options.budgetLeftUsd === void 0 ? {} : { budgetLeftUsd: options.budgetLeftUsd },
+		...session.checkout === void 0 ? {} : { checkout: session.checkout },
+		...template === void 0 ? {} : { template }
+	});
+	if (!plan.ok) return plan.error;
+	const record = appendRecorder(store, run.id, runDir);
+	record({
+		type: "user.message",
+		node,
+		body: options.body,
+		delivered: "resumed"
+	});
+	const started = (await options.runtime(options.driver ?? session.driver ?? plan.driver)).start({
+		...plan.spec,
+		resume: session.sessionId,
+		prompt: options.body
+	}, { human: options.human });
+	if (options.signal?.aborted === true) started.interrupt();
+	options.signal?.addEventListener("abort", () => {
+		started.interrupt();
+	}, { once: true });
+	const tools = /* @__PURE__ */ new Map();
+	let failure = null;
+	for await (const event of started.events) {
+		record({
+			type: "node.event",
+			id: node,
+			event
 		});
+		for (const line of formatEvent(node, event, tools)) options.out(line);
+		if (event.type === "session.finished" && event.outcome.subtype === "error_driver") failure = event.outcome.errors.join("; ");
 	}
-	return [...byName.values()];
-};
-const parsePorcelain = (text) => text.split("\n\n").map((block) => lines(block)).map((fields) => {
-	const value = (key) => fields.find((f) => f.startsWith(`${key} `))?.slice(key.length + 1);
-	return {
-		path: value("worktree") ?? "",
-		branch: (value("branch") ?? "").replace(/^refs\/heads\//u, ""),
-		prunable: fields.some((f) => f.startsWith("prunable"))
-	};
-}).filter((entry) => entry.path !== "");
-/** The `ork/<run>/<node>` branches of runs that recorded nothing. */
-const prefixed = (branch) => {
-	const [, runId = "", ...rest] = branch.split("/");
-	return {
-		runId,
-		nodeId: rest.join("/"),
-		path: "",
-		branch
-	};
-};
-/** How many commits a detached worktree holds that no branch, tag or remote has. */
-const onNoBranch = async (entry) => entry === void 0 ? "0" : (await git(entry.path, [
-	"rev-list",
-	"--count",
-	"HEAD",
-	"--not",
-	"--branches",
-	"--tags",
-	"--remotes"
-])).stdout;
-/** One created worktree or branch, with its state read from git. */
-const stateOf = async (root, entries, item) => {
-	const { branch } = item;
-	const entry = branch === void 0 ? entries.find((e) => e.path === item.path) : entries.find((e) => e.branch === branch);
-	const missing = entry !== void 0 && (entry.prunable || !existsSync(entry.path));
-	const status = entry === void 0 || missing ? "" : (await git(entry.path, ["status", "--porcelain"])).stdout;
-	const checkedOut = branch === void 0 && entry !== void 0 && entry.branch !== "" ? entry.branch : void 0;
-	const on = branch ?? checkedOut;
-	const counted = on === void 0 ? await onNoBranch(entry === void 0 || missing ? void 0 : entry) : (await git(root, [
-		"rev-list",
-		"--count",
-		`HEAD..${on}`
-	])).stdout;
-	const ahead = Number(counted);
-	return {
-		...branch === void 0 ? {} : { branch },
-		...checkedOut === void 0 ? {} : { checkedOut },
-		runId: item.runId,
-		nodeId: item.nodeId,
-		path: entry?.path ?? null,
-		missing,
-		dirty: lines(status).length > 0,
-		ahead: Number.isNaN(ahead) ? 0 : ahead,
-		merged: on !== void 0 && ahead === 0,
-		inMainCheckout: entry?.path === root
-	};
-};
-/**
-* Every worktree and branch Ork's runs created in the repository at `root`,
-* with its state: those the runs recorded (`created`, whatever the project's
-* git rules named them), and any `ork/` branch besides. A recorded one that git
-* no longer has is left out.
-*/
-const listOrkWorktrees = async (root, created = []) => {
-	const entries = parsePorcelain(await gitOk(root, [
-		"worktree",
-		"list",
-		"--porcelain"
-	]));
-	const branches = lines(await gitOk(root, [
-		"for-each-ref",
-		"--format=%(refname:short)",
-		"refs/heads/"
-	]));
-	const recordedBranches = new Set(created.flatMap((c) => c.branch ?? []));
-	const items = [...created.filter((c) => c.branch === void 0 ? entries.some((e) => e.path === c.path) : branches.includes(c.branch)), ...branches.filter((b) => b.startsWith("ork/") && !recordedBranches.has(b)).map((b) => prefixed(b))];
-	return Promise.all(items.map((item) => stateOf(root, entries, item)));
-};
-const cleanStep = (item, options) => {
-	if (item.inMainCheckout) return {
-		item,
-		removeWorktree: false,
-		deleteBranch: false,
-		skip: "checked out in the main checkout"
-	};
-	if (item.dirty && !options.force) return {
-		item,
-		removeWorktree: false,
-		deleteBranch: false,
-		skip: "uncommitted changes"
-	};
-	if (item.branch === void 0 && item.checkedOut === void 0 && item.ahead > 0 && !options.force) return {
-		item,
-		removeWorktree: false,
-		deleteBranch: false,
-		skip: "commits on no branch"
-	};
-	const removable = item.path !== null && !item.missing;
-	if (options.branches && item.branch !== void 0 && !item.merged && !options.force) return {
-		item,
-		removeWorktree: removable,
-		deleteBranch: false,
-		skip: "branch not merged"
-	};
-	return {
-		item,
-		removeWorktree: removable,
-		deleteBranch: options.branches && item.branch !== void 0
-	};
-};
-/**
-* What `ork worktrees clean` would do. A worktree with uncommitted changes, an
-* unmerged branch, or a detached worktree holding commits no branch has, is
-* kept unless `force`.
-*/
-const planClean = (items, filter, options) => items.filter((item) => filter.runId === void 0 || item.runId === filter.runId).filter((item) => !filter.merged || item.merged).map((item) => cleanStep(item, options));
-/** Carries out a clean plan, then prunes stale worktree entries. */
-const applyClean = async (root, steps, force) => {
-	const done = [];
-	await gitOk(root, ["worktree", "prune"]);
-	for (const step of steps) {
-		const { item } = step;
-		if (step.removeWorktree && item.path !== null) {
-			await removeWorktree(root, item.path, force);
-			done.push(`removed ${item.path}`);
-		}
-		if (step.deleteBranch && item.branch !== void 0) {
-			await gitOk(root, [
-				"branch",
-				force ? "-D" : "-d",
-				item.branch
-			]);
-			done.push(`deleted ${item.branch}`);
-		}
-	}
-	await gitOk(root, ["worktree", "prune"]);
-	return done;
-};
-// src/output.ts
-/**
-* @file Terminal output helpers: styled text that turns plain when stdout is
-*   not a TTY or `NO_COLOR` is set, and a yes-or-no question on the terminal.
-*/
-/** Styles text for stdout; plain when stdout is not a TTY or NO_COLOR is set. */
-const style = (format, text) => styleText(format, text, { stream: process.stdout });
-const write = (text) => {
-	process.stdout.write(`${text}\n`);
-};
-const writeErr = (text) => {
-	process.stderr.write(`${text}\n`);
-};
-/** Asks a yes-or-no question on the terminal; anything but yes is no. */
-const confirm = async (question) => {
-	const rl = createInterface({
-		input: process.stdin,
-		output: process.stderr
-	});
-	try {
-		const answer = await rl.question(question);
-		return ["y", "yes"].includes(answer.trim().toLowerCase());
-	} finally {
-		rl.close();
-	}
-};
-// src/human.ts
-/**
-* @file The terminal `HumanChannel`: answers `ask_user` questions, gates and
-*   permission prompts on the terminal, one at a time, and denies or defers
-*   when no one is there. In a run it is the decision queue's local answerer,
-*   racing `ork decide`.
-*/
-const PREVIEW = 160;
-const NO_ONE_TO_PERMIT = "No one is at the terminal to approve this tool, so it is not allowed in this run.";
-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 = [
-		"command",
-		"file_path",
-		"path",
-		"url",
-		"pattern"
-	].find((k) => typeof input[k] === "string");
-	const line = (key === void 0 ? JSON.stringify(input) : `${key}: ${String(input[key])}`).replaceAll(/\s+/gu, " ").trim();
-	return line.length > PREVIEW ? `${toolName} ${line.slice(0, 159)}…` : `${toolName} ${line}`;
-};
-/** The option an answer names: its number, or its id. */
-const pickOption = (answer, options, recommended) => {
-	const value = answer.trim();
-	if (value === "") return recommended;
-	const index = Number(value);
-	if (Number.isInteger(index) && index >= 1 && index <= options.length) return options[index - 1]?.id;
-	return options.find((o) => o.id === value)?.id;
-};
-const optionLine = (option, index, recommended) => {
-	const label = option.label === void 0 ? "" : ` ${option.label}`;
-	const description = option.description === void 0 ? "" : style("dim", ` - ${option.description}`);
-	const mark = option.id === recommended ? style("green", " (recommended)") : "";
-	return `  ${String(index + 1)}) ${style("bold", option.id)}${label}${description}${mark}`;
-};
-/**
-* Answers permission prompts and `ask_user` questions on the terminal, one at a
-* time. Without a terminal it denies tools and leaves questions to the node. A
-* withdrawn prompt (answered elsewhere) rejects, which frees the turn.
-*/
-const createTerminalHuman = (io) => {
-	let rl;
-	let turn = Promise.resolve();
-	const say = (text) => {
-		io.output.write(`${text}\n`);
-	};
-	const prompt = (text, signal) => {
-		rl ??= createInterface({
-			input: io.input,
-			output: io.output
-		});
-		return signal === void 0 ? rl.question(text) : rl.question(text, { signal });
-	};
-	const choose = async (hint, options, recommended, signal) => {
-		const picked = pickOption(await prompt(`  Choose${hint}: `, signal), options, recommended);
-		if (picked !== void 0) return picked;
-		say(style("dim", "  Type an option's number or id."));
-		return choose(hint, options, recommended, signal);
-	};
-	const oneAtATime = (work) => {
-		const result = turn.then(work);
-		turn = result.catch(() => null);
-		return result;
-	};
-	return {
-		permit: ({ nodeId, toolName, input, signal }) => oneAtATime(async () => {
-			if (signal?.aborted === true) throw new Error("the prompt was withdrawn");
-			say(`${style(["yellow", "bold"], "?")} ${style("bold", nodeId)} wants to run ${previewInput(toolName, input)}`);
-			if (!io.interactive) {
-				say(style("dim", `  denied: ${NO_ONE_TO_PERMIT}`));
-				return {
-					allow: false,
-					message: NO_ONE_TO_PERMIT
-				};
-			}
-			const answer = (await prompt("  Allow? [y/N] ", signal)).trim().toLowerCase();
-			return answer === "y" || answer === "yes" ? { allow: true } : {
-				allow: false,
-				message: "The user did not allow this tool."
-			};
-		}),
-		ask: ({ nodeId, question, options, recommended, context, signal }) => oneAtATime(() => {
-			if (signal?.aborted === true) return Promise.reject(/* @__PURE__ */ new Error("the question was withdrawn"));
-			say(`${style(["yellow", "bold"], "?")} ${style("bold", nodeId)} asks: ${question}`);
-			if (context !== void 0) say(style("dim", `  ${context}`));
-			for (const [index, option] of options.entries()) say(optionLine(option, index, recommended));
-			if (!io.interactive) {
-				const answer = recommended ?? NO_ONE_TO_ASK;
-				say(style("dim", `  no terminal; answered ${answer}`));
-				return Promise.resolve(answer);
-			}
-			const fallback = options.findIndex((o) => o.id === recommended);
-			const hint = fallback === -1 ? "" : ` [${String(fallback + 1)}]`;
-			return choose(hint, options, recommended, signal);
-		}),
-		close: () => {
-			rl?.close();
-		}
-	};
-};
-// src/project/place.ts
-/**
-* @file Which project a folder belongs to, from the projects the store has
-*   registered (ADR-035): an attached project's files are in
-*   `~/.ork/projects/<id>/`, an in-repo one's in its `.ork/`.
-*/
-/** The registered projects; none before Ork has a store (never creates one). */
-const registeredProjects = (home) => {
-	const file = storePath(home);
-	if (!existsSync(file)) return [];
-	const store = openStore(file);
-	try {
-		return store.projects();
-	} finally {
-		store.close();
-	}
-};
-/** The project `dir` is in: registered, or the in-repo one at its git root. */
-const projectAt = (dir, home) => placeFor(dir, registeredProjects(home));
-/** A path to show: relative to `cwd` when inside it, else as it is. */
-const fromCwd = (target, cwd) => inside(cwd, target) ? path.relative(cwd, target) || "." : target;
-// src/workflows.ts
-/**
-* @file Finding workflow files: the project's workflows folder by default
-*   (`.ork/workflows/`, or an attached project's), directories expanded, and a
-*   workflow given by name.
-*/
-const WORKFLOW_DIR = path.join(".ork", "workflows");
-const WORKFLOW_SUFFIX = ".ork.yaml";
-/**
-* Expands the given paths to workflow files: a directory contributes its
-* `*.ork.yaml` files, and a name one in the project's workflows folder
-* (`workflows`, default `.ork/workflows/` under `cwd`). With no paths, uses
-* that folder.
-*/
-const findWorkflowFiles = (paths, cwd, workflows = path.join(cwd, WORKFLOW_DIR)) => {
-	return (paths.length > 0 ? paths : [fromCwd(workflows, cwd)]).flatMap((target) => {
-		const absolute = path.resolve(cwd, target);
-		if (existsSync(absolute) && statSync(absolute).isDirectory()) return readdirSync(absolute).filter((name) => name.endsWith(WORKFLOW_SUFFIX)).toSorted().map((name) => path.join(target, name));
-		return [resolveWorkflowArg(target, cwd, workflows)];
-	});
-};
-/**
-* A workflow given by path, or by name for one in the project's workflows
-* folder: `hello` is `.ork/workflows/hello.ork.yaml` when no file `hello`
-* exists.
-*/
-const resolveWorkflowArg = (arg, cwd, workflows = path.join(cwd, WORKFLOW_DIR)) => {
-	if (existsSync(path.resolve(cwd, arg)) || arg.endsWith(".ork.yaml")) return arg;
-	const named = path.join(workflows, `${arg}${WORKFLOW_SUFFIX}`);
-	return existsSync(named) ? fromCwd(named, cwd) : arg;
-};
-/**
-* A command's workflow argument, by path or by name in the project `cwd` is in,
-* with the project the file belongs to and a run's folder there.
-*/
-const workflowArg = (arg, cwd) => {
-	const file = resolveWorkflowArg(arg, cwd, placeFiles(projectAt(cwd)).workflows);
-	const place = projectAt(path.dirname(path.resolve(cwd, file)));
-	return {
-		file,
-		place,
-		runDir: (runId) => runDirOf(place, runId)
-	};
-};
-// src/commands/validate.ts
-/**
-* @file `ork validate`: loads, parses and compiles workflow files with the
-*   project's rules (`.ork/project.yaml`) and the agents they name, checks
-*   their skill and context references, and reports diagnostics compiler-style,
-*   with file, line and column. `loadWorkflow` is shared with `ork run`.
-*/
-const hasErrors = (diagnostics) => diagnostics.some((d) => d.severity === "error");
-/**
-* Parses and compiles one workflow file, with the agents the user and its
-* project offer. `home` is the user's `~` (tests pass a folder); `registered`
-* the projects a caller's store has, else those of the store in `home`.
-*/
-const loadWorkflow = (file, cwd, home, registered = registeredProjects(home)) => {
-	const absolute = path.resolve(cwd, file);
-	const place = placeFor(path.dirname(absolute), registered);
-	const workflowDir = workflowDirOf(place, absolute);
-	const where = {
-		place,
-		workflowDir
-	};
-	let text;
-	try {
-		text = readFileSync(path.resolve(cwd, file), "utf8");
-	} catch (error) {
-		return {
-			report: {
-				file,
-				diagnostics: [{
-					severity: "error",
-					code: "file.read",
-					message: error instanceof Error && "code" in error && error.code === "ENOENT" ? "file not found" : "cannot read file",
-					path: []
-				}]
-			},
-			workflow: null,
-			graph: null,
-			...where
-		};
-	}
-	const parsed = parseWorkflow(text);
-	if (!parsed.ok) return {
-		report: {
-			file,
-			diagnostics: parsed.diagnostics
-		},
-		workflow: null,
-		graph: null,
-		...where
-	};
-	const projectRoot = place.root;
-	const catalog = loadAgents({
-		projectRoot,
-		orkDir: place.dir,
-		...home === void 0 ? {} : { home }
-	});
-	const loaded = loadProject(projectRoot, placeFiles(place).rules);
-	const compiled = compileWorkflow(parsed.workflow, {
-		catalog,
-		workflowDir,
-		projectRoot,
-		...loaded.project === void 0 ? {} : { project: loaded.project }
-	});
-	const { graph } = compiled;
-	const diagnostics = [
-		...loaded.diagnostics,
-		...compiled.diagnostics,
-		...graph === null ? [] : contextDiagnostics(graph.workflow, {
-			workflowDir,
-			projectRoot
-		})
-	];
-	const located = [];
-	for (const diagnostic of diagnostics) {
-		const position = parsed.locate(diagnostic.path);
-		located.push(position === null ? diagnostic : {
-			...diagnostic,
-			...position
-		});
-	}
-	if (graph === null) return {
-		report: {
-			file,
-			diagnostics: located
-		},
-		workflow: null,
-		graph: null,
-		...where
-	};
-	return {
-		report: {
-			file,
-			diagnostics: located,
-			summary: {
-				nodes: graph.nodes.size,
-				edges: graph.edges.length,
-				entries: graph.entries
-			}
-		},
-		workflow: hasErrors(located) ? null : graph.workflow,
-		graph: hasErrors(located) ? null : graph,
-		...where
-	};
-};
-const validateFile = (file, cwd) => loadWorkflow(file, cwd).report;
-const plural$1 = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
-/** Human-readable report, one line per diagnostic, compiler style. */
-const formatReport = (report) => {
-	const lines = report.diagnostics.map((d) => {
-		const where = d.line === void 0 ? report.file : `${report.file}:${d.line}:${d.column ?? 1}`;
-		const severity = d.severity === "error" ? style(["red", "bold"], "error") : style(["yellow", "bold"], "warning");
-		return `${style("dim", where)} ${severity} ${d.message} ${style("dim", `(${d.code})`)}`;
-	});
-	const errors = report.diagnostics.filter((d) => d.severity === "error").length;
-	const warnings = report.diagnostics.length - errors;
-	if (report.summary !== void 0 && errors === 0) {
-		const { nodes, edges, entries } = report.summary;
-		const extra = warnings > 0 ? `, ${plural$1(warnings, "warning")}` : "";
-		lines.push(`${style("green", "✓")} ${report.file} ${style("dim", `(${plural$1(nodes, "node")}, ${plural$1(edges, "edge")}, starts at ${entries.join(", ")}${extra})`)}`);
-	} else lines.push(`${style("red", "✗")} ${report.file} ${style("dim", `(${plural$1(errors, "error")}, ${plural$1(warnings, "warning")})`)}`);
-	return lines;
-};
-const validate = defineCommand({
-	meta: {
-		name: "validate",
-		description: "Check workflow files: schema, ownership tree, edges, loops, and references"
-	},
-	args: { json: {
-		type: "boolean",
-		description: "Print the reports as JSON",
-		default: false
-	} },
-	run: ({ args }) => {
-		const cwd = process.cwd();
-		const files = findWorkflowFiles(args._, cwd, placeFiles(projectAt(cwd)).workflows);
-		if (files.length === 0) {
-			write("No workflow files found. Run `ork init`, or pass a path.");
-			process.exitCode = 1;
-			return;
-		}
-		const reports = files.map((file) => validateFile(file, cwd));
-		if (args.json) write(JSON.stringify(reports, void 0, 2));
-		else for (const report of reports) for (const line of formatReport(report)) write(line);
-		if (reports.some((r) => hasErrors(r.diagnostics))) process.exitCode = 1;
-	}
-});
-// src/run/format.ts
-const STATUS_MARK = {
-	pass: style("green", "✓"),
-	done: style("green", "✓"),
-	changes_requested: style("yellow", "!"),
-	fail: style("red", "✗")
-};
-const seconds = (ms) => `${(ms / 1e3).toFixed(1)}s`;
-const indent = (text) => text.trimEnd().split("\n").map((line) => `  ${line}`);
-/** The usage line: cost, tokens, turns and time. */
-const formatUsage = ({ usage }) => style("dim", [
-	`$${usage.costUsd.toFixed(4)}`,
-	`${String(usage.inputTokens)} in / ${String(usage.outputTokens)} out (${String(usage.cacheReadTokens)} cached)`,
-	`${String(usage.turns)} turns`,
-	seconds(usage.durationMs)
-].join(" · "));
-/** How a finished session reads on the terminal. */
-const formatOutcome = (nodeId, outcome) => {
-	const { report } = outcome;
-	if (report === null) return [
-		`${style("red", "✗")} ${style("bold", nodeId)} ended without a report (${outcome.subtype})`,
-		...outcome.errors.map((e) => `  ${style("red", e)}`),
-		`  ${formatUsage(outcome)}`
-	];
-	const lines = [`${STATUS_MARK[report.status] ?? "-"} ${style("bold", nodeId)} ${report.status}: ${report.summary}`];
-	if (report.branch !== void 0) lines.push(`  branch: ${report.branch}`);
-	for (const [name, file] of Object.entries(report.artifacts)) lines.push(`  ${name}: ${file}`);
-	for (const [name, value] of Object.entries(report.fields)) lines.push(`  ${name}: ${JSON.stringify(value)}`);
-	lines.push(`  ${formatUsage(outcome)}`);
-	return lines;
-};
-/** The transcript lines for one event; tool names come from `tools`. */
-const formatEvent = (nodeId, event, tools) => {
-	if (event.type === "session.started") return [style("dim", `▸ ${nodeId} (${event.model}, session ${event.sessionId})`)];
-	if (event.type === "assistant.text") return indent(event.text);
-	if (event.type === "tool.called") {
-		tools.set(event.id, event.name);
-		return [style("dim", `  · ${previewInput(event.name, event.input)}`)];
-	}
-	if (event.type === "tool.result") return event.isError ? [style("red", `  ✗ ${tools.get(event.id) ?? "tool"} failed`)] : [];
-	return formatOutcome(nodeId, event.outcome);
-};
-/** A one-line verdict for a finished node, by what its type outputs. */
-const nodeVerdict = (output) => {
-	const { status, summary, exitCode, choice, answeredBy, count } = output;
-	if (typeof status === "string") return typeof summary === "string" && summary !== "" ? `${status}: ${summary}` : status;
-	if (typeof exitCode === "number") return `exit ${String(exitCode)}`;
-	if (typeof choice === "string") return `${choice} (${String(answeredBy)})`;
-	if (typeof count === "number") return `${String(count)} ran`;
-	return "done";
-};
-/** Transcript lines for one run event, prefixed with the node they are from. */
-const formatRunEvent = (event, width, tools) => {
-	const tag = (id) => style("cyan", `${id.padEnd(width)} │`);
-	if (event.type === "run.started") return [style("dim", `▸ run ${event.runId} of ${event.workflow} (starts at ${event.entries.join(", ")})`)];
-	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 [];
-		if (inner.type === "session.started") return [`${tag(event.id)} ${style("dim", `${inner.model}, session ${inner.sessionId}`)}`];
-		return formatEvent(event.id, event.event, tools).map((line) => `${tag(event.id)} ${line.replace(/^ {2}/u, "")}`);
-	}
-	if (event.type === "node.finished") {
-		const mark = event.ok ? style("green", "✓") : style("red", "✗");
-		const cost = event.usage === void 0 ? "" : style("dim", ` · $${event.usage.costUsd.toFixed(4)}`);
-		return [`${tag(event.id)} ${mark} ${nodeVerdict(event.output)}${cost}`];
-	}
-	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 === "edge.taken") return [];
-	if (event.type === "worktree") {
-		const detail = event.detail === void 0 ? "" : ` (${event.detail})`;
-		const line = `${event.action} ${event.branch ?? event.path}${detail}`;
-		return [`${tag(event.id)} ${event.action === "conflict" ? style("yellow", `! ${line}`) : style("dim", `⎇ ${line}`)}`];
-	}
-	if (event.type === "decision.opened") {
-		const what = event.kind === "permission" ? "asks to" : "asks:";
-		const question = event.kind === "permission" ? event.question.replace(/^Allow /u, "run ").replace(/\?$/u, "") : event.question;
-		return [`${tag(event.node)} ${style(["yellow", "bold"], "?")} ${what} ${question} ${style("dim", `(decision ${event.decision}; ork decide)`)}`];
-	}
-	if (event.type === "decision.answered") {
-		const by = event.by === "decide" ? "ork decide" : "terminal";
-		return [`${tag(event.node)} ${style("dim", `→ ${event.answer} (${by})`)}`];
-	}
-	if (event.type === "decision.withdrawn") return [`${tag(event.node)} ${style("dim", "→ question withdrawn")}`];
-	if (event.type === "run.command") return [style(["yellow", "bold"], `! ork ${event.command} received`)];
-	if (event.type === "run.finished") return formatRunResult(event.result);
-	if (event.type === "run.resumed") {
-		const [one] = event.kept;
-		const kept = one === void 0 ? "every node runs again" : event.kept.length === 1 ? `${one} keeps its result` : `${event.kept.join(", ")} keep their results`;
-		return ["", style("dim", `▸ resumed: ${kept}`)];
-	}
-	if (event.type === "feedback.recorded") {
-		const { target, kind, title } = event.feedback;
-		const line = style("dim", `✎ feedback (${target}, ${kind}): ${title}`);
-		return [event.node === void 0 ? line : `${tag(event.node)} ${line}`];
-	}
-	if (event.type === "user.message") {
-		const note = event.delivered === "queued" ? " (for its next session)" : "";
-		return [`${tag(event.node)} ${style(["magenta", "bold"], "you:")} ${firstLine(event.body)}${style("dim", note)}`];
-	}
-	return formatBusEvent(event).map((line) => `${tag(event.node)} ${line}`);
-};
-/** The first line of a message body, cut to fit one terminal line. */
-const firstLine = (body) => {
-	const [line = ""] = body.trim().split("\n");
-	return line.length > 100 ? `${line.slice(0, 99)}…` : line;
-};
-/** Messages, owner questions and claims, without the node prefix. */
-const formatBusEvent = (event) => {
-	if (event.type === "claim.taken") return [style("dim", `⚑ claimed ${event.resource}`)];
-	if (event.type === "claim.refused") {
-		const held = event.held === event.resource ? "" : ` (it holds ${event.held})`;
-		return [style("yellow", `⚑ ${event.resource} is ${event.holder}'s${held}`)];
-	}
-	if (event.type === "claim.released") return [style("dim", `⚑ released ${event.resource}`)];
-	if (event.type === "message.sent") return [style("dim", `✉ to ${event.to}: ${firstLine(event.body)}`)];
-	if (event.type === "message.read") return [];
-	if (event.type === "owner.asked") return [`${style(["yellow", "bold"], "?")} asked as the owner of ${event.about}: ${event.text} ${style("dim", `(${event.question})`)}`];
-	if (event.type === "owner.answered") return [style("dim", `→ ${event.answer} (owner)`)];
-	return [style("dim", "→ its session ended first; asking you")];
-};
-const RUN_MARK = {
-	succeeded: style("green", "✓"),
-	failed: style("red", "✗"),
-	budget_exhausted: style("yellow", "!"),
-	interrupted: style("yellow", "!")
-};
-/** The run summary: status, cost, what ran, branches to look at, and why. */
-const formatRunResult = (result) => {
-	const ran = result.nodes.filter((n) => n.runs > 0).length;
-	const skipped = result.nodes.length - ran;
-	const lines = ["", `${RUN_MARK[result.status]} run ${result.runId} ${result.status.replace("_", " ")} ${style("dim", `· $${result.costUsd.toFixed(4)} · ${String(ran)} ran, ${String(skipped)} skipped`)}`];
-	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)}`);
-	return lines;
-};
-// src/runs/chat.ts
-/**
-* @file `ork chat`'s two paths. A node of a live run gets the message through
-*   the store and the run's socket, and the run's bus pushes it into the node's
-*   session (specs/messaging.md#chat). A node of a finished run gets it by
-*   resuming its last Claude session where it ran, and the exchange is added to
-*   the run's record.
-*/
-const chattable = (type) => type === "claude.leader" || type === "claude.worker";
-/** Reads `node`'s session from a run's events, and every node's last output. */
-const nodeSession = (events, node) => {
-	const session = {
-		known: false,
-		chattable: false,
-		running: false
-	};
-	const outputs = {};
-	for (const { event } of events) {
-		if (event.type === "run.started") {
-			const declared = event.nodes.find((n) => n.id === node);
-			if (declared !== void 0) {
-				session.known = true;
-				session.chattable = chattable(declared.type);
-			}
-		}
-		if (event.type === "node.finished") outputs[event.id] = event.output;
-		if (!("id" in event) || event.id !== node) continue;
-		if (event.type === "node.started") {
-			session.known = true;
-			session.chattable = chattable(event.nodeType);
-			session.running = true;
-		}
-		if (event.type === "node.finished") session.running = false;
-		if (event.type === "worktree" && event.action === "created") session.checkout = {
-			path: event.path,
-			...event.branch === void 0 ? {} : { branch: event.branch },
-			own: true,
-			owner: node
-		};
-		if (event.type !== "node.event") continue;
-		const inner = event.event;
-		if (inner.type === "session.started") {
-			session.sessionId = inner.sessionId;
-			if (inner.cwd !== void 0) session.cwd = inner.cwd;
-			if (inner.driver !== void 0) session.driver = inner.driver;
-		}
-		if (inner.type === "session.finished" && inner.outcome.sessionId !== "") session.sessionId = inner.outcome.sessionId;
-	}
-	return {
-		session,
-		outputs
-	};
-};
-/** Sends a live run's node a message; false when the run did not wake. */
-const tellLiveRun = (store, run, node, body, home) => {
-	store.command(run.id, {
-		kind: "message",
-		node,
-		body
-	});
-	return wakeRun(socketPath(run.id, home));
-};
-/** 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;
-};
-/**
-* Resumes a finished node's last session with the user's message, prints the
-* session, and adds it to the run's record. Returns why it could not.
-*/
-const resumeChat = async (options) => {
-	const { store, run, node } = options;
-	const { session, outputs } = nodeSession(store.events(run.id, 0), node);
-	if (!session.known) return `${node} is not a node of run ${run.id}.`;
-	if (!session.chattable) return `${node} is not a leader or worker; only they have sessions to talk to.`;
-	if (session.sessionId === void 0) return `${node} has no Claude session to resume in run ${run.id}.`;
-	const cwd = session.cwd ?? session.checkout?.path;
-	if (cwd === void 0 || !existsSync(cwd)) return `${node}'s session ran in ${cwd ?? "a folder Ork did not record"}, which is gone (a merged worktree is removed), so it cannot be resumed.`;
-	const { workflow, place, workflowDir } = loadWorkflow(run.file, path.dirname(run.file), void 0, store.projects());
-	if (workflow === null) return `The workflow ${run.file} is gone or no longer valid.`;
-	const runDir = runDirOf(place, run.id);
-	const template = templateOf(workflow.nodes, node);
-	const plan = planNodeSession(workflow, node, {
-		cwd,
-		inputs: {},
-		outputs,
-		inPlace: session.checkout === void 0,
-		workflowDir,
-		projectRoot: run.project,
-		orkDir: place.dir,
-		pluginDir: path.join(runDir, "plugins", node),
-		...session.checkout === void 0 ? {} : { checkout: session.checkout },
-		...template === void 0 ? {} : { template }
-	});
-	if (!plan.ok) return plan.error;
-	const record = appendRecorder(store, run.id, runDir);
-	record({
-		type: "user.message",
-		node,
-		body: options.body,
-		delivered: "resumed"
-	});
-	const started = (await options.runtime(options.driver ?? session.driver ?? plan.driver)).start({
-		...plan.spec,
-		resume: session.sessionId,
-		prompt: options.body
-	}, { human: options.human });
-	const tools = /* @__PURE__ */ new Map();
-	let failure = null;
-	for await (const event of started.events) {
-		record({
-			type: "node.event",
-			id: node,
-			event
-		});
-		for (const line of formatEvent(node, event, tools)) options.out(line);
-		if (event.type === "session.finished" && event.outcome.subtype === "error_driver") failure = event.outcome.errors.join("; ");
-	}
-	return failure;
-};
-// src/runs/find.ts
-/**
-* @file Finding a stored run from a command's argument: a run id or a unique
-*   prefix of one, or, with none, the newest run of this project.
-*/
-const findRun = (store, arg, cwd) => {
-	if (arg === void 0 || arg === "") {
-		const [latest] = store.runs({
-			project: placeFor(cwd, store.projects()).root,
-			limit: 1
-		});
-		return latest === void 0 ? {
-			ok: false,
-			error: "No runs in this project yet; see `ork ps --all`."
-		} : {
-			ok: true,
-			run: latest
-		};
-	}
-	const found = store.lookup(arg);
-	const [only] = found;
-	if (only === void 0) return {
-		ok: false,
-		error: `No run "${arg}".`
-	};
-	if (found.length > 1) return {
-		ok: false,
-		error: `"${arg}" matches ${String(found.length)} runs: ${found.map((r) => r.id).join(", ")}`
-	};
-	return {
-		ok: true,
-		run: only
-	};
+	return failure;
 };
 // src/runs/logs.ts
 /**
@@ -2284,887 +698,50 @@ const findRun = (store, arg, cwd) => {
 *   printed, for the whole run or one node, and tails a live run until it
 *   ends.
 */
-/** Turns stored events into lines, keeping the state a transcript needs. */
-const createLogPrinter = (options) => {
-	const tools = /* @__PURE__ */ new Map();
-	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.json) return [JSON.stringify(stored)];
-		return formatRunEvent(event, width, tools);
-	};
-};
-/**
-* Prints a run's events; with `follow`, then each new one as it is stored:
-* pushed over the run's socket, or polled from the store when there is none.
-* Returns when `run.finished` is stored, the run's process is gone, or `signal`
-* aborts.
-*/
-const followRun = async (store, run, out, options) => {
-	const print = createLogPrinter(options);
-	/** Prints what the run's socket pushes after `after`, until it closes. */
-	const viaSocket = async (after) => {
-		let last = after;
-		let finished = false;
-		return {
-			via: await followSocket(socketPath(run.id, options.home), after, (stored) => {
-				if (stored.seq <= last) return;
-				last = stored.seq;
-				for (const line of print(stored)) out(line);
-				if (stored.event.type === "run.finished") finished = true;
-			}, options.signal),
-			seq: last,
-			finished
-		};
-	};
-	let seq = options.after ?? 0;
-	for (;;) {
-		let finished = false;
-		for (const stored of store.events(run.id, seq)) {
-			seq = stored.seq;
-			for (const line of print(stored)) out(line);
-			finished ||= stored.event.type === "run.finished";
-		}
-		if (finished || !options.follow) return;
-		const pushed = await viaSocket(seq);
-		seq = pushed.seq;
-		if (pushed.finished || options.signal?.aborted === true) return;
-		const { via } = pushed;
-		if (via === "ended") continue;
-		const [now] = store.lookup(run.id);
-		if (now === void 0 || liveStatus(now) !== "running") {
-			if (now !== void 0 && liveStatus(now) === "crashed") out(style("red", `run ${run.id} stopped without finishing (its process is gone)`));
-			return;
-		}
-		try {
-			await setTimeout$1(options.intervalMs ?? 250, void 0, { signal: options.signal });
-		} catch {
-			return;
-		}
-	}
-};
-// src/run/detach.ts
-/**
-* @file `ork run --detach` and `ork resume --detach`: starts the same command
-*   as a background process with no terminal, its output in the run's folder
-*   (`.ork/runs/<run>/`, or the attached project's) as `output.log`, and
-*   returns once the run is running. Its questions wait for `ork decide`.
-*/
-/** Set in a detached run's environment: no terminal answers its questions. */
-const DETACHED_ENV = "ORK_DETACHED";
-const detachRun = async (options) => {
-	const { runId } = options;
-	const dir = options.runDir;
-	mkdirSync(dir, { recursive: true });
-	const log = path.join(dir, "output.log");
-	const fd = openSync(log, "a");
-	let exited = null;
-	const script = process.argv[1] ?? "";
-	const child = spawn(process.execPath, [
-		...process.execArgv,
-		script,
-		...options.args
-	], {
-		cwd: options.cwd,
-		detached: true,
-		stdio: [
-			"ignore",
-			fd,
-			fd
-		],
-		env: {
-			...process.env,
-			[DETACHED_ENV]: "1",
-			NO_COLOR: "1"
-		}
-	});
-	child.on("exit", (code) => {
-		exited = code ?? 1;
-	});
-	child.unref();
-	const deadline = Date.now() + (options.timeoutMs ?? 15e3);
-	while (Date.now() < deadline) {
-		if (options.started?.(child.pid) ?? options.store.lookup(runId).length > 0) return {
-			ok: true,
-			runId,
-			log
-		};
-		if (exited !== null) return {
-			ok: false,
-			error: readFileSync(log, "utf8").trim(),
-			log
-		};
-		await setTimeout$1(100);
-	}
-	return {
-		ok: false,
-		error: "the run did not start in time",
-		log
-	};
-};
-// ../nodes/src/claude.ts
-/**
-* @file The Claude node type: runs a `claude.leader` or `claude.worker` as one
-*   session, planned with the run's outputs (and the brief its owner gave it),
-*   and turns its report into the node's output. A leader gets its children
-*   through the session's ports, and resumes its session on re-entry
-*   (ADR-019).
-*/
-const MAX_INPUT = 8192;
-/** On a loop re-entry, the brief carries what the workflow sent back. */
-const reentryNote = (round, input) => {
-	const json = JSON.stringify(input ?? {}, void 0, 2);
-	const body = json.length > MAX_INPUT ? `${json.slice(0, MAX_INPUT)}\n…` : json;
-	return `\n\n## Round ${String(round)}\n\nThe workflow sent this task back to you with:\n\n\`\`\`json\n${body}\n\`\`\``;
-};
-/**
-* What a resumed leader is told: it already has its brief and its earlier work,
-* so only the new round, and the new task when its owner sent one.
-*/
-const resumeMessage = (round, input, brief) => [brief === void 0 ? sentBack(round, input) : `## New task from \`${brief.from}\`\n\n${brief.text}`, "End with a new structured report."].join("\n\n");
-/** A first-round resume is a session the run was cut off in (`ork resume`). */
-const sentBack = (round, input) => round === 1 ? "Ork was stopped while you worked on this task, and the run is resumed. Your earlier turns are above: check what you finished, and carry on from there." : `The workflow sent your task back to you.${reentryNote(round, input)}`;
-/** What a session is told when messages came in as it finished. */
-const lateMessage = (count) => `[ork] ${String(count)} message${count === 1 ? "" : "s"} came in while you finished. Call read_inbox, act on ${count === 1 ? "it" : "them"} if needed, and end with a new structured report.`;
-/** The later outcome, with the cost and tokens of both sessions. */
-const withUsageOf = (first, later) => {
-	const sum = (key) => first.usage[key] + later.usage[key];
-	const usage = {
-		costUsd: sum("costUsd"),
-		inputTokens: sum("inputTokens"),
-		outputTokens: sum("outputTokens"),
-		cacheReadTokens: sum("cacheReadTokens"),
-		cacheWriteTokens: sum("cacheWriteTokens"),
-		turns: sum("turns"),
-		durationMs: sum("durationMs")
-	};
-	return {
-		...later,
-		usage
-	};
-};
-/** A finished session as a node result: its report is the node's output. */
-const resultOf = (outcome) => {
-	if (outcome === null) return {
-		ok: false,
-		output: {
-			status: "fail",
-			summary: "the session ended without a result"
-		},
-		error: "the session ended without a result"
-	};
-	const { report, usage } = outcome;
-	if (report === null) {
-		const reason = outcome.errors[0] ?? "no valid report";
-		return {
-			ok: false,
-			output: {
-				status: "fail",
-				summary: reason,
-				usage
-			},
-			usage,
-			error: `ended without a report (${outcome.subtype}): ${reason}`,
-			sessionId: outcome.sessionId
-		};
-	}
-	const ran = { sessionId: outcome.sessionId };
-	const output = {
-		...report.fields,
-		status: report.status,
-		summary: report.summary,
-		artifacts: report.artifacts,
-		usage
-	};
-	if (report.branch !== void 0) output["branch"] = report.branch;
-	const result = {
-		ok: report.status !== "fail",
-		output,
-		usage,
-		...ran
-	};
-	if (!result.ok) result.error = report.summary;
-	return result;
-};
-/** A re-entered leader resumes; anyone else starts with the full brief. */
-const specFor = (spec, context) => {
-	if (context.resume !== void 0) return {
-		...spec,
-		resume: context.resume,
-		prompt: resumeMessage(context.round, context.input, context.brief)
-	};
-	if (context.round > 1 && context.brief === void 0) return {
-		...spec,
-		prompt: spec.prompt + reentryNote(context.round, context.input)
-	};
-	return spec;
-};
-/** Runs a `claude.leader` or `claude.worker` as one session. */
-const claudeExecutor = (options) => async (context) => {
-	const planOptions = {
-		cwd: context.cwd,
-		inputs: context.inputs,
-		outputs: context.outputs,
-		inPlace: options.inPlace,
-		workflowDir: context.workflowDir,
-		projectRoot: context.projectRoot,
-		...context.orkDir === void 0 ? {} : { orkDir: context.orkDir },
-		pluginDir: path.join(context.runDir, "plugins", context.id)
-	};
-	if (context.budgetLeftUsd !== void 0) planOptions.budgetLeftUsd = context.budgetLeftUsd;
-	if (context.checkout !== void 0) planOptions.checkout = context.checkout;
-	if (context.brief !== void 0) planOptions.brief = context.brief;
-	if (context.template !== void 0) planOptions.template = context.template;
-	if (context.ownership !== void 0) planOptions.ownership = context.ownership;
-	if (context.mailbox !== void 0) planOptions.mailbox = context.mailbox;
-	if (context.claims !== void 0) planOptions.claims = context.claims;
-	const plan = planNodeSession(context.workflow, context.id, planOptions);
-	if (!plan.ok) return {
-		ok: false,
-		output: {
-			status: "fail",
-			summary: plan.error
-		},
-		error: plan.error
-	};
-	const spec = specFor(plan.spec, context);
-	const runtime = await options.runtimeFor(options.driver ?? plan.driver);
-	const ports = { human: context.human };
-	if (context.ownership !== void 0) ports.ownership = context.ownership;
-	if (context.mailbox !== void 0) ports.mailbox = context.mailbox;
-	if (context.claims !== void 0) ports.claims = context.claims;
-	if (context.feedback !== void 0) ports.feedback = context.feedback;
-	const run = async (asked) => {
-		const session = runtime.start(asked, ports);
-		const stop = () => {
-			session.interrupt();
-		};
-		context.signal.addEventListener("abort", stop, { once: true });
-		const disconnect = context.mailbox?.connect((notice) => {
-			session.send(notice);
-		});
-		let outcome = null;
-		try {
-			for await (const event of session.events) {
-				if (event.type === "session.finished") outcome = event.outcome;
-				context.emit(event);
-			}
-		} finally {
-			disconnect?.();
-			context.signal.removeEventListener("abort", stop);
-		}
-		return outcome;
-	};
-	const first = await run(spec);
-	const late = context.mailbox?.pending() ?? 0;
-	const stopped = context.signal.aborted;
-	if (first === null || first.report === null || late === 0 || stopped) return resultOf(first);
-	const again = await run({
-		...spec,
-		resume: first.sessionId,
-		prompt: lateMessage(late)
-	});
-	return resultOf(again === null ? first : withUsageOf(first, again));
-};
-// ../nodes/src/gate.ts
-/**
-* @file The `human.gate` node type: asks the human the rendered question, and
-*   answers with the `default` when the `timeout` passes.
-*/
-const UNITS = {
-	s: 1e3,
-	m: 6e4,
-	h: 36e5
-};
-/** `30s`, `15m`, `2h` in milliseconds; `undefined` without a timeout. */
-const timeoutMs = (timeout) => {
-	const match = /^(\d+)([smh])$/u.exec(timeout ?? "");
-	if (match === null) return void 0;
-	const [, amount = "0", unit = "s"] = match;
-	return Number(amount) * (UNITS[unit] ?? 1e3);
-};
-const choiceOf = (option) => {
-	if (typeof option === "string") return { id: option };
-	const choice = { id: option.id };
-	if (option.label !== void 0) choice.label = option.label;
-	if (option.description !== void 0) choice.description = option.description;
-	return choice;
-};
-/**
-* Asks the human and outputs `choice` and `answeredBy`. With `timeout`, the
-* `default` answers when no one has.
-*/
-const gateExecutor = async (context) => {
-	const { node } = context;
-	if (node.type !== "human.gate") return {
-		ok: false,
-		output: {},
-		error: `${context.id} is not a gate`
-	};
-	const template = parseTemplate(node.question);
-	const question = template.ok ? renderTemplate(template.parts, runScope(context.inputs, context.outputs, context.runId)) : node.question;
-	const options = node.options.map((o) => choiceOf(o));
-	const withdraw = new AbortController();
-	context.signal.addEventListener("abort", () => {
-		withdraw.abort();
-	});
-	const asked = {
-		nodeId: context.id,
-		question,
-		options,
-		signal: withdraw.signal
-	};
-	if (node.recommended !== void 0) asked.recommended = node.recommended;
-	const answer = context.human.ask(asked).then((choice) => ({
-		choice,
-		answeredBy: "user"
-	}));
-	const ms = timeoutMs(node.timeout);
-	let timer;
-	const expired = ms === void 0 || node.default === void 0 ? [] : [new Promise((resolve) => {
-		timer = setTimeout(() => {
-			withdraw.abort();
-			resolve({
-				choice: node.default ?? "",
-				answeredBy: "timeout"
-			});
-		}, ms);
-	})];
-	try {
-		const output = await Promise.race([answer, ...expired]);
-		if (!options.some((o) => o.id === output.choice)) return {
-			ok: false,
-			output,
-			error: "no one answered the gate"
-		};
-		return {
-			ok: true,
-			output
-		};
-	} catch {
-		return {
-			ok: false,
-			output: {},
-			error: "the gate was withdrawn"
-		};
-	} finally {
-		clearTimeout(timer);
-	}
-};
-// ../nodes/src/tools.ts
-/**
-* @file The tool node executor, for every registered integration (`tool.gh`,
-*   `tool.aws`, `tool.git`, `tool.shell`, …): the user's own program, run
-*   without a shell, checked against `allow` (or the integration's default),
-*   its arguments and observed output fields from the integration's adapter,
-*   long output kept in run files.
-*/
-/** How much of stdout and stderr a node's output keeps. */
-const OUTPUT_LIMIT = 65536;
-/**
-* Splits a command into arguments the way a shell would, without running one:
-* whitespace separates, `'…'` is literal, `"…"` and `\` escape, and `{{ … }}`
-* stays whole so a template is rendered inside its own argument.
-*/
-const tokenize = (command) => {
-	const args = [];
-	let current = null;
-	let index = 0;
-	const add = (text) => {
-		current = (current ?? "") + text;
-	};
-	while (index < command.length) {
-		const char = command.charAt(index);
-		if (command.startsWith("{{", index)) {
-			const end = command.indexOf("}}", index + 2);
-			if (end === -1) return {
-				ok: false,
-				error: "unclosed {{ in command"
-			};
-			add(command.slice(index, end + 2));
-			index = end + 2;
-		} else if (/\s/u.test(char)) {
-			if (current !== null) args.push(current);
-			current = null;
-			index += 1;
-		} else if (char === "'") {
-			const end = command.indexOf("'", index + 1);
-			if (end === -1) return {
-				ok: false,
-				error: "unclosed ' in command"
-			};
-			add(command.slice(index + 1, end));
-			index = end + 1;
-		} else if (char === "\"") {
-			let text = "";
-			index += 1;
-			while (index < command.length && command.charAt(index) !== "\"") {
-				if (command.charAt(index) === "\\") index += 1;
-				text += command.charAt(index);
-				index += 1;
-			}
-			if (index >= command.length) return {
-				ok: false,
-				error: "unclosed \" in command"
-			};
-			add(text);
-			index += 1;
-		} else if (char === "\\") {
-			add(command.charAt(index + 1));
-			index += 2;
-		} else {
-			add(char);
-			index += 1;
-		}
-	}
-	if (current !== null) args.push(current);
-	return {
-		ok: true,
-		args
-	};
-};
-/** Whether `args` starts with one of the allowed prefixes (`"pr merge"`). */
-const isAllowed = (args, allow) => allow === void 0 || allow.some((prefix) => {
-	return prefix.trim().split(/\s+/u).every((word, i) => args[i] === word);
-});
-const render = (text, context) => {
-	const template = parseTemplate(text);
-	if (!template.ok) return {
-		ok: false,
-		error: template.message
-	};
-	return {
-		ok: true,
-		value: renderTemplate(template.parts, runScope(context.inputs, context.outputs, context.runId))
-	};
-};
-/** The program and arguments a tool node runs, before the allow check. */
-const commandOf = (node, context) => {
-	const tokens = tokenize(node.command);
-	if (!tokens.ok) return tokens;
-	const args = [];
-	for (const token of tokens.args) {
-		const rendered = render(token, context);
-		if (!rendered.ok) return rendered;
-		args.push(rendered.value);
-	}
-	const integration = integrationFor(node.type);
-	if (integration === void 0) return {
-		ok: false,
-		error: `no integration for ${node.type}`
-	};
-	const extra = integration.args(node);
-	if (integration.program !== null) return {
-		ok: true,
-		program: integration.program,
-		args: [...args, ...extra]
-	};
-	const [program, ...rest] = [...args, ...extra];
-	if (program === void 0 || program === "") return {
-		ok: false,
-		error: "the command names no program"
-	};
-	return {
-		ok: true,
-		program,
-		args: rest
-	};
-};
-/** Keeps the first `OUTPUT_LIMIT` characters; the rest goes to a file. */
-const capped = (text, file) => {
-	if (text.length <= 65536) return text;
-	return `${text.slice(0, OUTPUT_LIMIT)}\n… (truncated; the full output is in ${file()})`;
-};
-const failed$1 = (error) => ({
-	ok: false,
-	output: {
-		exitCode: -1,
-		stdout: "",
-		stderr: error
-	},
-	error
-});
-/** Runs a user's CLI through its integration's adapter, with its own login. */
-const toolExecutor = (runner) => async (context) => {
-	const { node } = context;
-	if (!isToolNode(node)) return failed$1(`${context.id} is not a tool node`);
-	const command = commandOf(node, context);
-	if (!command.ok) return failed$1(command.error);
-	const integration = integrationFor(node.type);
-	const checked = integration?.program === null ? [command.program, ...command.args] : command.args;
-	const allow = node.allow ?? integration?.allow;
-	if (!isAllowed(checked, allow)) return failed$1(`"${checked.join(" ")}" is not in the node's allow list (${(allow ?? []).join(", ")})`);
-	let cwd = context.cwd;
-	if (node.cwd !== void 0) {
-		const rendered = render(node.cwd, context);
-		if (!rendered.ok) return failed$1(rendered.error);
-		cwd = path.resolve(context.cwd, rendered.value);
-	}
-	context.emit({
-		type: "tool.called",
-		id: context.id,
-		name: command.program,
-		input: { command: [command.program, ...command.args].join(" ") }
-	});
-	const run = await runner(command.program, command.args, {
-		cwd,
-		signal: context.signal
-	});
-	const observed = await integration?.observe?.read(async (args) => {
-		const seen = await runner(command.program, args, {
-			cwd,
-			signal: context.signal
-		});
-		return {
-			ok: seen.exitCode === 0,
-			stdout: seen.stdout
-		};
-	}) ?? {};
-	const keep = (field, text) => () => {
-		const dir = context.runDir;
-		mkdirSync(dir, { recursive: true });
-		const file = path.join(dir, `${context.id}.${String(context.round)}.${field}.txt`);
-		writeFileSync(file, text);
-		return file;
-	};
-	const output = {
-		exitCode: run.exitCode,
-		stdout: capped(run.stdout, keep("stdout", run.stdout)),
-		stderr: capped(run.stderr, keep("stderr", run.stderr))
-	};
-	for (const [field, text] of Object.entries(observed)) output[field] = capped(text, keep(field, text));
-	context.emit({
-		type: "tool.result",
-		id: context.id,
-		isError: run.exitCode !== 0
-	});
-	if (run.exitCode === 0) return {
-		ok: true,
-		output
-	};
-	const last = run.stderr.trim().split("\n").at(-1) ?? "";
-	return {
-		ok: false,
-		output,
-		error: `${command.program} exited with ${String(run.exitCode)}${last === "" ? "" : `: ${last}`}`
-	};
-};
-/** The real runner: `spawn` without a shell, output collected as text. */
-const spawnTool = (program, args, { cwd, signal }) => new Promise((resolve) => {
-	const stdout = [];
-	const stderr = [];
-	const child = spawn(program, args, {
-		cwd,
-		signal,
-		stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		]
-	});
-	child.stdout.setEncoding("utf8").on("data", (chunk) => {
-		stdout.push(chunk);
-	});
-	child.stderr.setEncoding("utf8").on("data", (chunk) => {
-		stderr.push(chunk);
-	});
-	child.on("error", (error) => {
-		resolve({
-			exitCode: -1,
-			stdout: stdout.join(""),
-			stderr: `could not run ${program}: ${error.message}`
-		});
-	});
-	child.on("close", (code) => {
-		resolve({
-			exitCode: code ?? -1,
-			stdout: stdout.join(""),
-			stderr: stderr.join("")
-		});
-	});
-});
-// ../nodes/src/builtins.ts
-/** Every built-in node type that does work; control nodes are the scheduler's. */
-const builtinExecutors = (options) => {
-	const claude = claudeExecutor(options);
-	const tool = toolExecutor(options.tools ?? spawnTool);
-	const executors = {
-		"claude.leader": claude,
-		"claude.worker": claude,
-		"human.gate": gateExecutor
-	};
-	for (const integration of INTEGRATIONS) executors[`${TOOL_PREFIX}${integration.id}`] = tool;
-	return executors;
-};
-// ../nodes/src/programs.ts
-/**
-* @file Which programs a workflow's tool nodes run, and which of them are not
-*   installed. Integrations are optional: `ork run` checks only the programs
-*   the workflow uses, before anything starts.
-*/
-/**
-* The programs the workflow's tool nodes run: an integration's own (`gh`,
-* `aws`), or a `tool.shell` command's first word when it is not a template.
-*/
-const neededPrograms = (workflow) => Object.entries(workflow.nodes).flatMap(([id, node]) => {
-	if (!isToolNode(node)) return [];
-	const integration = integrationFor(node.type);
-	if (integration === void 0) return [];
-	if (integration.program !== null) return [{
-		node: id,
-		type: node.type,
-		program: integration.program
-	}];
-	const tokens = tokenize(node.command);
-	const first = tokens.ok ? tokens.args[0] : void 0;
-	return first === void 0 || first.includes("{{") ? [] : [{
-		node: id,
-		type: node.type,
-		program: first
-	}];
-});
-const runnable = (file) => {
-	try {
-		accessSync(file, constants.X_OK);
-		return true;
-	} catch {
-		return false;
-	}
-};
-/** Whether `program` runs: a path that is executable, or a name on `PATH`. */
-const onPath = (program, env = process.env) => {
-	if (program.includes(path.sep)) return runnable(program);
-	return (env["PATH"] ?? "").split(path.delimiter).filter((dir) => dir !== "").some((dir) => runnable(path.join(dir, program)));
-};
-/** The needed programs that are not installed, one entry per program. */
-const missingPrograms = (workflow, installed = (program) => onPath(program)) => {
-	const missing = /* @__PURE__ */ new Map();
-	for (const need of neededPrograms(workflow)) {
-		if (installed(need.program)) continue;
-		const entry = missing.get(need.program) ?? {
-			program: need.program,
-			nodes: [],
-			type: need.type
-		};
-		entry.nodes.push(need.node);
-		missing.set(need.program, entry);
-	}
-	return [...missing.values()];
-};
-// src/__build_info__.ts
-/**
-* @file The published package's name and version, bound to
-*   `packages/cli/package.json`. Do not edit by hand: `pnpm changesets:version`
-*   and `pnpm build` rewrite it (`tools/release/build-info.ts`), and a test
-*   fails when it is stale.
-*/
-const ORK_NAME = "@krapht/ork";
-const ORK_VERSION = "0.2.0";
-// src/run/origin.ts
-/**
-* @file Where a run's feedback comes from, beyond what its events say: Ork's
-*   version (bound from the CLI's `package.json`) and the workflow file's
-*   content hash.
-*/
-/** Ork's version and the workflow's hash, for the run's feedback records. */
-const feedbackOrigin = (workflowFile) => {
-	const origin = { version: ORK_VERSION };
-	try {
-		origin.workflowHash = createHash("sha256").update(readFileSync(workflowFile)).digest("hex").slice(0, 12);
-	} catch {}
-	return origin;
-};
-// src/run/checkout.ts
-/**
-* @file Before a run with worktree nodes: the project must be a git repository
-*   with a commit, its instructions, skills and agents must be committed
-*   (worktrees get only committed files, unless `--allow-dirty`), and the
-*   project's `git.base` must name a commit, which root worktrees start from.
-*/
-/** Why a run refuses to start with uncommitted agent files. */
-const dirtyAgentMessage = (files) => [
-	"These instructions, skills or agents have uncommitted changes, and the worktrees only get committed files:",
-	...files.slice(0, 20).map((f) => `  ${f}`),
-	...files.length > 20 ? [`  … and ${String(files.length - 20)} more`] : [],
-	"Commit or stash them, or pass --allow-dirty to run with the committed versions."
-];
-/** Claude nodes that get their own worktree. */
-const worktreeNodes = (workflow) => Object.entries(workflow.nodes).filter(([, node]) => isClaudeNode(node) && node.type !== "claude.subagent" && (node.isolation ?? workflow.defaults?.isolation ?? "worktree") === "worktree").map(([id]) => id);
-/** Checks the project for a run's worktrees, and resolves `git.base`. */
-const prepareCheckout = async (workflow, options, inputs) => {
-	const isolated = worktreeNodes(workflow);
-	if (isolated.length === 0 || options.inPlace) return {
-		ok: true,
-		base: ""
-	};
-	const project = await inspectProject(options.cwd);
-	if (project === null) return {
-		ok: false,
-		lines: [`${isolated.join(", ")} need a git worktree, but ${options.cwd} is not in a git repository with a commit; pass --in-place to run them here`]
-	};
-	if (project.dirtyAgentFiles.length > 0 && options.allowDirty !== true) return {
-		ok: false,
-		lines: dirtyAgentMessage(project.dirtyAgentFiles)
-	};
-	if (project.dirtyOther > 0) options.err(`${style(["yellow", "bold"], "warning")} ${String(project.dirtyOther)} uncommitted change(s) in this checkout are not in the worktrees`);
-	try {
-		const base = await resolveBase(project.root, gitRulesOf(workflow), inputs);
-		return {
-			ok: true,
-			root: project.root,
-			base
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			lines: [error instanceof Error ? error.message : String(error)]
-		};
-	}
-};
-// src/run/workflow.ts
-/**
-* @file `ork run` for a whole workflow: checks the workflow, its inputs and the
-*   project (git, uncommitted agent files), sets up the worktree workspace, and
-*   streams the scheduler's run. `ork resume` comes through here too, with the
-*   run's recorded state.
-*/
-/** Why a run refuses to start when a program its tool nodes need is missing. */
-const missingProgramMessage = (missing) => [
-	"This workflow runs programs that are not installed:",
-	...missing.map((m) => `  ${m.program}, for ${m.nodes.join(", ")} (${m.type})`),
-	"Install them, or take those nodes out. Integrations are optional: only the ones a workflow uses must be installed (`ork doctor` shows what you have)."
-];
-/** A run id no stored run has yet; `node-…` for a run of one node. */
-const newRunId = (store, prefix = "") => {
-	for (;;) {
-		const id = `${prefix}${randomUUID().slice(0, 8)}`;
-		if (store.lookup(id).length === 0) return id;
-	}
-};
-/**
-* Runs a whole workflow: checks it and its inputs, then hands the compiled
-* graph to the scheduler with the built-in node types, and streams the run.
-*/
-const runWorkflowFile = async (options) => {
-	const failed = (lines) => {
-		for (const line of lines) options.err(line);
-		return {
-			exitCode: 1,
-			result: null
-		};
-	};
-	const { report, workflow, graph, place, workflowDir } = loadWorkflow(options.file, options.cwd, options.home, options.store.projects());
-	if (workflow === null || graph === null) return failed(formatReport(report));
-	const pairs = parseInputPairs(options.inputs);
-	if (!pairs.ok) return failed([`--input: ${pairs.error}`]);
-	const recorded = Object.fromEntries(Object.entries(options.resume?.inputs ?? {}).map(([k, v]) => [k, String(v)]));
-	const inputs = resolveInputs(workflow, {
-		...recorded,
-		...pairs.raw
-	});
-	if (!inputs.ok) return failed(inputs.errors);
-	const installed = options.installed ?? (options.tools === void 0 ? (p) => onPath(p) : () => true);
-	const missing = missingPrograms(workflow, installed);
-	if (missing.length > 0) return failed(missingProgramMessage(missing));
-	const checkout = await prepareCheckout(workflow, {
-		...options,
-		cwd: place.root
-	}, inputs.inputs);
-	if (!checkout.ok) return failed(checkout.lines);
-	const { root, base } = checkout;
-	const cwd = root ?? (inside(place.root, options.cwd) ? options.cwd : place.root);
-	const runId = options.runId ?? newRunId(options.store);
-	const runDir = runDirOf(place, runId);
-	if (options.resume !== void 0) options.store.reopen(runId);
-	const record = options.resume === void 0 ? createRecorder(options.store, {
-		id: runId,
-		workflow: workflow.name,
-		file: path.resolve(options.cwd, options.file),
-		project: place.root
-	}, runDir) : appendRecorder(options.store, runId, runDir);
-	const width = Math.max(...Object.keys(workflow.nodes).map((id) => id.length));
+/** Turns stored events into lines, keeping the state a transcript needs. */
+const createLogPrinter = (options) => {
 	const tools = /* @__PURE__ */ new Map();
-	const started = Promise.withResolvers();
-	const control = await startControl({
-		store: options.store,
-		runId,
-		emit: (event) => {
-			onEvent(event);
-		},
-		onStop: () => {
-			(async () => {
-				(await started.promise).interrupt();
-			})();
-		},
-		onMessage: (node, body) => {
-			(async () => {
-				(await started.promise).tell(node, body);
-			})();
-		},
-		...options.human === void 0 ? {} : { local: options.human },
-		...options.home === void 0 ? {} : { home: options.home },
-		...options.intervalMs === void 0 ? {} : { intervalMs: options.intervalMs }
-	});
-	const signals = createSignals(feedbackOrigin(path.resolve(options.cwd, options.file)));
-	const onEvent = (raw) => {
-		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);
-		}
-	};
-	const workspace = root === void 0 ? void 0 : createWorkspace({
-		graph,
-		runId,
-		root,
-		head: base,
-		inputs: inputs.inputs,
-		onEvent,
-		...options.resume === void 0 ? {} : {
-			adopt: options.resume.worktrees,
-			known: options.resume.branches
-		}
-	});
-	const executorOptions = {
-		runtimeFor: options.runtime,
-		inPlace: options.inPlace
-	};
-	if (options.driver !== void 0) executorOptions.driver = options.driver;
-	if (options.tools !== void 0) executorOptions.tools = options.tools;
-	const replay = options.resume === void 0 ? void 0 : createReplay(options.resume.history, options.resume.cutOff, options.resume.mail);
-	if (replay !== void 0) onEvent({
-		type: "run.resumed",
-		kept: replay.kept()
-	});
-	const handle = startRun({
-		graph,
-		runId,
-		inputs: inputs.inputs,
-		cwd,
-		executors: builtinExecutors(executorOptions),
-		human: options.resume === void 0 ? control.human : replayLoopAnswers(control.human, options.resume.loopAnswers),
-		onEvent,
-		settings: {
-			inPlace: options.inPlace,
-			...options.driver === void 0 ? {} : { driver: options.driver }
-		},
-		...replay === void 0 ? {} : { replay },
-		workflowDir,
-		projectRoot: root ?? place.root,
-		orkDir: place.dir,
-		...workspace === void 0 ? {} : { workspace }
-	});
-	started.resolve(handle);
-	options.onRun?.(handle);
-	const result = await handle.done;
-	await control.close();
-	return {
-		exitCode: result.status === "succeeded" ? 0 : 1,
-		result
+	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.json) return [JSON.stringify(stored)];
+		return formatRunEvent(event, width, tools);
 	};
 };
+/**
+* Prints a run's events; with `follow`, then each new one as it is stored:
+* pushed over the run's socket, or polled from the store when there is none.
+* Returns when `run.finished` is stored, the run's process is gone, or `signal`
+* aborts.
+*/
+const followRun = async (store, run, out, options) => {
+	const print = createLogPrinter(options);
+	if (await followEvents(store, run.id, (stored) => {
+		for (const line of print(stored)) out(line);
+	}, {
+		follow: options.follow,
+		...options.after === void 0 ? {} : { after: options.after },
+		...options.intervalMs === void 0 ? {} : { intervalMs: options.intervalMs },
+		...options.home === void 0 ? {} : { home: options.home },
+		...options.signal === void 0 ? {} : { signal: options.signal }
+	}) === "crashed") out(style("red", `run ${run.id} stopped without finishing (its process is gone)`));
+};
+// src/run/origin.ts
+/**
+* @file Where a run's feedback comes from, beyond what its events say: Ork's
+*   version (bound from the CLI's `package.json`) and the workflow file's
+*   content hash.
+*/
+/** Ork's version and the workflow's hash, for the run's feedback records. */
+const feedbackOrigin = (workflowFile) => {
+	const origin = { version: ORK_VERSION };
+	try {
+		origin.workflowHash = createHash("sha256").update(readFileSync(workflowFile)).digest("hex").slice(0, 12);
+	} catch {}
+	return origin;
+};
 // src/run/node.ts
 /**
 * @file `ork run --node`: checks a workflow and its inputs, plans one Claude
@@ -3186,15 +763,21 @@ const runNode = async (options) => {
 	};
 	const { report, workflow, graph, place, workflowDir } = loadWorkflow(options.file, options.cwd, options.home, options.store.projects());
 	if (workflow === null) return failed(formatReport(report));
+	for (const line of warningLines(report)) options.err(line);
 	const pairs = parseInputPairs(options.inputs);
 	if (!pairs.ok) return failed([`--input: ${pairs.error}`]);
 	const inputs = resolveInputs(workflow, pairs.raw);
 	if (!inputs.ok) return failed(inputs.errors);
+	const limits = runLimits(options.store, place, options.home);
+	const refused = limitsRefusal(limits, workflow);
+	if (refused.length > 0) return failed(refused);
+	const left = limits.now().leftUsd;
 	const projectRoot = place.root;
 	const runId = options.runId ?? newRunId(options.store, "node-");
 	const runDir = runDirOf(place, runId);
 	const cwd = inside(projectRoot, options.cwd) ? options.cwd : projectRoot;
 	const plan = planNodeSession(workflow, options.nodeId, {
+		...left === void 0 ? {} : { budgetLeftUsd: left },
 		cwd,
 		inputs: inputs.inputs,
 		inPlace: options.inPlace,
@@ -3204,6 +787,10 @@ const runNode = async (options) => {
 		pluginDir: path.join(runDir, "plugins", options.nodeId)
 	});
 	if (!plan.ok) return failed([plan.error]);
+	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}`);
 	const id = options.nodeId;
 	const recorder = createRecorder(options.store, {
@@ -3313,11 +900,362 @@ const runNode = async (options) => {
 	});
 	await control.close();
 	return {
-		exitCode: succeeded(outcome) ? 0 : 1,
-		outcome
+		exitCode: succeeded(outcome) ? 0 : 1,
+		outcome
+	};
+};
+/** Every value of a repeatable flag: `--input a=1 --input=b=2`. */
+// src/run/calls.ts
+/**
+* @file What a run needs to reach other runs: its port for `workflow.call`
+*   nodes (RFC-004), its relay when links are on (RFC-003), and the budget a
+*   caller has capped it to. A called run being resumed keeps its caller and
+*   its cap, which the run recorded.
+*/
+const callPorts = (options) => {
+	const { graph, store, runId, home, human, runtime, out } = options;
+	const linksOff = graph.workflow.rules?.links === "off";
+	const cap = options.budgetCap ?? options.resume?.settings.budgetCap;
+	const calledBy = options.calledBy ?? options.resume?.settings.calledBy;
+	const baseRef = options.baseRef ?? options.resume?.settings.baseRef;
+	const trigger = options.trigger ?? options.resume?.settings.trigger;
+	const untrusted = options.untrusted ?? options.resume?.settings.untrusted;
+	const own = graph.workflow.limits?.budgetUsd;
+	const budgetUsd = cap === void 0 ? own : Math.min(cap, own ?? Number.POSITIVE_INFINITY);
+	return {
+		graph: {
+			...graph,
+			workflow: {
+				...graph.workflow,
+				limits: {
+					...graph.workflow.limits,
+					...budgetUsd === void 0 ? {} : { budgetUsd }
+				}
+			}
+		},
+		calls: createCalls({
+			store,
+			runId,
+			place: options.place,
+			emit: options.emit,
+			home,
+			adopt: adoptedCalls(store, runId),
+			newId: () => newRunId(store),
+			env: maskedEnv(maskedNamesOfRun(graph.workflow, options.place, store.projects())),
+			resumeSession: (run, node, body, signal) => {
+				const { blocked, leftUsd } = runLimits(store, options.place, home).now();
+				return blocked === void 0 ? resumeChat({
+					store,
+					run,
+					node,
+					body,
+					runtime,
+					human,
+					out,
+					signal,
+					...home === void 0 ? {} : { home },
+					...leftUsd === void 0 ? {} : { budgetLeftUsd: leftUsd }
+				}) : Promise.resolve(`${NOT_STARTED}${blocked}.`);
+			}
+		}),
+		...linksOff ? {} : { relay: createRelay({
+			store,
+			runId,
+			home,
+			human
+		}) },
+		settings: {
+			...linksOff ? { links: "off" } : {},
+			...cap === void 0 ? {} : { budgetCap: cap },
+			...calledBy === void 0 ? {} : { calledBy },
+			...baseRef === void 0 ? {} : { baseRef },
+			...trigger === void 0 ? {} : { trigger },
+			...untrusted === void 0 ? {} : { untrusted }
+		}
+	};
+};
+// src/run/live-handlers.ts
+/**
+* Takes what is on its way before the run ends: with no socket, a program's
+* message may not have been seen yet. Each command waits on `started`, so
+* waiting on it too lets them all land first.
+*/
+const takeLastCommands = (control, started) => async () => {
+	control.check();
+	await started;
+};
+/** `ork pause`, `ork continue` and `ork stop --node`, on the run as it is. */
+const liveControl = (live) => (command, node) => {
+	const { handle } = live;
+	if (handle === void 0) return false;
+	if (command === "pause") return handle.pause(node);
+	if (command === "continue") return handle.proceed(node);
+	return node !== void 0 && handle.stopNode(node);
+};
+const liveHandlers = (started) => {
+	const when = (act) => {
+		started.then(act);
+	};
+	return {
+		onStop: () => {
+			when((run) => {
+				run.interrupt();
+			});
+		},
+		onMessage: (node, body) => {
+			when((run) => {
+				run.tell(node, body);
+			});
+		},
+		onRelay: (node, from, body) => {
+			when((run) => {
+				run.receive(node, from, body);
+			});
+		},
+		onScript: (node, from, body) => {
+			when((run) => {
+				run.receive(node, from, body, "script");
+			});
+		},
+		onNotice: (node, text) => {
+			when((run) => {
+				run.notice(node, text);
+			});
+		}
+	};
+};
+// src/run/checkout.ts
+/**
+* @file Before a run with worktree nodes: the project must be a git repository
+*   with a commit, its instructions, skills and agents must be committed
+*   (worktrees get only committed files, unless `--allow-dirty`), and the
+*   project's `git.base` must name a commit, which root worktrees start from.
+*/
+/** Why a run refuses to start with uncommitted agent files. */
+const dirtyAgentMessage = (files) => [
+	"These instructions, skills or agents have uncommitted changes, and the worktrees only get committed files:",
+	...files.slice(0, 20).map((f) => `  ${f}`),
+	...files.length > 20 ? [`  … and ${String(files.length - 20)} more`] : [],
+	"Commit or stash them, or pass --allow-dirty to run with the committed versions."
+];
+/** Claude nodes that get their own worktree. */
+const worktreeNodes = (workflow) => Object.entries(workflow.nodes).filter(([, node]) => isClaudeNode(node) && node.type !== "claude.subagent" && (node.isolation ?? workflow.defaults?.isolation ?? "worktree") === "worktree").map(([id]) => id);
+/** Checks the project for a run's worktrees, and resolves `git.base`. */
+const prepareCheckout = async (workflow, options, inputs) => {
+	const isolated = worktreeNodes(workflow);
+	if (isolated.length === 0 || options.inPlace) return {
+		ok: true,
+		base: ""
+	};
+	const project = await inspectProject(options.cwd);
+	if (project === null) return {
+		ok: false,
+		lines: [`${isolated.join(", ")} need a git worktree, but ${options.cwd} is not in a git repository with a commit; pass --in-place to run them here`]
+	};
+	if (project.dirtyAgentFiles.length > 0 && options.allowDirty !== true) return {
+		ok: false,
+		lines: dirtyAgentMessage(project.dirtyAgentFiles)
+	};
+	if (project.dirtyOther > 0) options.err(`${style(["yellow", "bold"], "warning")} ${String(project.dirtyOther)} uncommitted change(s) in this checkout are not in the worktrees`);
+	try {
+		const base = await resolveBase(project.root, gitRulesOf(workflow), inputs);
+		return {
+			ok: true,
+			root: project.root,
+			base
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			lines: [error instanceof Error ? error.message : String(error)]
+		};
+	}
+};
+// src/run/preflight.ts
+const preflight = async (options, given) => {
+	const { workflow, place, projects } = given;
+	const installed = options.installed ?? (options.tools === void 0 ? (p) => onPath(p) : () => true);
+	const missing = missingPrograms(workflow, installed);
+	if (missing.length > 0) return {
+		ok: false,
+		lines: missingProgramMessage(missing)
+	};
+	const unset = envProblems(workflow, place, projects, options.resume?.history, options.err);
+	if (unset.length > 0) return {
+		ok: false,
+		lines: unset
+	};
+	const limits = runLimits(options.store, place, options.home);
+	const refused = limitsRefusal(limits, workflow, options.resume?.history);
+	if (refused.length > 0) return {
+		ok: false,
+		lines: refused
+	};
+	const checkout = await prepareCheckout(workflow, {
+		...options,
+		cwd: place.root
+	}, given.inputs);
+	if (!checkout.ok) return {
+		ok: false,
+		lines: checkout.lines
+	};
+	return {
+		...checkout,
+		limits: limits.now
+	};
+};
+// src/run/workflow.ts
+/**
+* @file `ork run` for a whole workflow: checks the workflow, its inputs and the
+*   project (git, uncommitted agent files), sets up the worktree workspace, and
+*   streams the scheduler's run. `ork resume` comes through here too, with the
+*   run's recorded state.
+*/
+/**
+* Runs a whole workflow: checks it and its inputs, then hands the compiled
+* graph to the scheduler with the built-in node types, and streams the run.
+*/
+const runWorkflowFile = async (options) => {
+	const failed = (lines) => {
+		for (const line of lines) options.err(line);
+		return {
+			exitCode: 1,
+			result: null
+		};
+	};
+	const loaded = loadWorkflow(options.file, options.cwd, options.home, options.store.projects());
+	const { workflow, graph, place, workflowDir, textHash } = loaded;
+	if (options.expectWorkflow !== void 0 && options.expectWorkflow !== textHash) return failed([`${options.file} isn't what was accepted: it changed after ork watch read it. Accept it again with \`ork watch --accept\`.`]);
+	if (workflow === null || graph === null) return failed(formatReport(loaded.report));
+	const { report } = options.resume === void 0 ? await walkLoaded(loaded) : loaded;
+	for (const line of warningLines(report)) options.err(line);
+	if (report.walk?.complete === false) options.err(walkSummary(report.walk));
+	const pairs = parseInputPairs(options.inputs);
+	if (!pairs.ok) return failed([`--input: ${pairs.error}`]);
+	const recorded = Object.fromEntries(Object.entries(options.resume?.inputs ?? {}).map(([k, v]) => [k, String(v)]));
+	const inputs = resolveInputs(workflow, {
+		...recorded,
+		...pairs.raw
+	});
+	if (!inputs.ok) return failed(inputs.errors);
+	const projects = options.store.projects();
+	const ready = await preflight(options, {
+		workflow,
+		place,
+		projects,
+		inputs: inputs.inputs
+	});
+	if (!ready.ok) return failed(ready.lines);
+	const { root, base } = ready;
+	const cwd = root ?? (inside(place.root, options.cwd) ? options.cwd : place.root);
+	const runId = options.runId ?? newRunId(options.store);
+	const runDir = runDirOf(place, runId);
+	if (options.resume !== void 0) options.store.reopen(runId);
+	const record = options.resume === void 0 ? createRecorder(options.store, {
+		id: runId,
+		workflow: workflow.name,
+		file: path.resolve(options.cwd, options.file),
+		project: place.root,
+		...options.calledBy === void 0 ? {} : { parent: options.calledBy.split("/")[0] ?? "" }
+	}, runDir) : appendRecorder(options.store, runId, runDir);
+	const width = Math.max(...Object.keys(workflow.nodes).map((id) => id.length));
+	const tools = /* @__PURE__ */ new Map();
+	const started = Promise.withResolvers();
+	const live = {};
+	const control = await startControl({
+		store: options.store,
+		runId,
+		emit: (event) => {
+			onEvent(event);
+		},
+		...liveHandlers(started.promise),
+		onControl: liveControl(live),
+		...options.human === void 0 ? {} : { local: options.human },
+		...options.home === void 0 ? {} : { home: options.home },
+		...options.intervalMs === void 0 ? {} : { intervalMs: options.intervalMs }
+	});
+	const signals = createSignals(feedbackOrigin(path.resolve(options.cwd, options.file)));
+	const onEvent = (raw) => {
+		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);
+		}
+	};
+	const workspace = root === void 0 ? void 0 : createWorkspace({
+		graph,
+		runId,
+		root,
+		head: options.baseRef ?? options.resume?.settings.baseRef ?? base,
+		inputs: inputs.inputs,
+		onEvent,
+		...options.resume === void 0 ? {} : {
+			adopt: options.resume.worktrees,
+			known: options.resume.branches
+		}
+	});
+	const maskedNames = maskedNamesOfRun(workflow, place, projects);
+	const executorOptions = {
+		runtimeFor: options.runtime,
+		inPlace: options.inPlace,
+		maskedNames
+	};
+	if (options.driver !== void 0) executorOptions.driver = options.driver;
+	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);
+	if (replay !== void 0) onEvent({
+		type: "run.resumed",
+		kept: replay.kept()
+	});
+	const ports = callPorts({
+		...options,
+		graph,
+		runId,
+		place,
+		human: control.human,
+		emit: onEvent
+	});
+	clearOutputFiles(runDir, options.err);
+	const handle = startRun({
+		graph: ports.graph,
+		calls: ports.calls,
+		runId,
+		runDir,
+		inputs: inputs.inputs,
+		cwd,
+		executors: builtinExecutors(executorOptions),
+		human: options.resume === void 0 ? control.human : replayLoopAnswers(control.human, options.resume.loopAnswers),
+		onEvent,
+		settings: {
+			inPlace: options.inPlace,
+			...options.driver === void 0 ? {} : { driver: options.driver },
+			...ports.settings
+		},
+		...ports.relay === void 0 ? {} : { relay: ports.relay },
+		...replay === void 0 ? {} : { replay },
+		workflowDir,
+		projectRoot: root ?? place.root,
+		orkDir: place.dir,
+		...workspace === void 0 ? {} : { workspace },
+		scrub: runScrubber(maskedNames, process.env),
+		limits: ready.limits,
+		beforeFinish: takeLastCommands(control, started.promise)
+	});
+	live.handle = handle;
+	started.resolve(handle);
+	options.onRun?.(handle);
+	const result = await handle.done;
+	clearOutputFiles(runDir, options.err);
+	if (result.status === "succeeded") clearStateFiles(runDir, options.err);
+	await endLinksOf(options.store, runId, result.status, options.home);
+	await control.close();
+	return {
+		exitCode: result.status === "succeeded" ? 0 : 1,
+		result
 	};
 };
-/** Every value of a repeatable flag: `--input a=1 --input=b=2`. */
 // src/commands/run.ts
 /**
 * @file `ork run`: the command and its flags. It runs a whole workflow, or one
@@ -3335,13 +1273,22 @@ const flagValues = (rawArgs, flag) => {
 };
 const isDriver = (value) => CLAUDE_DRIVERS.some((d) => d.id === value);
 /** Loads the drivers only when a run starts, so other commands stay fast. */
-const loadRuntime = async (driver) => (await import("./src-DAsOYtoR.mjs")).createRuntime(driver, process.env);
-/** Ctrl-C asks the run to stop. */
+const loadRuntime = async (driver) => (await import("./src-CZOVF2yU.mjs")).createRuntime(driver, sessionEnv(process.env));
+/**
+* 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.
+*/
 const onInterrupt = (stop) => {
-	process.once("SIGINT", () => {
+	let asked = false;
+	const interrupt = () => {
+		if (asked) return;
+		asked = true;
 		writeErr(style("dim", "\ninterrupting…"));
 		stop();
-	});
+	};
+	process.once("SIGINT", interrupt);
+	process.once("SIGTERM", interrupt);
+	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({
@@ -3395,11 +1342,35 @@ const run = defineCommand({
 		"run-id": {
 			type: "string",
 			description: "Internal: the id `--detach` picked for the run"
+		},
+		"called-by": {
+			type: "string",
+			description: "Internal: the workflow.call that started this run"
+		},
+		"budget-cap": {
+			type: "string",
+			description: "Internal: what the caller has left of its budget"
+		},
+		"base-ref": {
+			type: "string",
+			description: "Internal: what this run's worktrees start from"
+		},
+		trigger: {
+			type: "string",
+			description: "Internal: the trigger that started this run"
+		},
+		"expect-workflow": {
+			type: "string",
+			description: "Internal: the hash the workflow's text must have"
+		},
+		untrusted: {
+			type: "string",
+			description: "Internal: an input from what a trigger's check reported"
 		}
 	},
 	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(`--driver must be ${CLAUDE_DRIVERS.map((d) => d.id).join(" or ")}, got \`${args.driver}\``);
 			process.exitCode = 1;
 			return;
 		}
@@ -3454,6 +1425,14 @@ const run = defineCommand({
 			const { exitCode } = args.node === void 0 || args.node === "" ? await runWorkflowFile({
 				...common,
 				allowDirty: args["allow-dirty"],
+				...args["called-by"] === void 0 ? {} : { calledBy: args["called-by"] },
+				...args["budget-cap"] === void 0 ? {} : { budgetCap: Number(args["budget-cap"]) },
+				...args["base-ref"] === void 0 ? {} : { baseRef: args["base-ref"] },
+				...args["expect-workflow"] === void 0 ? {} : { expectWorkflow: args["expect-workflow"] },
+				...args.trigger === void 0 ? {} : {
+					trigger: args.trigger,
+					untrusted: flagValues(rawArgs, "--untrusted")
+				},
 				onRun: (handle) => {
 					onInterrupt(handle.interrupt);
 				}
@@ -3551,6 +1530,12 @@ const chat = defineCommand({
 		}
 	},
 	run: async ({ args }) => {
+		const refusal = chatRefusal();
+		if (refusal !== null) {
+			writeErr(refusal);
+			process.exitCode = 1;
+			return;
+		}
 		const store = openStore();
 		try {
 			const found = findRun(store, args.run, process.cwd());
@@ -3567,7 +1552,7 @@ const chat = defineCommand({
 				return;
 			}
 			if (args.driver !== void 0 && !isDriver(args.driver)) {
-				writeErr(`--driver must be sdk or cli, not "${args.driver}".`);
+				writeErr(`--driver must be sdk or cli, not \`${args.driver}\`.`);
 				process.exitCode = 1;
 				return;
 			}
@@ -3606,257 +1591,13 @@ const chat = defineCommand({
 		}
 	}
 });
-// src/commands/context.ts
-/**
-* @file `ork context explain <wf> <node>`: what one node's session would load,
-*   layer by layer. Its project instructions, every skill with the layer it
-*   came from and whether it is live, shadowed or switched off, its context
-*   files, its practices, and estimated tokens. Plans the session without
-*   writing anything.
-*/
-/** A rough count, for comparing sizes: about four characters a token. */
-const tokens = (text) => Math.ceil(text.length / 4);
-/** Which project instruction file Claude Code reads from the checkout. */
-const instructionsOf = (stack, checkout) => {
-	if (stack.instructions === "ignore") return "left out (project.instructions: ignore)";
-	const has = (file) => existsSync(path.join(checkout, file));
-	if ([
-		"CLAUDE.md",
-		".claude/CLAUDE.md",
-		"CLAUDE.local.md"
-	].some((file) => has(file))) return "CLAUDE.md, loaded by Claude Code";
-	if (has("AGENTS.md")) return "AGENTS.md, loaded by Claude Code";
-	return "none in the project";
-};
-const skillLines = (stack, root) => stack.skills.map((skill) => {
-	const source = skill.text === void 0 ? path.relative(root, skill.dir) || "." : "built-in";
-	const line = {
-		name: skill.layer !== "project" ? `ork:${skill.name}` : skill.name,
-		layer: skill.layer,
-		source: source.startsWith("..") ? skill.dir : source,
-		state: skill.shadowedBy === void 0 && skill.ignored === void 0 ? "live" : "off",
-		tokens: tokens(skill.text ?? readFileSync(path.join(skill.dir, "SKILL.md"), "utf8"))
-	};
-	if (skill.shadowedBy !== void 0) line.why = `shadowed by the ${skill.shadowedBy} layer`;
-	else if (skill.ignored !== void 0) line.why = skill.ignored === "ignore" ? "project.skills: ignore" : "not in project.skills.allow";
-	return line;
-});
-const explainNode = (file, nodeId, cwd, home) => {
-	const { report, workflow, graph, place, workflowDir } = loadWorkflow(file, cwd, home);
-	if (workflow === null) return {
-		ok: false,
-		lines: formatReport(report)
-	};
-	const { root } = place;
-	const plan = planNodeSession(workflow, nodeId, {
-		cwd: root,
-		inputs: {},
-		inPlace: true,
-		workflowDir,
-		projectRoot: root,
-		orkDir: place.dir,
-		...home === void 0 ? {} : { home }
-	});
-	if (!plan.ok) return {
-		ok: false,
-		lines: [plan.error]
-	};
-	const { context } = plan;
-	const practices = practiceInstructions(resolvePractices(workflow, nodeId), root);
-	const names = ["caveman", "ponytail"].filter((n) => !practices.skipped.includes(n));
-	const ref = graph?.agents.get(nodeId);
-	const role = ref === void 0 ? void 0 : workflow.agents?.[ref.name]?.instructions;
-	return {
-		ok: true,
-		explanation: {
-			node: nodeId,
-			type: workflow.nodes[nodeId]?.type ?? "",
-			workflow: workflow.name,
-			...ref === void 0 ? {} : { agent: {
-				name: ref.name,
-				where: ref.where,
-				tokens: tokens(role ?? "")
-			} },
-			instructions: instructionsOf(context, root),
-			skills: skillLines(context, root),
-			files: context.files.map((f) => ({
-				layer: f.layer,
-				name: f.name,
-				tokens: tokens(f.text)
-			})),
-			practices: practices.text.map((text, index) => ({
-				name: names[index] ?? "practice",
-				tokens: tokens(text)
-			})),
-			skippedPractices: practices.skipped,
-			appendedTokens: tokens(plan.spec.systemAppend)
-		}
-	};
-};
-const approx = (count) => style("dim", `≈${count.toLocaleString("en")} tokens`);
-const formatExplanation = (e) => {
-	const width = Math.max(8, ...e.skills.map((s) => s.name.length));
-	const sourceWidth = Math.max(0, ...e.skills.map((s) => s.source.length));
-	const lines = [
-		`${style("bold", e.node)} ${style("dim", `(${e.type}) in ${e.workflow}`)}`,
-		"",
-		...e.agent === void 0 ? [] : [`${style("bold", "Agent")}  ${e.agent.name} ${style("dim", `(${e.agent.where})`)}  ${approx(e.agent.tokens)}`],
-		`${style("bold", "Instructions")}  ${e.instructions}`,
-		"",
-		style("bold", "Skills")
-	];
-	if (e.skills.length === 0) lines.push(style("dim", "  none"));
-	for (const s of e.skills) {
-		const mark = s.state === "live" ? style("green", "✓") : style("dim", "−");
-		const state = s.why === void 0 ? approx(s.tokens).replace("tokens", "tokens when used") : style("yellow", `off: ${s.why}`);
-		lines.push(`  ${mark} ${s.name.padEnd(width)}  ${s.layer.padEnd(8)}  ${style("dim", s.source.padEnd(sourceWidth))}  ${state}`);
-	}
-	lines.push("", style("bold", "Context files"));
-	if (e.files.length === 0) lines.push(style("dim", "  none"));
-	for (const f of e.files) lines.push(`  ${f.layer.padEnd(8)}  ${f.name}  ${approx(f.tokens)}`);
-	lines.push("", style("bold", "Practices"));
-	for (const p of e.practices) lines.push(`  ${p.name.padEnd(8)}  ${approx(p.tokens)}`);
-	for (const name of e.skippedPractices) lines.push(`  ${name.padEnd(8)}  ${style("dim", "the project's own skill wins")}`);
-	if (e.practices.length === 0 && e.skippedPractices.length === 0) lines.push(style("dim", "  off"));
-	lines.push("", `Appended to Claude Code's system prompt: ${approx(e.appendedTokens)}`);
-	return lines;
-};
-const explain = defineCommand({
-	meta: {
-		name: "explain",
-		description: "Show what one node's session loads, layer by layer"
-	},
-	args: {
-		workflow: {
-			type: "positional",
-			description: "A workflow file, or the name of one in the project's workflows (.ork/workflows/)",
-			required: true
-		},
-		node: {
-			type: "positional",
-			description: "Node id",
-			required: true
-		},
-		json: {
-			type: "boolean",
-			description: "Print JSON",
-			default: false
-		}
-	},
-	run: ({ args }) => {
-		const cwd = process.cwd();
-		const result = explainNode(workflowArg(args.workflow, cwd).file, args.node, cwd);
-		if (!result.ok) {
-			for (const line of result.lines) process.stderr.write(`${line}\n`);
-			process.exitCode = 1;
-			return;
-		}
-		if (args.json) write(JSON.stringify(result.explanation, void 0, 2));
-		else for (const line of formatExplanation(result.explanation)) write(line);
-	}
-});
-const context = defineCommand({
-	meta: {
-		name: "context",
-		description: "Inspect the context Ork compiles for each node"
-	},
-	subCommands: { explain }
-});
-// src/runs/decide.ts
-/**
-* @file `ork decide`: the open decisions of live runs, from any terminal, and
-*   answering them. An answer goes to the store (the first one wins), then the
-*   run is woken on its socket so it picks the answer up at once.
-*/
-/** Open decisions whose run is still live, oldest first. */
-const pendingDecisions = (store, filter) => {
-	const live = /* @__PURE__ */ new Map();
-	return store.decisions({
-		...filter,
-		status: "open"
-	}).filter((decision) => {
-		if (!live.has(decision.runId)) {
-			const [run] = store.lookup(decision.runId);
-			live.set(decision.runId, run !== void 0 && liveStatus(run) === "running");
-		}
-		return live.get(decision.runId) === true;
-	});
-};
-/** Answers an open decision with one of its options, and wakes its run. */
-const answerDecision = async (store, id, choice, home) => {
-	const decision = store.decision(id);
-	if (decision === void 0) return {
-		ok: false,
-		error: `No decision "${id}".`
-	};
-	if (!decision.options.some((o) => o.id === choice)) return {
-		ok: false,
-		error: `"${choice}" is not an option of ${id}: ${decision.options.map((o) => o.id).join(", ")}`
-	};
-	if (!store.answerDecision(id, choice, "decide")) {
-		const now = store.decision(id);
-		return {
-			ok: false,
-			error: now?.status === "answered" ? `${id} was already answered: ${now.answer ?? ""} (${now.answeredBy ?? ""})` : `${id} was withdrawn`
-		};
-	}
-	return {
-		ok: true,
-		woke: await wakeRun(socketPath(decision.runId, home))
-	};
-};
-// src/runs/resume.ts
-/**
-* @file Whether a stored run can be resumed, and with what: its recorded state,
-*   and the flags it was started with unless the user changes them; and `ork
-*   resume --detach`, which resumes it in the background.
-*/
-/** A run `ork resume` can continue: not running, not done, of a workflow. */
-const resumable = (store, run, flags) => {
-	if (liveStatus(run) === "running") return {
-		ok: false,
-		error: `Run ${run.id} is still running.`
-	};
-	const events = store.events(run.id, 0).map((stored) => stored.event);
-	const state = resumeState(events);
-	if (state.succeeded) return {
-		ok: false,
-		error: `Run ${run.id} succeeded; there is nothing to resume.`
-	};
-	if (run.id.startsWith("node-")) return {
-		ok: false,
-		error: `Run ${run.id} ran one node; run it again with ork run --node.`
-	};
-	const driver = flags.driver ?? state.settings.driver;
-	return {
-		ok: true,
-		state,
-		inPlace: flags.inPlace ?? state.settings.inPlace ?? false,
-		...driver === void 0 ? {} : { driver }
-	};
-};
-/**
-* `ork resume --detach`: resumes `run` in a background process with the same
-* flags, and returns once it is running again.
-*/
-const detachResume = (store, run, flags) => detachRun({
-	store,
-	runId: run.id,
-	args: [
-		"resume",
-		run.id,
-		...flags
-	],
-	cwd: run.project,
-	runDir: workflowArg(run.file, run.project).runDir(run.id),
-	started: (pid) => store.lookup(run.id)[0]?.pid === pid
-});
 // src/commands/control.ts
 /**
 * @file `ork decide`, `ork stop` and `ork resume`: answer a live run's open
-*   decisions and stop a live run from any terminal (both write to the store,
-*   then wake the run on its socket; specs/messaging.md), and continue a
-*   stopped or crashed run with its recorded state (ADR-026).
+*   decisions and stop a live run, or one of its nodes (ADR-041), from any
+*   terminal (both write to the store, then wake the run on its socket;
+*   specs/messaging.md), and continue a stopped or crashed run with its
+*   recorded state (ADR-026).
 */
 const failed = (message) => {
 	writeErr(message);
@@ -3900,6 +1641,11 @@ const decide = defineCommand({
 		}
 	},
 	run: async ({ args }) => {
+		const refusal = args.id !== void 0 || args.choose !== void 0 || process.stdin.isTTY && !args.list && !args.json ? decideRefusal() : null;
+		if (refusal !== null) {
+			failed(refusal);
+			return;
+		}
 		const store = openStore();
 		const human = createTerminalHuman({
 			input: process.stdin,
@@ -3957,13 +1703,19 @@ const decide = defineCommand({
 const stop = defineCommand({
 	meta: {
 		name: "stop",
-		description: "Stop a live run"
+		description: "Stop a live run, or one of its nodes"
+	},
+	args: {
+		run: {
+			type: "positional",
+			description: "A run id or a prefix (default: this project's newest)",
+			required: false
+		},
+		node: {
+			type: "string",
+			description: "Stop only this running node: it fails, and the run goes on"
+		}
 	},
-	args: { run: {
-		type: "positional",
-		description: "A run id or a prefix (default: this project's newest)",
-		required: false
-	} },
 	run: async ({ args }) => {
 		const store = openStore();
 		try {
@@ -3973,20 +1725,22 @@ const stop = defineCommand({
 				return;
 			}
 			const { run } = found;
-			const status = liveStatus(run);
-			if (status !== "running") {
-				failed(`Run ${run.id} is not running (${status}).`);
+			const asked = await requestStop(store, run, void 0, args.node);
+			if (!asked.ok) {
+				failed(asked.error);
+				return;
+			}
+			if (args.node !== void 0) {
+				write(`${style("green", "✓")} ${args.node} in run ${run.id} stops: its session is interrupted and it fails, "stopped by the user"; the run goes on.`);
 				return;
 			}
-			store.command(run.id, { kind: "stop" });
-			await wakeRun(socketPath(run.id));
 			for (let i = 0; i < 150; i += 1) {
 				const [now] = store.lookup(run.id);
 				if (now !== void 0 && liveStatus(now) !== "running") {
 					write(`${style("green", "✓")} run ${run.id} ${liveStatus(now)}`);
 					return;
 				}
-				await setTimeout$1(100);
+				await setTimeout(100);
 			}
 			write(`Asked run ${run.id} to stop; it is still finishing its running nodes (see ork logs ${run.id} -f).`);
 		} finally {
@@ -4036,7 +1790,7 @@ const resume = defineCommand({
 	},
 	run: async ({ args, rawArgs }) => {
 		if (args.driver !== void 0 && !isDriver(args.driver)) {
-			failed(`--driver must be sdk or cli, got "${args.driver}"`);
+			failed(`--driver must be sdk or cli, got \`${args.driver}\``);
 			return;
 		}
 		const store = openStore();
@@ -4275,7 +2029,7 @@ const checkGit = async (run) => {
 	return [{
 		name: "git",
 		status: "ok",
-		detail: firstLine$1(version.stdout)
+		detail: firstLine(version.stdout)
 	}, inside.ok ? {
 		name: "git repo",
 		status: "ok",
@@ -4309,6 +2063,134 @@ const runChecks = async (run, env, nodeVersion) => {
 		ok: drivers.some((d) => d.status === "ok") && !results.some((r) => r.status === "fail")
 	};
 };
+/**
+* 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).
+*/
+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();
+	}
+};
+// src/project/ork-skills.ts
+/**
+* @file The Claude Code plugin's skills (`plugins/ork/skills/`) as text, by
+*   name, for `ork init --skills` (RFC-012). Do not edit by hand:
+*   `node tools/release/plugin-skills.ts` and `pnpm build` rewrite it, and a
+*   test fails when it is stale.
+*/
+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",
+	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"
+};
+// src/project/init-skills.ts
+/**
+* @file Ork's skills for Claude Code in a project (RFC-012): `ork init
+*   --skills` writes the plugin's skills into `.ork/skills/ork-<name>/`, each
+*   naming the Ork that wrote it, and links Claude Code's skills folder there,
+*   so teammates get them through git. It rewrites Ork's own copies, but never
+*   one a newer Ork wrote or a skill someone else wrote; `ork doctor` says when
+*   a copy is older than Ork.
+*/
+/** A project copy's folder name: `ork-write` for the plugin's `write`. */
+const SKILL_PREFIX = "ork-";
+const STAMP = /^<!-- Ork (\S+) wrote this with `ork init --skills`/mu;
+/** The Ork version a copy names, or `null` for a skill Ork didn't write. */
+const stampOf = (text) => STAMP.exec(text)?.[1] ?? null;
+/**
+* A plugin skill as a project skill: named `ork-<name>`, its references to
+* `/ork:<name>` as `/ork-<name>`, and the Ork that wrote it after its
+* frontmatter.
+*/
+const projectSkill = (name, text, version) => text.replace(/^name: .*$/mu, `name: ${SKILL_PREFIX}${name}`).replace(/^(---\n[\s\S]*?\n---\n)/u, `$1\n<!-- Ork ${version} wrote this with \`ork init --skills\`, which rewrites it. To keep your own version, rename its folder. -->\n`).replaceAll("/ork:", `/${SKILL_PREFIX}`);
+const fileOf = (root, name) => path.join(root, ORK_LAYOUT.skills, `${SKILL_PREFIX}${name}`, "SKILL.md");
+const sameFolder = (a, b) => {
+	try {
+		return realpathSync(a) === realpathSync(b);
+	} catch {
+		return false;
+	}
+};
+/**
+* Writes Ork's skills into the project at `root`, and links Claude Code's
+* folder.
+*/
+const writeSkills = (root, version, options) => {
+	const result = {
+		created: [],
+		updated: [],
+		skipped: [],
+		newer: [],
+		links: []
+	};
+	for (const [name, text] of Object.entries(ORK_SKILLS)) {
+		const file = fileOf(root, name);
+		const shown = path.relative(root, file);
+		const wanted = projectSkill(name, text, version);
+		const current = existsSync(file) ? readFileSync(file, "utf8") : null;
+		const stamp = current === null ? null : stampOf(current);
+		if (current !== null && (current === wanted || stamp === null)) result.skipped.push(shown);
+		else if (stamp !== null && isNewer(stamp, version)) result.newer.push(`${shown} (Ork ${stamp})`);
+		else {
+			mkdirSync(path.dirname(file), { recursive: true });
+			writeFileSync(file, wanted);
+			(current === null ? result.created : result.updated).push(shown);
+		}
+	}
+	const claude = path.join(root, ".claude", "skills");
+	const ork = path.join(root, ORK_LAYOUT.skills);
+	if (options.link && !sameFolder(claude, ork)) {
+		const linked = linkTools(root, ["claude"]);
+		if (linked.ok) {
+			result.created.push(...linked.created);
+			result.links = linked.links;
+		}
+	}
+	return result;
+};
+/** Whether the project has Ork's skills, current or not. */
+const hasSkills = (root) => Object.keys(ORK_SKILLS).some((name) => existsSync(fileOf(root, name)));
+/** What `ork doctor` says of the project's copies of Ork's skills. */
+const skillChecks = (root, version) => {
+	const folder = path.join(root, ORK_LAYOUT.skills);
+	if (!existsSync(folder)) return [];
+	const old = readdirSync(folder).filter((name) => name.startsWith(SKILL_PREFIX)).flatMap((name) => {
+		const file = path.join(folder, name, "SKILL.md");
+		const stamp = existsSync(file) ? stampOf(readFileSync(file, "utf8")) : null;
+		return stamp !== null && isNewer(version, stamp) ? [`${name} (${stamp})`] : [];
+	});
+	return old.length === 0 ? [] : [{
+		name: "skills",
+		status: "warn",
+		detail: `older than Ork ${version}: ${old.join(", ")}`,
+		hint: "Rewrite them with `ork init --skills`."
+	}];
+};
 // src/project/link.ts
 /**
 * @file What `ork link` and `ork doctor` say about a project's tool folders:
@@ -4365,6 +2247,8 @@ const linkChecks = (projectRoot) => {
 	const links = toolLinks(projectRoot, toolsInUse(projectRoot));
 	return Object.entries(Object.groupBy(links, (link) => link.tool)).map(([tool, group = []]) => checkOf(tool, group));
 };
+// src/doctor/project-checks.ts
+const projectChecks = (root) => [...linkChecks(root), ...skillChecks(root, ORK_VERSION)];
 // src/commands/install.ts
 /**
 * @file This installation of Ork: its name and version for the root command;
@@ -4404,7 +2288,8 @@ const doctor = defineCommand({
 		for (const result of [
 			orkCheck(),
 			...results,
-			...place.mode === "attached" ? [] : linkChecks(place.root)
+			...place.mode === "attached" ? [] : projectChecks(place.root),
+			...triggerChecks()
 		]) 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.`);
@@ -4741,7 +2626,7 @@ const registerProject = (store, target, options = {}) => {
 	if (options.id !== void 0) {
 		if (!ID.test(options.id)) return {
 			ok: false,
-			error: `--id "${options.id}" must be lowercase letters, digits, ".", "_" or "-"`
+			error: `--id \`${options.id}\` must be lowercase letters, digits, ".", "_" or "-"`
 		};
 		if (taken.includes(options.id)) return {
 			ok: false,
@@ -5335,119 +3220,6 @@ const migrate = defineCommand({
 		}, (file) => formatReport(validateFile(file, process.cwd())));
 	}
 });
-// src/runs/format.ts
-/**
-* @file How stored runs read on the terminal: the `ork ps` table and the `ork
-*   tree` ownership tree with each node's state, tokens and cost.
-*/
-const STATUS_STYLE = {
-	running: "cyan",
-	succeeded: "green",
-	failed: "red",
-	crashed: "red",
-	budget_exhausted: "yellow",
-	interrupted: "yellow"
-};
-/** `just now`, `5m ago`, `3h ago`, `2d ago`, then the date. */
-const ago = (iso, now = Date.now()) => {
-	const minutes = Math.floor((now - Date.parse(iso)) / 6e4);
-	if (minutes < 1) return "just now";
-	if (minutes < 60) return `${String(minutes)}m ago`;
-	if (minutes < 1440) return `${String(Math.floor(minutes / 60))}h ago`;
-	if (minutes < 10080) return `${String(Math.floor(minutes / 1440))}d ago`;
-	return iso.slice(0, 10);
-};
-/** `42s`, `3m12s`, `1h05m`. */
-const duration = (ms) => {
-	const s = Math.max(0, Math.round(ms / 1e3));
-	if (s < 60) return `${String(s)}s`;
-	if (s < 3600) return `${String(Math.floor(s / 60))}m${String(s % 60).padStart(2, "0")}s`;
-	return `${String(Math.floor(s / 3600))}h${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}m`;
-};
-const cost = (usd) => `$${usd.toFixed(4)}`;
-/** The `ork ps` table; `withProject` adds each run's project. */
-const formatRuns = (runs, withProject, now = Date.now()) => {
-	if (runs.length === 0) return ["No runs."];
-	const rows = runs.map((run) => {
-		const status = liveStatus(run);
-		const end = run.finishedAt === void 0 ? now : Date.parse(run.finishedAt);
-		return {
-			id: run.id,
-			workflow: run.workflow,
-			status,
-			when: `${ago(run.startedAt, now)} · ${duration(end - Date.parse(run.startedAt))}`,
-			cost: cost(run.costUsd),
-			project: run.project
-		};
-	});
-	const width = (pick, title) => Math.max(title.length, ...rows.map((r) => pick(r).length));
-	const w = {
-		id: width((r) => r.id, "RUN"),
-		workflow: width((r) => r.workflow, "WORKFLOW"),
-		status: width((r) => r.status, "STATUS"),
-		when: width((r) => r.when, "STARTED"),
-		cost: width((r) => r.cost, "COST")
-	};
-	const header = [
-		"RUN".padEnd(w.id),
-		"WORKFLOW".padEnd(w.workflow),
-		"STATUS".padEnd(w.status),
-		"STARTED".padEnd(w.when),
-		"COST".padStart(w.cost),
-		...withProject ? ["PROJECT"] : []
-	].join("  ");
-	return [style("dim", header), ...rows.map((r) => [
-		style("bold", r.id.padEnd(w.id)),
-		r.workflow.padEnd(w.workflow),
-		style(STATUS_STYLE[r.status] ?? "reset", r.status.padEnd(w.status)),
-		style("dim", r.when.padEnd(w.when)),
-		r.cost.padStart(w.cost),
-		...withProject ? [style("dim", r.project)] : []
-	].join("  "))];
-};
-const STATE_MARK = {
-	waiting: style("dim", "·"),
-	running: style("cyan", "●"),
-	ok: style("green", "✓"),
-	failed: style("red", "✗"),
-	skipped: style("dim", "-")
-};
-/** `950`, `12.3k`, `1.2M`. */
-const count = (n) => {
-	if (n < 1e3) return String(n);
-	if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`;
-	return `${(n / 1e6).toFixed(1)}M`;
-};
-const stateText = (node) => {
-	if (node.state === "running") return node.runs > 1 ? `running (round ${String(node.runs)})` : "running";
-	if (node.state === "ok" || node.state === "failed") {
-		const verdict = nodeVerdict(node.output ?? {});
-		const line = verdict.length > 60 ? `${verdict.slice(0, 59)}…` : verdict;
-		return node.runs > 1 ? `${line} (${String(node.runs)} runs)` : line;
-	}
-	return node.state;
-};
-/** The ownership tree, one line per node, children under their owner. */
-const formatTree = (roots) => {
-	const lines = [];
-	const walk = (node, lead, branch) => {
-		lines.push({
-			label: `${lead}${branch}${node.id}`,
-			node
-		});
-		const next = lead + (branch === "├─ " ? "│  " : branch === "" ? "" : "   ");
-		node.children.forEach((child, index) => {
-			walk(child, next, index === node.children.length - 1 ? "└─ " : "├─ ");
-		});
-	};
-	for (const root of roots) walk(root, "", "");
-	const label = Math.max(...lines.map((l) => l.label.length));
-	const type = Math.max(...lines.map((l) => l.node.type.length));
-	return lines.map(({ label: text, node }) => {
-		const usage = node.inputTokens + node.outputTokens === 0 ? "" : style("dim", `  ${count(node.inputTokens)} in / ${count(node.outputTokens)} out · ${cost(node.costUsd)}`);
-		return `${text.padEnd(label)}  ${style("dim", node.type.padEnd(type))}  ${STATE_MARK[node.state]} ${stateText(node)}${usage}`;
-	});
-};
 // src/runs/feedback.ts
 /**
 * @file `ork feedback`'s helpers (specs/feedback.md): finding an item by a
@@ -5599,8 +3371,9 @@ 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) : []);
 		if (args.json) write(JSON.stringify(runs, void 0, 2));
-		else for (const line of formatRuns(runs, args.all)) write(line);
+		else for (const line of formatRuns(runs, args.all, Date.now(), statusOf)) write(line);
 	})
 });
 const runArg = {
@@ -5671,12 +3444,13 @@ const tree = defineCommand({
 			return;
 		}
 		const { run } = found;
-		const roots = runTree(store.events(run.id).map((s) => s.event));
+		const events = store.events(run.id).map((s) => s.event);
+		const roots = runTree(events);
 		if (args.json) {
 			write(JSON.stringify(roots, void 0, 2));
 			return;
 		}
-		write(`${style("bold", `run ${run.id}`)} ${style("dim", `of ${run.workflow} · ${liveStatus(run)} · ${cost(run.costUsd)}`)}`);
+		write(`${style("bold", `run ${run.id}`)} ${style("dim", `of ${run.workflow} · ${runStatus(run, events)} · ${cost(run.costUsd)}`)}`);
 		for (const line of formatTree(roots)) write(line);
 	})
 });
@@ -5868,6 +3642,35 @@ const addAgent = (options) => {
 	if (options.model !== void 0) agent.model = options.model;
 	return createAgent(options.name, agent, options);
 };
+// src/project/skills-step.ts
+/**
+* @file The skills step of `ork init` (RFC-012): with `--skills` it writes
+*   Ork's skills for Claude Code into the project, with `--no-skills` it
+*   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 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) => {
+	if (asked !== void 0) return Promise.resolve(asked);
+	if (hasSkills(root)) return Promise.resolve(false);
+	return process.stdin.isTTY && process.stdout.isTTY ? confirm(QUESTION) : Promise.resolve(null);
+};
+const skillsStep = async (root, options) => {
+	const choice = await wanted(root, options.skills);
+	if (choice === null) {
+		write(style("dim", HINT));
+		return;
+	}
+	if (!choice) return;
+	const result = writeSkills(root, ORK_VERSION, { link: options.link });
+	for (const item of result.created) write(`${style("green", "created")} ${item}`);
+	for (const item of result.updated) write(`${style("green", "updated")} ${item}`);
+	for (const item of result.skipped) write(`${style("dim", "exists")}  ${item}`);
+	for (const item of result.newer) write(`${style("yellow", "kept")}    ${item}, from a newer Ork than ${ORK_VERSION}`);
+	for (const line of formatLinks(result.links.filter((l) => l.state !== "linked"))) write(line);
+};
 // src/commands/setup.ts
 /**
 * @file Setting up: `ork init` scaffolds `.ork/` in a project, records it, and
@@ -5881,12 +3684,18 @@ const init = defineCommand({
 		name: "init",
 		description: "Set up .ork/ in this project with a starter workflow, and link the tool folders it uses"
 	},
-	args: { link: {
-		type: "boolean",
-		description: "Link .claude/agents and the like to .ork/ (--no-link: don't)",
-		default: true
-	} },
-	run: ({ args }) => {
+	args: {
+		link: {
+			type: "boolean",
+			description: "Link .claude/agents and the like to .ork/ (--no-link: don't)",
+			default: true
+		},
+		skills: {
+			type: "boolean",
+			description: "Write Ork's skills for Claude Code into .ork/skills/ (--no-skills: don't; asked otherwise)"
+		}
+	},
+	run: async ({ args }) => {
 		const store = openStore();
 		let result;
 		try {
@@ -5903,6 +3712,10 @@ const init = defineCommand({
 		for (const item of created) write(`${style("green", "created")} ${item}`);
 		for (const item of skipped) write(`${style("dim", "exists")}  ${item}`);
 		for (const line of formatLinks(links.filter((l) => l.state !== "linked"))) write(line);
+		await skillsStep(process.cwd(), {
+			skills: args.skills,
+			link: args.link
+		});
 		write(`\nNext: edit ${WORKFLOW_DIR}/, then run ${style("bold", "ork validate")}.`);
 	}
 });
@@ -6091,14 +3904,23 @@ const main = defineCommand({
 		ps,
 		logs,
 		tree,
+		usage: () => import("./usage-BIjf9Xdt.mjs").then((module) => module.usage),
+		prune: () => import("./usage-BIjf9Xdt.mjs").then((module) => module.prune),
 		decide,
+		relay: () => import("./relay-CbK-Wme9.mjs").then((module) => module.relay),
+		pause: () => import("./pause-DKACDfV1.mjs").then((module) => module.pause),
+		continue: () => import("./pause-DKACDfV1.mjs").then((module) => module.continueRun),
 		stop,
 		chat,
+		send: () => import("./send-C6yr04Fe.mjs").then((module) => module.send),
 		resume,
 		feedback,
 		context,
 		worktrees,
 		wt: worktrees,
+		watch: () => import("./watch-B8o4Szd_.mjs").then((module) => module.watch),
+		mcp: () => import("./mcp-BWsdQyri.mjs").then((module) => module.mcp),
+		ui: () => import("./ui-CZS1XKla.mjs").then((module) => module.ui),
 		doctor,
 		upgrade
 	}