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

package/dist/{completion-CzXUGSVn.mjs → completion-DKPuD_Rw.mjs}

@@ -1,10 +1,10 @@
-import { An as liveStatus, Fr as placeFor, L as openStore, Pr as placeFiles, R as storePath, Ti as AGENT_DRIVERS, mi as NodeIdSchema, rt as pendingDecisions } from "./src-Frwpx3WF.mjs";
-import { a as isBuiltinArg, i as builtinWorkflowText, r as builtinWorkflowNames } from "./builtin-files-dnTP2GaX.mjs";
-import { t as findRun } from "./find-P-VV4B47.mjs";
-import { a as SHELL_SCRIPTS, i as SHELLS, n as groupedEntries, r as COMPLETE_COMMAND, t as groupOf } from "./help-groups-hB6kY34d.mjs";
-import { i as findEntry, n as argInfoOf, s as subcommandsOf } from "./command-tree-BkSYWmYJ.mjs";
+import { Ci as NodeIdSchema, Nn as liveStatus, Pi as AGENT_DRIVERS, R as openStore, Ur as placeFiles, Wr as placeFor, ot as pendingDecisions, z as storePath } from "./src-Ciy7i3se.mjs";
+import { a as isBuiltinArg, i as builtinWorkflowText, r as builtinWorkflowNames } from "./builtin-files-CWL3JEo-.mjs";
+import { t as findRun } from "./find-B30-rd-u.mjs";
+import { a as SHELL_SCRIPTS, i as SHELLS, n as groupedEntries, r as COMPLETE_COMMAND, t as groupOf } from "./help-groups-BpRgBSTh.mjs";
+import { o as subcommandsOf, r as findEntry, t as argInfoOf } from "./command-tree-B6uvMJq1.mjs";
 import { l as writeErr } from "./output-B1kwo0YU.mjs";
-import { a as resolveWorkflowArg, n as WORKFLOW_SUFFIX } from "./workflows-CBYtycIy.mjs";
+import { n as WORKFLOW_SUFFIX, o as resolveWorkflowArg } from "./workflows-8GV-SeRm.mjs";
 import path from "node:path";
 import { parse } from "yaml";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
@@ -279,7 +279,8 @@ const providerFor = (providers, path, name) => providers[[...path, name].join("
 /**
 * @file What `ork __complete` offers at a position: subcommands (the root's in
 *   `ork --help`'s groups), a command's public flags, an argument's values from
-*   its provider, or an enum flag's values; filtered by what was typed, and
+*   its provider, or an enum flag's values (also when written `--flag=value`,
+*   each candidate then keeping `--flag=`); filtered by what was typed, and
 *   printed one per line as `value<TAB>description`, with `:group <title>`
 *   before each group and `:files` when file names fit too.
 */
@@ -365,10 +366,14 @@ const offerAt = (position, providers, context) => {
 /** What fits at `position`, keeping what starts with the typed word. */
 const offerFor = (position, providers, context) => {
 	const offer = offerAt(position, providers, context);
+	const prefix = position.slot.kind === "value" ? position.slot.prefix ?? "" : "";
 	return {
 		sections: offer.sections.map((section) => ({
 			...section,
-			candidates: section.candidates.filter((c) => c.value.startsWith(position.current))
+			candidates: section.candidates.filter((c) => c.value.startsWith(position.current)).map((c) => ({
+				value: `${prefix}${c.value}`,
+				description: c.description
+			}))
 		})).filter((section) => section.candidates.length > 0),
 		files: offer.files
 	};
@@ -436,12 +441,26 @@ const step = async (walk, word) => {
 		index: walk.index + 1
 	};
 };
-const slotOf = (walk, current) => {
+/** `--flag=` of a typed `--flag=text` whose flag takes a value, else nothing. */
+const valuePrefixOf = (walk, typed) => {
+	if (walk.pending !== void 0 || walk.rest || !typed.startsWith("-")) return;
+	const at = typed.indexOf("=");
+	return (at < 0 ? void 0 : flagNamed(walk.flags, typed))?.takesValue === true ? typed.slice(0, at + 1) : void 0;
+};
+const slotOf = (walk, typed, prefix) => {
 	if (walk.pending !== void 0) return {
 		kind: "value",
 		flag: walk.pending
 	};
-	if (!walk.rest && current.startsWith("-")) return { kind: "flag" };
+	if (prefix !== void 0) {
+		const flag = flagNamed(walk.flags, prefix);
+		if (flag !== void 0) return {
+			kind: "value",
+			flag,
+			prefix
+		};
+	}
+	if (!walk.rest && typed.startsWith("-")) return { kind: "flag" };
 	const positional = walk.positionals[walk.index];
 	return positional === void 0 ? { kind: "word" } : {
 		kind: "word",
@@ -454,7 +473,7 @@ const slotOf = (walk, current) => {
 */
 const positionOf = async (root, words) => {
 	const before = words.slice(0, -1);
-	const current = words.at(-1) ?? "";
+	const typed = words.at(-1) ?? "";
 	const start = {
 		...await argInfoOf(root),
 		path: [],
@@ -465,10 +484,12 @@ const positionOf = async (root, words) => {
 	};
 	const walk = await before.reduce(async (previous, word) => step(await previous, word), Promise.resolve(start));
 	const { pending: _pending, rest: _rest, ...reached } = walk;
+	const prefix = valuePrefixOf(walk, typed);
+	const current = prefix === void 0 ? typed : typed.slice(prefix.length);
 	return {
 		...reached,
 		current,
-		slot: slotOf(walk, current)
+		slot: slotOf(walk, typed, prefix)
 	};
 };
 // src/commands/completion.ts
@@ -495,12 +516,24 @@ const completionLines = async (root, words, cwd, storeFile) => {
 		opened.store?.close();
 	}
 };
+const guard = (error) => {
+	if (error.code !== "EPIPE") throw error;
+};
+/**
+* Writes `text` to stdout. A reader that quits early (`ork completion zsh |
+* head -1`) closes the pipe: that EPIPE is ignored, any other error is not.
+*/
+const writeOut = (text) => {
+	process.stdout.off("error", guard);
+	process.stdout.on("error", guard);
+	process.stdout.write(text);
+};
 /** `ork __complete`'s whole job: print the candidates, or nothing. */
 const printCompletions = async (root, args, cwd = process.cwd()) => {
 	try {
 		const words = args[0] === "--" ? args.slice(1) : args;
 		const lines = await completionLines(root, words, cwd);
-		process.stdout.write(lines.map((line) => `${line}\n`).join(""));
+		writeOut(lines.map((line) => `${line}\n`).join(""));
 	} catch {}
 };
 /** The hidden `ork __complete` of the command `root`. */
@@ -529,7 +562,7 @@ const completion = defineCommand({
 			process.exitCode = 1;
 			return;
 		}
-		process.stdout.write(script);
+		writeOut(script);
 	}
 });
 export { completeCommand, completion, printCompletions };

package/dist/{context-b4_gPlv3.mjs → context-Bw6R_EYq.mjs}

@@ -1,7 +1,7 @@
-import { Hr as LESSON_CAP_TOKENS, gt as explainSession } from "./src-Frwpx3WF.mjs";
+import { Zr as LESSON_CAP_TOKENS, yt as explainSession } from "./src-Ciy7i3se.mjs";
 import { c as write, s as style } from "./output-B1kwo0YU.mjs";
-import { i as refusedBuiltin, o as workflowArg } from "./workflows-CBYtycIy.mjs";
-import { a as formatReport, t as loadWorkflow } from "./validate-Xn2ZbJQC.mjs";
+import { a as refusedBuiltin, s as workflowArg } from "./workflows-8GV-SeRm.mjs";
+import { a as formatReport, t as loadWorkflow } from "./validate-UrmC5AG1.mjs";
 import { defineCommand } from "citty";
 // src/commands/context.ts
 /**

package/dist/detached-BQlbmqR0.mjs

@@ -0,0 +1,38 @@
+import { ft as detachRun } from "./src-Ciy7i3se.mjs";
+import { n as newRunId } from "./find-B30-rd-u.mjs";
+import { c as write, i as detachHint, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
+// src/run/detached.ts
+/**
+* @file `ork run --detach`: checks what the run would refuse (a `--follow-ups`
+*   that can't be taken) before any run folder is made, then starts the run in
+*   the background and says how to follow it.
+*/
+/** Starts the run in the background; `rawArgs` are `ork run`'s own, as typed. */
+const startDetached = async (store, options) => {
+	const { rawArgs, cwd, target } = options;
+	const { prepareFollowUps } = await import("./brief-BQbeoPMc.mjs");
+	if (await prepareFollowUps(store, rawArgs, void 0, target, void 0, false) === void 0) return;
+	const single = options.node !== void 0 && options.node !== "";
+	const runId = newRunId(store, single ? "node-" : "");
+	const detached = await detachRun({
+		store,
+		runId,
+		args: [
+			"run",
+			...rawArgs.filter((arg) => arg !== "--detach"),
+			"--run-id",
+			runId
+		],
+		cwd,
+		runDir: target.runDir(runId)
+	});
+	if (detached.ok) {
+		write(`▸ run ${detached.runId} started in the background`);
+		write(style("dim", `  ${detachHint(detached.runId)}`));
+	} else {
+		writeErr(detached.error);
+		writeErr(style("dim", `(output: ${detached.log})`));
+		process.exitCode = 1;
+	}
+};
+export { startDetached };

package/dist/{find-P-VV4B47.mjs → find-B30-rd-u.mjs}

@@ -1,4 +1,4 @@
-import { Fr as placeFor } from "./src-Frwpx3WF.mjs";
+import { Wr as placeFor } from "./src-Ciy7i3se.mjs";
 import { randomUUID } from "node:crypto";
 // ../core/src/remote/find.ts
 /**

package/dist/flags-ByYBx-Xb.mjs

@@ -0,0 +1,170 @@
+import "./src-Ciy7i3se.mjs";
+import { i as parseLimit, n as unknownProjectRefusal, r as parseFilters, t as limitRefusal } from "./refusals-DQQX3AIb.mjs";
+import { t as findRun } from "./find-B30-rd-u.mjs";
+import { a as resolved, n as argsOf } from "./command-tree-B6uvMJq1.mjs";
+import { l as writeErr } from "./output-B1kwo0YU.mjs";
+import { parseArgs } from "citty";
+// src/list/known-flags.ts
+/**
+* @file The citty plugin that refuses a flag a list command does not have (`ork
+*   ps --bogus`, `ork decide --list --since 24h`). citty's parser is not
+*   strict: it puts an unknown `--since 24h` into the arguments as `since:
+*   true` plus a positional, which `decide` would read as a run id. The plugin
+*   runs before the command, on the nine list commands only (specs/cli/
+*   list-filters.md), and refuses with citty's own argument error, so the
+*   one-line message and exit code 1 are the same as for a wrong enum value.
+*/
+/** Names citty reads without the command declaring them. */
+const BUILT_IN = /* @__PURE__ */ new Set([
+	"_",
+	"help",
+	"h"
+]);
+/** A flag's name without its spelling: `run-id`, `runId` and `run_id` agree. */
+const spelling = (name) => name.replaceAll(/[-_]/gu, "").toLowerCase();
+/**
+* An error citty's `runMain` takes for an argument error (its `CLIError`, which
+* it does not export): a failed parse gives one, and it takes `message`.
+*/
+const argumentError = (message) => {
+	try {
+		parseArgs([], { x: {
+			type: "string",
+			required: true
+		} });
+	} catch (error) {
+		if (error instanceof Error) {
+			error.message = message;
+			return error;
+		}
+	}
+	return new Error(message);
+};
+/** How the flag is typed: `--since`, or `-x` for a one-letter name. */
+const written = (name) => name.length === 1 ? `-${name}` : `--${name}`;
+/** Refuses the first flag the command does not declare. */
+const refuseUnknownFlags = {
+	name: "refuse-unknown-flags",
+	setup: async ({ cmd, rawArgs, args }) => {
+		const [first] = rawArgs;
+		const subs = await resolved(cmd.subCommands ?? {});
+		if (first !== void 0 && first in subs) return;
+		const known = /* @__PURE__ */ new Set();
+		for (const [name, def] of Object.entries(await argsOf(cmd))) {
+			known.add(spelling(name));
+			if ("alias" in def && def.alias !== void 0) for (const alias of [def.alias].flat()) known.add(spelling(alias));
+		}
+		const unknown = Object.keys(args).find((key) => !BUILT_IN.has(key) && !known.has(spelling(key)));
+		if (unknown !== void 0) throw argumentError(`Unknown flag \`${written(unknown)}\`.`);
+	}
+};
+// src/list/flags.ts
+/**
+* @file The flags every list command shares (RFC-017), made from its field
+*   table: one flag per field (an enum field's values as citty `options`, so
+*   `--help` and Tab completion read them), `--ids`, `--limit` and `--json`;
+*   and reading them back: each value checked by core's `parseFilters`,
+*   `--limit` a positive whole number, `--project` a registered one. A refusal
+*   says why on stderr and sets the exit code; the command then returns.
+*/
+const fieldArg = (field) => {
+	if (field.type !== "enum") return {
+		type: "string",
+		description: field.description
+	};
+	return {
+		type: "enum",
+		options: [...field.values ?? [], ...field.all === true ? ["all"] : []],
+		description: field.description
+	};
+};
+/** The citty flags of `table`, then `--ids`, `--limit`, `--json`, `extra`. */
+const filterArgs = (table, options = {}) => ({
+	...Object.fromEntries(table.fields.map((field) => [field.name, fieldArg(field)])),
+	...options.ids ?? table.id !== void 0 ? { ids: {
+		type: "boolean",
+		description: "Print only the ids, comma-separated, on one line",
+		default: false
+	} } : {},
+	...options.limit ?? true ? { limit: {
+		type: "string",
+		description: "Show at most this many (a positive whole number)"
+	} } : {},
+	...options.json ?? true ? { json: {
+		type: "boolean",
+		description: "Print JSON",
+		default: false
+	} } : {},
+	...options.extra
+});
+/** Says why, and makes the command exit 1. */
+const fail = (message) => {
+	writeErr(message);
+	process.exitCode = 1;
+};
+/** The `--ids` with `--json` refusal; `true` when `args` has both. */
+const refuseIdsWithJson = (args) => {
+	if (args.ids !== true || args.json !== true) return false;
+	fail("--ids and --json can't be used together.");
+	return true;
+};
+/**
+* `args` (a command's parsed flags) read against `table`: the filter, and the
+* limit. `undefined` when something was refused (already said, exit code set).
+*/
+const readListArgs = (table, args, options = {}) => {
+	if (refuseIdsWithJson(args)) return void 0;
+	const parsed = parseFilters(table, args, options.now ?? Date.now());
+	if (!parsed.ok) {
+		fail(parsed.error);
+		return;
+	}
+	const text = args["limit"];
+	if (typeof text !== "string") return {
+		filter: parsed.filter,
+		limit: void 0
+	};
+	const limit = parseLimit(text);
+	if (limit === null) {
+		fail(limitRefusal(text));
+		return;
+	}
+	return {
+		filter: parsed.filter,
+		limit
+	};
+};
+/**
+* The scope the filter's `project` names, checked against the registered
+* projects (core does not know them): an id or a root, or `all`; none given is
+* `here`. A project not registered is refused, listing the registered ones
+* (said, exit code set, `undefined`).
+*/
+const projectScope = (filter, projects) => {
+	const key = filter["project"];
+	if (key === void 0) return "here";
+	if (key === "all") return "all";
+	const found = projects.find((p) => p.id === key || p.root === key);
+	if (found !== void 0) return { root: found.root };
+	fail(unknownProjectRefusal(key, projects.map((p) => p.id)));
+};
+/**
+* `filter` with its `run` (a prefix) made the full id of the run it names, as
+* `ork decide --run` reads it; an unknown or ambiguous run is refused with
+* `findRun`'s message (said, exit code set, `undefined`). No `run` (or an empty
+* one) leaves `filter` as it is.
+*/
+const resolveRun = (store, filter) => {
+	const run = filter["run"];
+	if (run === void 0 || run === "") return filter;
+	const found = findRun(store, run, process.cwd());
+	if (!found.ok) {
+		fail(found.error);
+		return;
+	}
+	return {
+		...filter,
+		run: found.run.id
+	};
+};
+export { refuseIdsWithJson as a, readListArgs as i, filterArgs as n, resolveRun as o, projectScope as r, refuseUnknownFlags as s, fail as t };

package/dist/{follow-ups-B_c1DSpA.mjs → follow-ups-Cxca1Jgg.mjs}

@@ -1,13 +1,12 @@
-import { Fr as placeFor, Ht as followUpListTable, hn as recordPublished, mn as markDue, nr as runGh, vn as deliverFollowUp, yn as followUpProblem } from "./src-Frwpx3WF.mjs";
-import { d as followUpsRule, f as refreshDue, n as flagValues } from "./run-D4yuTmmJ.mjs";
-import { g as changeFollowUp, v as findFollowUp, x as isGithubIssueUrl, y as followUpActions } from "./__build_info__-B8TNbFtN.mjs";
-import { t as postFollowUpMessage } from "./post-y1qL1Fnj.mjs";
+import { Gt as followUpListTable, Jn as changeFollowUp, Qn as isGithubIssueUrl, Sn as followUpProblem, Wr as placeFor, Xn as findFollowUp, Zn as followUpActions, gn as postFollowUpMessage, pr as runGh, vn as markDue, xn as deliverFollowUp, yn as recordPublished } from "./src-Ciy7i3se.mjs";
+import { d as followUpsRule, f as refreshDue, n as flagValues } from "./run-C0C54UiU.mjs";
 import { t as applyFilters } from "./apply-Mb0fNpCX.mjs";
-import { t as findRun } from "./find-P-VV4B47.mjs";
+import { n as unknownProjectRefusal } from "./refusals-DQQX3AIb.mjs";
+import { t as findRun } from "./find-B30-rd-u.mjs";
 import { a as plain, c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
-import { i as readListArgs, n as filterArgs, o as allAlias } from "./flags-CqjJ44uW.mjs";
-import { t as printList } from "./print-DLe4MHn-.mjs";
-import { t as withStore } from "./store-B0nGqnPq.mjs";
+import { i as readListArgs, n as filterArgs, s as refuseUnknownFlags } from "./flags-ByYBx-Xb.mjs";
+import { t as printList } from "./print-Bd8MWVJk.mjs";
+import { t as withStore } from "./store-2KXzMCEN.mjs";
 import { homedir } from "node:os";
 import { defineCommand } from "citty";
 // src/follow-ups/command.ts
@@ -41,8 +40,7 @@ const placeOf = (store, key) => {
 	if (key === void 0) return placeFor(process.cwd(), projects);
 	const found = projects.find((p) => p.id === key || p.root === key);
 	if (found === void 0) {
-		const names = projects.map((p) => p.id);
-		fail(`No registered project \`${key}\`; registered: ${names.length === 0 ? "none" : names.join(", ")}.`);
+		fail(unknownProjectRefusal(key, projects.map((p) => p.id)));
 		return;
 	}
 	return placeFor(found.root, projects);
@@ -112,8 +110,10 @@ const byFor = (a, b) => forOrder(a.for) - forOrder(b.for) || a.for.localeCompare
 /** A multi-line text, each line safe to print. */
 const linesOf = (text) => text.split("\n").map((line) => plain(line));
 const when = (f) => f.ref === void 0 ? f.due : `${f.due} ${f.ref}`;
-/** One follow-up on one line. */
-const followUpLine = (f) => `${style("dim", f.id)}  ${f.kind.padEnd(7)} ${plain(f.title)} ${style("dim", `(${plain(when(f))})`)}`;
+/** One follow-up on one line; a short note when a run has taken it. */
+const followUpLine = (f) => `${style("dim", f.id)}  ${f.kind.padEnd(7)} ${plain(f.title)} ${style("dim", `(${plain(when(f))})`)}${f.takenBy === void 0 ? "" : style("dim", ` taken by ${plain(f.takenBy)}`)}`;
+/** What to do with a draft: copy and send it, unless it is closed already. */
+const draftHeading = (f, to) => f.status === "done" || f.status === "dropped" ? `Draft to ${to} (${f.status})` : `Draft to ${to}: copy it, send it, then \`ork follow-ups done ${f.id}\``;
 /**
 * The follow-ups grouped by status, then by `for`; the closed ones only with
 * `all`. A line each, under a heading each.
@@ -139,13 +139,14 @@ const formatFollowUp = (f) => [
 	`${style("bold", plain(f.title))}  ${style("dim", f.id)}`,
 	`status ${f.status}${f.note === void 0 ? "" : ` (${plain(f.note)})`}, for ${plain(f.for)}, ${f.kind}, due ${plain(f.due)}`,
 	...f.ref === void 0 ? [] : [`waits on ${plain(f.ref)}`],
+	...f.takenBy === void 0 ? [] : [`taken by run ${plain(f.takenBy)}`],
 	...fromLine(f),
 	...f.where.length === 0 ? [] : [`files ${f.where.map((file) => plain(file)).join(", ")}`],
 	...f.url === void 0 ? [] : [`kept at ${plain(f.url)}`],
 	...f.body === "" ? [] : ["", ...linesOf(f.body)],
 	...f.draft === void 0 ? [] : [
 		"",
-		style("bold", `Draft to ${plain(f.draft.to)}${f.draft.channel === void 0 ? "" : ` (${plain(f.draft.channel)})`}: copy it, send it, then \`ork follow-ups done ${f.id}\``),
+		style("bold", draftHeading(f, `${plain(f.draft.to)}${f.draft.channel === void 0 ? "" : ` (${plain(f.draft.channel)})`}`)),
 		...linesOf(f.draft.text).map((line) => `  ${line}`)
 	],
 	...f.steps === void 0 ? [] : [
@@ -419,6 +420,7 @@ const add = defineCommand({
 		const { followUp } = added;
 		write(`${style("green", "✓")} ${added.merged ? "merged into" : "added"} ${followUp.id}: ${plain(followUp.title)}`);
 		if (added.note !== void 0) writeErr(style("dim", added.note));
+		if (added.merged && input.draft !== void 0 && followUp.draft !== void 0 && input.draft.text !== followUp.draft.text) write(style("dim", `  the new --text was not kept: ${followUp.id} keeps its first draft (see \`ork follow-ups show ${followUp.id}\`)`));
 		if (relayed !== void 0) write(style("dim", `  sent to ${relayed.node} of run ${relayed.run}, which is live in that project`));
 	})
 });
@@ -450,17 +452,21 @@ const followUps = defineCommand({
 				name: "list",
 				description: "List the follow-ups, due first, then by who they are for"
 			},
-			args: {
-				...filterArgs(followUpListTable),
-				...allAlias
-			},
+			plugins: [refuseUnknownFlags],
+			args: filterArgs(followUpListTable),
 			run: async ({ args }) => {
 				const given = args;
-				const asked = readListArgs(followUpListTable, given, { all: "status" });
+				const asked = readListArgs(followUpListTable, given);
 				if (asked === void 0) return;
 				const { filter, limit } = asked;
 				const status = filter["status"];
 				await inProjects(filter["project"], (store, places) => {
+					const target = filter["for"]?.match(/^project:(.*)$/u)?.[1];
+					const ids = store.projects().map((p) => p.id);
+					if (target !== void 0 && !ids.includes(target)) {
+						fail(unknownProjectRefusal(target, ids));
+						return;
+					}
 					const stored = places.flatMap((place) => store.followUps(place.root));
 					const shown = applyFilters(followUpListTable, stored, filter).filter((f) => status !== void 0 || OPEN.has(f.status)).toSorted((a, b) => RANK[a.status] - RANK[b.status] || byFor(a, b)).slice(0, limit);
 					printList(shown, followUpListTable, given, (rows) => {

package/dist/{format-BS1qzpkf.mjs → format-C-nEZv-P.mjs}

@@ -1,4 +1,4 @@
-import { An as liveStatus, Nn as runStatus, Pn as slotWaitsOf, Rn as isItem, jn as lockWaitsOf, kt as lockWaitLine } from "./src-Frwpx3WF.mjs";
+import { In as runStatus, Ln as slotWaitsOf, Mt as lockWaitLine, Nn as liveStatus, Or as maskSecrets, Pn as lockWaitsOf, Vn as isItem } from "./src-Ciy7i3se.mjs";
 import { C as termOf, E as widthOf, n as cost, o as shortCount, r as costOf, s as style, w as cut } from "./output-B1kwo0YU.mjs";
 import { i as statusChip, n as chip } from "./chips-BqcT58qr.mjs";
 import { n as nodeVerdict } from "./verdict-CMvPCpWC.mjs";
@@ -193,13 +193,27 @@ const worth = (node) => {
 	return style("dim", `  ${node.unpriced === true ? tok : `${tok} · ${cost(node.costUsd)}`}`);
 };
 /**
+* A crashed run's node that never ended: cut off when it had started, not run
+* when it had not; `null` for one that ended.
+*/
+const crashedState = (node) => {
+	if (node.state === "running") return `${STATE_MARK.failed()} cut off`;
+	if (node.state === "waiting") return `${STATE_MARK.skipped()} not run`;
+	return null;
+};
+/**
 * The ownership tree, one line per node, children under their owner. A node in
-* `waits` (a live run's `lockWaitsOf`) reads `waiting for <lock>`, an item
-* too.
+* `waits` (a live run's `lockWaitsOf`) reads `waiting for <lock>`, an item too.
+* In a `crashed` run, a node started but not ended reads `cut off` and one not
+* started `not run`: nothing will end them.
 */
-const formatTree = (roots, now = Date.now(), waits = []) => {
+const formatTree = (roots, now = Date.now(), waits = [], crashed = false) => {
 	const lines = [];
-	const walk = (node, lead, branch) => {
+	const walk = (raw, lead, branch) => {
+		const node = raw.description === void 0 ? raw : {
+			...raw,
+			description: maskSecrets(raw.description)
+		};
 		const named = node.description === void 0 ? "" : `  ${node.description}`;
 		lines.push({
 			label: `${lead}${branch}${node.id}${named}`,
@@ -211,14 +225,15 @@ const formatTree = (roots, now = Date.now(), waits = []) => {
 		});
 	};
 	for (const root of roots) walk(root, "", "");
-	const label = Math.max(...lines.map((l) => l.label.length));
+	const label = Math.max(...lines.map((l) => widthOf(l.label)));
 	const type = Math.max(...lines.map((l) => l.node.type.length));
 	return lines.map(({ label: text, node }) => {
 		const usage = worth(node);
 		const lock = waits.find((wait) => wait.id === node.id)?.lock;
-		const state = node.held === true ? `${style("yellow", "‖")} paused` : lock === void 0 ? `${STATE_MARK[node.state]()} ${stateText(node)}` : `${STATE_MARK.waiting()} waiting for ${lock}`;
-		const spent = isItem(node) && node.startedAt !== void 0 ? style("dim", `  ${duration((node.finishedAt === void 0 ? now : Date.parse(node.finishedAt)) - Date.parse(node.startedAt))}`) : "";
-		return `${node.description === void 0 ? text : `${text.slice(0, text.length - node.description.length)}${dim(node.description)}`}${" ".repeat(label - text.length)}  ${style("dim", node.type.padEnd(type))}  ${state}${spent}${usage}`;
+		const cut = crashed ? crashedState(node) : null;
+		const state = cut ?? (node.held === true ? `${style("yellow", "‖")} paused` : lock === void 0 ? `${STATE_MARK[node.state]()} ${stateText(node)}` : `${STATE_MARK.waiting()} waiting for ${lock}`);
+		const spent = isItem(node) && node.startedAt !== void 0 && cut === null ? style("dim", `  ${duration((node.finishedAt === void 0 ? now : Date.parse(node.finishedAt)) - Date.parse(node.startedAt))}`) : "";
+		return `${node.description === void 0 ? text : `${text.slice(0, text.length - node.description.length)}${dim(node.description)}`}${" ".repeat(label - widthOf(text))}  ${style("dim", node.type.padEnd(type))}  ${state}${spent}${usage}`;
 	});
 };
 /**
@@ -227,7 +242,8 @@ const formatTree = (roots, now = Date.now(), waits = []) => {
 * show; `events` are the run's, `roots` its nested tree.
 */
 const formatTreeView = (run, events, roots, now = Date.now()) => {
-	const waits = runStatus(run, events) === "running" ? lockWaitsOf(events) : [];
-	return [`${style("bold", `run ${run.id}`)} ${dim(`of ${run.workflow} · ${listedStatus(run, events)} · ${cost(run.costUsd)}`)}`, ...formatTree(roots, now, waits)];
+	const status = runStatus(run, events);
+	const waits = status === "running" ? lockWaitsOf(events) : [];
+	return [`${style("bold", `run ${run.id}`)} ${dim(`of ${run.workflow} · ${listedStatus(run, events)} · ${cost(run.costUsd)}`)}`, ...formatTree(roots, now, waits, status === "crashed")];
 };
 export { header as a, listedStatus as i, formatRuns as n, table as o, formatTreeView as r, ago as t };

package/dist/{help-groups-hB6kY34d.mjs → help-groups-BpRgBSTh.mjs}

@@ -54,9 +54,10 @@ fi
 `,
 	bash: `# Tab completion for ork, in bash. Add to your ~/.bashrc:
 #   eval "$(ork completion bash)"
-# (macOS's bash 3.2 can't source <(…); saving it to a file and sourcing that
-# works too.) Every expansion is quoted and lines are read with read -r, so a
-# candidate is never split or glob-expanded.
+# (macOS's bash 3.2 loads nothing from source <(…), and prints no error;
+# saving it to a file and sourcing that works in every version.) Every
+# expansion is quoted and lines are read with read -r, so a candidate is never
+# split or glob-expanded.
 
 _ork() {
   local line="\${COMP_LINE:0:COMP_POINT}" cur files=0 strip="" out
@@ -65,10 +66,15 @@ _ork() {
   if [[ "$line" == *[[:space:]] ]]; then words+=(""); fi
   cur="\${words[\${#words[@]}-1]}"
   COMPREPLY=()
-  # bash splits a word at ":" (ork:feature); offer only what follows it.
-  if [[ "$cur" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
-    strip="\${cur%"\${cur##*:}"}"
-  fi
+  # bash splits a word at ":" and "=" (ork:feature, --input=plan=); offer only
+  # what follows the last of them that is a word break.
+  local brk pre
+  for brk in : =; do
+    if [[ "$cur" == *"$brk"* && "$COMP_WORDBREAKS" == *"$brk"* ]]; then
+      pre="\${cur%"\${cur##*"$brk"}"}"
+      if (( \${#pre} > \${#strip} )); then strip="$pre"; fi
+    fi
+  done
   out="$("\${words[0]}" ${COMPLETE_COMMAND} -- "\${words[@]:1}" 2>/dev/null)"
   while IFS= read -r line; do
     case "$line" in

package/dist/{in-a-run-DKoMGTNE.mjs → in-a-run-CZFzoT3R.mjs}

@@ -1,5 +1,5 @@
-import { R as storePath } from "./src-Frwpx3WF.mjs";
-import { g as storeGuarded, h as runMarkerIn } from "./src-CVeA4tAw.mjs";
+import { z as storePath } from "./src-Ciy7i3se.mjs";
+import { g as storeGuarded, h as runMarkerIn } from "./src-DP02RP9O.mjs";
 // src/commands/in-a-run.ts
 /**
 * @file The commands that act as the user refuse a program or an agent in a run