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

package/dist/bin.mjs

@@ -1,26 +1,28 @@
 #!/usr/bin/env node
-import { Ai as driverChecks, Ar as applySteps, Fi as DRIVER_IDS, Fr as createAgent, G as listOrkWorktrees, Hn as nestItems, I as activeTree, In as runStatus, Ir as deleteAgent, Kn as loadProject, Kt as runListTable, Lr as AGENT_SOURCES, Mi as AGENT_TOOL_LAYOUTS, Mn as tellLiveRun, Mr as linkTools, Ni as ORK_LAYOUT, Nn as liveStatus, Nr as toolLinks, Pr as toolsInUse, Qt as planClean, R as openStore, Rr as catalogAgent, S as runningScript, T as isNewer, Ur as placeFiles, Ut as decisionListTable, Vr as inRepoPlace, W as createdWorktrees, Wn as PROJECT_FILE, Wr as placeFor, Wt as feedbackListTable, Yt as applyClean, _r as feedbackActions, ar as previewPost, at as answerDecision, b as releaseNotes, cr as FEEDBACK_KINDS, di as parseWorkflow, fi as serializeWorkflow, fr as planPost, gr as normalizeTitle, hi as WorkflowSchema, in as clearGitLocalEnv, ji as readyDriver, jn as requestStop, jr as planMoveInto, kr as planAgentMigration, lr as FEEDBACK_SEVERITIES, lt as detachResume, mr as sendPost, on as modelDriver, or as checkNote, ot as pendingDecisions, qr as shownPath, si as renameNodeTypes, sr as recordNote, ur as FEEDBACK_TARGETS, ut as resumable, vi as settingsOf, vr as openFixRun, x as runningRunIds, y as planUpgrade, zr as loadAgents } from "./src-Ciy7i3se.mjs";
-import { i as placeOf, n as acceptItem, t as runInstall } from "./install-CsqK1avz.mjs";
-import { _ as machineSlotLedger, a as onInterrupt, c as runWorkflowFile, g as sweepLocks, h as machineLocksDir, i as loadRuntime, m as resumeChat, n as flagValues, o as run, r as isDriver, s as terminalHuman, t as badDriver } from "./run-C0C54UiU.mjs";
+import { $t as planClean, Ar as planAgentMigration, Br as loadAgents, Fr as toolsInUse, G as listOrkWorktrees, Gn as PROJECT_FILE, Gr as placeFor, Gt as feedbackListTable, Hr as inRepoPlace, I as activeTree, Ii as DRIVER_IDS, Ir as createAgent, Jr as shownPath, Ln as runStatus, Lr as deleteAgent, Mi as readyDriver, Mn as requestStop, Mr as planMoveInto, Ni as AGENT_TOOL_LAYOUTS, Nn as tellLiveRun, Nr as linkTools, Pi as ORK_LAYOUT, Pn as liveStatus, Pr as toolLinks, R as openStore, Rr as AGENT_SOURCES, S as runningScript, T as isNewer, Un as nestItems, W as createdWorktrees, Wr as placeFiles, Wt as decisionListTable, Xt as applyClean, _r as normalizeTitle, an as clearGitLocalEnv, at as followRunTree, b as releaseNotes, ci as renameNodeTypes, cr as recordNote, dr as FEEDBACK_TARGETS, dt as resumable, fi as parseWorkflow, gi as WorkflowSchema, hr as sendPost, it as followRuns, ji as driverChecks, jr as applySteps, lr as FEEDBACK_KINDS, or as previewPost, ot as answerDecision, pi as serializeWorkflow, pr as planPost, qn as loadProject, qt as runListTable, sn as modelDriver, sr as checkNote, st as pendingDecisions, ur as FEEDBACK_SEVERITIES, ut as detachResume, vr as feedbackActions, x as runningRunIds, y as planUpgrade, yi as settingsOf, yr as openFixRun, zr as catalogAgent } from "./src-8cOPOgrT.mjs";
+import { i as placeOf, n as acceptItem, t as runInstall } from "./install-CWcpX5g4.mjs";
+import { _ as machineSlotLedger, a as onInterrupt, c as runWorkflowFile, g as sweepLocks, h as machineLocksDir, i as loadRuntime, m as resumeChat, n as flagValues, o as run, r as isDriver, s as terminalHuman, t as badDriver } from "./run-DBUAq-Uu.mjs";
 import { t as applyFilters } from "./apply-Mb0fNpCX.mjs";
-import { n as builtinWorkflowFile, t as builtinProblem } from "./builtin-files-CWL3JEo-.mjs";
-import { p as scrubberOfRun } from "./src-DP02RP9O.mjs";
-import { t as findRun } from "./find-B30-rd-u.mjs";
-import { c as fetchLatest, d as readUpdateCache, h as nodeSession, i as registryOf, m as writeUpdateCache, n as ORK_VERSION, p as updateCachePath, t as ORK_NAME } from "./__build_info__-dPf4cEGL.mjs";
+import { n as builtinWorkflowFile, t as builtinProblem } from "./builtin-files-Cf-NZDqM.mjs";
+import { p as scrubberOfRun } from "./src-I_RyKu6_.mjs";
+import { t as findRun } from "./find-BTikxc54.mjs";
+import { c as fetchLatest, d as readUpdateCache, h as nodeSession, i as registryOf, m as writeUpdateCache, n as ORK_VERSION, p as updateCachePath, t as ORK_NAME } from "./__build_info__-D6mXC4cD.mjs";
 import { n as groupedEntries, t as groupOf } from "./help-groups-BpRgBSTh.mjs";
-import { a as resolved, i as publicArgs, n as argsOf, o as subcommandsOf } from "./command-tree-B6uvMJq1.mjs";
+import { a as resolved, i as publicArgs, n as argsOf, o as subcommandsOf } from "./command-tree-CEkzWNy6.mjs";
 import { C as termOf, D as wrap, E as widthOf, S as takePlainFlag, T as hang, a as plain, b as canKey, c as write, h as paint, l as writeErr, m as bold, s as style, t as confirm, w as cut } from "./output-B1kwo0YU.mjs";
 import { n as chip, r as nodeChip, t as CHIP_LABELS } from "./chips-BqcT58qr.mjs";
-import { a as unknownNode, i as logListTable, l as createTerminalHuman, n as askStored, r as followRun, u as readText } from "./attach-DhZQ87Nz.mjs";
-import { c as projectAt, l as registeredProjects, n as WORKFLOW_SUFFIX, t as WORKFLOW_DIR } from "./workflows-8GV-SeRm.mjs";
-import { C as startUpdateCheck, S as showUpdateNotice, _ as runChecks, a as formatReport, c as checksHere, g as orkCheck, h as headWarning, m as experimentsCheck, n as validate, p as exec, r as validateFile, v as socketCheck, w as updateCheckOff, x as runUpdateChild, y as triggerChecks } from "./validate-UrmC5AG1.mjs";
-import { a as decideRefusal, r as chatRefusal } from "./in-a-run-CZFzoT3R.mjs";
-import { t as context } from "./context-Bw6R_EYq.mjs";
-import { i as readListArgs, n as filterArgs, o as resolveRun, r as projectScope, s as refuseUnknownFlags, t as fail$1 } from "./flags-ByYBx-Xb.mjs";
-import { i as listedStatus, n as formatRuns, r as formatTreeView, t as ago } from "./format-C-nEZv-P.mjs";
-import { t as printList } from "./print-Bd8MWVJk.mjs";
-import { a as formatRegistered, i as formatProjects, n as move, o as recordInRepo, r as withStore, s as registerProject, t as forget } from "./project-records-BOEVs69i.mjs";
-import { t as withStore$1 } from "./store-2KXzMCEN.mjs";
+import { a as printerFor, c as logListTable, h as readText, i as printUnder, l as matcher, m as createTerminalHuman, n as createPrompts, o as createLogPrinter, r as askStored, s as followRun, u as unknownNode } from "./attach-CEGbRg1D.mjs";
+import { c as projectAt, l as registeredProjects, n as WORKFLOW_SUFFIX, t as WORKFLOW_DIR } from "./workflows-DHHi-APg.mjs";
+import { C as startUpdateCheck, S as showUpdateNotice, _ as runChecks, a as formatReport, c as checksHere, g as orkCheck, h as headWarning, m as experimentsCheck, n as validate, p as exec, r as validateFile, v as socketCheck, w as updateCheckOff, x as runUpdateChild, y as triggerChecks } from "./validate-BxayjjkV.mjs";
+import { a as createView, o as styler } from "./verdict-CMvPCpWC.mjs";
+import { a as decideRefusal, r as chatRefusal } from "./in-a-run-CbnKjO7t.mjs";
+import { t as context } from "./context-CGPh12HV.mjs";
+import { t as refuseExtraArguments } from "./extra-arguments-BxQMXARO.mjs";
+import { c as refuseUnknownFlags, i as readListArgs, n as filterArgs, o as resolveRun, r as projectScope, s as rootOf, t as fail$1 } from "./flags-C8yCq0j5.mjs";
+import { i as listedStatus, n as formatRuns, r as formatTreeView, t as ago } from "./format-BB4E-T6x.mjs";
+import { t as printList } from "./print-DNYzq4Rr.mjs";
+import { a as formatRegistered, i as formatProjects, n as move, o as recordInRepo, r as withStore, s as registerProject, t as forget } from "./project-records-XY3ku95x.mjs";
+import { t as withStore$1 } from "./store-CDpk8Wtz.mjs";
 import path from "node:path";
 import { stringify } from "yaml";
 import { z } from "zod";
@@ -358,6 +360,97 @@ const noteRun = (store, cwd, args) => {
 * file names (by pattern only when the file is gone or no longer parses).
 */
 const noteOn = (store, run, ask) => recordNote(store, run, ask, "--", scrubberOfRun(run, store.projects()));
+// src/runs/follow-decisions.ts
+/**
+* @file `ork decide --follow`: ask the open decisions of the live runs in scope
+*   on this terminal, then each one a run opens later, one prompt at a time
+*   (specs/cli.md). Runs are followed with core's `followRuns`, so a run
+*   started after this one, and a called run, are found; a decision answered
+*   elsewhere withdraws its prompt. Ctrl-C and `--until-idle` end it; no
+*   decision is closed by either.
+*/
+const scopeOf$1 = ({ project, runId, workflow }) => ({
+	...project === void 0 ? {} : { project },
+	...runId === void 0 ? {} : { run: runId },
+	...workflow === void 0 ? {} : { workflow }
+});
+/**
+* Asks `open` (the decisions open now, in the store's order) and then each
+* decision the runs in `filter` open, until `session.signal` aborts or, with
+* `untilIdle`, nothing is live and nothing is being asked. Says why it stopped
+* and returns.
+*/
+const followDecisions = async (store, open, filter, session) => {
+	const stop = new AbortController();
+	session.signal?.addEventListener("abort", () => {
+		stop.abort();
+	});
+	const human = createTerminalHuman({
+		...session.terminal,
+		interrupt: () => {
+			stop.abort();
+		}
+	});
+	const term = termOf(session.terminal.output, session.terminal.env);
+	const say = styler(term);
+	const prompts = createPrompts(store, human, {
+		by: "decide",
+		out: session.out,
+		term,
+		...session.home === void 0 ? {} : { home: session.home }
+	});
+	stop.signal.addEventListener("abort", () => {
+		prompts.abort();
+	});
+	/**
+	* Every decision put to the person: one that was left (`q`) isn't asked
+	* again.
+	*/
+	const asked = /* @__PURE__ */ new Set();
+	const workflowOf = (run) => store.lookup(run).find((r) => r.id === run)?.workflow;
+	const ask = (run, decision, path) => {
+		if (asked.has(decision)) return;
+		asked.add(decision);
+		const workflow = workflowOf(run);
+		prompts.ask({
+			run,
+			...workflow === void 0 ? {} : { workflow },
+			...path === void 0 ? {} : { path }
+		}, decision);
+	};
+	try {
+		for (const d of open) ask(d.runId, d.id);
+		let end;
+		for (;;) {
+			end = await followRuns(store, scopeOf$1(filter), ({ run, workflow, path, stored }) => {
+				const { event } = stored;
+				if (prompts.seen(event)) return;
+				if (event.type === "decision.opened" && (filter.runId === void 0 || run === filter.runId) && (filter.workflow === void 0 || workflow === filter.workflow) && pendingDecisions(store, { runId: run }).some((d) => d.id === event.decision)) ask(run, event.decision, path);
+			}, {
+				untilIdle: session.untilIdle === true,
+				...session.home === void 0 ? {} : { home: session.home },
+				...session.intervalMs === void 0 ? {} : { intervalMs: session.intervalMs },
+				signal: stop.signal
+			});
+			if (end === "aborted" || prompts.open() === 0) break;
+			await prompts.settled();
+			if (stop.signal.aborted) {
+				end = "aborted";
+				break;
+			}
+		}
+		prompts.abort();
+		await prompts.settled();
+		if (end === "idle") session.out(say("dim", "no live runs"));
+		else {
+			const left = (/* @__PURE__ */ new Set([...pendingDecisions(store, filter).map((d) => d.id), ...[...asked].filter((id) => store.decision(id)?.status === "open")])).size;
+			session.out(say("dim", `stopped following; ${left} decision(s) still open`));
+		}
+		return end;
+	} finally {
+		human.close();
+	}
+};
 // src/commands/decide-list.ts
 /**
 * @file The list `ork decide --list` prints: one line per open decision, and
@@ -426,7 +519,8 @@ const selectDecisions = (store, args) => {
 	const pending = pendingDecisions(store, filter);
 	return {
 		open: request.limit === void 0 ? pending : pending.slice(0, request.limit),
-		workflow
+		workflow,
+		filter
 	};
 };
 /** Prints `open` as `--ids`, `--json` or the lines of `formatDecisions`. */
@@ -445,6 +539,95 @@ const decisionHint = (store, arg) => {
 	if (decision === void 0 || decision.status !== "open") return void 0;
 	return `${arg} is a decision id, not a run: answer it with \`ork decide --id ${arg} --choose ${decision.recommended ?? decision.options[0]?.id ?? "<option>"}\``;
 };
+/** The flags that list or answer one decision, which `--follow` can't take. */
+const NOT_WITH_FOLLOW = [
+	"list",
+	"json",
+	"ids",
+	"limit",
+	"id",
+	"choose",
+	"document",
+	"say",
+	"note",
+	"rating"
+];
+/** Why the flags can't follow decisions, or `undefined` when they can. */
+const followRefusal = (args) => {
+	if (args["follow"] !== true) return args["until-idle"] === true ? "--until-idle goes with --follow." : void 0;
+	const given = NOT_WITH_FOLLOW.filter((name) => args[name] !== void 0 && args[name] !== false);
+	return given.length === 0 ? void 0 : `--follow asks decisions as they open; it can't go with ${given.map((name) => `--${name}`).join(", ")}.`;
+};
+// src/commands/decide-ask.ts
+/**
+* @file `ork decide` answering on a terminal: the open decisions one at a time
+*   (`askOpen`), or those and every one a live run opens later (`--follow`,
+*   `followCommand`), with the line a plain terminal gets after an answer.
+*/
+/** 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}`);
+};
+/** The workflow a card names for a run, when the store knows it. */
+const workflowOf = (store, run) => {
+	const workflow = store.lookup(run).find((r) => r.id === run)?.workflow;
+	return workflow === void 0 ? {} : { workflow };
+};
+/** Asks `open` on `human`, one question at a time, in order. */
+const askOpen = async (store, human, open) => {
+	const collapses = canKey(process.stdin, process.stdout);
+	for (const [index, d] of open.entries()) {
+		const asked = await askStored(store, human, d, {
+			by: "decide",
+			place: {
+				run: d.runId,
+				...workflowOf(store, d.runId),
+				decision: d.id,
+				index: index + 1,
+				total: open.length
+			}
+		});
+		if (asked.kind === "refused") write(`${style("yellow", "!")} ${asked.message}\n`);
+		else if (asked.kind === "answered" && !collapses) write(`${style("green", "✓")} ${d.id}: ${asked.choice}${saidLine(store, d.id)}\n`);
+	}
+};
+/** `ork decide --follow`: the person at this terminal answers as decisions open. */
+const followCommand = async (args) => {
+	const refusal = decideRefusal();
+	if (refusal !== null) {
+		fail$1(refusal);
+		return;
+	}
+	if (!process.stdin.isTTY) {
+		fail$1("--follow needs a terminal to answer on; `ork decide --list` shows what is open.");
+		return;
+	}
+	const store = openStore();
+	const stop = new AbortController();
+	const onSigint = () => {
+		stop.abort();
+	};
+	try {
+		const selected = selectDecisions(store, args);
+		if (selected === void 0) return;
+		process.once("SIGINT", onSigint);
+		await followDecisions(store, selected.open, selected.filter, {
+			out: write,
+			signal: stop.signal,
+			untilIdle: args["until-idle"] === true,
+			terminal: {
+				input: process.stdin,
+				output: process.stdout,
+				interactive: true,
+				verbose: args["verbose"] === true
+			}
+		});
+	} finally {
+		process.off("SIGINT", onSigint);
+		store.close();
+	}
+};
 // src/commands/decide.ts
 /**
 * @file `ork decide`: answer a live run's open decisions from any terminal (it
@@ -485,11 +668,6 @@ const noteProblem = (note, 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}`);
-};
 const decide = defineCommand({
 	meta: {
 		name: "decide",
@@ -532,9 +710,29 @@ const decide = defineCommand({
 			type: "boolean",
 			description: "Show each question's whole context, not its first lines",
 			default: false
+		},
+		follow: {
+			type: "boolean",
+			alias: ["watch"],
+			description: "Ask the open decisions, then each new one of any live run (Ctrl-C stops)",
+			default: false
+		},
+		"until-idle": {
+			type: "boolean",
+			description: "With --follow, stop once no live run is left",
+			default: false
 		}
 	},
 	run: async ({ args }) => {
+		const conflict = followRefusal(args);
+		if (conflict !== void 0) {
+			failed$2(conflict);
+			return;
+		}
+		if (args.follow) {
+			await followCommand(args);
+			return;
+		}
 		const listing = asksForList(args);
 		const refusal = !args.document && (args.id !== void 0 || args.choose !== void 0 || process.stdin.isTTY && !listing) ? decideRefusal() : null;
 		if (refusal !== null) {
@@ -596,20 +794,7 @@ const decide = defineCommand({
 				printDecisions(open, args, workflow);
 				return;
 			}
-			const collapses = canKey(process.stdin, process.stdout);
-			for (const [index, d] of open.entries()) {
-				const asked = await askStored(store, human, d, {
-					by: "decide",
-					place: {
-						run: d.runId,
-						decision: d.id,
-						index: index + 1,
-						total: open.length
-					}
-				});
-				if (asked.kind === "refused") write(`${style("yellow", "!")} ${asked.message}\n`);
-				else if (asked.kind === "answered" && !collapses) write(`${style("green", "✓")} ${d.id}: ${asked.choice}${saidLine(store, d.id)}\n`);
-			}
+			await askOpen(store, human, open);
 		} finally {
 			human?.close();
 			store.close();
@@ -634,6 +819,7 @@ const stop = defineCommand({
 		name: "stop",
 		description: "Stop a live run, or one of its nodes"
 	},
+	plugins: [refuseExtraArguments],
 	args: {
 		run: {
 			type: "positional",
@@ -683,6 +869,7 @@ const resume = defineCommand({
 		name: "resume",
 		description: "Continue a run that didn't succeed (stopped, failed or crashed): finished nodes keep their results"
 	},
+	plugins: [refuseExtraArguments],
 	args: {
 		run: {
 			type: "positional",
@@ -822,7 +1009,7 @@ const formatCheck = (result, term = termOf(process.stdout)) => {
 * folder. Says nothing when there were none. `bin` is the `cmd` program.
 */
 const leaseChecks = async (place, env = process.env, bin = "cmd") => {
-	const { cleanStaleLeases, leaseLedger } = await import("./src-D2qpd-G7.mjs");
+	const { cleanStaleLeases, leaseLedger } = await import("./src-D4JSymhK.mjs");
 	const { cleaned, failed } = await cleanStaleLeases({
 		bin,
 		ledger: leaseLedger(placeFiles(place).runs),
@@ -1935,12 +2122,57 @@ const triageSummary = ({ merged, declined, triaged }) => {
 		`${String(triaged)} new item(s) triaged`
 	].join("; ");
 };
+// src/commands/feedback-resolve.ts
+/**
+* @file `ork feedback resolve`: marks items resolved that were fixed by hand,
+*   outside `ork feedback apply`, so they leave the list (specs/feedback.md).
+*   Takes several ids, space or comma separated, and changes none when one is
+*   unknown or can't be resolved (dismissed, or resolved or published already).
+*   An item seen again after it was resolved opens again.
+*/
+const resolve = defineCommand({
+	meta: {
+		name: "resolve",
+		description: "Mark items fixed by hand resolved: they leave the list, and open again if they recur"
+	},
+	args: { item: {
+		type: "positional",
+		description: "A feedback item's id, or a prefix of one; several allowed, space or comma separated",
+		required: true
+	} },
+	run: ({ args }) => withStore$1((store) => {
+		const named = [...new Set(args._.flatMap((word) => word.split(",")).map((word) => word.trim()).filter((word) => word !== ""))];
+		const items = /* @__PURE__ */ new Map();
+		const refusals = [];
+		for (const prefix of named) {
+			const found = findFeedbackItem(store, prefix);
+			if (!found.ok) {
+				refusals.push(found.error);
+				continue;
+			}
+			const allowed = feedbackActions(found.item).resolve;
+			if (allowed.ok) items.set(found.item.id, found.item);
+			else refusals.push(allowed.error);
+		}
+		if (refusals.length > 0 || items.size === 0) {
+			for (const refusal of refusals) writeErr(refusal);
+			if (items.size === 0 && refusals.length === 0) writeErr("Give a feedback item's id.");
+			process.exitCode = 1;
+			return;
+		}
+		for (const item of items.values()) {
+			store.setFeedbackStatus(item.id, "resolved");
+			write(`${style("green", "✓")} resolved ${item.id.slice(0, 12)}: ${item.title}`);
+		}
+	})
+});
 // 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.
+*   apart. `resolve` (marking items fixed by hand) is passed on from its own
+*   file.
 */
 const itemArg$1 = {
 	type: "positional",
@@ -2276,10 +2508,10 @@ const importFeedback = defineCommand({
 /**
 * @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`.
+*   item, accept one, as a lesson its workflow reads from then on, and resolve
+*   ones fixed by hand (`feedback-resolve.ts`). 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$1((store) => {
@@ -2299,7 +2531,7 @@ const itemArg = {
 const feedback = defineCommand({
 	meta: {
 		name: "feedback",
-		description: "What got in the way in your runs, grouped: list, show, note, dismiss, restore, accept, apply, triage, split, publish, export, import"
+		description: "What got in the way in your runs, grouped: list, show, note, dismiss, restore, accept, resolve, apply, triage, split, publish, export, import"
 	},
 	subCommands: {
 		list,
@@ -2308,6 +2540,7 @@ const feedback = defineCommand({
 				name: "show",
 				description: "Show an item and its records"
 			},
+			plugins: [refuseExtraArguments],
 			args: {
 				item: itemArg,
 				json: {
@@ -2333,6 +2566,7 @@ const feedback = defineCommand({
 				name: "note",
 				description: "Note how a run or one of its nodes went; it joins the feedback"
 			},
+			plugins: [refuseExtraArguments],
 			args: {
 				run: {
 					type: "positional",
@@ -2381,6 +2615,7 @@ const feedback = defineCommand({
 				name: "accept",
 				description: "Accept an item; with --lesson, every later session of its workflow reads it"
 			},
+			plugins: [refuseExtraArguments],
 			args: {
 				item: itemArg,
 				lesson: {
@@ -2414,17 +2649,31 @@ const feedback = defineCommand({
 				for (const line of rest) write(`  ${line}`);
 			})
 		}),
-		apply,
+		resolve,
+		apply: {
+			...apply,
+			plugins: [refuseExtraArguments]
+		},
 		triage,
-		split,
-		publish,
+		split: {
+			...split,
+			plugins: [refuseExtraArguments]
+		},
+		publish: {
+			...publish,
+			plugins: [refuseExtraArguments]
+		},
 		export: exportFeedback,
-		import: importFeedback,
+		import: {
+			...importFeedback,
+			plugins: [refuseExtraArguments]
+		},
 		dismiss: defineCommand({
 			meta: {
 				name: "dismiss",
 				description: "Dismiss an item: it leaves the list, and stays dismissed"
 			},
+			plugins: [refuseExtraArguments],
 			args: { item: itemArg },
 			run: ({ args }) => withItem(args.item, (store, item) => {
 				store.setFeedbackStatus(item.id, "dismissed");
@@ -2436,6 +2685,7 @@ const feedback = defineCommand({
 				name: "restore",
 				description: "Bring a dismissed item back to the list, as new"
 			},
+			plugins: [refuseExtraArguments],
 			args: { item: itemArg },
 			run: ({ args }) => withItem(args.item, (store, item) => {
 				store.setFeedbackStatus(item.id, "new");
@@ -2444,57 +2694,144 @@ const feedback = defineCommand({
 		})
 	}
 });
-// src/commands/runs.ts
+// src/runs/logs-many.ts
 /**
-* @file `ork ps`, `ork logs` and `ork tree`: read what every project's runs
-*   recorded in `~/.ork/state.db` (specs/event-store.md).
+* @file `ork logs` over several runs: a run with the runs it called inline
+*   under their call paths, and every live run of a project interleaved behind
+*   a `<id> <workflow> › ` prefix (`logs -f --all`; specs/cli.md,
+*   specs/scheduler/calls.md).
 */
-/** How many runs `ork ps` shows without `--limit`. */
-const PS_LIMIT = 20;
-/** The project root a scope other than `all` names. */
-const rootOf = (scope, projects) => scope === "here" ? placeFor(process.cwd(), projects).root : scope.root;
-const ps = defineCommand({
-	meta: {
-		name: "ps",
-		description: "List this project's runs, newest first"
-	},
-	plugins: [refuseUnknownFlags],
-	args: { ...filterArgs(runListTable, { extra: { limit: {
-		type: "string",
-		description: `Show at most this many, a positive whole number (default ${String(PS_LIMIT)})`
-	} } }) },
-	run: ({ args }) => withStore$1((store) => {
-		const req = readListArgs(runListTable, args);
-		if (req === void 0) return;
-		const scope = projectScope(req.filter, store.projects());
-		if (scope === void 0) return;
-		const stored = store.runs(scope === "all" ? {} : { project: rootOf(scope, store.projects()) });
-		const rows = req.filter["status"] === void 0 ? stored : stored.map((run) => run.status === "running" ? {
-			...run,
-			listed: runStatus(run, store.events(run.id).map((s) => s.event))
-		} : run);
-		const shown = applyFilters(runListTable, rows, req.filter).slice(0, req.limit ?? PS_LIMIT);
-		const byId = new Map(stored.map((run) => [run.id, run]));
-		const statusOf = (run) => listedStatus(run, run.status === "running" ? store.events(run.id).map((s) => s.event) : []);
-		printList(shown, runListTable, {
-			ids: args["ids"],
-			json: args["json"]
-		}, (runs) => {
-			for (const line of formatRuns(runs, scope === "all", Date.now(), statusOf)) write(line);
-		}, (runs) => runs.map((run) => {
-			const record = byId.get(run.id) ?? run;
-			return {
-				...record,
-				live: statusOf(record)
-			};
-		}));
-	})
+/**
+* The stored events of `roots` and of the runs they called, at any depth, in
+* the order they print: a called run's right after its `call.started`.
+*/
+const treeEvents = (store, roots) => {
+	const seen = new Set(roots);
+	const walk = (id, into) => {
+		for (const stored of store.events(id)) {
+			into.push(stored);
+			const { event } = stored;
+			if (event.type === "call.started" && !seen.has(event.run)) {
+				seen.add(event.run);
+				walk(event.run, into);
+			}
+		}
+		return into;
+	};
+	return roots.flatMap((id) => walk(id, []));
+};
+/** `run:seq` of an event, to name it in a set. */
+const keyOf = (stored) => `${stored.runId}:${stored.seq}`;
+/**
+* The stored events (in print order, over all of `roots`' runs) that `--limit`
+* cuts: all but the last `limit` that pass the filters. Events stored after
+* this read are not in it, so they always print.
+*/
+const droppedBy = (store, roots, options) => {
+	if (options.limit === void 0) return /* @__PURE__ */ new Set();
+	const matches = matcher(options);
+	const kept = treeEvents(store, roots).filter((stored) => matches(stored));
+	return new Set(kept.slice(0, -options.limit).map((stored) => keyOf(stored)));
+};
+/** A run's printer: JSON lines as stored, or text laid out behind `path`. */
+const printerOf = (term, options, path) => options.json ? createLogPrinter({ json: true }) : printerFor(term, path, {
+	...options.verbose === void 0 ? {} : { verbose: options.verbose },
+	...options.node === void 0 ? {} : { node: options.node }
+});
+/** Prints a run's `lines` behind `path`'s gutter; JSON lines have none. */
+const show = (out, term, options, path, lines) => {
+	if (options.json) for (const line of lines) out(line);
+	else printUnder(out, term, path, lines);
+};
+/** What the clock-free options of a follower are, as `followRuns` takes them. */
+const pollOf = (options) => ({
+	...options.home === void 0 ? {} : { home: options.home },
+	...options.intervalMs === void 0 ? {} : { intervalMs: options.intervalMs },
+	...options.signal === void 0 ? {} : { signal: options.signal }
 });
-const runArg = {
+/**
+* Whether `--node` names nothing in `root` or the runs it called (none of them
+* has such an event or declares it), as `unknownNode` says for one run.
+*/
+const unknownCallNode = (store, root, node, live) => unknownNode(treeEvents(store, [root]), node, live);
+/**
+* Prints `root`'s events and those of the runs it called, each called run's
+* right after the `call.started` that started it, under its call path. With
+* `follow`, goes on until the root ends (or `signal` aborts), then names the
+* called runs still running.
+*/
+const printCalls = async (store, root, out, options) => {
+	const { term } = options.view ?? createView();
+	const say = styler(term);
+	const matches = matcher(options);
+	const dropped = droppedBy(store, [root.id], options);
+	const printers = /* @__PURE__ */ new Map();
+	const { end, stillRunning } = await followRunTree(store, root.id, ({ run, path, stored }) => {
+		let print = printers.get(run);
+		if (print === void 0) {
+			print = printerOf(term, options, path);
+			printers.set(run, print);
+		}
+		const lines = print(stored);
+		if (matches(stored) && !dropped.has(keyOf(stored))) show(out, term, options, path, lines);
+	}, {
+		follow: options.follow,
+		...pollOf(options)
+	});
+	if (end === "crashed") out(style("red", `run ${root.id} stopped without finishing (its process is gone)`));
+	if (!options.follow || options.json) return;
+	for (const id of stillRunning) out(say("dim", `↳ run ${id} still running · ork attach ${id}`));
+};
+/**
+* Prints the events of every live run in `scope` (a called run too, once), each
+* line behind `<4-char id> <workflow> › `: the stored events first, then new
+* ones, runs that start later included. Ends when `signal` aborts, or with
+* `untilIdle` once no run is live.
+*/
+const printAll = async (store, scope, out, options) => {
+	const { term } = options.view ?? createView();
+	const matches = matcher(options);
+	const { project } = scope;
+	const live = store.runs(project === void 0 || project === "all" ? {} : { project }).filter((run) => liveStatus(run) === "running");
+	const dropped = droppedBy(store, live.map((run) => run.id), options);
+	const printers = /* @__PURE__ */ new Map();
+	await followRuns(store, scope, ({ run, workflow, stored }) => {
+		const path = [`${run.slice(0, 4)} ${workflow}`];
+		let print = printers.get(run);
+		if (print === void 0) {
+			print = printerOf(term, options, path);
+			printers.set(run, print);
+		}
+		const lines = print(stored);
+		if (matches(stored) && !dropped.has(keyOf(stored))) show(out, term, options, path, lines);
+	}, {
+		...options.untilIdle === true ? { untilIdle: true } : {},
+		...pollOf(options)
+	});
+};
+// src/commands/logs.ts
+/**
+* @file `ork logs`: prints a run's transcript (with the runs it called inline),
+*   or follows every live run of a project (`--all`), from `~/.ork/state.db`
+*   (specs/event-store.md, specs/cli.md).
+*/
+const runArg$1 = {
 	type: "positional",
 	description: "A run id or a prefix of one (default: this project's newest)",
 	required: false
 };
+/** Why `ork logs`'s flags can't go together, or `null`. */
+const logsRefusal = (args) => {
+	if (args.all) {
+		if (!args.follow) return "--all needs -f.";
+		if (args.run !== void 0) return "--all can't be used with a run.";
+		if (args.calls !== void 0) return "--calls and --no-calls don't apply to --all (a called run prints as its own).";
+		return null;
+	}
+	if (args.project !== void 0) return "--project needs --all.";
+	if (args["until-idle"]) return "--until-idle needs --all.";
+	return null;
+};
 const logs = defineCommand({
 	meta: {
 		name: "logs",
@@ -2502,7 +2839,7 @@ const logs = defineCommand({
 	},
 	plugins: [refuseUnknownFlags],
 	args: {
-		run: runArg,
+		run: runArg$1,
 		...filterArgs(logListTable, {
 			ids: false,
 			json: false,
@@ -2510,7 +2847,7 @@ const logs = defineCommand({
 		}),
 		limit: {
 			type: "string",
-			description: "Print only the last this many stored events, a positive whole number (a live follow goes on past it)"
+			description: "Print only the last this many stored events, a positive whole number, counted overall in print order, not per run (a live follow goes on past it)"
 		},
 		node: {
 			type: "string",
@@ -2531,27 +2868,79 @@ const logs = defineCommand({
 			type: "boolean",
 			description: "Show each tool call whole, and why each failed node stopped, with its scrubbed details (always on with --node)",
 			default: false
+		},
+		all: {
+			type: "boolean",
+			description: "With -f: every live run of the project, interleaved, each line behind its run id and workflow (a called run too, once; runs that start later join)",
+			default: false
+		},
+		project: {
+			type: "string",
+			description: "With --all: a registered project (id or root), or all (default: this one)"
+		},
+		"until-idle": {
+			type: "boolean",
+			description: "With --all: end once no live run is left",
+			default: false
+		},
+		calls: {
+			type: "boolean",
+			description: "Print the runs a run called inline under their call paths (default in text; --no-calls prints the run alone; --json needs --calls to include them)",
+			negativeDescription: "Print the run alone, without the runs it called"
 		}
 	},
 	run: ({ args }) => withStore$1(async (store) => {
+		const refusal = logsRefusal(args);
+		if (refusal !== null) {
+			fail$1(refusal);
+			return;
+		}
 		const req = readListArgs(logListTable, args);
 		if (req === void 0) return;
+		const abort = new AbortController();
+		process.once("SIGINT", () => {
+			abort.abort();
+		});
+		if (args.all) {
+			const scope = projectScope(args.project === void 0 ? {} : { project: args.project }, store.projects());
+			if (scope === void 0) return;
+			await printAll(store, scope === "all" ? {} : { project: rootOf(scope, store.projects()) }, write, {
+				json: args.json,
+				verbose: args.verbose,
+				filter: req.filter,
+				...req.limit === void 0 ? {} : { limit: req.limit },
+				...args.node === void 0 ? {} : { node: args.node },
+				...args["until-idle"] ? { untilIdle: true } : {},
+				signal: abort.signal
+			});
+			return;
+		}
 		const found = findRun(store, args.run, process.cwd());
 		if (!found.ok) {
 			writeErr(found.error);
 			process.exitCode = 1;
 			return;
 		}
-		const problem = args.node === void 0 ? null : unknownNode(store.events(found.run.id), args.node, args.follow && found.run.status === "running");
+		const calls = args.calls ?? !args.json;
+		const live = args.follow && found.run.status === "running";
+		const problem = args.node === void 0 ? null : calls ? unknownCallNode(store, found.run.id, args.node, live) : unknownNode(store.events(found.run.id), args.node, live);
 		if (problem !== null) {
 			writeErr(problem);
 			process.exitCode = 1;
 			return;
 		}
-		const abort = new AbortController();
-		process.once("SIGINT", () => {
-			abort.abort();
-		});
+		if (calls) {
+			await printCalls(store, found.run, write, {
+				follow: args.follow,
+				json: args.json,
+				verbose: args.verbose,
+				filter: req.filter,
+				...req.limit === void 0 ? {} : { limit: req.limit },
+				signal: abort.signal,
+				...args.node === void 0 ? {} : { node: args.node }
+			});
+			return;
+		}
 		await followRun(store, found.run, write, {
 			follow: args.follow,
 			json: args.json,
@@ -2563,13 +2952,61 @@ const logs = defineCommand({
 		});
 	})
 });
+// 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).
+*/
+/** How many runs `ork ps` shows without `--limit`. */
+const PS_LIMIT = 20;
+const ps = defineCommand({
+	meta: {
+		name: "ps",
+		description: "List this project's runs, newest first"
+	},
+	plugins: [refuseUnknownFlags],
+	args: { ...filterArgs(runListTable, { extra: { limit: {
+		type: "string",
+		description: `Show at most this many, a positive whole number (default ${String(PS_LIMIT)})`
+	} } }) },
+	run: ({ args }) => withStore$1((store) => {
+		const req = readListArgs(runListTable, args);
+		if (req === void 0) return;
+		const scope = projectScope(req.filter, store.projects());
+		if (scope === void 0) return;
+		const stored = store.runs(scope === "all" ? {} : { project: rootOf(scope, store.projects()) });
+		const rows = req.filter["status"] === void 0 ? stored : stored.map((run) => run.status === "running" ? {
+			...run,
+			listed: runStatus(run, store.events(run.id).map((s) => s.event))
+		} : run);
+		const shown = applyFilters(runListTable, rows, req.filter).slice(0, req.limit ?? PS_LIMIT);
+		const byId = new Map(stored.map((run) => [run.id, run]));
+		const statusOf = (run) => listedStatus(run, run.status === "running" ? store.events(run.id).map((s) => s.event) : []);
+		printList(shown, runListTable, {
+			ids: args["ids"],
+			json: args["json"]
+		}, (runs) => {
+			for (const line of formatRuns(runs, scope === "all", Date.now(), statusOf)) write(line);
+		}, (runs) => runs.map((run) => {
+			const record = byId.get(run.id) ?? run;
+			return {
+				...record,
+				live: statusOf(record)
+			};
+		}));
+	})
+});
 const tree = defineCommand({
 	meta: {
 		name: "tree",
 		description: "Show a run's ownership tree with status, tokens and cost. A delegated task shows its task label: the lead's short description, whitespace folded, clipped to 80 characters, secrets masked"
 	},
 	args: {
-		run: runArg,
+		run: {
+			type: "positional",
+			description: "A run id or a prefix of one (default: this project's newest)",
+			required: false
+		},
 		json: {
 			type: "boolean",
 			description: "Print JSON",
@@ -3035,31 +3472,31 @@ const main = defineCommand({
 		run,
 		ps,
 		logs,
-		attach: () => import("./attach-BQl8nQz2.mjs").then((module) => module.attach),
+		attach: () => import("./attach-C1OnxyMh.mjs").then((module) => module.attach),
 		tree,
-		usage: () => import("./usage-BFBco5OS.mjs").then((module) => module.usage),
-		prune: () => import("./usage-BFBco5OS.mjs").then((module) => module.prune),
+		usage: () => import("./usage-1VwSg_Qt.mjs").then((module) => module.usage),
+		prune: () => import("./usage-1VwSg_Qt.mjs").then((module) => module.prune),
 		decide,
-		relay: () => import("./relay-CeNiq3GT.mjs").then((module) => module.relay),
-		pause: () => import("./pause-B1grR1cl.mjs").then((module) => module.pause),
-		continue: () => import("./pause-B1grR1cl.mjs").then((module) => module.continueRun),
+		relay: () => import("./relay-BA6tsnpc.mjs").then((module) => module.relay),
+		pause: () => import("./pause-C_Wxh-KM.mjs").then((module) => module.pause),
+		continue: () => import("./pause-C_Wxh-KM.mjs").then((module) => module.continueRun),
 		stop,
 		chat,
-		once: () => import("./once-BKn3pOtg.mjs").then((module) => module.once),
-		send: () => import("./send-DqgF58hb.mjs").then((module) => module.send),
+		once: () => import("./once-BHxSdZz_.mjs").then((module) => module.once),
+		send: () => import("./send-nrKtak5F.mjs").then((module) => module.send),
 		resume,
 		feedback,
-		"follow-ups": () => import("./follow-ups-Cxca1Jgg.mjs").then((module) => module.followUps),
+		"follow-ups": () => import("./follow-ups-CtlhHbwe.mjs").then((module) => module.followUps),
 		context,
-		worktrees: () => import("./worktrees-CUdUvZlO.mjs").then((module) => module.worktrees),
-		wt: () => import("./worktrees-CUdUvZlO.mjs").then((module) => module.worktrees),
-		watch: () => import("./watch-DTxkgB8R.mjs").then((module) => module.watch),
-		mcp: () => import("./mcp-B4wME9C4.mjs").then((module) => module.mcp),
-		ui: () => import("./ui-CAvygxTb.mjs").then((module) => module.ui),
+		worktrees: () => import("./worktrees-CZvbHzbN.mjs").then((module) => module.worktrees),
+		wt: () => import("./worktrees-CZvbHzbN.mjs").then((module) => module.worktrees),
+		watch: () => import("./watch-CT0EtLPZ.mjs").then((module) => module.watch),
+		mcp: () => import("./mcp-wGfkMCVF.mjs").then((module) => module.mcp),
+		ui: () => import("./ui-DY3Dnpho.mjs").then((module) => module.ui),
 		doctor,
 		upgrade,
-		completion: () => import("./completion-DKPuD_Rw.mjs").then((module) => module.completion),
-		__complete: () => import("./completion-DKPuD_Rw.mjs").then((module) => module.completeCommand(main))
+		completion: () => import("./completion-DS0gCZRm.mjs").then((module) => module.completion),
+		__complete: () => import("./completion-DS0gCZRm.mjs").then((module) => module.completeCommand(main))
 	}
 });
 // src/bin.ts
@@ -3081,7 +3518,7 @@ const main = defineCommand({
 clearGitLocalEnv();
 const argv = takePlainFlag(process.argv.slice(2));
 if (argv[0] === "__complete") {
-	const { printCompletions } = await import("./completion-DKPuD_Rw.mjs");
+	const { printCompletions } = await import("./completion-DS0gCZRm.mjs");
 	await printCompletions(main, argv.slice(1));
 } else if (process.env["ORK_UPDATE_CHECK_CHILD"] === "1") await runUpdateChild();
 else {
@@ -3094,7 +3531,7 @@ else {
 	const dash = argv.indexOf("--");
 	const askedHelp = argv.slice(1, dash === -1 ? 0 : dash).some((arg) => arg === "--help" || arg === "-h");
 	if (argv[0] === "once" && dash !== -1 && !askedHelp) try {
-		const { once } = await import("./once-BKn3pOtg.mjs");
+		const { once } = await import("./once-BHxSdZz_.mjs");
 		await runCommand(once, { rawArgs: argv.slice(1) });
 	} catch (error) {
 		console.error(error);