@krapht/ork 0.3.0 → 1.0.0-alpha.0

package/dist/bin.mjs

@@ -1,23 +1,58 @@
 #!/usr/bin/env node
-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 { Bn as serializeWorkflow, Bt as FEEDBACK_TARGETS, Cn as runDirOf, D as inspectProject, Dn as projectRootOf, Dt as userMessageText, En as inside, Ft as PROJECT_FILE, H as tellNode, Ht as planPost, I as createCalls, It as gitRulesOf, J as tellLiveRun, Jn as beforeOf, Jt as normalizeTitle, Kn as settingsOf, Kt as createFeedback, L as addressOf, Lt as loadProject, M as clearGitLocalEnv, N as parseInputPairs, P as resolveInputs, R as endLink, Rt as FEEDBACK_KINDS, Sn as projectsHome, Tt as startRun, Un as WorkflowSchema, V as peerOf, W as flattenTree, Wt as sendPost, Xt as maskReplacer, Yn as isClaudeNode, _ as lateTriggers, _n as hasInRepoFiles, _t as runStatus, an as wakeRun, ar as CLAUDE_DRIVERS, bn as placeFiles, cn as planMoveInto, d as runningRunIds, dn as toolsInUse, dt as namingNoDriver, er as INTEGRATIONS, et as adoptedCalls, f as runningScript, fn as createAgent, ft as sessionDriver, h as isNewer, hn as loadAgents, ht as liveStatus, i as NOT_STARTED, in as socketRoom, ir as ORK_LAYOUT, it as replayLoopAnswers, l as planUpgrade, ln as linkTools, mn as catalogAgent, n as resolveBase, nn as serveRun, nt as resumable, on as planAgentMigration, or as firstLine, ot as detachRun, pn as deleteAgent, q as requestStop, qt as fingerprint, rn as socketPath, rr as AGENT_TOOL_LAYOUTS, rt as createReplay, sn as applySteps, st as followEvents, t as createWorkspace, tt as detachResume, u as releaseNotes, un as toolLinks, ut as planNodeSession, v as triggersReport, vn as inRepoPlace, vt as runTree, wn as shownPath, wt as walkSummary, xn as placeFor, yn as newProjectId, z as endLinksOf, zt as FEEDBACK_SEVERITIES } from "./src-DHvWU4tX.mjs";
+import { C as feedbackActions, S as placeOf, _ as previewPost, b as acceptItem, c as checkDue, d as pendingNotice, f as readUpdateCache, g as nodeSession, h as writeUpdateCache, i as registryOf, l as fetchLatest, m as updateCachePath, n as ORK_VERSION, o as updateSwitchOff, p as refreshUpdateCache, r as isSwitchedOn, s as runInstall, t as ORK_NAME, u as newerVersion$1, v as checkNote, w as openFixRun, y as recordNote } from "./__build_info__-DdTVd2p5.mjs";
+import { i as builtinWorkflowFile, n as pendingDecisions, r as builtinProblem, t as answerDecision } from "./decide-B81wCZQg.mjs";
+import { n as newRunId, t as findRun } from "./find-BKW-uGey.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-B1V6ZJSx.mjs";
+import { n as listOrkWorktrees, t as createdWorktrees } from "./list-C7UEgmtd.mjs";
+import { a as planClean, t as applyClean } from "./clean-NnboOuz6.mjs";
+import { c as subcommandsOf, i as argsOf, n as groupedEntries, o as publicArgs, s as resolved, t as groupOf } from "./help-groups-BwYoAWsh.mjs";
+import { a as formatRunEvent, i as formatEvent, n as formatRuns, o as createTerminalHuman, r as formatTree, t as ago } from "./format-CmTlTOjT.mjs";
+import { c as registeredProjects, i as refusedBuiltin, n as WORKFLOW_SUFFIX, o as workflowArg, s as projectAt, t as WORKFLOW_DIR } from "./workflows-CiM7S3l0.mjs";
+import { a as validate, c as warningLines, i as loadWorkflow, o as validateFile, r as formatReport, s as walkLoaded, t as context } from "./context-DO3sBy9v.mjs";
+import { i as runLimits, r as limitsRefusal, t as chatNotice } from "./limits-JCve2QpI.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-C38BPzit.mjs";
+import { i as decideRefusal, n as chatRefusal } from "./in-a-run-BPXX09Bs.mjs";
 import path from "node:path";
 import { stringify } from "yaml";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { z } from "zod";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
-import { setTimeout } from "node:timers/promises";
 import { execFile, spawn } from "node:child_process";
+import { setTimeout } from "node:timers/promises";
+import { defineCommand, renderUsage, runMain } from "citty";
+import { createInterface } from "node:readline/promises";
 import { styleText } from "node:util";
+// ../integrations/src/ready.ts
+/**
+* @file Which Claude driver is ready on this machine: each driver's own check
+*   (what `ork doctor` shows), and the one a run takes for the nodes that name
+*   no driver, so a committed workflow never carries one person's login.
+*/
+/** Each registered Claude driver's own check, in registry order. */
+const driverChecks = (run, env) => Promise.all(CLAUDE_DRIVERS.map(async (driver) => ({
+	id: driver.id,
+	result: await driver.doctor(run, env)
+})));
+/**
+* The driver ready here: the one whose check passes; with more than one,
+* {@link PREFERRED_DRIVER}; with none, each driver's hint.
+*/
+const readyDriver = (checks) => {
+	const ready = checks.filter(({ result }) => result.status === "ok");
+	const pick = ready.find(({ id }) => id === "cli") ?? ready.at(0);
+	if (pick === void 0) return {
+		ok: false,
+		hints: checks.flatMap(({ result }) => result.hint === void 0 ? [] : [result.hint])
+	};
+	return {
+		ok: true,
+		driver: pick.id,
+		detail: pick.result.detail,
+		ready: ready.length
+	};
+};
 // ../core/src/control/queue.ts
 const PERMISSION_OPTIONS = [{
 	id: "allow",
@@ -27,6 +62,8 @@ const PERMISSION_OPTIONS = [{
 	label: "Deny"
 }];
 const DENIED = "The user did not allow this tool.";
+/** The deny message a session gets, with the person's words when given. */
+const deniedMessage = (note) => note === void 0 ? DENIED : `${DENIED} They said: ${note}`;
 /** At most `max` characters of a tool's input, for the decision's context. */
 const inputPreview = (input, max = 400) => {
 	const json = JSON.stringify(input);
@@ -53,22 +90,30 @@ const createDecisionQueue = (options) => {
 			options: record.options
 		};
 		if (record.recommended !== void 0) event.recommended = record.recommended;
+		if (record.owner !== void 0) event.owner = record.owner;
 		emit(event);
 		const { promise, resolve, reject } = Promise.withResolvers();
 		const settled = new AbortController();
-		const finish = (answer, by) => {
+		/** `note` is the stored one: masked, and absent when blank. */
+		const finish = (answer, by, note) => {
 			if (settled.signal.aborted) return;
 			settled.abort();
-			emit({
+			const answered = {
 				type: "decision.answered",
 				node: open.node,
 				decision: id,
 				answer,
 				by
-			});
-			resolve({
+			};
+			if (note !== void 0) answered.note = note;
+			emit(answered);
+			resolve(note === void 0 ? {
 				answer,
 				by
+			} : {
+				answer,
+				by,
+				note
 			});
 		};
 		const withdraw = () => {
@@ -87,13 +132,13 @@ const createDecisionQueue = (options) => {
 		const fromStore = async () => {
 			try {
 				const closed = await options.waitFor(id, settled.signal);
-				if (closed.status === "answered" && closed.answer !== void 0) finish(closed.answer, closed.answeredBy ?? "decide");
+				if (closed.status === "answered" && closed.answer !== void 0) finish(closed.answer, closed.answeredBy ?? "decide", closed.note);
 			} catch {}
 		};
 		const fromTerminal = async (ask) => {
 			try {
-				const answer = await ask(settled.signal);
-				if (store.answerDecision(id, answer, "terminal")) finish(answer, "terminal");
+				const { answer, note } = await ask(settled.signal);
+				if (store.answerDecision(id, answer, "terminal", note)) finish(answer, "terminal", store.decision(id)?.note);
 			} catch {}
 		};
 		fromStore();
@@ -110,31 +155,92 @@ const createDecisionQueue = (options) => {
 			};
 			if (question.recommended !== void 0) open.recommended = question.recommended;
 			if (question.context !== void 0) open.context = question.context;
+			if (question.owner !== void 0) open.owner = question.owner;
 			const { local } = options;
-			return decide(open, local === void 0 ? void 0 : (signal) => local.ask({
-				...question,
-				signal
-			}), question.signal).then(({ answer }) => answer);
+			return decide(open, local === void 0 ? void 0 : (signal) => {
+				let note;
+				return local.ask({
+					...question,
+					signal,
+					onNote: (given) => {
+						note = given;
+					}
+				}).then((answer) => note === void 0 ? { answer } : {
+					answer,
+					note
+				});
+			}, question.signal).then(({ answer, note }) => {
+				if (note !== void 0) question.onNote?.(note);
+				return answer;
+			});
+		},
+		settled: (question) => {
+			count += 1;
+			const id = `${runId}-${String(count)}`;
+			const { owner } = question;
+			const record = store.openDecision({
+				id,
+				runId,
+				node: question.nodeId,
+				kind: "question",
+				question: question.question,
+				options: question.options,
+				owner,
+				...question.recommended === void 0 ? {} : { recommended: question.recommended },
+				...question.context === void 0 ? {} : { context: question.context }
+			});
+			emit({
+				type: "decision.opened",
+				node: record.node,
+				decision: id,
+				kind: "question",
+				question: record.question,
+				options: record.options,
+				owner,
+				...record.recommended === void 0 ? {} : { recommended: record.recommended }
+			});
+			store.answerDecision(id, question.answer, "owner", question.note);
+			const note = store.decision(id)?.note;
+			emit({
+				type: "decision.answered",
+				node: record.node,
+				decision: id,
+				answer: question.answer,
+				by: "owner",
+				owner,
+				...note === void 0 ? {} : { note }
+			});
 		},
 		permit: async (request) => {
 			const { local } = options;
 			let localMessage = DENIED;
-			const { answer } = await decide({
+			const { answer, note } = await decide({
 				node: request.nodeId,
 				kind: "permission",
 				question: `Allow ${request.toolName}?`,
 				options: PERMISSION_OPTIONS,
 				context: inputPreview(request.input)
-			}, local === void 0 ? void 0 : (signal) => local.permit({
-				...request,
-				signal
-			}).then((result) => {
-				if (!result.allow) localMessage = result.message;
-				return result.allow ? "allow" : "deny";
-			}));
+			}, local === void 0 ? void 0 : (signal) => {
+				let said;
+				return local.permit({
+					...request,
+					signal,
+					onNote: (given) => {
+						said = given;
+					}
+				}).then((result) => {
+					if (!result.allow) localMessage = result.message;
+					const choice = result.allow ? "allow" : "deny";
+					return said === void 0 ? { answer: choice } : {
+						answer: choice,
+						note: said
+					};
+				});
+			});
+			if (note !== void 0) request.onNote?.(note);
 			return answer === "allow" ? { allow: true } : {
 				allow: false,
-				message: localMessage
+				message: note === void 0 ? localMessage : deniedMessage(note)
 			};
 		}
 	};
@@ -208,41 +314,6 @@ const startControl = async (options) => {
 		}
 	};
 };
-// ../core/src/feedback/human.ts
-const RATINGS = ["good", "bad"];
-const MAX_TITLE = 120;
-/** The run event a note becomes; its title is the note's first line. */
-const humanNoteEvent = (note) => {
-	const text = maskSecrets(note.text.trim());
-	const [first = ""] = text.split("\n");
-	const title = first.slice(0, MAX_TITLE);
-	const kind = note.kind ?? "friction";
-	const target = targetOf({
-		kind,
-		title,
-		...note.target === void 0 ? {} : { target: note.target }
-	});
-	const feedback = {
-		source: "human",
-		kind,
-		target,
-		severity: note.severity ?? (note.rating === "bad" ? "high" : "medium"),
-		title,
-		body: text,
-		evidence: note.rating === void 0 ? [] : [`rating: ${note.rating}`],
-		fingerprint: fingerprint({
-			target,
-			kind,
-			title
-		}),
-		origin: { workflow: note.workflow }
-	};
-	return {
-		type: "feedback.recorded",
-		...note.node === void 0 ? {} : { node: note.node },
-		feedback
-	};
-};
 // ../core/src/feedback/signals.ts
 const ORK_TOOL = "mcp__ork__";
 /**
@@ -375,7 +446,7 @@ const createSignals = (options = {}) => {
 		}
 		if (event.type !== "node.event") return;
 		const inner = event.event;
-		if (inner.type === "session.started") sessions.set(event.id, {
+		if (inner.type === "session.started" && inner.fork !== true) sessions.set(event.id, {
 			model: inner.model,
 			...inner.driver === void 0 ? {} : { driver: inner.driver }
 		});
@@ -402,6 +473,47 @@ const createSignals = (options = {}) => {
 		return signal === null ? [event] : [event, ...record(...signal)];
 	};
 };
+/** A title's words, as fingerprints compare them. */
+const titleWords = (title) => new Set(normalizeTitle(title).split(" ").filter((word) => word !== ""));
+/** The share of two titles' words they have in common (Jaccard). */
+const titleOverlap = (a, b) => {
+	const left = titleWords(a);
+	const right = titleWords(b);
+	const union = /* @__PURE__ */ new Set([...left, ...right]);
+	if (union.size === 0) return 0;
+	return [...left].filter((word) => right.has(word)).length / union.size;
+};
+const unsettled = (item) => item.status === "new" || item.status === "triaged";
+const firstSeen = (a, b) => a.firstSeen.localeCompare(b.firstSeen) || a.id.localeCompare(b.id);
+/**
+* One kind of item's groups, oldest first: an item joins the first group whose
+* first-seen item it is near enough, so every member is within the rule of the
+* item the others go under, never only of one another.
+*/
+const groupsOf = (items) => {
+	const groups = [];
+	for (const item of items.toSorted(firstSeen)) {
+		const group = groups.find(([root]) => root !== void 0 && titleOverlap(root.title, item.title) >= .8);
+		if (group === void 0) groups.push([item]);
+		else group.push(item);
+	}
+	return groups;
+};
+/** The merges triage would make among `items`, oldest group first. */
+const proposeMerges = (items) => {
+	const byKind = /* @__PURE__ */ new Map();
+	for (const item of items.filter((i) => unsettled(i))) {
+		const key = `${item.target}/${item.kind}`;
+		byKind.set(key, [...byKind.get(key) ?? [], item]);
+	}
+	return [...byKind.values()].flatMap((sameKind) => groupsOf(sameKind)).filter((group) => group.length > 1 && group.some((item) => item.status === "new")).map((group) => {
+		const [into, ...from] = group;
+		return into === void 0 ? void 0 : {
+			into,
+			from
+		};
+	}).filter((merge) => merge !== void 0).toSorted((a, b) => firstSeen(a.into, b.into));
+};
 // ../core/src/remote/relay.ts
 /**
 * @file A run's side of the relay (RFC-003): its nodes' links, read from the
@@ -526,229 +638,491 @@ const createRecorder = (store, run, runDir) => {
 	store.begin(run);
 	return appendRecorder(store, run.id, runDir);
 };
-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) => {
-	const value = record[key];
-	return typeof value === "string" ? value : void 0;
-};
-const notifiedOf = (value) => {
-	if (!isRecord(value)) return void 0;
-	const version = text(value, "version");
-	const at = text(value, "at");
-	return version === void 0 || at === void 0 ? void 0 : {
-		version,
-		at
+// src/help-root.ts
+/** Where the user docs start. */
+const DOCS_URL = "https://github.com/mimshins/ork/blob/main/docs/README.md";
+const rowOf = (entry) => {
+	const short = groupOf(entry.name)?.short ?? entry.description;
+	const alias = entry.aliases.length === 0 ? "" : ` (alias: ${entry.aliases.join(", ")})`;
+	return {
+		name: entry.name,
+		line: `${short}${alias}`
 	};
 };
-/** The cache, or `null` when there is none or it cannot be read. */
-const readUpdateCache = (file) => {
-	let parsed;
-	try {
-		parsed = JSON.parse(readFileSync(file, "utf8"));
-	} catch {
-		return null;
-	}
-	if (!isRecord(parsed)) return null;
-	const checkedAt = text(parsed, "checkedAt");
-	if (checkedAt === void 0) return null;
-	const latest = text(parsed, "latest");
-	const notified = notifiedOf(parsed["notified"]);
-	return {
-		checkedAt,
-		...latest === void 0 ? {} : { latest },
-		...notified === void 0 ? {} : { notified }
-	};
-};
-/** Writes the cache whole (a temporary file, then a rename). */
-const writeUpdateCache = (file, cache) => {
-	mkdirSync(path.dirname(file), { recursive: true });
-	const temporary = `${file}.${process.pid}.tmp`;
-	writeFileSync(temporary, `${JSON.stringify(cache, null, 2)}\n`);
-	renameSync(temporary, file);
-};
-const age = (iso, now) => {
-	const time = Date.parse(iso);
-	return Number.isNaN(time) ? Infinity : now.getTime() - time;
-};
-/** Whether it is time to ask the registry again. */
-const checkDue = (cache, now) => cache === null || age(cache.checkedAt, now) >= 864e5;
-/** The package's `latest` version on the registry, or `null` on any failure. */
-const fetchLatest = async (name, options = {}) => {
-	const registry = (options.registry ?? "https://registry.npmjs.org").replace(/\/+$/u, "");
-	const get = options.fetch ?? globalThis.fetch;
-	try {
-		const response = await get(`${registry}/-/package/${name}/dist-tags`, {
-			headers: { accept: "application/json" },
-			signal: AbortSignal.timeout(options.timeoutMs ?? 5e3)
-		});
-		if (!response.ok) return null;
-		const tags = await response.json();
-		return (isRecord(tags) ? text(tags, "latest") : void 0) ?? null;
-	} catch {
-		return null;
-	}
+const groupedRows = (entries) => groupedEntries(entries).map((group) => ({
+	title: group.title,
+	rows: group.entries.map((entry) => rowOf(entry))
+}));
+/** A group's title, its rows with names `width` wide, and a blank line. */
+const groupLines = (group, width) => [style("bold", `${group.title}:`)].concat(group.rows.map((row) => `  ${style("cyan", row.name.padEnd(width))}  ${row.line}`), [""]);
+/** The root command's help text. */
+const renderRootHelp = async (cmd) => {
+	const meta = cmd.meta === void 0 ? {} : await resolved(cmd.meta);
+	const name = meta.name ?? "ork";
+	const groups = groupedRows(await subcommandsOf(cmd));
+	const width = Math.max(...groups.flatMap((g) => g.rows.map((r) => r.name.length)));
+	return [
+		`${meta.description ?? ""}.`,
+		`Docs: ${DOCS_URL}`,
+		"",
+		...groups.flatMap((group) => groupLines(group, width)),
+		`Usage: ${name} <command> [flags]`,
+		"",
+		`Use "${name} <command> --help" for more about a command.`,
+		`${name} v${meta.version ?? ""}`
+	].join("\n");
 };
+// src/help.ts
 /**
-* Asks the registry and records the answer. A failed check is recorded too, so
-* an offline machine is not asked again until the interval passes; the last
-* known `latest` is kept.
+* @file `ork <command> --help`: citty's usage, without the flags Ork passes to
+*   itself (the command tree's filter), and with `<command> [flags]` in place
+*   of citty's `a|b|c` list for a command with subcommands. The root command's
+*   help is grouped (`help-root.ts`).
 */
-const refreshUpdateCache = async (file, name, now, options = {}) => {
-	const before = readUpdateCache(file);
-	const latest = await fetchLatest(name, options) ?? before?.latest;
-	const cache = {
-		...before,
-		checkedAt: now.toISOString(),
-		...latest === void 0 ? {} : { latest }
+/** Citty's `a|b|c` usage list of a command's shown subcommands. */
+const choicesOf = async (cmd) => (await subcommandsOf(cmd)).flatMap((entry) => entry.hidden ? [] : [entry.name].concat(entry.aliases)).join("|");
+/** The usage of `cmd` (under `parent`), as people see it. */
+const renderHelp = async (cmd, parent) => {
+	const shown = {
+		args: publicArgs(await argsOf(cmd)),
+		...cmd.meta === void 0 ? {} : { meta: cmd.meta },
+		...cmd.subCommands === void 0 ? {} : { subCommands: cmd.subCommands }
 	};
-	writeUpdateCache(file, cache);
-	return cache;
+	if (cmd.subCommands !== void 0 && parent === void 0) return renderRootHelp(shown);
+	const above = parent?.meta === void 0 ? void 0 : { meta: parent.meta };
+	const usage = await renderUsage(shown, above);
+	if (cmd.subCommands === void 0) return usage;
+	const choices = await choicesOf(shown);
+	return usage.replace(` [OPTIONS] ${choices}`, ` <command> [flags]`).replace(` ${choices}`, ` <command> [flags]`);
 };
-/** The newer version the cache knows of, if any. */
-const newerVersion = (cache, current) => cache?.latest !== void 0 && isNewer(cache.latest, current) ? cache.latest : null;
-/**
-* The version to tell the user about now: newer than theirs, and not already
-* told today. `null` when there is nothing to say.
-*/
-const pendingNotice = (cache, current, now) => {
-	const newer = newerVersion(cache, current);
-	if (newer === null) return null;
-	const told = cache?.notified;
-	return told?.version === newer && age(told.at, now) < 864e5 ? null : newer;
+/** Prints {@link renderHelp}'s usage, as citty prints its own. */
+const showHelp = async (cmd, parent) => {
+	process.stdout.write(`${await renderHelp(cmd, parent)}\n\n`);
 };
-// src/runs/chat.ts
+// src/update/notify.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; `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.
+* @file The new-version notice (ADR-038). At most once a day a command starts a
+*   detached copy of `ork` that asks the npm registry for the latest version
+*   and records it in `~/.ork/update-check.json`, so no command waits on the
+*   network; a later command, when a newer version is known, ends with one line
+*   on stderr (once a day). Off in CI, without a terminal, with `--json`, and
+*   with `ORK_NO_UPDATE_CHECK=1` or `NO_UPDATE_NOTIFIER=1`.
 */
-/** The 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;
-};
+/** Set in the background copy of `ork` that only runs the check. */
+const UPDATE_CHILD_ENV = "ORK_UPDATE_CHECK_CHILD";
 /**
-* 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.
+* Why the automatic check is off for this command, or `null` when it is on: the
+* environment's switches (core's, which `ork ui` reads too), then where a
+* notice on stderr would go.
 */
-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 failure;
+const updateCheckOff = (env, argv, terminal) => {
+	const switched = updateSwitchOff(env);
+	if (switched !== null) return switched === "CI" ? "in CI" : "turned off";
+	if (isSwitchedOn(env["ORK_DETACHED"]) || !terminal) return "no terminal";
+	if (argv.includes("--json")) return "JSON output";
+	if (argv[0] === "upgrade") return "ork upgrade checks for itself";
+	if (argv[0] === "ui" && argv.includes("--serve")) return "ork ui's server checks for itself";
+	return null;
 };
-// src/runs/logs.ts
+/** The notice's text. */
+const updateNotice = (latest, current) => `Ork ${latest} is out (you have ${current}). Upgrade with: ork upgrade`;
 /**
-* @file `ork logs`: replays a stored run's events as the transcript `ork run`
-*   printed, for the whole run or one node, and tails a live run until it
-*   ends.
+* Starts the background check when one is due. Records the attempt first, so
+* commands started in the next moments do not start one too.
 */
-/** 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);
-	};
+const startUpdateCheck = (file = updateCachePath(), now = /* @__PURE__ */ new Date()) => {
+	try {
+		const cache = readUpdateCache(file);
+		if (!checkDue(cache, now)) return;
+		writeUpdateCache(file, {
+			...cache,
+			checkedAt: now.toISOString()
+		});
+		const child = spawn(process.execPath, [...process.execArgv, process.argv[1] ?? ""], {
+			detached: true,
+			stdio: "ignore",
+			env: {
+				...process.env,
+				[UPDATE_CHILD_ENV]: "1"
+			}
+		});
+		child.on("error", () => {});
+		child.unref();
+	} catch {}
 };
-/**
-* 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)`));
+/** The background copy's whole job: ask the registry, record the answer. */
+const runUpdateChild = async () => {
+	const registry = registryOf(process.env);
+	await refreshUpdateCache(updateCachePath(), ORK_NAME, /* @__PURE__ */ new Date(), {
+		current: ORK_VERSION,
+		...registry === void 0 ? {} : { registry }
+	});
 };
-// 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 };
+/** Prints the notice when a newer version is known and not told today. */
+const showUpdateNotice = (file = updateCachePath(), now = /* @__PURE__ */ new Date()) => {
 	try {
-		origin.workflowHash = createHash("sha256").update(readFileSync(workflowFile)).digest("hex").slice(0, 12);
+		const cache = readUpdateCache(file);
+		const latest = pendingNotice(cache, ORK_VERSION, now);
+		if (cache === null || latest === null) return;
+		const text = updateNotice(latest, ORK_VERSION);
+		process.stderr.write(`\n${styleText("yellow", text, { stream: process.stderr })}\n`);
+		writeUpdateCache(file, {
+			...cache,
+			notified: {
+				version: latest,
+				at: now.toISOString()
+			}
+		});
 	} catch {}
-	return origin;
 };
-// src/run/node.ts
+// src/update/upgrade.ts
 /**
-* @file `ork run --node`: checks a workflow and its inputs, plans one Claude
-*   node's session, streams it to the terminal, and records it as a run of one
-*   node.
+* @file `ork doctor`'s line for Ork itself (ADR-038): the running version
+*   against the last update check, read from the record without asking the
+*   network. What `ork upgrade` does is core's (`planUpgrade`, `runInstall`),
+*   shared with the server behind `ork ui`.
 */
-const succeeded = (outcome) => outcome?.report !== null && outcome?.report !== void 0 && outcome.report.status !== "fail";
+/** `ork doctor`'s line for Ork itself, from the last check. */
+const versionCheck = (current, cache, checksOff) => {
+	const newer = newerVersion$1(cache, current);
+	if (newer !== null) return {
+		name: "ork",
+		status: "warn",
+		detail: `${current}; ${newer} is out`,
+		hint: "Run ork upgrade."
+	};
+	return {
+		name: "ork",
+		status: "ok",
+		detail: `${current} (${cache?.latest === void 0 ? checksOff ? "update check off" : "not checked for updates yet" : `the latest as of ${cache.checkedAt.slice(0, 10)}`})`
+	};
+};
+// src/doctor/checks.ts
+/**
+* @file The checks behind `ork doctor`: Ork's own version against the last
+*   update check, each tool's presence and login status (the drivers' own
+*   checks, which `ork run` also reads to pick the one ready), and whether a
+*   run's socket path fits, through an injectable `exec` so tests need no real
+*   tools. Never prints a token or an account.
+*/
+const TIMEOUT_MS = 15e3;
+const exec = (program, args) => new Promise((resolve) => {
+	execFile(program, args, {
+		timeout: TIMEOUT_MS,
+		encoding: "utf8"
+	}, (error, stdout) => {
+		resolve({
+			ok: error === null,
+			stdout
+		});
+	});
+});
+/** Ork's own version, against the last update check (no network). */
+const orkCheck = () => versionCheck(ORK_VERSION, readUpdateCache(updateCachePath()), updateCheckOff(process.env, [], true) !== null);
+const MIN_NODE = [24, 20];
+const checkNode = (version) => {
+	const [major = 0, minor = 0] = version.split(".").map(Number);
+	const [minMajor, minMinor] = MIN_NODE;
+	return major > minMajor || major === minMajor && minor >= minMinor ? {
+		name: "node",
+		status: "ok",
+		detail: `v${version}`
+	} : {
+		name: "node",
+		status: "fail",
+		detail: `v${version}`,
+		hint: `Ork needs Node ${MIN_NODE.join(".")} or later.`
+	};
+};
+const checkGit = async (run) => {
+	const version = await run("git", ["--version"]);
+	if (!version.ok) return [{
+		name: "git",
+		status: "fail",
+		detail: "not found",
+		hint: "Install git; Ork gives each writing node its own worktree."
+	}];
+	const inside = await run("git", ["rev-parse", "--is-inside-work-tree"]);
+	return [{
+		name: "git",
+		status: "ok",
+		detail: firstLine(version.stdout)
+	}, inside.ok ? {
+		name: "git repo",
+		status: "ok",
+		detail: "inside a work tree"
+	} : {
+		name: "git repo",
+		status: "warn",
+		detail: "not a git repository",
+		hint: "Run Ork inside a git repository so nodes can use worktrees."
+	}];
+};
+/**
+* Runs every check: Node and git, then every registered Claude driver and
+* integration (ADR-022). Node, git, and at least one driver are required;
+* integrations are optional.
+*/
+const runChecks = async (run, env, nodeVersion) => {
+	const [git, checked, tools] = await Promise.all([
+		checkGit(run),
+		driverChecks(run, env),
+		Promise.all(INTEGRATIONS.flatMap((i) => i.doctor === void 0 ? [] : [i.doctor(run, env)]))
+	]);
+	const drivers = checked.map(({ result }) => result);
+	const results = [
+		checkNode(nodeVersion),
+		...git,
+		...drivers,
+		...tools
+	];
+	return {
+		results,
+		ok: drivers.some((d) => d.status === "ok") && !results.some((r) => r.status === "fail")
+	};
+};
+/**
+* Whether a run's socket fits under `~` (L38). Past the limit a run can't
+* listen, and nothing else says so: answers, commands and followers fall back
+* to the store, a second at a time. `home` is the user's `~`.
+*/
+const socketCheck = (home, platform) => {
+	const { bytes, max } = socketRoom(home, platform);
+	if (max === void 0 || bytes <= max) return {
+		name: "sockets",
+		status: "ok",
+		detail: max === void 0 ? "not Unix sockets here" : `${String(bytes)} of ${String(max)} bytes`
+	};
+	return {
+		name: "sockets",
+		status: "warn",
+		detail: `a run's socket path is ${String(bytes)} bytes, past the ${String(max)} this system allows`,
+		hint: "Runs still work, but answers, commands and `ork logs --follow` wait up to a second for each, as they read the store instead. A shorter home folder path fixes it."
+	};
+};
+/**
+* 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/run/ready-driver.ts
+/**
+* @file The driver a run takes for the session nodes that name none (core's
+*   `driver.ts` has the whole rule): the one `ork doctor`'s own checks find
+*   ready on this machine, said in one line. With none ready, the run stops
+*   before any session starts, with the hints `ork doctor` gives. A resumed run
+*   keeps the driver it recorded.
+*/
+/** The real checks: the tools on this machine and its environment. */
+const checksHere = () => driverChecks(exec, process.env);
+const subject = (names, all) => {
+	if (all) return "No driver is named, so the run uses";
+	const [only] = names;
+	return names.length === 1 && only !== void 0 ? `${only} names no driver, so it uses` : `${names.join(", ")} name no driver, so they use`;
+};
+/**
+* The driver for `names`, the session nodes that name none, from `checks`.
+* `all` says whether they are every session node of the run.
+*/
+const chooseReadyDriver = (names, all, checks) => {
+	const ready = readyDriver(checks);
+	if (!ready.ok) return {
+		ok: false,
+		lines: [
+			`No Claude driver is ready here, and ${names.join(", ")} ${names.length === 1 ? "names" : "name"} none.`,
+			...ready.hints,
+			"See `ork doctor`."
+		]
+	};
+	const why = ready.ready === 1 ? `the one ready here (${ready.detail})` : `more than one is ready, and a run takes ${ready.driver} first`;
+	return {
+		ok: true,
+		driver: ready.driver,
+		line: `${subject(names, all)} the ${ready.driver} driver: ${why}.`
+	};
+};
+/**
+* What a run takes for its session nodes that name no driver: nothing when
+* `--driver` overrides them all or each names one; the driver a resumed run
+* recorded; otherwise the one ready here.
+*/
+const runReadyDriver = async (workflow, options) => {
+	if (options.override !== void 0) return { ok: true };
+	const names = namingNoDriver(workflow);
+	if (names.length === 0) return { ok: true };
+	if (options.recorded !== void 0) return {
+		ok: true,
+		driver: options.recorded
+	};
+	const sessions = Object.values(workflow.nodes).filter((node) => node.type === "claude.leader" || node.type === "claude.worker").length;
+	return chooseReadyDriver(names, names.length === sessions, await (options.checks ?? checksHere)());
+};
+// 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; `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;
+};
+/**
+* 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 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;
+	let driver = options.driver ?? session.driver ?? plan.driver;
+	if (driver === void 0) {
+		const ready = readyDriver(await (options.driverChecks ?? checksHere)());
+		if (!ready.ok) return ["No Claude driver is ready here.", ...ready.hints].join(" ");
+		driver = ready.driver;
+	}
+	const record = appendRecorder(store, run.id, runDir);
+	record({
+		type: "user.message",
+		node,
+		body: options.body,
+		delivered: "resumed"
+	});
+	const started = (await options.runtime(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 failure;
+};
+// src/runs/logs.ts
+/**
+* @file `ork logs`: replays a stored run's events as the transcript `ork run`
+*   printed, for the whole run or one node, and tails a live run until it
+*   ends.
+*/
+/** Turns stored events into lines, keeping the state a transcript needs. */
+const createLogPrinter = (options) => {
+	const tools = /* @__PURE__ */ new Map();
+	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
+*   node's session, streams it to the terminal, and records it as a run of one
+*   node.
+*/
+const succeeded = (outcome) => outcome?.report !== null && outcome?.report !== void 0 && outcome.report.status !== "fail";
 /**
 * Runs one Claude node of a workflow on its own: checks the workflow and the
 * inputs, plans the session, and streams it to the terminal.
@@ -787,6 +1161,15 @@ const runNode = async (options) => {
 		pluginDir: path.join(runDir, "plugins", options.nodeId)
 	});
 	if (!plan.ok) return failed([plan.error]);
+	const named = sessionDriver({
+		override: options.driver,
+		named: plan.driver
+	});
+	const ready = named === void 0 ? chooseReadyDriver([options.nodeId], true, await (options.driverChecks ?? checksHere)()) : null;
+	if (ready?.ok === false) return failed(ready.lines);
+	if (ready?.line !== void 0) options.err(ready.line);
+	const driver = named ?? ready?.driver;
+	if (driver === void 0) return failed(["No Claude driver is ready here."]);
 	const planned = workflow.nodes[options.nodeId];
 	if (planned !== void 0 && "notify" in planned && planned.notify) options.err(`${style(["yellow", "bold"], "warning")} ${options.nodeId}'s notify: does nothing here: a run of one node has no message bus.`);
 	const skipped = planned === void 0 ? [] : [...beforeOf(planned, workflow.defaults) === void 0 ? [] : ["before"], ..."verify" in planned && planned.verify !== void 0 ? ["verify"] : []];
@@ -848,7 +1231,7 @@ const runNode = async (options) => {
 		nodeType,
 		round: 1
 	});
-	const session = (await options.runtime(options.driver ?? plan.driver)).start(plan.spec, {
+	const session = (await options.runtime(driver)).start(plan.spec, {
 		human: control.human,
 		...graph === null ? {} : { feedback: createFeedback({
 			graph,
@@ -895,7 +1278,9 @@ const runNode = async (options) => {
 				...result.error === void 0 ? {} : { error: result.error }
 			}],
 			reasons: result.error === void 0 ? [] : [`${id}: ${result.error}`],
-			worktrees: []
+			worktrees: [],
+			skipped: 0,
+			failuresHandled: 0
 		}
 	});
 	await control.close();
@@ -1091,6 +1476,16 @@ const preflight = async (options, given) => {
 		ok: false,
 		lines: refused
 	};
+	const driver = await runReadyDriver(given.effective, {
+		override: options.driver,
+		recorded: options.resume?.settings.readyDriver,
+		checks: options.driverChecks
+	});
+	if (!driver.ok) return {
+		ok: false,
+		lines: driver.lines
+	};
+	if (driver.line !== void 0) options.err(driver.line);
 	const checkout = await prepareCheckout(workflow, {
 		...options,
 		cwd: place.root
@@ -1101,7 +1496,8 @@ const preflight = async (options, given) => {
 	};
 	return {
 		...checkout,
-		limits: limits.now
+		limits: limits.now,
+		...driver.driver === void 0 ? {} : { readyDriver: driver.driver }
 	};
 };
 // src/run/workflow.ts
@@ -1141,6 +1537,7 @@ const runWorkflowFile = async (options) => {
 	const projects = options.store.projects();
 	const ready = await preflight(options, {
 		workflow,
+		effective: graph.workflow,
 		place,
 		projects,
 		inputs: inputs.inputs
@@ -1201,6 +1598,7 @@ const runWorkflowFile = async (options) => {
 		maskedNames
 	};
 	if (options.driver !== void 0) executorOptions.driver = options.driver;
+	if (ready.readyDriver !== void 0) executorOptions.readyDriver = ready.readyDriver;
 	if (options.tools !== void 0) executorOptions.tools = options.tools;
 	const script = process.argv[1];
 	if (script !== void 0 && onPath(script)) executorOptions.orkBin = script;
@@ -1231,6 +1629,7 @@ const runWorkflowFile = async (options) => {
 		settings: {
 			inPlace: options.inPlace,
 			...options.driver === void 0 ? {} : { driver: options.driver },
+			...ready.readyDriver === void 0 ? {} : { readyDriver: ready.readyDriver },
 			...ports.settings
 		},
 		...ports.relay === void 0 ? {} : { relay: ports.relay },
@@ -1273,7 +1672,7 @@ 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-CZOVF2yU.mjs")).createRuntime(driver, sessionEnv(process.env));
+const loadRuntime = async (driver) => (await import("./src-Dyz_Gy1q.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.
@@ -1304,7 +1703,7 @@ const run = defineCommand({
 	args: {
 		workflow: {
 			type: "positional",
-			description: "A workflow file, or the name of one in the project's workflows (.ork/workflows/)",
+			description: "A workflow file, the name of one in the project's workflows (.ork/workflows/), or one of Ork's own (ork:feedback-apply)",
 			required: true
 		},
 		node: {
@@ -1375,6 +1774,7 @@ const run = defineCommand({
 			return;
 		}
 		const cwd = process.cwd();
+		if (refusedBuiltin([args.workflow], cwd)) return;
 		const target = workflowArg(args.workflow, cwd);
 		const store = openStore();
 		if (args.detach) {
@@ -1591,20 +1991,52 @@ const chat = defineCommand({
 		}
 	}
 });
-// src/commands/control.ts
+// src/commands/decide.ts
 /**
-* @file `ork decide`, `ork stop` and `ork resume`: answer a live run's open
-*   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).
+* @file `ork decide`: answer a live run's open decisions from any terminal (it
+*   writes to the store, then wakes the run on its socket; specs/messaging.md).
+*   `--say` gives the answer a note, which goes to the run with it. With `--id`
+*   and `--choose`, `--note` and `--rating` instead note how the decision's
+*   node went, as the run's feedback (specs/feedback.md).
 */
-const failed = (message) => {
+const failed$2 = (message) => {
 	writeErr(message);
 	process.exitCode = 1;
 };
+/**
+* Notes the answered decision's node, when there's a note or a rating; a rating
+* alone is its note's words.
+*/
+const noteDecision = (store, id, note, rating) => {
+	if (note === void 0 && rating === void 0) return void 0;
+	const decision = store.decision(id);
+	const [run] = decision === void 0 ? [] : store.lookup(decision.runId);
+	if (decision === void 0 || run === void 0) return {
+		ok: false,
+		error: `No decision ${id} to note.`
+	};
+	return recordNote(store, run, {
+		text: note ?? `Rated ${rating ?? ""} at ${decision.question}`,
+		node: decision.node,
+		rating
+	}, "--");
+};
+/** Why a note given with an answer can't be recorded, before answering. */
+const noteProblem = (note, rating) => {
+	if (note === void 0 && rating === void 0) return void 0;
+	const checked = checkNote({
+		text: note ?? "rated",
+		rating
+	}, "--");
+	return checked.ok ? void 0 : checked.error;
+};
+/** What the answer said, as stored (masked), after the answer's line. */
+const saidLine = (store, id) => {
+	const note = store.decision(id)?.note;
+	return note === void 0 ? "" : style("dim", ` · said: ${note}`);
+};
 /** One line per open decision, for `--list`. */
-const formatDecisions = (decisions) => decisions.length === 0 ? ["No open decisions."] : decisions.map((d) => `${style("bold", d.id)}  ${style("cyan", d.node)}  ${d.question} ${style("dim", `[${d.options.map((o) => o.id === d.recommended ? `${o.id}*` : o.id).join(", ")}]`)}`);
+const formatDecisions = (decisions) => decisions.length === 0 ? ["No open decisions."] : decisions.map((d) => `${style("bold", d.id)}  ${style("cyan", d.node)}${d.owner === void 0 ? "" : style("dim", ` via ${d.owner}`)}  ${d.question} ${style("dim", `[${d.options.map((o) => o.id === d.recommended ? `${o.id}*` : o.id).join(", ")}]`)}`);
 const decide = defineCommand({
 	meta: {
 		name: "decide",
@@ -1638,12 +2070,24 @@ const decide = defineCommand({
 		choose: {
 			type: "string",
 			description: "…with this option"
+		},
+		say: {
+			type: "string",
+			description: "…and say this with it: the answer's note, which goes to the run"
+		},
+		note: {
+			type: "string",
+			description: "…and note how its node went; the note joins the run's feedback"
+		},
+		rating: {
+			type: "string",
+			description: "…rating it good or bad"
 		}
 	},
 	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);
+			failed$2(refusal);
 			return;
 		}
 		const store = openStore();
@@ -1655,19 +2099,39 @@ const decide = defineCommand({
 		try {
 			if (args.id !== void 0 || args.choose !== void 0) {
 				if (args.id === void 0 || args.choose === void 0) {
-					failed("--id and --choose go together.");
+					failed$2("--id and --choose go together.");
+					return;
+				}
+				const problem = noteProblem(args.note, args.rating);
+				if (problem !== void 0) {
+					failed$2(problem);
 					return;
 				}
-				const answered = await answerDecision(store, args.id, args.choose);
-				if (answered.ok) write(`${style("green", "✓")} ${args.id}: ${args.choose}`);
-				else failed(answered.error);
+				const answered = await answerDecision(store, args.id, args.choose, void 0, "decide", args.say);
+				if (!answered.ok) {
+					failed$2(answered.error);
+					return;
+				}
+				write(`${style("green", "✓")} ${args.id}: ${args.choose}${saidLine(store, args.id)}`);
+				const noted = noteDecision(store, args.id, args.note, args.rating);
+				if (noted === void 0) return;
+				if (noted.ok) write(`${style("green", "✓")} noted in item ${noted.item}`);
+				else failed$2(noted.error);
+				return;
+			}
+			if (args.note !== void 0 || args.rating !== void 0) {
+				failed$2("--note and --rating go with --id and --choose.");
+				return;
+			}
+			if (args.say !== void 0) {
+				failed$2("--say goes with --id and --choose; answering here asks for a note after each choice.");
 				return;
 			}
 			const filter = {};
 			if (args.run !== void 0 && args.run !== "") {
 				const found = findRun(store, args.run, process.cwd());
 				if (!found.ok) {
-					failed(found.error);
+					failed$2(found.error);
 					return;
 				}
 				filter.runId = found.run.id;
@@ -1690,9 +2154,13 @@ const decide = defineCommand({
 				};
 				if (d.recommended !== void 0) question.recommended = d.recommended;
 				if (d.context !== void 0) question.context = d.context;
+				let note;
+				question.onNote = (given) => {
+					note = given;
+				};
 				const choice = await human.ask(question);
-				const answered = await answerDecision(store, d.id, choice);
-				write(answered.ok ? `${style("green", "✓")} ${d.id}: ${choice}\n` : `${style("yellow", "!")} ${answered.error}\n`);
+				const answered = await answerDecision(store, d.id, choice, void 0, "decide", note);
+				write(answered.ok ? `${style("green", "✓")} ${d.id}: ${choice}${saidLine(store, d.id)}\n` : `${style("yellow", "!")} ${answered.error}\n`);
 			}
 		} finally {
 			human?.close();
@@ -1700,6 +2168,17 @@ const decide = defineCommand({
 		}
 	}
 });
+// src/commands/control.ts
+/**
+* @file `ork stop` and `ork resume`: stop a live run, or one of its nodes
+*   (ADR-041), from any terminal (it writes to the store, then wakes the run on
+*   its socket; specs/messaging.md), and continue a stopped or crashed run with
+*   its recorded state (ADR-026). `ork decide` is in `decide.ts`.
+*/
+const failed$1 = (message) => {
+	writeErr(message);
+	process.exitCode = 1;
+};
 const stop = defineCommand({
 	meta: {
 		name: "stop",
@@ -1721,13 +2200,13 @@ const stop = defineCommand({
 		try {
 			const found = findRun(store, args.run, process.cwd());
 			if (!found.ok) {
-				failed(found.error);
+				failed$1(found.error);
 				return;
 			}
 			const { run } = found;
 			const asked = await requestStop(store, run, void 0, args.node);
 			if (!asked.ok) {
-				failed(asked.error);
+				failed$1(asked.error);
 				return;
 			}
 			if (args.node !== void 0) {
@@ -1752,7 +2231,7 @@ const stop = defineCommand({
 const resume = defineCommand({
 	meta: {
 		name: "resume",
-		description: "Continue a stopped or crashed run: finished nodes keep their results"
+		description: "Continue a run that didn't succeed (stopped, failed or crashed): finished nodes keep their results"
 	},
 	args: {
 		run: {
@@ -1790,7 +2269,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$1(`--driver must be sdk or cli, got \`${args.driver}\``);
 			return;
 		}
 		const store = openStore();
@@ -1802,300 +2281,45 @@ const resume = defineCommand({
 				...args.driver === void 0 ? {} : { driver: args.driver }
 			}) : found;
 			if (!found.ok || !ready.ok) {
-				failed(ready.ok ? "" : ready.error);
+				failed$1(ready.ok ? "" : ready.error);
 				return;
 			}
 			if (args.detach) {
 				const flags = rawArgs.filter((a) => a !== "--detach" && a !== args.run);
 				const detached = await detachResume(store, found.run, flags);
 				if (detached.ok) write(`▸ run ${found.run.id} resumed in the background`);
-				else failed(`${detached.error}\n(output: ${detached.log})`);
+				else failed$1(`${detached.error}\n(output: ${detached.log})`);
 				return;
-			}
-			const { exitCode } = await runWorkflowFile({
-				file: found.run.file,
-				cwd: found.run.project,
-				inputs: flagValues(rawArgs, "--input"),
-				inPlace: ready.inPlace,
-				allowDirty: args["allow-dirty"],
-				json: args.json,
-				runtime: loadRuntime,
-				store,
-				...human === void 0 ? {} : { human },
-				runId: found.run.id,
-				resume: ready.state,
-				out: write,
-				err: writeErr,
-				...ready.driver === void 0 ? {} : { driver: ready.driver },
-				onRun: (handle) => {
-					process.once("SIGINT", () => {
-						writeErr(style("dim", "\ninterrupting…"));
-						handle.interrupt();
-					});
-				}
-			});
-			process.exitCode = exitCode;
-		} finally {
-			human?.close();
-			store.close();
-		}
-	}
-});
-// src/update/notify.ts
-/**
-* @file The new-version notice (ADR-038). At most once a day a command starts a
-*   detached copy of `ork` that asks the npm registry for the latest version
-*   and records it in `~/.ork/update-check.json`, so no command waits on the
-*   network; a later command, when a newer version is known, ends with one line
-*   on stderr (once a day). Off in CI, without a terminal, with `--json`, and
-*   with `ORK_NO_UPDATE_CHECK=1` or `NO_UPDATE_NOTIFIER=1`.
-*/
-/** Set in the background copy of `ork` that only runs the check. */
-const UPDATE_CHILD_ENV = "ORK_UPDATE_CHECK_CHILD";
-/** A registry to ask instead of npm's, e.g. a company mirror. */
-const UPDATE_REGISTRY_ENV = "ORK_UPDATE_REGISTRY";
-const on = (value) => value !== void 0 && value !== "" && value !== "0" && value.toLowerCase() !== "false";
-/** Why the automatic check is off for this command, or `null` when it is on. */
-const updateCheckOff = (env, argv, terminal) => {
-	if (on(env["ORK_NO_UPDATE_CHECK"]) || on(env["NO_UPDATE_NOTIFIER"])) return "turned off";
-	if (on(env["CI"])) return "in CI";
-	if (on(env["ORK_DETACHED"]) || !terminal) return "no terminal";
-	if (argv.includes("--json")) return "JSON output";
-	if (argv[0] === "upgrade") return "ork upgrade checks for itself";
-	return null;
-};
-const registryOf = (env) => {
-	const registry = env[UPDATE_REGISTRY_ENV];
-	return registry === void 0 || registry === "" ? void 0 : registry;
-};
-/** The notice's text. */
-const updateNotice = (latest, current) => `Ork ${latest} is out (you have ${current}). Upgrade with: ork upgrade`;
-/**
-* Starts the background check when one is due. Records the attempt first, so
-* commands started in the next moments do not start one too.
-*/
-const startUpdateCheck = (file = updateCachePath(), now = /* @__PURE__ */ new Date()) => {
-	try {
-		const cache = readUpdateCache(file);
-		if (!checkDue(cache, now)) return;
-		writeUpdateCache(file, {
-			...cache,
-			checkedAt: now.toISOString()
-		});
-		const child = spawn(process.execPath, [...process.execArgv, process.argv[1] ?? ""], {
-			detached: true,
-			stdio: "ignore",
-			env: {
-				...process.env,
-				[UPDATE_CHILD_ENV]: "1"
-			}
-		});
-		child.on("error", () => {});
-		child.unref();
-	} catch {}
-};
-/** The background copy's whole job: ask the registry, record the answer. */
-const runUpdateChild = async () => {
-	const registry = registryOf(process.env);
-	await refreshUpdateCache(updateCachePath(), ORK_NAME, /* @__PURE__ */ new Date(), registry === void 0 ? {} : { registry });
-};
-/** Prints the notice when a newer version is known and not told today. */
-const showUpdateNotice = (file = updateCachePath(), now = /* @__PURE__ */ new Date()) => {
-	try {
-		const cache = readUpdateCache(file);
-		const latest = pendingNotice(cache, ORK_VERSION, now);
-		if (cache === null || latest === null) return;
-		const text = updateNotice(latest, ORK_VERSION);
-		process.stderr.write(`\n${styleText("yellow", text, { stream: process.stderr })}\n`);
-		writeUpdateCache(file, {
-			...cache,
-			notified: {
-				version: latest,
-				at: now.toISOString()
-			}
-		});
-	} catch {}
-};
-// src/update/upgrade.ts
-/**
-* @file What `ork upgrade` does (ADR-038): compares the registry's latest
-*   version with this one, works out how Ork was installed, and gives the
-*   command to run (a global npm, pnpm, yarn, bun or Volta install) or advice
-*   (a clone, `npx`); runs the command when the user agrees. Also the version
-*   line of `ork doctor`, read from the cache without asking the network.
-*/
-const REPOSITORY = "https://github.com/mimshins/ork";
-/** The GitHub release page of a version, with its changes. */
-const releaseNotes = (name, version) => `${REPOSITORY}/releases/tag/${encodeURIComponent(`${name}@${version}`)}`;
-/** The running script's real path, which tells how Ork was installed. */
-const runningScript = () => {
-	const script = process.argv[1] ?? "";
-	try {
-		return realpathSync(script);
-	} catch {
-		return script;
-	}
-};
-const planUpgrade = (options) => {
-	const { latest, name } = options;
-	if (latest === null) return { kind: "unreachable" };
-	if (!isNewer(latest, options.current)) return { kind: "latest" };
-	const spec = `${name}@${latest}`;
-	const installer = detectInstaller(options.script, options.installers);
-	if (installer?.command !== void 0) return {
-		kind: "command",
-		latest,
-		installer,
-		argv: installer.command(spec)
-	};
-	return {
-		kind: "advice",
-		latest,
-		text: installer?.advice?.(spec, options.script.replaceAll("\\", "/")) ?? `Ork could not tell how it was installed. With npm: npm install --global ${spec}`
-	};
-};
-/** Runs the installer's command on this terminal; resolves its exit code. */
-const runInstall = (argv) => new Promise((resolve) => {
-	const [program = "", ...args] = argv;
-	const child = spawn(program, args, { stdio: "inherit" });
-	child.on("error", (error) => {
-		process.stderr.write(`Could not run ${program}: ${error.message}\n`);
-		resolve(127);
-	});
-	child.on("close", (code) => {
-		resolve(code ?? 1);
-	});
-});
-/** `ork doctor`'s line for Ork itself, from the last check. */
-const versionCheck = (current, cache, checksOff) => {
-	const newer = newerVersion(cache, current);
-	if (newer !== null) return {
-		name: "ork",
-		status: "warn",
-		detail: `${current}; ${newer} is out`,
-		hint: "Run ork upgrade."
-	};
-	return {
-		name: "ork",
-		status: "ok",
-		detail: `${current} (${cache?.latest === void 0 ? checksOff ? "update check off" : "not checked for updates yet" : `the latest as of ${cache.checkedAt.slice(0, 10)}`})`
-	};
-};
-// src/doctor/checks.ts
-/**
-* @file The checks behind `ork doctor`: Ork's own version against the last
-*   update check, and each tool's presence and login status, through an
-*   injectable `exec` so tests need no real tools. Never prints a token or an
-*   account.
-*/
-const TIMEOUT_MS = 15e3;
-const exec = (program, args) => new Promise((resolve) => {
-	execFile(program, args, {
-		timeout: TIMEOUT_MS,
-		encoding: "utf8"
-	}, (error, stdout) => {
-		resolve({
-			ok: error === null,
-			stdout
-		});
-	});
-});
-/** Ork's own version, against the last update check (no network). */
-const orkCheck = () => versionCheck(ORK_VERSION, readUpdateCache(updateCachePath()), updateCheckOff(process.env, [], true) !== null);
-const MIN_NODE = [24, 20];
-const checkNode = (version) => {
-	const [major = 0, minor = 0] = version.split(".").map(Number);
-	const [minMajor, minMinor] = MIN_NODE;
-	return major > minMajor || major === minMajor && minor >= minMinor ? {
-		name: "node",
-		status: "ok",
-		detail: `v${version}`
-	} : {
-		name: "node",
-		status: "fail",
-		detail: `v${version}`,
-		hint: `Ork needs Node ${MIN_NODE.join(".")} or later.`
-	};
-};
-const checkGit = async (run) => {
-	const version = await run("git", ["--version"]);
-	if (!version.ok) return [{
-		name: "git",
-		status: "fail",
-		detail: "not found",
-		hint: "Install git; Ork gives each writing node its own worktree."
-	}];
-	const inside = await run("git", ["rev-parse", "--is-inside-work-tree"]);
-	return [{
-		name: "git",
-		status: "ok",
-		detail: firstLine(version.stdout)
-	}, inside.ok ? {
-		name: "git repo",
-		status: "ok",
-		detail: "inside a work tree"
-	} : {
-		name: "git repo",
-		status: "warn",
-		detail: "not a git repository",
-		hint: "Run Ork inside a git repository so nodes can use worktrees."
-	}];
-};
-/**
-* Runs every check: Node and git, then every registered Claude driver and
-* integration (ADR-022). Node, git, and at least one driver are required;
-* integrations are optional.
-*/
-const runChecks = async (run, env, nodeVersion) => {
-	const [git, drivers, tools] = await Promise.all([
-		checkGit(run),
-		Promise.all(CLAUDE_DRIVERS.map((d) => d.doctor(run, env))),
-		Promise.all(INTEGRATIONS.flatMap((i) => i.doctor === void 0 ? [] : [i.doctor(run, env)]))
-	]);
-	const results = [
-		checkNode(nodeVersion),
-		...git,
-		...drivers,
-		...tools
-	];
-	return {
-		results,
-		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();
+			}
+			const { exitCode } = await runWorkflowFile({
+				file: found.run.file,
+				cwd: found.run.project,
+				inputs: flagValues(rawArgs, "--input"),
+				inPlace: ready.inPlace,
+				allowDirty: args["allow-dirty"],
+				json: args.json,
+				runtime: loadRuntime,
+				store,
+				...human === void 0 ? {} : { human },
+				runId: found.run.id,
+				resume: ready.state,
+				out: write,
+				err: writeErr,
+				...ready.driver === void 0 ? {} : { driver: ready.driver },
+				onRun: (handle) => {
+					process.once("SIGINT", () => {
+						writeErr(style("dim", "\ninterrupting…"));
+						handle.interrupt();
+					});
+				}
+			});
+			process.exitCode = exitCode;
+		} finally {
+			human?.close();
+			store.close();
+		}
 	}
-};
+});
 // src/project/ork-skills.ts
 /**
 * @file The Claude Code plugin's skills (`plugins/ork/skills/`) as text, by
@@ -2106,6 +2330,7 @@ const triggerChecks = (home) => {
 const ORK_SKILLS = {
 	principles: "---\nname: principles\ndescription: Use when deciding how to split work into an Ork workflow - which steps are programs, which are Claude sessions, where a person decides - so it costs less than doing it by hand and can't go wrong quietly.\n---\n\n# How Ork splits work\n\nOrk exists to do long jobs for less than doing them by hand, and safely. Four\nrules decide the shape of a workflow.\n\n## 1. A program for what a program can do\n\nA model turn is for judgment. Anything a program can decide, it should: run the\ntests, read a pull request's state, count what changed, wait for CI.\n\n- **A tool node** (`tool.shell`, `tool.git`, `tool.gh`, `tool.aws`) or an\n  **`mcp.call`** does it with no session. With `output: { format: json }`, its\n  answer routes the run: `when: \"json.state == 'OPEN'\"`.\n- **`verify:`** on a session runs a check before its report counts, so a session\n  can't claim success past failing tests. **`before:`** hands it what a program\n  found, so it doesn't spend turns finding it.\n- **`watch:`** waits on CI or a review with a program that looks every few\n  seconds; hours of waiting cost nothing.\n- **`notify:`** lets a program tell a running session what it found, with no\n  model turn to carry the news.\n\n## 2. Spend where it pays\n\n- A small model and low effort for a narrow task (`model: haiku`,\n  `effort: low`); the large ones where thinking pays.\n- `budgetUsd` on each session and on the run (`limits.budgetUsd`). A loop of\n  sessions without a budget or `limits.timeout` gets a warning, for good reason.\n- Give a session what it needs in its `prompt` and `before:`, rather than\n  letting it search; and `isolation: readonly` for a reviewer that only reads.\n\n## 3. Make a mistake impossible before checking for it\n\n- Declare what a node says: `output.schema` lists on tool JSON and Claude\n  reports (`verdict: [approve, escalate]`). Conditions then compare against a\n  closed list, and a run fails a value off it rather than matching nothing.\n- A verdict is a declared field, never words to search a summary for.\n- Give each condition its opposite, and each failure a handler (`when: \"!ok\"`).\n- Check every draft with Ork's `check` tool until it's clean.\n\n## 4. A person decides what can't be undone\n\nMerging, deploying, publishing, spending a lot: put a `human.gate` before it,\nwith the safe option `recommended`. For a run nobody watches, give it a\n`timeout` and the safe `default`. You never answer a gate yourself.\n\n## An example\n\nA review that a program checks first, and a person signs off:\n\n```yaml\nschemaVersion: 1\nname: careful-review\ndescription: Lint with a program, review with a small model, and ask before merging.\ninputs:\n  pr:\n    type: string\n    required: true\nlimits:\n  budgetUsd: 3\nnodes:\n  lint:\n    type: tool.shell\n    command: pnpm lint\n    allow: [pnpm lint]\n  review:\n    type: claude.worker\n    prompt: \"Review pull request {{inputs.pr}}. The linter passed.\"\n    model: haiku\n    effort: low\n    isolation: readonly\n    budgetUsd: 1\n    output:\n      schema:\n        verdict: [approve, escalate]\n  ask:\n    type: human.gate\n    question: \"Merge pull request {{inputs.pr}}? The review says {{nodes.review.output.verdict}}.\"\n    options: [merge, wait]\n    recommended: wait\n  merge:\n    type: tool.gh\n    command: pr merge {{inputs.pr}} --squash\n    allow: [pr merge]\nedges:\n  - lint -> review\n  - review -> ask\n  - from: ask\n    to: merge\n    when: \"choice == 'merge'\"\n```\n\n`lint` costs nothing, `review` is a small model with a cap, and nothing merges\nwithout a person.\n",
 	run: "---\nname: run\ndescription: Use when starting, following or explaining an Ork run - what it's doing, why it failed, what it cost, and what waits on the person - and when the person asks about their Ork runs.\n---\n\n# Running and following Ork workflows\n\nOrk runs workflows on the person's machine with their accounts, so a run spends\ntheir money and can push, merge or deploy. Start one only when they ask, and\nnever answer a decision for them.\n\n## Starting\n\n1. Find it: Ork's `workflows` tool gives each workflow's name and inputs.\n2. Check it first with `check` (`workflow: <name>`). Don't start one with an\n   error.\n3. Start it with `start_run`, giving every required input. Claude Code asks the\n   person first, unless they've allowed it. It answers with the run's id; the run goes on in the\n   background, whatever happens to this conversation.\n\nWithout Ork's tools: `ork run <workflow> --detach --input name=value`.\n\n## Following\n\n- `run` gives a run's status, what it waits on, its cost so far, and each\n  node's state. `runs` lists the newest runs.\n- `run_events` gives its newest events; `node` narrows them, and `last` or\n  `after` widens them. A `node.finished` event with `ok: false` says why a node\n  failed.\n- `explain_context` says what a node's session was given: its agent,\n  instructions, skills and files. Use it when a node didn't know something.\n- `usage` says what runs spent, by workflow and model, and how close the limits\n  are.\n\nSay what you found plainly: which node, what it said, and what it cost. Quote a\nnode's own words rather than retelling them.\n\n## What only the person does\n\n- **Decisions.** `decisions` lists the questions waiting on them: a gate, a loop\n  that ran out of rounds, a permission. Tell them what each asks, the options,\n  and the recommended one, and that they answer in `ork ui` or with\n  `ork decide` in their own terminal. Don't answer one: never run\n  `ork decide --id … --choose …`; with Ork's plugin, a hook stops it.\n- **Stopping, pausing, resuming.** Tell them the command: `ork stop <run>`,\n  `ork pause <run>`, `ork continue <run>`, `ork resume <run>`. A node can be\n  stopped alone with `--node <id>`.\n\n## Without Ork's tools\n\n| Want                   | Command                        |\n| ---------------------- | ------------------------------ |\n| Runs, newest first     | `ork ps`                       |\n| A run's transcript     | `ork logs <run>` (`--follow`)  |\n| Its nodes and cost     | `ork tree <run>`               |\n| What runs spent        | `ork usage`                    |\n| What waits on a person | `ork decide --list`            |\n| A node's context       | `ork context explain <wf> <n>` |\n",
+	setup: "---\nname: setup\ndescription: Use when the person asks you to set up Ork, install it, or get started with it in a repository - checking it's installed, setting up the project, making Ork's tools available to you, and a first workflow.\n---\n\n# Setting up Ork\n\nOrk runs workflows on the person's machine with their own accounts. Setting it\nup changes their machine and their repository, so say what each step does and\nask before it. Work through these in order, and stop where they say no.\n\n## 1. Check\n\n```sh\nork --version\nork doctor\n```\n\n- **No `ork`:** it needs Node 24.20 or later (`node --version`). The install is\n  `npm install --global @krapht/ork`; show it and run it only when they say\n  yes. The guide:\n  https://github.com/mimshins/ork/blob/main/docs/getting-started/installation.md\n- **Read `ork doctor` to them.** It needs git, a git repository with a commit,\n  and one Claude driver. Don't run `git init` or a commit without asking.\n- **A driver not ready:** they log in themselves, with `claude` (the CLI\n  driver), or by setting `ANTHROPIC_API_KEY` or a cloud provider in their own\n  shell (the SDK driver). Never ask for a key, never take one pasted to you, and\n  never write one into a file or a command. `gh` and `aws` are optional, and\n  their logins are their own too (`gh auth login`, `aws sso login`).\n\n## 2. The project\n\n- **`ork init`** keeps Ork's files in the repository, in `.ork/`, committed with\n  the code. It adds `.ork/runs/` to `.gitignore`, links `.claude/` and similar\n  folders to `.ork/`, and writes a starter workflow, `hello`.\n- **`ork register`** keeps them beside it, in `~/.ork/projects/<id>/`, and\n  writes nothing into the repository. For a repository whose process isn't\n  theirs to change, or to try Ork first.\n\nExplain both and ask which. Skip the question when the repository decides it: a\n`.ork/` folder means `ork init` has run (`ork projects` lists what's\nregistered). Neither overwrites a file.\n\n## 3. Make Ork available to you\n\nIf Ork's tools (`workflows`, `check`) already answer you, skip this. Otherwise,\nby where you run, and asking before each change to a config:\n\n- **Claude Code:** Ork's plugin brings the skills and the tools. The person\n  types these themselves:\n\n  ```\n  /plugin marketplace add mimshins/ork\n  /plugin install ork@ork\n  ```\n\n  Or, in a project set up with `ork init`, the skills in the repository for\n  everyone who clones it, then the tools:\n\n  ```sh\n  ork init --skills\n  claude mcp add ork -- ork mcp\n  ```\n\n  New tools start when they restart Claude Code or reconnect `ork` in `/mcp`;\n  so does the plugin's, once `ork` is installed.\n\n- **Another MCP client:** add a server named `ork` with command `ork` and args\n  `[\"mcp\"]` to its MCP config, where its own docs say. Its tools find the\n  project by its id, from `ork projects`.\n- **A shell only:** use the CLI. `ork --help` and each command's `--help` say\n  what it takes.\n\n## 4. A first workflow\n\nOffer to write one for a task they name. Follow `/ork:write`, check each draft\n(the `check` tool, or `ork validate <file>`) until it has no error, then save\nit. Don't start it: a run spends their money. Start it only when they say so,\nin the background with its inputs (`start_run`, or\n`ork run <name> --detach --input name=value`), and follow it with `/ork:run`.\n\n## 5. Show them `ork ui`\n\nTell them to run `ork ui` in their own terminal: their runs, graphs and logs in\nthe browser, and where they answer what a run asks.\n\n## Never\n\n- Ask for, store or pass on a password, key or token.\n- Answer a run's decision: they answer in `ork ui` or with `ork decide` in\n  their own terminal.\n- Install, edit a config, or start a run without a yes.\n",
 	write: "---\nname: write\ndescription: Use when writing or changing an Ork workflow (a `.ork/workflows/*.ork.yaml` file) - its nodes, edges, conditions and loops - and checking each draft until Ork accepts it.\n---\n\n# Writing an Ork workflow\n\nAn Ork workflow is one YAML file in the project, `.ork/workflows/<name>.ork.yaml`.\nIt names the nodes (Claude sessions, programs, a person's decisions) and the\nedges that carry work between them. Ork runs it on the person's machine with\ntheir own accounts.\n\n## How to work\n\n1. **Look first.** Ork's `workflows` tool lists the project's workflows; read\n   one that's close. `agents` lists the agents a node can use. Before you split\n   the work, read `/ork:principles`: a program where a program will do, a\n   session only for judgment.\n2. **Don't guess a field.** `workflow_format` gives the format; ask it for one\n   node type (`nodeType: \"human.gate\"`) to see that type's fields.\n3. **Check every draft** with Ork's `check` tool (`text`, or `workflow` for a\n   file), and fix what it says until it has no error. Read its warnings: they\n   mean something. Without Ork's tools, run `ork validate <file>`.\n4. **Then save the file**, beginning with the schema line below, so editors can\n   check it too.\n\n## The shape of a file\n\n```yaml\n# yaml-language-server: $schema=https://raw.githubusercontent.com/mimshins/ork/main/packages/schema/workflow.schema.json\nschemaVersion: 1\nname: fix-and-ship\ndescription: Fix a failing test, check it with the test suite, and ask before opening a pull request.\ninputs:\n  issue:\n    type: string\n    required: true\n    description: What fails.\ndefaults:\n  model: sonnet\n  budgetUsd: 2\nlimits:\n  budgetUsd: 10\nnodes:\n  fix:\n    type: claude.worker\n    prompt: \"Fix this, and keep the change small: {{inputs.issue}}\"\n  tests:\n    type: tool.shell\n    command: pnpm test\n    allow: [pnpm test]\n  ask:\n    type: human.gate\n    question: \"Open a pull request for {{nodes.fix.output.branch}}?\"\n    options: [open, hold]\n    recommended: hold\n  pr:\n    type: tool.gh\n    command: pr create --fill --head {{nodes.fix.output.branch}}\n    allow: [pr create]\nedges:\n  - fix -> tests\n  - from: tests\n    to: fix\n    when: \"!ok\"\n    maxRounds: 2\n  - from: tests\n    to: ask\n    when: ok\n  - from: ask\n    to: pr\n    when: \"choice == 'open'\"\n```\n\nNode ids are lowercase: letters, digits, `-` and `_`. Secrets never go in the\nfile: a tool reads one with `env:` and `{{env.NAME}}`.\n\n## Nodes\n\n| Type                              | Does                                                                |\n| --------------------------------- | ------------------------------------------------------------------- |\n| `claude.worker`                   | A Claude session that does one task and reports                     |\n| `claude.leader`                   | A session that plans and delegates to the nodes it owns (`parent:`) |\n| `claude.subagent`                 | A subagent inside its parent's session; it takes no edges           |\n| `tool.shell`                      | Any program, run without a shell; `allow:` lists command prefixes   |\n| `tool.git`, `tool.gh`, `tool.aws` | The person's own `git`, `gh`, `aws`, with an allow list             |\n| `mcp.call`                        | One tool call on an MCP server, with no session                     |\n| `human.gate`                      | A question with options and a recommended one                       |\n| `control.join`                    | Waits for its inputs: `all` (default), `any`, or `n` of them        |\n| `control.router`, `control.split` | Pass their input on; a router takes its first matching edge         |\n| `workflow.call`                   | Starts another workflow as its own run                              |\n\n- **A Claude node reports** `status` (`pass`, `changes_requested`, `done` or\n  `fail`), `summary`, `artifacts`, `branch`, and any field its `output.schema`\n  declares, such as `verdict: [approve, escalate]`. For another verdict, declare\n  a field: `status` can't take other values.\n- **A tool node reports** `exitCode`, `stdout`, `stderr`, and with\n  `output: { format: json, schema: { state: [OPEN, CLOSED] } }` its JSON as\n  `json`. Declare the fields you read: a run then checks them, and a typo can't\n  pass.\n- **A gate reports** `choice` and `answeredBy`. A `timeout` needs a `default`.\n\n## Edges and conditions\n\n- `a -> b`, `a -> b, c`, `b, c -> j` are plain edges, taken when the source\n  succeeded. A failed node takes no plain edge: handle a failure with\n  `when: \"!ok\"`, or `status == 'fail'` on a Claude node.\n- `{ from: a, to: b, when: \"...\" }` is taken when the condition holds. A bare\n  name reads the source's output: `when: \"verdict == 'approve'\"`. Quote any\n  condition that starts with `!`, or YAML reads it as a tag.\n- Conditions have `==`, `!=`, `<`, `>`, `&&`, `||`, `!`, and `any`, `all`,\n  `count`, `len`, `contains`. A join's `statuses` suits `any(statuses, 'fail')`.\n- A node runs when any edge into it is taken; only a join waits. A node with no\n  way in taken is skipped, and so is what follows it.\n- Templates, `{{inputs.x}}`, `{{nodes.a.output.field}}`, `{{run.id}}`, go in\n  `prompt`, `instructions`, `command`, `cwd` and `question`. Each value stays\n  one argument of a command, so it can't inject one.\n\n## Loops\n\nEvery cycle needs an edge with `maxRounds`. Give the way back a condition and\nthe way out its opposite, as `!ok` and `ok` above; a plain edge beside a loop\nfires every round. When a loop runs out, Ork asks a person what to do.\n\n## What `check` refuses, and why\n\n- **A value the source can't have** (`when.value`): `status == 'failed'` (it's\n  `fail`), a gate's `choice == 'aprove'` for `approve`, a value outside a\n  declared list. The message names the values it can have.\n- **A loop no condition ends**, a plain edge beside a loop, a loop of sessions\n  with no `limits.budgetUsd` or `limits.timeout`: warnings, each worth fixing.\n- **`no way the walk tried reaches x`**: Ork tried every way through, and none\n  got to `x`. A join waiting on a branch a first-match router never takes is\n  the usual cause.\n"
 };
 // src/project/init-skills.ts
@@ -2289,6 +2514,7 @@ const doctor = defineCommand({
 			orkCheck(),
 			...results,
 			...place.mode === "attached" ? [] : projectChecks(place.root),
+			socketCheck(),
 			...triggerChecks()
 		]) for (const line of formatCheck(result)) write(line);
 		if (!ok) {
@@ -2301,7 +2527,7 @@ const doctor = defineCommand({
 const runningRuns = () => {
 	const store = openStore();
 	try {
-		return store.runs({ limit: 500 }).filter((run) => liveStatus(run) === "running").map((run) => run.id.slice(0, 8));
+		return runningRunIds(store).map((id) => id.slice(0, 8));
 	} finally {
 		store.close();
 	}
@@ -2352,7 +2578,8 @@ const upgrade = defineCommand({
 		const registry = registryOf(process.env);
 		const latest = await fetchLatest(ORK_NAME, {
 			...registry === void 0 ? {} : { registry },
-			timeoutMs: 15e3
+			timeoutMs: 15e3,
+			current: ORK_VERSION
 		});
 		const plan = planUpgrade({
 			name: ORK_NAME,
@@ -2728,13 +2955,22 @@ const formatRegistered = (project, created) => {
 /**
 * @file Scaffolding a project: `.ork/workflows/` with a starter workflow and
 *   the `.gitignore` entry for run state, never overwriting a file; then the
-*   tool folders the project already uses are linked to `.ork/`.
+*   tool folders the project already uses are linked to `.ork/`. The starter
+*   names no driver, as it is committed: a run takes the one ready on the
+*   machine running it, and `ork init` says which that is here.
 */
 /** Run state that never belongs in git. */
 const GITIGNORE_ENTRIES = [".ork/runs/"];
-const STARTER = {
+const STARTER_NAME = "hello";
+/** Where `ork init` writes the starter, relative to the project root. */
+const STARTER_FILE = path.join(WORKFLOW_DIR, `${STARTER_NAME}${WORKFLOW_SUFFIX}`);
+/**
+* The starter workflow. It names no driver: it is committed, and one person's
+* login doesn't belong in a shared file.
+*/
+const starterWorkflow = () => ({
 	schemaVersion: 1,
-	name: "hello",
+	name: STARTER_NAME,
 	description: "A leader plans the task, a worker does it, and you approve the result.",
 	inputs: { task: {
 		type: "string",
@@ -2742,7 +2978,6 @@ const STARTER = {
 		description: "What to do."
 	} },
 	defaults: {
-		driver: "sdk",
 		model: "sonnet",
 		isolation: "worktree"
 	},
@@ -2767,7 +3002,34 @@ const STARTER = {
 		}
 	},
 	edges: ["lead -> approve"]
+});
+/**
+* What `ork init` says of drivers, in one line: the project's `defaults.driver`
+* when it names one, else the driver a run would take here, the one ready
+* (`cli` when both are), or how to get one ready.
+*/
+const driverLine = (checks, projectDefault) => {
+	if (projectDefault !== void 0) return `Runs use the ${projectDefault} driver, ${PROJECT_FILE}'s default, unless a workflow names another.`;
+	const ready = readyDriver(checks);
+	if (ready.ok) {
+		const why = ready.ready === 1 ? ready.detail : `more than one is ready, and ${ready.driver} comes first`;
+		return `Runs use the driver that's ready when they start: ${ready.driver} here (${why}).`;
+	}
+	return `Runs use the driver that's ready when they start, and none is ready here yet: ${checks.find(({ id }) => id === "cli")?.result.hint ?? "see `ork doctor`."}`;
 };
+/**
+* The line for the project at `root`: `ork doctor`'s driver checks through
+* `run` and `env`, and the project's own default.
+*/
+const initDriverLine = async (run, env, root) => {
+	const projectDefault = loadProject(root).project?.defaults?.driver;
+	return driverLine(projectDefault === void 0 ? await driverChecks(run, env) : [], projectDefault);
+};
+/**
+* The line for a starter about to be written in `root`, with the real tools and
+* environment; `null` when the starter is already there.
+*/
+const initDriverLineHere = (root) => existsSync(path.join(root, STARTER_FILE)) ? Promise.resolve(null) : initDriverLine(exec, process.env, root);
 /** The run-state entries `root`'s `.gitignore` lacks. */
 const unignored = (root) => {
 	const gitignore = path.join(root, ".gitignore");
@@ -2794,11 +3056,10 @@ const initProject = (cwd, options = {}) => {
 	const created = [];
 	const skipped = [];
 	mkdirSync(path.join(cwd, WORKFLOW_DIR), { recursive: true });
-	const starter = path.join(WORKFLOW_DIR, `${STARTER.name}${WORKFLOW_SUFFIX}`);
-	if (existsSync(path.join(cwd, starter))) skipped.push(starter);
+	if (existsSync(path.join(cwd, STARTER_FILE))) skipped.push(STARTER_FILE);
 	else {
-		writeFileSync(path.join(cwd, starter), serializeWorkflow(STARTER));
-		created.push(starter);
+		writeFileSync(path.join(cwd, STARTER_FILE), serializeWorkflow(starterWorkflow()));
+		created.push(STARTER_FILE);
 	}
 	const missing = ignoreRunState(cwd);
 	if (missing.length > 0) created.push(`.gitignore (${missing.join(", ")})`);
@@ -2914,33 +3175,6 @@ const migrateHere = async (cwd, options) => {
 		store.close();
 	}
 };
-// src/project/worktrees.ts
-/** One line of state: where it is and what clean would care about. */
-const worktreeState = (item) => {
-	const parts = [];
-	if (item.path === null) parts.push("no worktree");
-	else if (item.missing) parts.push("missing (prunable)");
-	if (item.dirty) parts.push(style("yellow", "uncommitted changes"));
-	const commits = item.merged ? style("green", "merged") : `${String(item.ahead)} commit(s) not merged`;
-	if (item.checkedOut !== void 0) parts.push(`on the workflow's branch ${item.checkedOut}`, commits);
-	else if (item.branch === void 0) parts.push(item.ahead > 0 ? style("yellow", `detached, ${String(item.ahead)} commit(s) on no branch`) : "detached, nothing committed");
-	else parts.push(commits);
-	if (item.inMainCheckout) parts.push("checked out here");
-	return parts.join(" · ");
-};
-/** A worktree's name: its branch, or its run and node when created detached. */
-const labelOf = (item) => item.branch ?? `${item.runId}/${item.nodeId} (detached)`;
-const formatWorktrees = (items) => {
-	if (items.length === 0) return ["No Ork worktrees or branches."];
-	const width = Math.max(...items.map((i) => labelOf(i).length));
-	return items.flatMap((item) => [`${style("bold", labelOf(item).padEnd(width))}  ${worktreeState(item)}`, ...item.path === null ? [] : [`  ${style("dim", item.path)}`]]);
-};
-const formatPlan = (steps) => steps.map((step) => {
-	const actions = [...step.removeWorktree ? ["remove worktree"] : [], ...step.deleteBranch ? ["delete branch"] : []];
-	const what = actions.length > 0 ? actions.join(" + ") : "keep";
-	const why = step.skip === void 0 ? "" : style("dim", ` (${step.skip})`);
-	return `  ${labelOf(step.item)}: ${what}${why}`;
-});
 // src/commands/project-records.ts
 /**
 * @file `ork projects`' subcommands on one project's record (ADR-035): `forget`
@@ -3006,124 +3240,8 @@ const move = defineCommand({
 *   follows its moved clone (ADR-035); none writes into a repository. `ork
 *   migrate` moves an attached project into its repository, brings its agents
 *   and skills under `.ork/`, or drafts a workflow from its agents (ADR-036),
-*   and commits nothing. `ork worktrees` lists the worktrees and branches runs
-*   left behind (those the runs recorded creating, whatever the project's git
-*   rules named them, and any `ork/` branch), with their state read from git,
-*   and cleans them up safely after showing the plan and asking.
-*/
-const projectRoot = async () => (await inspectProject(process.cwd()))?.root ?? null;
-/** What Ork created in the repo at `root`, from its runs' records and git. */
-const itemsIn = async (root) => {
-	const store = openStore();
-	try {
-		return await listOrkWorktrees(root, createdWorktrees(store, root));
-	} finally {
-		store.close();
-	}
-};
-const notGit = () => {
-	process.stderr.write("Not in a git repository with a commit.\n");
-	process.exitCode = 1;
-};
-const show = async (json) => {
-	const root = await projectRoot();
-	if (root === null) {
-		notGit();
-		return;
-	}
-	const items = await itemsIn(root);
-	if (json) write(JSON.stringify(items, void 0, 2));
-	else for (const line of formatWorktrees(items)) write(line);
-};
-const list = defineCommand({
-	meta: {
-		name: "list",
-		description: "List Ork's worktrees and branches (the default)"
-	},
-	args: { json: {
-		type: "boolean",
-		description: "Print JSON",
-		default: false
-	} },
-	run: ({ args }) => show(args.json)
-});
-const clean = defineCommand({
-	meta: {
-		name: "clean",
-		description: "Remove Ork's worktrees (merged ones by default); never one with uncommitted changes unless --force"
-	},
-	args: {
-		run: {
-			type: "string",
-			description: "Only this run's worktrees"
-		},
-		all: {
-			type: "boolean",
-			description: "Include worktrees whose branch is not merged",
-			default: false
-		},
-		branches: {
-			type: "boolean",
-			description: "Also delete the branches",
-			default: false
-		},
-		force: {
-			type: "boolean",
-			description: "Remove uncommitted changes and unmerged branches too",
-			default: false
-		},
-		yes: {
-			type: "boolean",
-			description: "Do not ask",
-			default: false
-		}
-	},
-	run: async ({ args }) => {
-		const root = await projectRoot();
-		if (root === null) {
-			notGit();
-			return;
-		}
-		const filter = { merged: !args.all };
-		if (args.run !== void 0) filter.runId = args.run;
-		const steps = planClean(await itemsIn(root), filter, {
-			branches: args.branches,
-			force: args.force
-		});
-		const acting = steps.filter((s) => s.removeWorktree || s.deleteBranch);
-		if (steps.length === 0 || acting.length === 0) {
-			for (const line of formatPlan(steps)) write(line);
-			write("Nothing to clean.");
-			return;
-		}
-		write("Plan:");
-		for (const line of formatPlan(steps)) write(line);
-		if (!args.yes) {
-			if (!process.stdin.isTTY) {
-				process.stderr.write("Pass --yes to clean without a terminal.\n");
-				process.exitCode = 1;
-				return;
-			}
-			if (!await confirm("Go ahead? [y/N] ")) return;
-		}
-		for (const line of await applyClean(root, acting, args.force)) write(`${style("green", "✓")} ${line}`);
-	}
-});
-const worktrees = defineCommand({
-	meta: {
-		name: "worktrees",
-		description: "Track and clean up the git worktrees Ork creates for runs"
-	},
-	subCommands: {
-		list,
-		clean
-	},
-	run: async ({ rawArgs }) => {
-		const [first] = rawArgs;
-		if (first === "list" || first === "clean") return;
-		await show(rawArgs.includes("--json"));
-	}
-});
+*   and commits nothing. `ork worktrees` is worktrees.ts.
+*/
 const json$2 = {
 	type: "boolean",
 	description: "Print JSON",
@@ -3220,6 +3338,20 @@ const migrate = defineCommand({
 		}, (file) => formatReport(validateFile(file, process.cwd())));
 	}
 });
+// src/store.ts
+/**
+* @file Opening the user's store (`~/.ork/state.db`) for the length of one
+*   command, and closing it after, whatever happens.
+*/
+/** Runs `body` with the user's store open, and closes it after. */
+const withStore = async (body) => {
+	const store = openStore();
+	try {
+		await body(store);
+	} finally {
+		store.close();
+	}
+};
 // src/runs/feedback.ts
 /**
 * @file `ork feedback`'s helpers (specs/feedback.md): finding an item by a
@@ -3269,6 +3401,7 @@ const formatFeedbackItem = (item, records, now = Date.now()) => {
 	];
 	if (item.workflows.length > 0) lines.push(`Workflows: ${item.workflows.join(", ")}`);
 	if (item.models.length > 0) lines.push(`Models: ${item.models.join(", ")}`);
+	if (item.merged.length > 0) lines.push(`Merged into it: ${item.merged.map((id) => id.slice(0, 12)).join(", ")} (ork feedback split ${item.id.slice(0, 12)} takes them apart)`);
 	for (const record of records) {
 		const { feedback } = record;
 		const where = record.node === void 0 ? "" : ` · ${record.node}`;
@@ -3279,181 +3412,545 @@ const formatFeedbackItem = (item, records, now = Date.now()) => {
 	}
 	return lines;
 };
-const oneOf = (name, value, allowed) => {
-	if (value === void 0) return { ok: true };
-	const found = allowed.find((a) => a === value);
-	return found === void 0 ? {
-		ok: false,
-		error: `--${name} is one of ${allowed.join(", ")}`
-	} : {
-		ok: true,
-		value: found
-	};
-};
 /**
 * `ork feedback note`: records a person's note on a run, or one of its nodes,
 * as that run's feedback; returns the item it joins, or why it could not.
 */
 const noteRun = (store, cwd, args) => {
-	if (args.text.trim() === "") return {
+	const found = findRun(store, args.run, cwd);
+	if (!found.ok) return found;
+	return recordNote(store, found.run, args, "--");
+};
+// src/runs/apply.ts
+/**
+* @file `ork feedback apply` (ADR-059): runs Ork's own `ork:feedback-apply` in
+*   the project an item came from, with the item as its untrusted input. Its
+*   worker proposes a fix on a branch and its gate asks to keep or discard it;
+*   Ork never merges. Kept, the item is `resolved`, unless its branch holds no
+*   new commits: then there is nothing to keep, and, as when discarded, the
+*   run's worktree and branch go and the item stays `accepted`.
+*/
+/** The most of an item's records the worker reads, newest first. */
+const RECORDS = 10;
+/** The most of a record's body the worker reads. */
+const BODY_CHARS = 1500;
+const BUILTIN = "ork:feedback-apply";
+/** An item and its newest records, as the worker reads them. */
+const aboutItem = (item, records) => {
+	const newest = records.toReversed().slice(0, RECORDS);
+	const lines = [`Item ${item.id.slice(0, 12)}: ${item.title}`, `About: ${item.target} (${item.kind}), severity ${item.severity}; seen ${String(item.count)} time(s) in ${String(item.runs.length)} run(s).`];
+	if (item.workflows.length > 0) lines.push(`Workflows: ${item.workflows.join(", ")}`);
+	for (const record of newest) {
+		const { feedback } = record;
+		const where = record.node === void 0 ? "" : `, node ${record.node}`;
+		lines.push("", `Record from run ${record.runId}${where} (${feedback.source}):`);
+		if (feedback.title !== item.title) lines.push(feedback.title);
+		if (feedback.body !== "") lines.push(feedback.body.slice(0, BODY_CHARS));
+		if (feedback.evidence.length > 0) lines.push(`Evidence: ${feedback.evidence.join(", ")}`);
+	}
+	if (records.length > newest.length) lines.push("", `(${String(records.length - newest.length)} older record(s) left out.)`);
+	return lines.join("\n");
+};
+const text = (value) => typeof value === "string" ? value : "";
+/** What a run of `ork:feedback-apply` ended with. */
+const outcomeOf = (result) => {
+	const node = (id) => result?.nodes.find((n) => n.id === id);
+	const fix = node("fix");
+	const choice = text(node("keep")?.output?.["choice"]);
+	const branch = text(fix?.output?.["branch"]);
+	const summary = text(fix?.output?.["summary"]);
+	if (choice === "keep") return {
+		kind: "kept",
+		branch,
+		summary
+	};
+	if (choice === "discard") return {
+		kind: "discarded",
+		branch
+	};
+	if (fix?.ok === false && result?.status === "failed") return {
+		kind: "nothing",
+		summary: summary || (fix.error ?? "")
+	};
+	return {
+		kind: "unfinished",
+		reasons: result?.reasons ?? []
+	};
+};
+/**
+* Removes what a run left in the repository at `root`: its worktrees and
+* branches.
+*/
+const discardRun = async (store, root, runId) => {
+	const items = await listOrkWorktrees(root, createdWorktrees(store, root));
+	const steps = planClean(items, {
+		merged: false,
+		runId
+	}, {
+		branches: true,
+		force: true
+	});
+	return applyClean(root, steps.filter((s) => s.removeWorktree || s.deleteBranch), true);
+};
+/** How many commits the run's worktrees hold that the current branch hasn't. */
+const commitsAhead = async (store, root, runId) => (await listOrkWorktrees(root, createdWorktrees(store, root))).filter((item) => item.runId === runId).reduce((sum, item) => sum + item.ahead, 0);
+/** What to say, and the item's status, after the run ends as `outcome`. */
+const settle = async (options, root, runId, outcome) => {
+	const { store, item } = options;
+	const short = item.id.slice(0, 12);
+	switch (outcome.kind) {
+		case "kept":
+			if (await (options.ahead ?? commitsAhead)(store, root, runId) === 0) {
+				const done = await discardRun(store, root, runId);
+				return [`the fix's branch holds no commits, so there's nothing to keep; ${short} stays accepted`, ...done];
+			}
+			store.setFeedbackStatus(item.id, "resolved");
+			return [`kept the fix on ${outcome.branch}; ${short} is resolved`, "Review and merge it like any other change; Ork never merges it."];
+		case "discarded": {
+			const done = await discardRun(store, root, runId);
+			return [`discarded the fix; ${short} stays accepted`, ...done];
+		}
+		case "nothing": return [`no fix proposed; ${short} stays accepted`, ...outcome.summary === "" ? [] : [outcome.summary]];
+		case "unfinished": return [`run ${runId} didn't finish, so ${short} stays as it was`, ...outcome.reasons];
+		default: return outcome;
+	}
+};
+/** Proposes a fix for an item, in the project it came from. */
+const applyItem = async (options) => {
+	const { store, item } = options;
+	const short = item.id.slice(0, 12);
+	const allowed = feedbackActions(item, openFixRun(store, item)).apply;
+	if (!allowed.ok) return {
 		ok: false,
-		error: "The note is empty."
+		error: allowed.error
 	};
-	const found = findRun(store, args.run, cwd);
+	const found = placeOf(store, item, void 0, options.registered);
 	if (!found.ok) return found;
-	const { run } = found;
-	const ran = store.events(run.id).some(({ event }) => "id" in event && event.id === args.node);
-	if (args.node !== void 0 && !ran) return {
+	const { place, project } = found;
+	const problem = builtinProblem(place, BUILTIN);
+	const file = builtinWorkflowFile(place, BUILTIN);
+	if (problem !== void 0 || file === void 0) return {
 		ok: false,
-		error: `No node ${args.node} ran in run ${run.id}.`
-	};
-	const kind = oneOf("kind", args.kind, FEEDBACK_KINDS);
-	const severity = oneOf("severity", args.severity, FEEDBACK_SEVERITIES);
-	const rating = oneOf("rating", args.rating, RATINGS);
-	for (const checked of [
-		kind,
-		severity,
-		rating
-	]) if (!checked.ok) return checked;
-	const event = humanNoteEvent({
-		text: args.text,
-		workflow: run.workflow,
-		...args.node === void 0 ? {} : { node: args.node },
-		...kind.ok && kind.value !== void 0 ? { kind: kind.value } : {},
-		...severity.ok && severity.value !== void 0 ? { severity: severity.value } : {},
-		...rating.ok && rating.value !== void 0 ? { rating: rating.value } : {}
+		error: problem ?? `${BUILTIN} couldn't be written.`
+	};
+	const records = store.feedbackRecords(item.id).filter((r) => store.lookup(r.runId)[0]?.project === project);
+	options.out(`▸ proposing a fix for ${short} in ${place.root}`);
+	const { result } = await runWorkflowFile({
+		...options,
+		file,
+		cwd: place.root,
+		inputs: [`item=${short}`, `about=${aboutItem(item, records)}`],
+		untrusted: ["about"],
+		inPlace: false,
+		json: false,
+		onRun: (handle) => {
+			store.setFeedbackStatus(item.id, "accepted");
+			options.onRun?.(handle);
+		}
 	});
-	store.append(run.id, event);
+	if (result === null) return {
+		ok: false,
+		error: `${BUILTIN} didn't start.`
+	};
+	const outcome = outcomeOf(result);
 	return {
 		ok: true,
-		item: event.type === "feedback.recorded" ? event.feedback.fingerprint : ""
+		outcome,
+		lines: await settle(options, place.root, result.runId, outcome)
 	};
 };
-// src/commands/runs.ts
+// src/runs/triage.ts
 /**
-* @file `ork ps`, `ork logs`, `ork tree` and `ork feedback`: read what every
-*   project's runs recorded in `~/.ork/state.db` (specs/event-store.md,
-*   specs/feedback.md).
+* @file `ork feedback triage` (ADR-059): the merges Ork's rules propose among
+*   unsettled items, each made only when the person says yes, then every new
+*   item marked `triaged`, so a declined merge isn't asked again until a new
+*   item joins it. `ork feedback split` takes a merge apart.
 */
-/** Runs `body` with the user's store open, and closes it after. */
-const withStore = async (body) => {
-	const store = openStore();
-	try {
-		await body(store);
-	} finally {
-		store.close();
-	}
+const lineOf = (item) => `${item.id.slice(0, 12)} ${`${String(item.count)}×`.padStart(4)}  ${item.title}`;
+/** A proposed merge as the person reads it before saying yes. */
+const formatMerge = (merge) => [`Merge into ${lineOf(merge.into)}`, ...merge.from.map((item) => `      ${lineOf(item)}`)];
+/**
+* Proposes each merge, makes those `ask` says yes to, and marks every item that
+* was new `triaged`.
+*/
+const triage$1 = async (store, ask) => {
+	const items = store.feedbackItems();
+	const fresh = items.filter((item) => item.status === "new");
+	let merged = 0;
+	let declined = 0;
+	for (const merge of proposeMerges(items)) if (await ask(merge)) merged += store.mergeFeedback(merge.into.id, merge.from.map((item) => item.id));
+	else declined += 1;
+	for (const item of fresh) store.setFeedbackStatus(item.id, "triaged");
+	return {
+		merged,
+		declined,
+		triaged: fresh.length
+	};
 };
-const ps = defineCommand({
+/** What triage did, in a line. */
+const triageSummary = ({ merged, declined, triaged }) => {
+	return [
+		merged === 0 ? "nothing merged" : `merged ${String(merged)} item(s)`,
+		...declined === 0 ? [] : [`${String(declined)} merge(s) declined`],
+		`${String(triaged)} new item(s) triaged`
+	].join("; ");
+};
+// src/commands/feedback-loop.ts
+/**
+* @file The `ork feedback` subcommands that close the loop (ADR-059): `apply`
+*   runs Ork's own workflow to propose a fix for an item, `triage` merges items
+*   about the same problem by rules after asking, and `split` takes a merge
+*   apart.
+*/
+const itemArg$1 = {
+	type: "positional",
+	description: "A feedback item's id, or a prefix of one",
+	required: true
+};
+const apply = defineCommand({
 	meta: {
-		name: "ps",
-		description: "List this project's runs, newest first"
+		name: "apply",
+		description: "Have Ork propose a fix for an item on a branch, then keep or discard it"
 	},
 	args: {
-		all: {
-			type: "boolean",
-			description: "Every project's runs",
-			default: false
-		},
-		limit: {
+		item: itemArg$1,
+		driver: {
 			type: "string",
-			description: "How many (default 20)"
+			description: "sdk (API key or cloud provider) or cli (your claude login)"
 		},
-		json: {
-			type: "boolean",
-			description: "Print JSON",
-			default: false
+		"run-id": {
+			type: "string",
+			description: "Internal: the id `ork ui` picked for the run"
+		}
+	},
+	run: async ({ args }) => {
+		if (args.driver !== void 0 && !isDriver(args.driver)) {
+			writeErr(`--driver must be sdk or cli, got \`${args.driver}\``);
+			process.exitCode = 1;
+			return;
+		}
+		const driver = args.driver;
+		const store = openStore();
+		const human = terminalHuman();
+		try {
+			const found = findFeedbackItem(store, args.item);
+			if (!found.ok) {
+				writeErr(found.error);
+				process.exitCode = 1;
+				return;
+			}
+			const applied = await applyItem({
+				store,
+				item: found.item,
+				registered: registeredProjects(),
+				runtime: loadRuntime,
+				...human === void 0 ? {} : { human },
+				...driver === void 0 ? {} : { driver },
+				...args["run-id"] === void 0 ? {} : { runId: args["run-id"] },
+				out: write,
+				err: writeErr,
+				onRun: (handle) => {
+					onInterrupt(handle.interrupt);
+				}
+			});
+			if (!applied.ok) {
+				writeErr(applied.error);
+				process.exitCode = 1;
+				return;
+			}
+			const [first, ...rest] = applied.lines;
+			const mark = applied.outcome.kind === "kept" ? style("green", "✓") : style("yellow", "·");
+			write(`${mark} ${first ?? ""}`);
+			for (const line of rest) write(`  ${line}`);
+			if (applied.outcome.kind === "unfinished") process.exitCode = 1;
+		} finally {
+			human?.close();
+			store.close();
+		}
+	}
+});
+const triage = defineCommand({
+	meta: {
+		name: "triage",
+		description: "Merge new items about the same problem as others, asking about each"
+	},
+	args: { yes: {
+		type: "boolean",
+		description: "Make every merge without asking",
+		default: false
+	} },
+	run: ({ args }) => withStore(async (store) => {
+		if (!args.yes && !process.stdin.isTTY) {
+			writeErr("Pass --yes to triage without a terminal.");
+			process.exitCode = 1;
+			return;
 		}
+		const done = await triage$1(store, async (merge) => {
+			for (const line of formatMerge(merge)) write(line);
+			return args.yes || await confirm("Merge them? [y/N] ");
+		});
+		write(`${style("green", "✓")} ${triageSummary(done)}`);
+	})
+});
+const split = defineCommand({
+	meta: {
+		name: "split",
+		description: "Take apart the items triage merged into one"
 	},
+	args: { item: itemArg$1 },
 	run: ({ args }) => withStore((store) => {
-		const limit = Number(args.limit ?? 20);
-		const runs = store.runs({
-			limit: Number.isInteger(limit) && limit > 0 ? limit : 20,
-			...args.all ? {} : { project: placeFor(process.cwd(), store.projects()).root }
+		const found = findFeedbackItem(store, args.item);
+		if (!found.ok) {
+			writeErr(found.error);
+			process.exitCode = 1;
+			return;
+		}
+		const moved = store.splitFeedback(found.item.id);
+		write(moved === 0 ? `Nothing was merged into ${found.item.id.slice(0, 12)}.` : `${style("green", "✓")} split ${String(moved)} item(s) back out of ${found.item.id.slice(0, 12)}`);
+	})
+});
+// src/runs/jsonl.ts
+/**
+* @file `ork feedback export` and `import` (specs/feedback.md): feedback
+*   records as JSON lines, one record a line, so a team can move feedback
+*   between machines without GitHub. A line is checked before it's added (one
+*   from a newer Ork says so), and a record already here (its run and event) is
+*   skipped.
+*/
+const Text = z.string();
+const LineSchema = z.strictObject({
+	feedbackVersion: z.literal(1),
+	runId: z.string().min(1),
+	seq: z.number().int().nonnegative(),
+	at: z.string().min(1),
+	node: z.string().min(1).optional(),
+	feedback: z.strictObject({
+		source: z.enum([
+			"system",
+			"agent",
+			"human"
+		]),
+		kind: z.enum(FEEDBACK_KINDS),
+		target: z.enum(FEEDBACK_TARGETS),
+		severity: z.enum(FEEDBACK_SEVERITIES),
+		title: Text.min(1),
+		body: Text,
+		evidence: z.array(Text),
+		code: Text.optional(),
+		fingerprint: z.string().regex(/^[0-9a-f]{8,64}$/u),
+		origin: z.strictObject({
+			workflow: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/u).optional(),
+			workflowHash: Text.optional(),
+			nodeType: Text.optional(),
+			model: Text.optional(),
+			driver: Text.optional(),
+			version: Text.optional()
+		})
+	})
+});
+/** Records as JSON lines, with the format's version on each. */
+const exportLines = (records) => records.map(({ id: _id, ...record }) => JSON.stringify({
+	feedbackVersion: 1,
+	...record
+})).map((line) => `${line}\n`).join("");
+/** Why a line from a newer Ork is left out, or `null` when it isn't one. */
+const newerVersion = (value) => {
+	const version = value !== null && typeof value === "object" ? Reflect.get(value, "feedbackVersion") : void 0;
+	return typeof version === "number" && version > 1 ? `made by a newer Ork (\`feedbackVersion: ${String(version)}\`; this one reads ${String(1)}). Upgrade with \`ork upgrade\`.` : null;
+};
+/** The records in a JSONL file's text, and what was wrong with the rest. */
+const parseLines = (text) => {
+	const records = [];
+	const problems = [];
+	for (const [index, line] of text.split("\n").entries()) {
+		if (line.trim() === "") continue;
+		let value;
+		try {
+			value = JSON.parse(line);
+		} catch {
+			problems.push(`line ${String(index + 1)}: not JSON`);
+			continue;
+		}
+		const newer = newerVersion(value);
+		if (newer !== null) {
+			problems.push(`line ${String(index + 1)}: ${newer}`);
+			continue;
+		}
+		const parsed = LineSchema.safeParse(value);
+		if (!parsed.success) {
+			const [issue] = parsed.error.issues;
+			problems.push(`line ${String(index + 1)}: ${issue?.path.join(".") ?? ""} ${issue?.message ?? "isn't a feedback record"}`.trim());
+			continue;
+		}
+		const { feedbackVersion: _version, node, feedback, ...rest } = parsed.data;
+		const { code, origin, ...report } = feedback;
+		records.push({
+			...rest,
+			...node === void 0 ? {} : { node },
+			feedback: {
+				...report,
+				...code === void 0 ? {} : { code },
+				origin: Object.fromEntries(Object.entries(origin).filter(([, v]) => v !== void 0))
+			}
 		});
-		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, Date.now(), statusOf)) write(line);
-	})
-});
-const runArg = {
-	type: "positional",
-	description: "A run id or a prefix of one (default: this project's newest)",
-	required: false
+	}
+	return {
+		records,
+		problems
+	};
 };
-const logs = defineCommand({
+// src/runs/publish.ts
+/** What will be sent, as the person reads it before saying yes. */
+const formatPreview = (post, plan) => plan.kind === "comment" ? [
+	`A thread for this exists (${plan.url}), so this comment goes on it:`,
+	"",
+	post.comment
+] : [
+	"A new thread in the Agent feedback category of mimshins/ork:",
+	"",
+	`Title: ${post.title}`,
+	"",
+	post.body
+];
+// src/commands/feedback-share.ts
+/**
+* @file The `ork feedback` subcommands that move feedback off this machine,
+*   only when the person says so (ADR-059): `publish` shares an item about Ork
+*   with its maintainers, through the person's own `gh`, after showing exactly
+*   what will be posted; `export` and `import` move records as JSON lines.
+*/
+const failed = (message) => {
+	writeErr(message);
+	process.exitCode = 1;
+};
+const publish = defineCommand({
 	meta: {
-		name: "logs",
-		description: "Print a run's transcript"
+		name: "publish",
+		description: "Share an item about Ork with its maintainers, after showing exactly what goes"
 	},
 	args: {
-		run: runArg,
-		node: {
-			type: "string",
-			description: "Only this node's events"
-		},
-		follow: {
-			type: "boolean",
-			alias: "f",
-			description: "Keep printing a live run's events until it ends",
-			default: false
+		item: {
+			type: "positional",
+			description: "A feedback item's id, or a prefix of one",
+			required: true
 		},
-		json: {
+		"hide-names": {
 			type: "boolean",
-			description: "Print the stored events as JSON lines",
+			description: "Also hide the repositories' and workflows' names",
 			default: false
 		}
 	},
 	run: ({ args }) => withStore(async (store) => {
-		const found = findRun(store, args.run, process.cwd());
+		if (!process.stdin.isTTY) {
+			failed("publish shows what it will post and asks you first: run it in a terminal.");
+			return;
+		}
+		const found = findFeedbackItem(store, args.item);
 		if (!found.ok) {
-			writeErr(found.error);
-			process.exitCode = 1;
+			failed(found.error);
 			return;
 		}
-		const abort = new AbortController();
-		process.once("SIGINT", () => {
-			abort.abort();
-		});
-		await followRun(store, found.run, write, {
-			follow: args.follow,
-			json: args.json,
-			signal: abort.signal,
-			...args.node === void 0 ? {} : { node: args.node }
+		const preview = previewPost(store, found.item, {
+			home: homedir(),
+			registered: registeredProjects(),
+			hideNames: args["hide-names"]
 		});
+		if (!preview.ok) {
+			failed(preview.error);
+			return;
+		}
+		const planned = await planPost(preview.post);
+		if (!planned.ok) {
+			failed(planned.error);
+			return;
+		}
+		for (const line of formatPreview(preview.post, planned.plan)) write(line);
+		write("");
+		if (!await confirm("Post it with your own gh login? [y/N] ")) {
+			write("Nothing was sent.");
+			return;
+		}
+		const sent = await sendPost(preview.post, planned.plan);
+		if (!sent.ok) {
+			failed(sent.error);
+			return;
+		}
+		store.setFeedbackStatus(found.item.id, "published");
+		write(`${style("green", "✓")} ${sent.kind === "created" ? "posted" : "added a +1 to"} ${sent.url}`);
 	})
 });
-const tree = defineCommand({
+const exportFeedback = defineCommand({
 	meta: {
-		name: "tree",
-		description: "Show a run's ownership tree with status, tokens and cost"
+		name: "export",
+		description: "Write feedback records as JSON lines, to share them"
 	},
 	args: {
-		run: runArg,
-		json: {
+		all: {
 			type: "boolean",
-			description: "Print JSON",
+			description: "Dismissed items' records too",
 			default: false
+		},
+		output: {
+			type: "string",
+			alias: "o",
+			description: "A file to write (default: the terminal)"
 		}
 	},
 	run: ({ args }) => withStore((store) => {
-		const found = findRun(store, args.run, process.cwd());
-		if (!found.ok) {
-			writeErr(found.error);
-			process.exitCode = 1;
+		const records = store.exportFeedback({ all: args.all });
+		const text = exportLines(records);
+		if (args.output === void 0) {
+			process.stdout.write(text);
 			return;
 		}
-		const { run } = found;
-		const events = store.events(run.id).map((s) => s.event);
-		const roots = runTree(events);
-		if (args.json) {
-			write(JSON.stringify(roots, void 0, 2));
+		writeFileSync(args.output, text);
+		write(`${style("green", "✓")} wrote ${String(records.length)} record(s) to ${args.output}`);
+	})
+});
+const importFeedback = defineCommand({
+	meta: {
+		name: "import",
+		description: "Add feedback records from a JSON-lines file"
+	},
+	args: { file: {
+		type: "positional",
+		description: "What `ork feedback export` wrote",
+		required: true
+	} },
+	run: ({ args }) => withStore((store) => {
+		let text;
+		try {
+			text = readFileSync(args.file, "utf8");
+		} catch {
+			failed(`Can't read ${args.file}.`);
 			return;
 		}
-		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);
+		const { records, problems } = parseLines(text);
+		const added = records.filter((r) => store.importFeedback(r)).length;
+		for (const problem of problems) writeErr(problem);
+		write(`${style("green", "✓")} added ${String(added)} record(s); ${String(records.length - added)} were here already${problems.length === 0 ? "" : `; ${String(problems.length)} line(s) left out`}`);
+		if (problems.length > 0) process.exitCode = 1;
 	})
 });
+// src/commands/feedback.ts
+/**
+* @file `ork feedback`: the feedback every run recorded, grouped into items
+*   (specs/feedback.md): list and show them, note a run, dismiss and restore an
+*   item, and accept one, as a lesson its workflow reads from then on. What
+*   closes the loop further (apply, triage, split) is in `feedback-loop.ts`,
+*   and what moves feedback off the machine (publish, export, import) in
+*   `feedback-share.ts`.
+*/
+/** Runs `body` on the item `prefix` names, or says why there's none. */
+const withItem = (prefix, body) => withStore((store) => {
+	const found = findFeedbackItem(store, prefix);
+	if (!found.ok) {
+		writeErr(found.error);
+		process.exitCode = 1;
+		return;
+	}
+	body(store, found.item);
+});
 const itemArg = {
 	type: "positional",
 	description: "A feedback item's id, or a prefix of one",
@@ -3467,7 +3964,7 @@ const json$1 = {
 const feedback = defineCommand({
 	meta: {
 		name: "feedback",
-		description: "What got in the way in your runs, grouped: list, show, note, dismiss, restore"
+		description: "What got in the way in your runs, grouped: list, show, note, dismiss, restore, accept, apply, triage, split, publish, export, import"
 	},
 	subCommands: {
 		list: defineCommand({
@@ -3498,22 +3995,16 @@ const feedback = defineCommand({
 				item: itemArg,
 				json: json$1
 			},
-			run: ({ args }) => withStore((store) => {
-				const found = findFeedbackItem(store, args.item);
-				if (!found.ok) {
-					writeErr(found.error);
-					process.exitCode = 1;
-					return;
-				}
-				const records = store.feedbackRecords(found.item.id);
+			run: ({ args }) => withItem(args.item, (store, item) => {
+				const records = store.feedbackRecords(item.id);
 				if (args.json) {
 					write(JSON.stringify({
-						...found.item,
+						...item,
 						records
 					}, void 0, 2));
 					return;
 				}
-				for (const line of formatFeedbackItem(found.item, records)) write(line);
+				for (const line of formatFeedbackItem(item, records)) write(line);
 			})
 		}),
 		note: defineCommand({
@@ -3564,21 +4055,59 @@ const feedback = defineCommand({
 				process.exitCode = 1;
 			})
 		}),
+		accept: defineCommand({
+			meta: {
+				name: "accept",
+				description: "Accept an item; with --lesson, every later session of its workflow reads it"
+			},
+			args: {
+				item: itemArg,
+				lesson: {
+					type: "boolean",
+					description: "Add it to the workflow's lessons (.ork/lessons/<workflow>.md)",
+					default: false
+				},
+				message: {
+					type: "string",
+					alias: "m",
+					description: "The lesson's words (default: the item's title)"
+				},
+				workflow: {
+					type: "string",
+					description: "Whose lessons, when it was seen in more than one"
+				}
+			},
+			run: ({ args }) => withItem(args.item, (store, item) => {
+				const accepted = acceptItem(store, item, {
+					lesson: args.lesson,
+					text: args.message,
+					workflow: args.workflow
+				}, registeredProjects());
+				if (!accepted.ok) {
+					writeErr(accepted.error);
+					process.exitCode = 1;
+					return;
+				}
+				const [first, ...rest] = accepted.lines;
+				write(`${style("green", "✓")} ${first ?? ""}`);
+				for (const line of rest) write(`  ${line}`);
+			})
+		}),
+		apply,
+		triage,
+		split,
+		publish,
+		export: exportFeedback,
+		import: importFeedback,
 		dismiss: defineCommand({
 			meta: {
 				name: "dismiss",
 				description: "Dismiss an item: it leaves the list, and stays dismissed"
 			},
 			args: { item: itemArg },
-			run: ({ args }) => withStore((store) => {
-				const found = findFeedbackItem(store, args.item);
-				if (!found.ok) {
-					writeErr(found.error);
-					process.exitCode = 1;
-					return;
-				}
-				store.setFeedbackStatus(found.item.id, "dismissed");
-				write(`${style("green", "✓")} dismissed ${found.item.id}: ${found.item.title}`);
+			run: ({ args }) => withItem(args.item, (store, item) => {
+				store.setFeedbackStatus(item.id, "dismissed");
+				write(`${style("green", "✓")} dismissed ${item.id}: ${item.title}`);
 			})
 		}),
 		restore: defineCommand({
@@ -3587,19 +4116,128 @@ const feedback = defineCommand({
 				description: "Bring a dismissed item back to the list, as new"
 			},
 			args: { item: itemArg },
-			run: ({ args }) => withStore((store) => {
-				const found = findFeedbackItem(store, args.item);
-				if (!found.ok) {
-					writeErr(found.error);
-					process.exitCode = 1;
-					return;
-				}
-				store.setFeedbackStatus(found.item.id, "new");
-				write(`${style("green", "✓")} restored ${found.item.id}: ${found.item.title}`);
+			run: ({ args }) => withItem(args.item, (store, item) => {
+				store.setFeedbackStatus(item.id, "new");
+				write(`${style("green", "✓")} restored ${item.id}: ${item.title}`);
 			})
 		})
 	}
 });
+// src/commands/runs.ts
+/**
+* @file `ork ps`, `ork logs` and `ork tree`: read what every project's runs
+*   recorded in `~/.ork/state.db` (specs/event-store.md).
+*/
+const ps = defineCommand({
+	meta: {
+		name: "ps",
+		description: "List this project's runs, newest first"
+	},
+	args: {
+		all: {
+			type: "boolean",
+			description: "Every project's runs",
+			default: false
+		},
+		limit: {
+			type: "string",
+			description: "How many (default 20)"
+		},
+		json: {
+			type: "boolean",
+			description: "Print JSON",
+			default: false
+		}
+	},
+	run: ({ args }) => withStore((store) => {
+		const limit = Number(args.limit ?? 20);
+		const runs = store.runs({
+			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, Date.now(), statusOf)) write(line);
+	})
+});
+const runArg = {
+	type: "positional",
+	description: "A run id or a prefix of one (default: this project's newest)",
+	required: false
+};
+const logs = defineCommand({
+	meta: {
+		name: "logs",
+		description: "Print a run's transcript"
+	},
+	args: {
+		run: runArg,
+		node: {
+			type: "string",
+			description: "Only this node's events"
+		},
+		follow: {
+			type: "boolean",
+			alias: "f",
+			description: "Keep printing a live run's events until it ends",
+			default: false
+		},
+		json: {
+			type: "boolean",
+			description: "Print the stored events as JSON lines",
+			default: false
+		}
+	},
+	run: ({ args }) => withStore(async (store) => {
+		const found = findRun(store, args.run, process.cwd());
+		if (!found.ok) {
+			writeErr(found.error);
+			process.exitCode = 1;
+			return;
+		}
+		const abort = new AbortController();
+		process.once("SIGINT", () => {
+			abort.abort();
+		});
+		await followRun(store, found.run, write, {
+			follow: args.follow,
+			json: args.json,
+			signal: abort.signal,
+			...args.node === void 0 ? {} : { node: args.node }
+		});
+	})
+});
+const tree = defineCommand({
+	meta: {
+		name: "tree",
+		description: "Show a run's ownership tree with status, tokens and cost"
+	},
+	args: {
+		run: runArg,
+		json: {
+			type: "boolean",
+			description: "Print JSON",
+			default: false
+		}
+	},
+	run: ({ args }) => withStore((store) => {
+		const found = findRun(store, args.run, process.cwd());
+		if (!found.ok) {
+			writeErr(found.error);
+			process.exitCode = 1;
+			return;
+		}
+		const { run } = found;
+		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} · ${runStatus(run, events)} · ${cost(run.costUsd)}`)}`);
+		for (const line of formatTree(roots)) write(line);
+	})
+});
 // src/agents/manage.ts
 /**
 * @file What `ork agents` prints and does: the catalog as a table, one agent in
@@ -3673,7 +4311,8 @@ const skillsStep = async (root, options) => {
 };
 // src/commands/setup.ts
 /**
-* @file Setting up: `ork init` scaffolds `.ork/` in a project, records it, and
+* @file Setting up: `ork init` scaffolds `.ork/` in a project, with a starter
+*   that names no driver (it says which a run takes here), records it, and
 *   links the tool folders it uses; `ork link` points tools' agents and skills
 *   folders at `.ork/` (never in an attached project); `ork agents` lists,
 *   shows, adds and removes the agents nodes can take. `ork doctor` and `ork
@@ -3696,10 +4335,12 @@ const init = defineCommand({
 		}
 	},
 	run: async ({ args }) => {
+		const cwd = process.cwd();
+		const driverLine = await initDriverLineHere(cwd);
 		const store = openStore();
 		let result;
 		try {
-			result = initRecorded(store, process.cwd(), { link: args.link });
+			result = initRecorded(store, cwd, { link: args.link });
 		} finally {
 			store.close();
 		}
@@ -3711,8 +4352,9 @@ const init = defineCommand({
 		const { created, skipped, links } = result;
 		for (const item of created) write(`${style("green", "created")} ${item}`);
 		for (const item of skipped) write(`${style("dim", "exists")}  ${item}`);
+		if (driverLine !== null && created.includes(STARTER_FILE)) write(driverLine);
 		for (const line of formatLinks(links.filter((l) => l.state !== "linked"))) write(line);
-		await skillsStep(process.cwd(), {
+		await skillsStep(cwd, {
 			skills: args.skills,
 			link: args.link
 		});
@@ -3724,11 +4366,18 @@ const link = defineCommand({
 		name: "link",
 		description: "Point tools' agents and skills folders (.claude/agents, …) at .ork/"
 	},
-	args: { check: {
-		type: "boolean",
-		description: "Only show each folder's state; change nothing",
-		default: false
-	} },
+	args: {
+		tools: {
+			type: "positional",
+			description: "The tools to link, e.g. claude opencode (default: the ones the project already uses)",
+			required: false
+		},
+		check: {
+			type: "boolean",
+			description: "Only show each folder's state; change nothing",
+			default: false
+		}
+	},
 	run: ({ args }) => {
 		const place = projectAt(process.cwd());
 		const { root } = place;
@@ -3889,7 +4538,10 @@ const agents = defineCommand({
 	}
 });
 // src/main.ts
-/** @file The root `ork` command and its subcommands. */
+/**
+* @file The root `ork` command and its subcommands. `ork --help` lists them in
+*   the groups of `help-groups.ts`.
+*/
 const main = defineCommand({
 	meta: ORK_META,
 	subCommands: {
@@ -3904,25 +4556,27 @@ const main = defineCommand({
 		ps,
 		logs,
 		tree,
-		usage: () => import("./usage-BIjf9Xdt.mjs").then((module) => module.usage),
-		prune: () => import("./usage-BIjf9Xdt.mjs").then((module) => module.prune),
+		usage: () => import("./usage-CJnytoe4.mjs").then((module) => module.usage),
+		prune: () => import("./usage-CJnytoe4.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),
+		relay: () => import("./relay-o-Luee1c.mjs").then((module) => module.relay),
+		pause: () => import("./pause-B_SL_yDz.mjs").then((module) => module.pause),
+		continue: () => import("./pause-B_SL_yDz.mjs").then((module) => module.continueRun),
 		stop,
 		chat,
-		send: () => import("./send-C6yr04Fe.mjs").then((module) => module.send),
+		send: () => import("./send-3B64fBNB.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),
+		worktrees: () => import("./worktrees-86ySXxR6.mjs").then((module) => module.worktrees),
+		wt: () => import("./worktrees-86ySXxR6.mjs").then((module) => module.worktrees),
+		watch: () => import("./watch-BJB82ZJ7.mjs").then((module) => module.watch),
+		mcp: () => import("./mcp-CKPyNaKD.mjs").then((module) => module.mcp),
+		ui: () => import("./ui-CY4xxJUu.mjs").then((module) => module.ui),
 		doctor,
-		upgrade
+		upgrade,
+		completion: () => import("./completion-snnYGjgK.mjs").then((module) => module.completion),
+		__complete: () => import("./completion-snnYGjgK.mjs").then((module) => module.completeCommand(main))
 	}
 });
 // src/bin.ts
@@ -3930,17 +4584,26 @@ const main = defineCommand({
 * @file The `ork` executable: runs the CLI's root command. The published
 *   package's `bin` points at its bundle. When the new-version check is on, it
 *   starts the daily background check and ends with the notice (ADR-038); the
-*   background copy it starts only runs the check.
+*   background copy it starts only runs the check. It first clears git's local
+*   variables (a hook's `GIT_DIR`, `GIT_INDEX_FILE`, …), so nothing Ork starts
+*   acts on the hook's repository (specs/worktrees.md). `--help` leaves out the
+*   flags only Ork passes to itself. `ork __complete`, which tab completion
+*   runs on every Tab, goes first: no update check, and no citty, so a typed
+*   `--help` is a word to complete.
 */
-if (process.env["ORK_UPDATE_CHECK_CHILD"] === "1") await runUpdateChild();
+clearGitLocalEnv();
+const argv = process.argv.slice(2);
+if (argv[0] === "__complete") {
+	const { printCompletions } = await import("./completion-snnYGjgK.mjs");
+	await printCompletions(main, argv.slice(1));
+} else if (process.env["ORK_UPDATE_CHECK_CHILD"] === "1") await runUpdateChild();
 else {
-	const argv = process.argv.slice(2);
 	if (updateCheckOff(process.env, argv, process.stderr.isTTY) === null) {
 		startUpdateCheck();
 		process.once("exit", () => {
 			showUpdateNotice();
 		});
 	}
-	await runMain(main);
+	await runMain(main, { showUsage: showHelp });
 }
 export {};