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

package/dist/{brief-za0ozN_E.mjs → brief-BvMtIFio.mjs}

@@ -1,8 +1,8 @@
-import { un as takeFollowUps } from "./src-Dr_fTSu-.mjs";
-import { l as briefOf, n as flagValues, u as checkTakeable } from "./run--4-1xAF2.mjs";
-import { n as newRunId } from "./find-BYLlszqj.mjs";
+import { gn as takeFollowUps } from "./src-DN-RPsil.mjs";
+import { l as briefOf, n as flagValues, u as checkTakeable } from "./run-B-j3Qxqc.mjs";
+import { n as newRunId } from "./find-mLYsR0uC.mjs";
 import { l as writeErr } from "./output-B1kwo0YU.mjs";
-import { t as loadWorkflow } from "./validate-Bs_gg22g.mjs";
+import { t as loadWorkflow } from "./validate-BVrT43GO.mjs";
 // src/follow-ups/brief.ts
 /**
 * @file `ork run --follow-ups <ids>`: the `agent` follow-ups become the run's

package/dist/{builtin-files-2bHf76x-.mjs → builtin-files-BRSOObAv.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 writePlainFile, Nr as placeFiles, Ur as guardedBase, Wr as plainPathInside } from "./src-DN-RPsil.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-Cgb2qPPh.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 { L as openStore, Nr as placeFiles, Pr as placeFor, R as storePath, kn as liveStatus, pi as NodeIdSchema, rt as pendingDecisions, wi as AGENT_DRIVERS } from "./src-DN-RPsil.mjs";
+import { a as isBuiltinArg, i as builtinWorkflowText, r as builtinWorkflowNames } from "./builtin-files-BRSOObAv.mjs";
+import { t as findRun } from "./find-mLYsR0uC.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-Bvl2Fquu.mjs";
 import path from "node:path";
 import { parse } from "yaml";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
@@ -118,6 +119,29 @@ 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
+	}))
+];
 // src/completion/values.ts
 const withStore = (context, read) => {
 	const store = context.store();
@@ -154,7 +178,19 @@ 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())
 };
 const drivers = {
 	group: "drivers",
@@ -178,6 +214,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,
@@ -188,6 +225,8 @@ const VALUE_PROVIDERS = {
 	"decide id": decisions,
 	"completion shell": shells,
 	driver: drivers,
+	project: projects,
+	for: forWhom,
 	path: files,
 	file: files,
 	output: files

package/dist/{context-BNqDw9z1.mjs → context-BN9A2Nnu.mjs}

@@ -1,7 +1,7 @@
-import { Pr as LESSON_CAP_TOKENS, wt as explainSession } from "./src-Dr_fTSu-.mjs";
+import { Vr as LESSON_CAP_TOKENS, gt as explainSession } from "./src-DN-RPsil.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-Bvl2Fquu.mjs";
+import { a as formatReport, t as loadWorkflow } from "./validate-BVrT43GO.mjs";
 import { defineCommand } from "citty";
 // src/commands/context.ts
 /**

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

@@ -1,4 +1,4 @@
-import { Dr as placeFor } from "./src-Dr_fTSu-.mjs";
+import { Pr as placeFor } from "./src-DN-RPsil.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-CdgIH1L6.mjs

@@ -0,0 +1,230 @@
+import "./src-DN-RPsil.mjs";
+import { t as INTERNAL } from "./command-tree-BkSYWmYJ.mjs";
+import { l as writeErr } from "./output-B1kwo0YU.mjs";
+// ../core/src/list-filters/time.ts
+/**
+* @file The times every list's `--since` and `--until` take (specs/usage.md,
+*   RFC-017), and `ork prune --older-than`'s age: an age (`24h`, `30d`, `12w`)
+*   or a day (`2026-11-01`, in the machine's time zone).
+*/
+const UNITS = {
+	h: 36e5,
+	d: 864e5,
+	w: 6048e5
+};
+/** `30d`, `12w`, `24h` before `now`, as an ISO time; `null` when it is not one. */
+const agoTime = (text, now) => {
+	const match = /^(\d+)([hdw])$/u.exec(text);
+	if (match === null) return null;
+	const [, amount = "0", unit = "d"] = match;
+	if (Number(amount) === 0) return null;
+	const date = new Date(now - Number(amount) * (UNITS[unit] ?? 0));
+	return Number.isNaN(date.getTime()) ? null : date.toISOString();
+};
+/** A `YYYY-MM-DD` day's start in the machine's time zone, `after` days on. */
+const dayTime = (text, after) => {
+	const match = /^(\d{4})-(\d{2})-(\d{2})$/u.exec(text);
+	if (match === null) return null;
+	const [, year = "", month = "", day = ""] = match;
+	const start = new Date(Number(year), Number(month) - 1, Number(day));
+	if (start.getMonth() !== Number(month) - 1) return null;
+	if (start.getDate() !== Number(day)) return null;
+	start.setDate(start.getDate() + after);
+	return start.toISOString();
+};
+/** The start of the day `days` whole days ago, counting today as one. */
+const wholeDays = (days, now) => {
+	const today = new Date(now);
+	return new Date(today.getFullYear(), today.getMonth(), today.getDate() - (days - 1)).toISOString();
+};
+/**
+* `--since`: an age or the day it starts from. Days and weeks are whole days,
+* today among them, as the Usage panel counts them; hours are exact.
+*/
+const sinceTime = (text, now) => {
+	const ago = agoTime(text, now);
+	if (ago === null) return dayTime(text, 0);
+	if (text.endsWith("h")) return ago;
+	const amount = Number(text.slice(0, -1));
+	return wholeDays(text.endsWith("w") ? amount * 7 : amount, now);
+};
+/** `--until`: the last day it includes. */
+const untilTime = (text) => dayTime(text, 1);
+// ../core/src/list-filters/parse.ts
+/**
+* @file Reads a list's filter flags against its field table (RFC-017): each
+*   value checked, times turned into ISO times, and `--limit`.
+*/
+const FOR = /^(agent|me|(project|person):\S+)$/u;
+/** The field's value, checked; `null` when the field does not take it. */
+const valueOf = (field, text, now) => {
+	if (text === "all" && field.all === true) return "all";
+	return {
+		enum: () => field.values?.includes(text) === true ? text : null,
+		text: () => text === "" ? null : text,
+		for: () => FOR.test(text) ? text : null,
+		since: () => sinceTime(text, now),
+		until: () => untilTime(text)
+	}[field.type]();
+};
+/** What the field takes, for the error that refuses a value. */
+const takes = (field) => {
+	const all = field.all === true ? ["all"] : [];
+	const or = all.length === 0 ? "" : " or all";
+	return {
+		enum: `one of ${[...field.values ?? [], ...all].join(", ")}`,
+		text: `a value${or}`,
+		for: "agent, me, project:<name> or person:<name>",
+		since: `an age (30d), a day (2026-11-01)${or}`,
+		until: "a day (2026-11-01)"
+	}[field.type];
+};
+/**
+* The filter `given` (a command's parsed flags, by field name) asks for, each
+* value checked against `table`; `now` dates an age. The first value a field
+* does not take is refused, naming the flag and what it takes.
+*/
+const parseFilters = (table, given, now) => {
+	const filter = {};
+	for (const field of table.fields) {
+		const text = given[field.name];
+		if (typeof text !== "string") continue;
+		const value = valueOf(field, text, now);
+		if (value === null) return {
+			ok: false,
+			error: `--${field.name} takes ${takes(field)}, not \`${text}\`.`
+		};
+		filter[field.name] = value;
+	}
+	return {
+		ok: true,
+		filter
+	};
+};
+/** `--limit`: a positive whole number, else `null` (`0`, `-1`, `abc`, `2.5`). */
+const parseLimit = (text) => {
+	if (!/^[1-9]\d*$/u.test(text)) return null;
+	const limit = Number(text);
+	return Number.isSafeInteger(limit) ? limit : null;
+};
+// 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, agoTime as s, fail as t };

package/dist/{follow-ups-B4GJ3Vzw.mjs → follow-ups-DxCsOby1.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 { Pr as placeFor, Vt as followUpListTable, _n as deliverFollowUp, mn as recordPublished, pn as markDue, tr as runGh, vn as followUpProblem } from "./src-DN-RPsil.mjs";
+import { d as followUpsRule, f as refreshDue, n as flagValues } from "./run-B-j3Qxqc.mjs";
+import { g as changeFollowUp, v as findFollowUp, x as isGithubIssueUrl, y as followUpActions } from "./__build_info__-DcRdK0Du.mjs";
+import { t as postFollowUpMessage } from "./post-C9soCx7i.mjs";
+import { t as applyFilters } from "./apply-Mb0fNpCX.mjs";
+import { i as readListArgs, n as filterArgs, o as allAlias } from "./flags-CdgIH1L6.mjs";
+import { t as findRun } from "./find-mLYsR0uC.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 { t as printList } from "./print-BaWiWf4v.mjs";
+import { t as withStore } from "./store-Dyr1mP8K.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-hiDvtNGM.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 lockWaitsOf, Ln as isItem, Mn as runStatus, Nn as slotWaitsOf, kn as liveStatus, kt as lockWaitLine } from "./src-DN-RPsil.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}`;
 	});
 };
 /**