@krapht/ork 1.0.0-alpha.13 → 1.0.0-alpha.15

package/dist/follow-ups-B4GJ3Vzw.mjs

@@ -0,0 +1,461 @@
+import { Dr as placeFor, Yn as runGh, cn as recordPublished, dn as deliverFollowUp, fn as followUpProblem, sn as markDue } from "./src-Dr_fTSu-.mjs";
+import { d as followUpsRule, f as refreshDue, n as flagValues } from "./run--4-1xAF2.mjs";
+import { g as changeFollowUp, v as findFollowUp, y as followUpActions } from "./__build_info__-Bsb1kjgF.mjs";
+import { t as postFollowUpMessage } from "./post-BzA6Qobq.mjs";
+import { t as findRun } from "./find-BYLlszqj.mjs";
+import { a as plain, c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
+import { t as withStore } from "./store-oKJ-cCf3.mjs";
+import { homedir } from "node:os";
+import { defineCommand } from "citty";
+// src/follow-ups/command.ts
+/**
+* @file What the `ork follow-ups` subcommands share: the flags, the project a
+*   call is about, and the due check every call runs first, in the user's
+*   store. A `gh` that fails only warns.
+*/
+const json = {
+	type: "boolean",
+	description: "Print JSON",
+	default: false
+};
+const project = {
+	type: "string",
+	description: "A registered project's id (default: the one you are in)"
+};
+const idArg = {
+	type: "positional",
+	description: "A follow-up's id, or a prefix of one",
+	required: true
+};
+/** Says why, and makes the command exit 1. */
+const fail = (message) => {
+	writeErr(message);
+	process.exitCode = 1;
+};
+/** The project a command is about, from `--project` or the folder. */
+const placeOf = (store, key) => {
+	const projects = store.projects();
+	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(", ")}.`);
+		return;
+	}
+	return placeFor(found.root, projects);
+};
+/** Runs `body` in the project, after the due check, in the user's store. */
+const inProject = (key, body) => withStore(async (store) => {
+	const place = placeOf(store, key);
+	if (place === void 0) return;
+	await refreshDue(store, place.root, (line) => {
+		writeErr(style("dim", line));
+	});
+	await body(store, place);
+});
+/** Runs `body` on the follow-up `id` names, or says why there is none. */
+const withFollowUp = (args, body) => inProject(args.project, async (store, place) => {
+	const found = findFollowUp(store, place.root, args.id);
+	if (!found.ok) {
+		fail(found.error);
+		return;
+	}
+	await body(store, place, found.followUp);
+});
+// src/follow-ups/format.ts
+/** The groups of the list, in the order they are shown. */
+const GROUPS = [
+	{
+		status: "due",
+		title: "Due"
+	},
+	{
+		status: "waiting",
+		title: "Waiting"
+	},
+	{
+		status: "done",
+		title: "Done"
+	},
+	{
+		status: "dropped",
+		title: "Dropped"
+	}
+];
+/** `agent` first, then the maintainer, other projects, then people. */
+const FOR_ORDER = [
+	"agent",
+	"me",
+	"project:",
+	"person:"
+];
+const forOrder = (value) => FOR_ORDER.findIndex((prefix) => value.startsWith(prefix));
+const byFor = (a, b) => forOrder(a.for) - forOrder(b.for) || a.for.localeCompare(b.for);
+/** 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))})`)}`;
+/**
+* The follow-ups grouped by status, then by `for`; the closed ones only with
+* `all`. A line each, under a heading each.
+*/
+const formatFollowUps = (followUps, all) => {
+	const lines = [];
+	for (const group of GROUPS) {
+		if (!all && group.status !== "due" && group.status !== "waiting") continue;
+		const inGroup = followUps.filter((f) => f.status === group.status).toSorted(byFor);
+		if (inGroup.length === 0) continue;
+		if (lines.length > 0) lines.push("");
+		lines.push(style("bold", `${group.title} (${String(inGroup.length)})`));
+		for (const kind of new Set(inGroup.map((f) => f.for))) {
+			lines.push(`  ${style("cyan", `for ${plain(kind)}`)}`);
+			for (const f of inGroup.filter((one) => one.for === kind)) lines.push(`    ${followUpLine(f)}`);
+		}
+	}
+	return lines.length === 0 ? [style("dim", "No follow-ups.")] : lines;
+};
+const fromLine = (f) => f.from.run === void 0 ? [] : [`from run ${plain(f.from.run)}${f.from.node === void 0 ? "" : `, node ${plain(f.from.node)}`}`];
+/** One follow-up whole: its record, its draft and its steps, ready to copy. */
+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)}`],
+	...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}\``),
+		...linesOf(f.draft.text).map((line) => `  ${line}`)
+	],
+	...f.steps === void 0 ? [] : [
+		"",
+		style("bold", "Steps (Ork never runs them):"),
+		...f.steps.flatMap((step, index) => [`  ${String(index + 1)}. ${plain(step.text)}`, ...step.command === void 0 ? [] : [`     ${plain(step.command)}`]])
+	]
+];
+// src/commands/follow-ups-act.ts
+/**
+* @file What `ork follow-ups` does to one follow-up: done (a message: sent),
+*   drop, reopen, make due, post a drafted GitHub comment, and `published`,
+*   which a workflow's step calls once its change is out. Posting goes through
+*   the person's own `gh` and only with `--confirm`, after showing the exact
+*   text; Ork never runs a task's commands.
+*/
+/** `done`, `drop` or `reopen`: one change of status, or why it can't be. */
+const closing = (action, description, verb) => defineCommand({
+	meta: {
+		name: action,
+		description
+	},
+	args: {
+		id: idArg,
+		project
+	},
+	run: ({ args }) => withFollowUp(args, (store, _place, followUp) => {
+		const changed = changeFollowUp(store, followUp, action);
+		if (!changed.ok) {
+			fail(changed.error);
+			return;
+		}
+		write(`${style("green", "✓")} ${verb} ${changed.followUp.id}: ${plain(changed.followUp.title)}`);
+	})
+});
+const due = defineCommand({
+	meta: {
+		name: "due",
+		description: "Make a waiting follow-up due now, or all of a run's (after a deploy, say)"
+	},
+	args: {
+		target: {
+			type: "positional",
+			description: "A follow-up's id (or a prefix), or a run id",
+			required: true
+		},
+		project
+	},
+	run: ({ args }) => inProject(args.project, (store, place) => {
+		const one = findFollowUp(store, place.root, args.target);
+		const run = findRun(store, args.target, "");
+		const runId = run.ok ? run.run.id : args.target;
+		const key = one.ok ? one.followUp.id : runId;
+		const marked = markDue(store, place.root, key);
+		if (marked.length === 0) {
+			fail(`Nothing waiting under \`${args.target}\`: give a waiting follow-up's id, or a run that left some.`);
+			return;
+		}
+		for (const f of marked) write(`${style("green", "✓")} due ${f.id}: ${plain(f.title)}`);
+	})
+});
+const post = defineCommand({
+	meta: {
+		name: "post",
+		description: "Post a message drafted for GitHub, as a comment through your own gh, with --confirm; without it, show what would be posted"
+	},
+	args: {
+		id: idArg,
+		confirm: {
+			type: "boolean",
+			description: "Yes: post exactly this text",
+			default: false
+		},
+		project
+	},
+	run: ({ args }) => withFollowUp(args, async (store, _place, followUp) => {
+		const allowed = followUpActions(followUp).post;
+		if (!allowed.ok) {
+			fail(allowed.error);
+			return;
+		}
+		const draft = followUp.draft;
+		if (!args.confirm && draft !== void 0) {
+			write(`Would post to ${plain(draft.to)} through your gh:`);
+			for (const line of draft.text.split("\n")) write(`  ${plain(line)}`);
+			fail("Run again with --confirm to post it.");
+			return;
+		}
+		const posted = await postFollowUpMessage(followUp, {
+			rows: store,
+			gh: runGh,
+			confirmed: args.confirm,
+			home: homedir()
+		});
+		if (!posted.ok) {
+			fail(posted.error);
+			return;
+		}
+		write(`${style("green", "✓")} posted${posted.url === void 0 ? "" : ` ${posted.url}`}; done ${followUp.id}`);
+	})
+});
+const published = defineCommand({
+	meta: {
+		name: "published",
+		description: "Record that this run published a pull request or branch (a workflow step calls it): its follow-ups wait on it, and the ones it took are done"
+	},
+	args: { ref: {
+		type: "positional",
+		description: "The pull request URL or the branch",
+		required: true
+	} },
+	run: ({ args }) => withStore((store) => {
+		const runId = process.env["ORK_RUN"];
+		if (runId === void 0 || runId === "") {
+			fail("ork follow-ups published runs inside a run: ORK_RUN is not set.");
+			return;
+		}
+		const found = findRun(store, runId, "");
+		if (!found.ok) {
+			fail(found.error);
+			return;
+		}
+		const callers = [];
+		for (let parent = found.run.parent; parent !== void 0 && !callers.includes(parent); parent = store.lookup(parent).find((r) => r.id === parent)?.parent) callers.push(parent);
+		const recorded = recordPublished(store, {
+			project: found.run.project,
+			run: found.run.id,
+			ref: args.ref,
+			callers
+		});
+		write(`${style("green", "✓")} ${String(recorded.referenced.length)} follow-up(s) now wait on ${plain(args.ref)}; ${String(recorded.done.length)} done`);
+	})
+});
+// src/commands/follow-ups-add.ts
+/**
+* @file `ork follow-ups add`: a follow-up the maintainer adds by hand, with its
+*   `for`, `kind` and `due`, a message's draft or a task's steps. It is kept
+*   where the project's rule says, and one for another project goes into that
+*   project's list and, when a run is live there, to its session.
+*/
+/** `text :: command` as a step; the command is optional. */
+const stepOf = (raw) => {
+	const [text = "", command] = raw.split(" :: ", 2);
+	return command === void 0 ? { text: text.trim() } : {
+		text: text.trim(),
+		command: command.trim()
+	};
+};
+const defaultKind = (value) => {
+	if (value.startsWith("person:")) return "message";
+	return value === "agent" || value.startsWith("project:") ? "change" : "task";
+};
+const isKind = (value) => [
+	"change",
+	"message",
+	"task",
+	"check"
+].includes(value);
+const isFor = (value) => /^(?:agent|me|project:.+|person:.+)$/u.test(value);
+const isDue = (value) => /^(?:now|after-merge|after-deploy|\d+-\d+-\d+)$/u.test(value);
+const add = defineCommand({
+	meta: {
+		name: "add",
+		description: "Add a follow-up: --for agent|me|project:<name>|person:<name>, --kind, --due"
+	},
+	args: {
+		title: {
+			type: "positional",
+			description: "What it is",
+			required: true
+		},
+		for: {
+			type: "string",
+			description: "agent, me, project:<name> or person:<name> (default: me)"
+		},
+		kind: {
+			type: "string",
+			description: "change, message, task or check (default: by --for)"
+		},
+		due: {
+			type: "string",
+			description: "now, after-merge, after-deploy or a YYYY-MM-DD date (default: now)"
+		},
+		body: {
+			type: "string",
+			description: "What and why"
+		},
+		where: {
+			type: "string",
+			description: "A file it is about (repeatable)"
+		},
+		ref: {
+			type: "string",
+			description: "The PR or branch it waits on"
+		},
+		to: {
+			type: "string",
+			description: "A message: who it is to"
+		},
+		channel: {
+			type: "string",
+			description: "A message: slack, email, github…"
+		},
+		text: {
+			type: "string",
+			description: "A message: its text, to send"
+		},
+		step: {
+			type: "string",
+			description: "A task's step, `text` or `text :: command` (repeatable); Ork never runs it"
+		},
+		project,
+		json
+	},
+	run: ({ args, rawArgs }) => inProject(args.project, async (store, place) => {
+		const recipient = args.for ?? "me";
+		const kind = args.kind ?? defaultKind(recipient);
+		if (!isKind(kind)) {
+			fail("--kind is change, message, task or check.");
+			return;
+		}
+		const due = args.due ?? "now";
+		if (!isFor(recipient) || !isDue(due)) {
+			fail(isFor(recipient) ? "--due is now, after-merge, after-deploy or a YYYY-MM-DD date." : "--for is agent, me, project:<name> or person:<name>.");
+			return;
+		}
+		const steps = flagValues(rawArgs, "--step").map((raw) => stepOf(raw));
+		const input = {
+			title: args.title,
+			for: recipient,
+			kind,
+			due,
+			where: flagValues(rawArgs, "--where"),
+			...args.body === void 0 ? {} : { body: args.body },
+			...args.ref === void 0 ? {} : { ref: args.ref },
+			...args.text === void 0 ? {} : { draft: {
+				to: args.to ?? recipient.replace(/^person:/u, ""),
+				...args.channel === void 0 ? {} : { channel: args.channel },
+				text: args.text
+			} },
+			...steps.length === 0 ? {} : { steps }
+		};
+		const problem = followUpProblem(input);
+		if (problem !== null) {
+			fail(`${problem}.`);
+			return;
+		}
+		const rule = followUpsRule(place);
+		const delivered = await deliverFollowUp(input, {
+			store,
+			project: place.root,
+			...rule === void 0 ? {} : { rule }
+		});
+		if (!delivered.ok) {
+			fail(delivered.error);
+			return;
+		}
+		if (args.json) {
+			write(JSON.stringify(delivered, void 0, 2));
+			return;
+		}
+		const { added, relayed } = delivered;
+		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 (relayed !== void 0) write(style("dim", `  sent to ${relayed.node} of run ${relayed.run}, which is live in that project`));
+	})
+});
+// src/commands/follow-ups.ts
+/**
+* @file `ork follow-ups`: what shipped changes left for later, apart from
+*   feedback (specs/follow-ups.md): list and show them, add one, and mark one
+*   done, dropped, reopened or due, or post its drafted GitHub comment (in
+*   `follow-ups-act.ts`). Every call first moves what has come due, reading
+*   pull requests through the person's own `gh`; a `gh` that fails only warns.
+*/
+const followUps = defineCommand({
+	meta: {
+		name: "follow-ups",
+		description: "What shipped changes left for later: list, show, add, done, drop, reopen, due, post, published"
+	},
+	subCommands: {
+		list: defineCommand({
+			meta: {
+				name: "list",
+				description: "List the follow-ups, due first, then by who they are for"
+			},
+			args: {
+				all: {
+					type: "boolean",
+					description: "Done and dropped ones too",
+					default: false
+				},
+				for: {
+					type: "string",
+					description: "Only those for agent, me, project:<name> or person:<name>"
+				},
+				project,
+				json
+			},
+			run: ({ args }) => inProject(args.project, (store, place) => {
+				const shown = store.followUps(place.root).filter((f) => (args.all || f.status === "due" || f.status === "waiting") && (args.for === void 0 || f.for === args.for));
+				if (args.json) write(JSON.stringify(shown, void 0, 2));
+				else for (const line of formatFollowUps(shown, args.all)) write(line);
+			})
+		}),
+		show: defineCommand({
+			meta: {
+				name: "show",
+				description: "Show a follow-up whole, with its draft and its steps to copy"
+			},
+			args: {
+				id: idArg,
+				project,
+				json
+			},
+			run: ({ args }) => withFollowUp(args, (_store, _place, followUp) => {
+				if (args.json) write(JSON.stringify(followUp, void 0, 2));
+				else for (const line of formatFollowUp(followUp)) write(line);
+			})
+		}),
+		add,
+		done: closing("done", "Mark a follow-up done; a message is done once you have sent it", "done"),
+		drop: closing("drop", "Drop a follow-up that no longer applies", "dropped"),
+		reopen: closing("reopen", "Bring a done or dropped follow-up back", "reopened"),
+		due,
+		post,
+		published
+	}
+});
+export { followUps };

package/dist/{format-C60TFpRe.mjs → format-C8MsFj8_.mjs}

@@ -1,7 +1,7 @@
-import { Tt as isItem, _t as liveStatus, xt as slotWaitsOf, yt as runStatus } from "./src-BeR6f70A.mjs";
-import { S as cut, a as style, n as cost, w as widthOf, x as termOf } from "./output-CnRzrbUM.mjs";
-import { i as statusChip, n as chip } from "./chips-CyeB_rhR.mjs";
-import { n as nodeVerdict } from "./verdict-CIy8tAyX.mjs";
+import { Cn as liveStatus, Dn as slotWaitsOf, En as runStatus, Lt as lockWaitLine, jn as isItem, wn as lockWaitsOf } from "./src-Dr_fTSu-.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";
 // src/term/table.ts
 /**
 * @file Aligned columns for the listing commands: each column as wide as its
@@ -85,13 +85,17 @@ const duration = (ms) => {
 };
 const dim = (s) => style("dim", s);
 /**
-* A run's status as `ork ps` reads it: `waiting for slot` for a running run
+* A run's status as `ork ps` reads it: for a running run, `waiting for <lock>,
+* held by <run>/<node>` with a node waiting for a lock, or `waiting for slot`
 * with a command waiting for a machine-wide slot; `events` are a running
 * run's.
 */
 const listedStatus = (run, events) => {
 	const status = runStatus(run, events);
-	return status === "running" && slotWaitsOf(events).length > 0 ? "waiting for slot" : status;
+	if (status !== "running") return status;
+	const [lock] = lockWaitsOf(events);
+	if (lock !== void 0) return lockWaitLine(lock.lock, lock.holders);
+	return slotWaitsOf(events).length > 0 ? "waiting for slot" : status;
 };
 /**
 * The `ork ps` table; `withProject` adds each run's project. A called run's
@@ -107,7 +111,7 @@ const formatRuns = (runs, withProject, now = Date.now(), statusOf = liveStatus,
 			workflow: run.workflow,
 			status,
 			when: `${ago(run.startedAt, now)} · ${duration(end - Date.parse(run.startedAt))}`,
-			cost: run.parent === void 0 ? cost(run.costUsd) : `${cost(run.costUsd)} in ${run.parent}`,
+			cost: run.parent === void 0 ? costOf(run.costUsd, run.partial, run.tokens) : `${costOf(run.costUsd, run.partial, run.tokens)} in ${run.parent}`,
 			called: run.parent !== void 0,
 			project: run.project
 		};
@@ -166,11 +170,7 @@ const STATE_MARK = {
 	skipped: () => style("dim", "-")
 };
 /** `950`, `12.3k`, `1.2M`. */
-const count = (n) => {
-	if (n < 1e3) return String(n);
-	if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`;
-	return `${(n / 1e6).toFixed(1)}M`;
-};
+const count = shortCount;
 const stateText = (node) => {
 	if (node.state === "running") return node.runs > 1 ? `running (round ${String(node.runs)})` : "running";
 	if (node.state === "ok" || node.state === "failed") {
@@ -180,8 +180,12 @@ const stateText = (node) => {
 	}
 	return node.state;
 };
-/** The ownership tree, one line per node, children under their owner. */
-const formatTree = (roots, now = Date.now()) => {
+/**
+* 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.
+*/
+const formatTree = (roots, now = Date.now(), waits = []) => {
 	const lines = [];
 	const walk = (node, lead, branch) => {
 		lines.push({
@@ -198,9 +202,19 @@ const formatTree = (roots, now = Date.now()) => {
 	const type = Math.max(...lines.map((l) => l.node.type.length));
 	return lines.map(({ label: text, node }) => {
 		const usage = node.inputTokens + node.outputTokens === 0 ? "" : style("dim", `  ${count(node.inputTokens)} in / ${count(node.outputTokens)} out · ${cost(node.costUsd)}`);
-		const state = node.held === true ? `${style("yellow", "‖")} paused` : `${STATE_MARK[node.state]()} ${stateText(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 `${text.padEnd(label)}  ${style("dim", node.type.padEnd(type))}  ${state}${spent}${usage}`;
 	});
 };
-export { header as a, listedStatus as i, formatRuns as n, table as o, formatTree as r, ago as t };
+/**
+* What `ork tree` prints: the run's header (its status as `ork ps` reads it)
+* and the tree. A finished run's lock waits are stale, so only a live run's
+* 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)];
+};
+export { header as a, listedStatus as i, formatRuns as n, table as o, formatTreeView as r, ago as t };

package/dist/{help-groups-CyfPWlST.mjs → help-groups-CQ98mLjF.mjs}

@@ -4,7 +4,9 @@
 *   shell. Each is thin: it runs `ork __complete -- <words…>` with the word
 *   under the cursor last, and offers the lines it prints, `value<TAB>
 *   description`. A line `:group <title>` starts a group (zsh labels the menu
-*   with it); `:files` asks for file names too. A new shell is one more entry.
+*   with it); `:files` asks for file names too. A value ending in `=` (an
+*   input's `name=`) takes no space after it, so its value is typed next. A new
+*   shell is one more entry.
 */
 /** The hidden command the scripts run. */
 const COMPLETE_COMMAND = "__complete";
@@ -15,9 +17,11 @@ const SHELL_SCRIPTS = {
 # (ork completion zsh > ~/.zsh/completions/_ork), or source it.
 
 _ork() {
-  local -a lines cands
+  local -a lines cands opens
   local line group=commands files=0 n=0 ret=1
   lines=("\${(@f)$("\${words[1]}" ${COMPLETE_COMMAND} -- "\${(@)words[2,CURRENT]}" 2>/dev/null)}")
+  # A last group line offers what the last group gathered.
+  lines+=(":group end")
   for line in "\${lines[@]}"; do
     case $line in
       (:files) files=1 ;;
@@ -25,15 +29,17 @@ _ork() {
         if (( \${#cands} )); then
           _describe -V -t "ork-$(( ++n ))" "$group" cands && ret=0
         fi
-        cands=()
+        # name= is followed by its value, not a space.
+        if (( \${#opens} )); then
+          _describe -V -t "ork-$(( ++n ))" "$group" opens -S '' && ret=0
+        fi
+        cands=() opens=()
         group=\${line#:group }
         ;;
+      (*=$'\\t'*) opens+=("\${\${line%%$'\\t'*}//:/\\\\:}:\${line#*$'\\t'}") ;;
       (?*) cands+=("\${\${line%%$'\\t'*}//:/\\\\:}:\${line#*$'\\t'}") ;;
     esac
   done
-  if (( \${#cands} )); then
-    _describe -V -t "ork-$(( ++n ))" "$group" cands && ret=0
-  fi
   if (( files )); then
     _files && ret=0
   fi
@@ -71,6 +77,10 @@ _ork() {
       *)
         line="\${line%%$'\\t'*}"
         COMPREPLY+=("\${line#"$strip"}")
+        # name= is followed by its value, not a space (bash 4 and later).
+        if [[ "$line" == *= ]] && type compopt &>/dev/null; then
+          compopt -o nospace
+        fi
         ;;
     esac
   done <<< "$out"
@@ -274,6 +284,10 @@ const HELP_GROUPS = [
 				name: "feedback",
 				short: "What got in the way in your runs"
 			},
+			{
+				name: "follow-ups",
+				short: "What shipped changes left for later"
+			},
 			{
 				name: "worktrees",
 				short: "Track and clean up Ork's worktrees"

package/dist/{in-a-run-BYjTXaST.mjs → in-a-run-Bp0k0J09.mjs}

@@ -1,4 +1,4 @@
-import { p as runMarkerIn } from "./src-D93tHZ5B.mjs";
+import { p as runMarkerIn } from "./src-DcrhgipG.mjs";
 // src/commands/in-a-run.ts
 /**
 * @file The commands that act as the user refuse a program or an agent in a run