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

package/dist/brief-Bs3cMQU0.mjs

@@ -0,0 +1,100 @@
+import { _n as takeFollowUps, nr as runGh } from "./src-DLsFsmOD.mjs";
+import { f as refreshDue, l as briefOf, n as flagValues, u as checkTakeable } from "./run-OOWQIKMJ.mjs";
+import { n as newRunId } from "./find-k489laBa.mjs";
+import { l as writeErr } from "./output-B1kwo0YU.mjs";
+import { t as loadWorkflow } from "./validate-BS0nCccW.mjs";
+// src/follow-ups/brief.ts
+/**
+* @file `ork run --follow-ups <ids>`: the `agent` follow-ups become the run's
+*   `brief` input, and are marked taken by the run, which finishes them when it
+*   publishes (`ork follow-ups published`). Everything that could refuse them
+*   (an unknown id, one for someone else, a workflow with no `brief` input) is
+*   checked before any is marked, so a run that doesn't start leaves them be.
+*/
+const FLAG = "--follow-ups";
+/** What `--follow-ups` takes besides ids: every due agent follow-up. */
+const DUE = "due";
+/**
+* Each `--follow-ups` value as typed (one per use, still comma-joined), and
+* whether one is missing: no value, an empty one, or a next argument that is
+* another flag.
+*/
+const given = (rawArgs) => {
+	const values = [];
+	let empty = false;
+	for (const [index, arg] of rawArgs.entries()) {
+		if (arg !== FLAG && !arg.startsWith(`${FLAG}=`)) continue;
+		const next = rawArgs[index + 1];
+		const parts = (arg === FLAG ? next === void 0 || next.startsWith("--") ? "" : next : arg.slice(13)).split(",").map((part) => part.trim()).filter((part) => part !== "");
+		if (parts.length === 0) empty = true;
+		values.push(...parts);
+	}
+	return {
+		values,
+		empty
+	};
+};
+/**
+* Says what `--follow-ups` needs when it is given with nothing after it, and
+* fails the command; true when it is fine (or not given).
+*/
+const followUpsFlagFine = (rawArgs) => {
+	if (!given(rawArgs).empty) return true;
+	writeErr(`${FLAG} needs follow-up ids, or \`${DUE}\` for every due agent follow-up. \`ork follow-ups list\` shows them.`);
+	process.exitCode = 1;
+	return false;
+};
+/**
+* What stops `--follow-ups` from starting a run, one line each; none when
+* nothing does.
+*/
+const problemsOf = (loaded, inputs) => {
+	const name = loaded.workflow?.name ?? "";
+	if (loaded.workflow?.inputs?.["brief"] === void 0) return [`--follow-ups fills a workflow's \`brief\` input, and ${name} has none.`];
+	return inputs.some((input) => input.startsWith("brief=")) ? ["--follow-ups and --input brief=… both set the brief."] : [];
+};
+/**
+* The inputs and run id `ork run` starts with: those it was given and, for
+* `--follow-ups`, a `brief` made of the follow-ups with the id of the run that
+* takes them. `undefined` after saying why it can't start.
+*/
+const prepareFollowUps = async (store, rawArgs, runId, target, gh = runGh) => {
+	const inputs = flagValues(rawArgs, "--input");
+	const plain = {
+		inputs,
+		...runId === void 0 ? {} : { runId }
+	};
+	if (!followUpsFlagFine(rawArgs)) return void 0;
+	const { values } = given(rawArgs);
+	if (values.length === 0) return plain;
+	const loaded = loadWorkflow(target.file, process.cwd(), void 0, store.projects());
+	if (loaded.workflow === null) return plain;
+	const project = loaded.place.root;
+	const named = values.filter((value) => value !== DUE);
+	if (values.includes(DUE)) await refreshDue(store, project, writeErr, gh);
+	const due = values.includes(DUE) ? store.followUps(project).filter((f) => f.for === "agent" && f.status === "due").map((f) => f.id) : [];
+	if (named.length === 0 && due.length === 0) {
+		writeErr(`${FLAG} ${DUE}: no agent follow-ups are due. \`ork follow-ups list\` shows them.`);
+		process.exitCode = 1;
+		return;
+	}
+	const takeable = checkTakeable(store, project, [...named, ...due]);
+	const problems = [...problemsOf(loaded, inputs), ...takeable.ok ? [] : takeable.lines];
+	if (!takeable.ok || problems.length > 0) {
+		for (const line of problems) writeErr(line);
+		process.exitCode = 1;
+		return;
+	}
+	const followUps = [...new Map(takeable.followUps.map((f) => [f.id, f])).values()];
+	const taker = runId ?? newRunId(store);
+	takeFollowUps(store, {
+		project,
+		run: taker,
+		ids: followUps.map((f) => f.id)
+	});
+	return {
+		inputs: [...inputs, `brief=${briefOf(followUps)}`],
+		runId: taker
+	};
+};
+export { followUpsFlagFine, prepareFollowUps };

package/dist/{builtin-files-2bHf76x-.mjs → builtin-files-yYaNTQRU.mjs}

@@ -1,4 +1,4 @@
-import { Er as placeFiles, Ir as guardedBase, Lr as plainPathInside, Rr as writePlainFile } from "./src-Dr_fTSu-.mjs";
+import { Gr as plainPathInside, Kr as writePlainFile, Pr as placeFiles, Wr as guardedBase } from "./src-DLsFsmOD.mjs";
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { createHash } from "node:crypto";

package/dist/command-tree-BkSYWmYJ.mjs

@@ -0,0 +1,63 @@
+// src/command-tree.ts
+/** How a flag that only Ork passes to itself starts its description. */
+const INTERNAL = "Internal:";
+/** Whether citty was given a function that gives the value. */
+const isThunk = (value) => typeof value === "function";
+/** A value citty lets be given as is, as a promise, or as a function. */
+const resolved = (value) => Promise.resolve(isThunk(value) ? value() : value);
+/** `args` without the flags only Ork passes to itself. */
+const publicArgs = (args) => Object.fromEntries(Object.entries(args).filter(([, def]) => !(def.description ?? "").startsWith(INTERNAL)));
+/** A command's flags and positionals, which citty lets be given lazily. */
+const argsOf = (cmd) => cmd.args === void 0 ? Promise.resolve({}) : resolved(cmd.args);
+const listOf = (value) => value === void 0 ? [] : [value].flat();
+const flagOf = (name, def) => ({
+	name,
+	description: def.description ?? "",
+	takesValue: def.type === "string" || def.type === "enum",
+	aliases: "alias" in def ? listOf(def.alias) : [],
+	options: def.type === "enum" ? def.options ?? [] : [],
+	negatable: def.type === "boolean" && def.default === true
+});
+/** A command's public flags and positionals, in the order it defines them. */
+const argInfoOf = async (cmd) => {
+	const entries = Object.entries(publicArgs(await argsOf(cmd)));
+	return {
+		flags: entries.filter(([, def]) => def.type !== "positional").map(([name, def]) => flagOf(name, def)),
+		positionals: entries.filter(([, def]) => def.type === "positional").map(([name, def]) => ({
+			name,
+			description: def.description ?? ""
+		}))
+	};
+};
+/**
+* A command's subcommands, in order, loaded ones resolved. A name whose
+* definition is one listed before it (`wt`, `worktrees`'s) is an alias of that
+* one, not an entry of its own.
+*/
+const subcommandsOf = async (cmd) => {
+	const subs = cmd.subCommands === void 0 ? {} : await resolved(cmd.subCommands);
+	const loaded = await Promise.all(Object.entries(subs).map(async ([name, sub]) => {
+		const def = await resolved(sub);
+		return {
+			name,
+			def,
+			meta: def.meta === void 0 ? {} : await resolved(def.meta)
+		};
+	}));
+	const entries = [];
+	for (const { name, def, meta } of loaded) {
+		const same = entries.find((entry) => entry.def === def);
+		if (same === void 0) entries.push({
+			name,
+			aliases: listOf(meta.alias),
+			description: meta.description ?? "",
+			hidden: meta.hidden === true,
+			def
+		});
+		else same.aliases.push(name);
+	}
+	return entries;
+};
+/** The subcommand `name` (or one of its aliases) of `entries`. */
+const findEntry = (entries, name) => entries.find((entry) => entry.name === name || entry.aliases.includes(name));
+export { publicArgs as a, findEntry as i, argInfoOf as n, resolved as o, argsOf as r, subcommandsOf as s, INTERNAL as t };

package/dist/{completion-CQ2UYKuJ.mjs → completion-DIXWlnAl.mjs}

@@ -1,9 +1,10 @@
-import { Cn as liveStatus, Dr as placeFor, Er as placeFiles, U as openStore, W as storePath, _i as AGENT_DRIVERS, oi as NodeIdSchema, ut as pendingDecisions } from "./src-Dr_fTSu-.mjs";
-import { a as isBuiltinArg, i as builtinWorkflowText, r as builtinWorkflowNames } from "./builtin-files-2bHf76x-.mjs";
-import { t as findRun } from "./find-BYLlszqj.mjs";
-import { a as findEntry, c as subcommandsOf, d as SHELL_SCRIPTS, l as COMPLETE_COMMAND, n as groupedEntries, r as argInfoOf, t as groupOf, u as SHELLS } from "./help-groups-CQ98mLjF.mjs";
+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-DLsFsmOD.mjs";
+import { a as isBuiltinArg, i as builtinWorkflowText, r as builtinWorkflowNames } from "./builtin-files-yYaNTQRU.mjs";
+import { t as findRun } from "./find-k489laBa.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 { l as writeErr } from "./output-B1kwo0YU.mjs";
-import { a as resolveWorkflowArg, n as WORKFLOW_SUFFIX } from "./workflows-CW28ZU-z.mjs";
+import { a as resolveWorkflowArg, n as WORKFLOW_SUFFIX } from "./workflows-Djo1edlK.mjs";
 import path from "node:path";
 import { parse } from "yaml";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
@@ -118,6 +119,62 @@ const decisionCandidates = (store, arg, cwd, place) => {
 		description: `${decision.kind} of ${decision.runId}/${decision.node}`
 	}));
 };
+/** The registered projects, by id, with their root. */
+const projectCandidates = (store) => store.projects().map((p) => ({
+	value: p.id,
+	description: p.root
+}));
+/**
+* Whom a follow-up is for (`--for`): `agent`, `me`, a registered project as
+* `project:<id>`; a person has no list, so `person:` is left to be typed.
+*/
+const forCandidates = (store) => [
+	{
+		value: "agent",
+		description: "an agent picks it up"
+	},
+	{
+		value: "me",
+		description: "you do"
+	},
+	...(store?.projects() ?? []).map((p) => ({
+		value: `project:${p.id}`,
+		description: p.root
+	}))
+];
+/** The longest title a menu shows. */
+const TITLE_LIMIT = 60;
+/** A title as one short line: first line only, cut with an ellipsis. */
+const shortTitle = (title) => {
+	const line = (title.split("\n")[0] ?? "").trim();
+	return line.length > TITLE_LIMIT ? `${line.slice(0, 59)}…` : line;
+};
+/**
+* What `ork run --follow-ups` takes: `due` (every due agent follow-up), then
+* the project's open agent follow-ups, due before waiting, each described by
+* its title. Closed and other people's follow-ups are left out; an unreadable
+* store gives `due` only.
+*/
+const followUpCandidates = (store, place) => {
+	const open = (status) => {
+		try {
+			return (store?.followUps(place.root) ?? []).filter((f) => f.for === "agent" && f.status === status).map((f) => ({
+				value: f.id,
+				description: shortTitle(f.title)
+			}));
+		} catch {
+			return [];
+		}
+	};
+	return [
+		{
+			value: "due",
+			description: "every due agent follow-up"
+		},
+		...open("due"),
+		...open("waiting")
+	];
+};
 // src/completion/values.ts
 const withStore = (context, read) => {
 	const store = context.store();
@@ -154,7 +211,27 @@ const inputs = {
 };
 const decisions = {
 	group: "decisions",
-	values: (context) => withStore(context, (store) => decisionCandidates(store, context.given["run"], context.cwd, placeOf(context.cwd, store)))
+	values: (context) => withStore(context, (store) => decisionCandidates(store, context.given["run"] ?? context.given["run-id"], context.cwd, placeOf(context.cwd, store)))
+};
+/** A registered project's id, for `--project`; `all` too (RFC-017). */
+const projects = {
+	group: "projects",
+	values: (context) => [{
+		value: "all",
+		description: "every project"
+	}, ...withStore(context, projectCandidates)]
+};
+const forWhom = {
+	group: "for",
+	values: (context) => forCandidates(context.store())
+};
+/** `ork run --follow-ups`: `due`, then the project's open agent follow-ups. */
+const followUps = {
+	group: "follow-ups",
+	values: (context) => {
+		const store = context.store();
+		return followUpCandidates(store, placeOf(context.cwd, store));
+	}
 };
 const drivers = {
 	group: "drivers",
@@ -178,6 +255,7 @@ const shells = {
 /** Providers by argument name, or by command path and name. */
 const VALUE_PROVIDERS = {
 	run: runs,
+	"decide run-id": runs,
 	workflow: workflows,
 	files: {
 		...workflows,
@@ -186,8 +264,11 @@ const VALUE_PROVIDERS = {
 	node: nodes,
 	input: inputs,
 	"decide id": decisions,
+	"run follow-ups": followUps,
 	"completion shell": shells,
 	driver: drivers,
+	project: projects,
+	for: forWhom,
 	path: files,
 	file: files,
 	output: files

package/dist/{context-BNqDw9z1.mjs → context-Dq-VM_sq.mjs}

@@ -1,7 +1,7 @@
-import { Pr as LESSON_CAP_TOKENS, wt as explainSession } from "./src-Dr_fTSu-.mjs";
+import { Hr as LESSON_CAP_TOKENS, gt as explainSession } from "./src-DLsFsmOD.mjs";
 import { c as write, s as style } from "./output-B1kwo0YU.mjs";
-import { i as refusedBuiltin, o as workflowArg } from "./workflows-CW28ZU-z.mjs";
-import { a as formatReport, t as loadWorkflow } from "./validate-Bs_gg22g.mjs";
+import { i as refusedBuiltin, o as workflowArg } from "./workflows-Djo1edlK.mjs";
+import { a as formatReport, t as loadWorkflow } from "./validate-BS0nCccW.mjs";
 import { defineCommand } from "citty";
 // src/commands/context.ts
 /**

package/dist/{find-BYLlszqj.mjs → find-k489laBa.mjs}

@@ -1,4 +1,4 @@
-import { Dr as placeFor } from "./src-Dr_fTSu-.mjs";
+import { Fr as placeFor } from "./src-DLsFsmOD.mjs";
 import { randomUUID } from "node:crypto";
 // ../core/src/remote/find.ts
 /**
@@ -16,7 +16,7 @@ const findRun = (store, arg, cwd) => {
 		});
 		return latest === void 0 ? {
 			ok: false,
-			error: "No runs in this project yet; see `ork ps --all`."
+			error: "No runs in this project yet; see `ork ps --project all`."
 		} : {
 			ok: true,
 			run: latest

package/dist/flags-B4ZZWspN.mjs

@@ -0,0 +1,125 @@
+import "./src-DLsFsmOD.mjs";
+import { n as parseLimit, t as parseFilters } from "./parse-BzWpMN-a.mjs";
+import { t as INTERNAL } from "./command-tree-BkSYWmYJ.mjs";
+import { l as writeErr } from "./output-B1kwo0YU.mjs";
+// src/list/all-alias.ts
+/**
+* @file The deprecated `--all` of `ps`, `usage`, `decide`, `follow-ups list`
+*   and `feedback list` (RFC-017): it stands for `--project all` or `--status
+*   all`, is left out of `--help` and Tab completion (an `Internal:` flag), and
+*   warns once on stderr. `prune --all` is not this one.
+*/
+/** The hidden `--all` flag, for a command's `args`. */
+const allAlias = { all: {
+	type: "boolean",
+	description: `${INTERNAL} deprecated, use --project all or --status all`,
+	default: false
+} };
+/**
+* `args` with `all` in `--all`'s place when `--all` was given and that flag was
+* not (a given one wins); the warning prints either way. `args` as is when
+* `--all` was not given.
+*/
+const warnAll = (args, flag) => {
+	if (args["all"] !== true) return args;
+	writeErr(`--all is deprecated; use --${flag} all.`);
+	return args[flag] === void 0 ? {
+		...args,
+		[flag]: "all"
+	} : args;
+};
+// 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. `all` names the flag `--all` stands for (`project` or `status`):
+* `--all` fills it when it is not given, with one warning. `undefined` when
+* something was refused (already said, exit code set).
+*/
+const readListArgs = (table, args, options = {}) => {
+	if (refuseIdsWithJson(args)) return void 0;
+	const given = options.all === void 0 ? args : warnAll(args, options.all);
+	const parsed = parseFilters(table, given, 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(`--limit takes a positive whole number, not \`${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 };
+	const names = projects.map((p) => p.id);
+	fail(`No registered project \`${key}\`; registered: ${names.length === 0 ? "none" : names.join(", ")}.`);
+};
+export { refuseIdsWithJson as a, readListArgs as i, filterArgs as n, allAlias as o, projectScope as r, fail as t };

package/dist/{follow-ups-B4GJ3Vzw.mjs → follow-ups-DD8NTPe6.mjs}

@@ -1,10 +1,13 @@
-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 { Fr as placeFor, Ht as followUpListTable, hn as recordPublished, mn as markDue, nr as runGh, vn as deliverFollowUp, yn as followUpProblem } from "./src-DLsFsmOD.mjs";
+import { d as followUpsRule, f as refreshDue, n as flagValues } from "./run-OOWQIKMJ.mjs";
+import { g as changeFollowUp, v as findFollowUp, x as isGithubIssueUrl, y as followUpActions } from "./__build_info__-C1Nm0hlJ.mjs";
+import { t as postFollowUpMessage } from "./post-2CaJz_mV.mjs";
+import { t as applyFilters } from "./apply-Mb0fNpCX.mjs";
+import { t as findRun } from "./find-k489laBa.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 { i as readListArgs, n as filterArgs, o as allAlias } from "./flags-B4ZZWspN.mjs";
+import { t as printList } from "./print-n2qetUHc.mjs";
+import { t as withStore } from "./store-DACH768X.mjs";
 import { homedir } from "node:os";
 import { defineCommand } from "citty";
 // src/follow-ups/command.ts
@@ -53,6 +56,20 @@ const inProject = (key, body) => withStore(async (store) => {
 	});
 	await body(store, place);
 });
+/**
+* Like `inProject`, for a list: `key` may be `all`, which gives every
+* registered project's place. The due check runs for each.
+*/
+const inProjects = (key, body) => withStore(async (store) => {
+	const projects = store.projects();
+	const places = key === "all" ? projects.map((p) => placeFor(p.root, projects)) : [placeOf(store, key)];
+	if (places.includes(void 0)) return;
+	const found = places.filter((place) => place !== void 0);
+	await Promise.all(found.map((place) => refreshDue(store, place.root, (line) => {
+		writeErr(style("dim", line));
+	})));
+	await body(store, found);
+});
 /** 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);
@@ -90,6 +107,7 @@ const FOR_ORDER = [
 	"person:"
 ];
 const forOrder = (value) => FOR_ORDER.findIndex((prefix) => value.startsWith(prefix));
+/** The list's order within a status: by who it is for. */
 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));
@@ -213,7 +231,7 @@ const post = defineCommand({
 		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.");
+			writeErr("Run again with --confirm to post it.");
 			return;
 		}
 		const posted = await postFollowUpMessage(followUp, {
@@ -325,7 +343,7 @@ const add = defineCommand({
 		},
 		to: {
 			type: "string",
-			description: "A message: who it is to"
+			description: "A message: who it is to (default: the person); for --channel github, the issue or PR URL"
 		},
 		channel: {
 			type: "string",
@@ -354,6 +372,14 @@ const add = defineCommand({
 			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;
 		}
+		if (kind === "message" && args.text === void 0) {
+			fail("a message needs --text.");
+			return;
+		}
+		if (args.channel === "github" && !isGithubIssueUrl(args.to ?? "")) {
+			fail("--channel github needs --to <the issue or pull request URL>, https://github.com/<owner>/<repo>/(issues|pull)/<n>.");
+			return;
+		}
 		const steps = flagValues(rawArgs, "--step").map((raw) => stepOf(raw));
 		const input = {
 			title: args.title,
@@ -404,6 +430,15 @@ const add = defineCommand({
 *   `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.
 */
+/** What a list with no `--status` shows. */
+const OPEN = /* @__PURE__ */ new Set(["due", "waiting"]);
+/** The list's own order: due first, then waiting, done, dropped; then `byFor`. */
+const RANK = {
+	due: 0,
+	waiting: 1,
+	done: 2,
+	dropped: 3
+};
 const followUps = defineCommand({
 	meta: {
 		name: "follow-ups",
@@ -416,23 +451,23 @@ const followUps = defineCommand({
 				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
+				...filterArgs(followUpListTable),
+				...allAlias
 			},
-			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);
-			})
+			run: async ({ args }) => {
+				const given = args;
+				const asked = readListArgs(followUpListTable, given, { all: "status" });
+				if (asked === void 0) return;
+				const { filter, limit } = asked;
+				const status = filter["status"];
+				await inProjects(filter["project"], (store, places) => {
+					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) => {
+						for (const line of formatFollowUps(rows, status !== void 0)) write(line);
+					});
+				});
+			}
 		}),
 		show: defineCommand({
 			meta: {

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

@@ -1,4 +1,4 @@
-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 { An as liveStatus, Nn as runStatus, Pn as slotWaitsOf, Rn as isItem, jn as lockWaitsOf, kt as lockWaitLine } from "./src-DLsFsmOD.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";
@@ -180,6 +180,18 @@ const stateText = (node) => {
 	}
 	return node.state;
 };
+/** A node's counted tokens: input, output and cache write. */
+const countedOf = (node) => node.inputTokens + node.outputTokens + (node.cacheWriteTokens ?? 0);
+/**
+* What a node spent: its counted tokens, then dollars unless its driver reports
+* none, where `$0.00` would be false. Blank with no tokens.
+*/
+const worth = (node) => {
+	const counted = countedOf(node);
+	if (counted === 0) return "";
+	const tok = `${count(counted)} tok`;
+	return style("dim", `  ${node.unpriced === true ? tok : `${tok} · ${cost(node.costUsd)}`}`);
+};
 /**
 * 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
@@ -188,8 +200,9 @@ const stateText = (node) => {
 const formatTree = (roots, now = Date.now(), waits = []) => {
 	const lines = [];
 	const walk = (node, lead, branch) => {
+		const named = node.description === void 0 ? "" : `  ${node.description}`;
 		lines.push({
-			label: `${lead}${branch}${node.id}`,
+			label: `${lead}${branch}${node.id}${named}`,
 			node
 		});
 		const next = lead + (branch === "├─ " ? "│  " : branch === "" ? "" : "   ");
@@ -201,11 +214,11 @@ const formatTree = (roots, now = Date.now(), waits = []) => {
 	const label = Math.max(...lines.map((l) => l.label.length));
 	const type = Math.max(...lines.map((l) => l.node.type.length));
 	return lines.map(({ label: text, node }) => {
-		const usage = node.inputTokens + node.outputTokens === 0 ? "" : style("dim", `  ${count(node.inputTokens)} in / ${count(node.outputTokens)} out · ${cost(node.costUsd)}`);
+		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 `${text.padEnd(label)}  ${style("dim", node.type.padEnd(type))}  ${state}${spent}${usage}`;
+		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}`;
 	});
 };
 /**