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

package/dist/brief-za0ozN_E.mjs

@@ -0,0 +1,58 @@
+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 { l as writeErr } from "./output-B1kwo0YU.mjs";
+import { t as loadWorkflow } from "./validate-Bs_gg22g.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.
+*/
+/** The ids `--follow-ups` was given, one per comma or repeat. */
+const idsOf = (rawArgs) => flagValues(rawArgs, "--follow-ups").flatMap((value) => value.split(",")).map((id) => id.trim()).filter((id) => id !== "");
+/**
+* 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 = (store, rawArgs, runId, target) => {
+	const inputs = flagValues(rawArgs, "--input");
+	const ids = idsOf(rawArgs);
+	const plain = {
+		inputs,
+		...runId === void 0 ? {} : { runId }
+	};
+	if (ids.length === 0) return plain;
+	const loaded = loadWorkflow(target.file, process.cwd(), void 0, store.projects());
+	if (loaded.workflow === null) return plain;
+	const takeable = checkTakeable(store, loaded.place.root, ids);
+	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 taker = runId ?? newRunId(store);
+	takeFollowUps(store, {
+		project: loaded.place.root,
+		run: taker,
+		ids: takeable.followUps.map((f) => f.id)
+	});
+	return {
+		inputs: [...inputs, `brief=${briefOf(takeable.followUps)}`],
+		runId: taker
+	};
+};
+export { prepareFollowUps };

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

@@ -1,4 +1,4 @@
-import { Cr as guardedBase, Tr as writePlainFile, pr as placeFiles, wr as plainPathInside } from "./src-tsuZRu0H.mjs";
+import { Er as placeFiles, Ir as guardedBase, Lr as plainPathInside, Rr as writePlainFile } from "./src-Dr_fTSu-.mjs";
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { createHash } from "node:crypto";

package/dist/{completion--ywde-56.mjs → completion-CQ2UYKuJ.mjs}

@@ -1,9 +1,9 @@
-import { U as openStore, Ut as liveStatus, W as storePath, ii as AGENT_DRIVERS, mr as placeFor, pr as placeFiles, qr as NodeIdSchema, ut as pendingDecisions } from "./src-tsuZRu0H.mjs";
-import { a as isBuiltinArg, i as builtinWorkflowText, r as builtinWorkflowNames } from "./builtin-files-Bdq23IIi.mjs";
-import { t as findRun } from "./find-BVX-bL4u.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-CpR2UzSn.mjs";
+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 writeErr } from "./output-B1kwo0YU.mjs";
-import { a as resolveWorkflowArg, n as WORKFLOW_SUFFIX } from "./workflows-B30QkwTk.mjs";
+import { a as resolveWorkflowArg, n as WORKFLOW_SUFFIX } from "./workflows-CW28ZU-z.mjs";
 import path from "node:path";
 import { parse } from "yaml";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";

package/dist/context-BNqDw9z1.mjs

@@ -0,0 +1,106 @@
+import { Pr as LESSON_CAP_TOKENS, wt as explainSession } from "./src-Dr_fTSu-.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 { defineCommand } from "citty";
+// src/commands/context.ts
+/**
+* @file `ork context explain <wf> <node>`: what one node's session would load,
+*   layer by layer, as core's `explainSession` plans it without writing
+*   anything (one of Ork's own `ork:` workflows is written into the project's
+*   run folder first, as `ork run` does): its project instructions, every skill
+*   with the layer it came from and whether it is live, shadowed or switched
+*   off, its context files, its practices, and estimated tokens.
+*/
+/** Loads a workflow file and plans one node's session in it, in place. */
+const explainNode = (file, nodeId, cwd, home) => {
+	const { report, workflow, graph, place, workflowDir } = loadWorkflow(file, cwd, home);
+	if (workflow === null) return {
+		ok: false,
+		lines: formatReport(report)
+	};
+	const result = explainSession(workflow, graph, nodeId, {
+		root: place.root,
+		orkDir: place.dir,
+		workflowDir,
+		...home === void 0 ? {} : { home }
+	});
+	return result.ok ? result : {
+		ok: false,
+		lines: [result.error]
+	};
+};
+const approx = (count) => style("dim", `≈${count.toLocaleString("en")} tokens`);
+const formatExplanation = (e) => {
+	const width = Math.max(8, ...e.skills.map((s) => s.name.length));
+	const sourceWidth = Math.max(0, ...e.skills.map((s) => s.source.length));
+	const lines = [
+		`${style("bold", e.node)} ${style("dim", `(${e.type}) in ${e.workflow}`)}${e.template === void 0 ? "" : style("dim", `, planned as ${e.template}, the node it was spawned from`)}`,
+		"",
+		...e.agent === void 0 ? [] : [`${style("bold", "Agent")}  ${e.agent.name} ${style("dim", `(${e.agent.where})`)}  ${approx(e.agent.tokens)}`],
+		`${style("bold", "Instructions")}  ${e.instructions}`,
+		"",
+		style("bold", "Skills")
+	];
+	if (e.skills.length === 0) lines.push(style("dim", "  none"));
+	for (const s of e.skills) {
+		const mark = s.state === "live" ? style("green", "✓") : style("dim", "−");
+		const state = s.why === void 0 ? approx(s.tokens).replace("tokens", "tokens when used") : style("yellow", `off: ${s.why}`);
+		lines.push(`  ${mark} ${s.name.padEnd(width)}  ${s.layer.padEnd(8)}  ${style("dim", s.source.padEnd(sourceWidth))}  ${state}`);
+	}
+	lines.push("", style("bold", "Context files"));
+	if (e.files.length === 0) lines.push(style("dim", "  none"));
+	for (const f of e.files) {
+		const cut = f.cutFrom === void 0 ? "" : `  ${style("yellow", `cut at the ${LESSON_CAP_TOKENS.toLocaleString("en")}-token cap; the whole file is ${approx(f.cutFrom)}`)}`;
+		lines.push(`  ${f.layer.padEnd(8)}  ${f.name}  ${approx(f.tokens)}${cut}`);
+	}
+	lines.push("", style("bold", "Practices"));
+	for (const p of e.practices) lines.push(`  ${p.name.padEnd(8)}  ${approx(p.tokens)}`);
+	for (const name of e.skippedPractices) lines.push(`  ${name.padEnd(8)}  ${style("dim", "the project's own skill wins")}`);
+	if (e.practices.length === 0 && e.skippedPractices.length === 0) lines.push(style("dim", "  off"));
+	lines.push("", `Appended to Claude Code's system prompt: ${approx(e.appendedTokens)}`);
+	return lines;
+};
+const explain = defineCommand({
+	meta: {
+		name: "explain",
+		description: "Show what one node's session loads, layer by layer"
+	},
+	args: {
+		workflow: {
+			type: "positional",
+			description: "A workflow file, the name of one in the project's workflows (.ork/workflows/), or one of Ork's own (ork:feedback-apply)",
+			required: true
+		},
+		node: {
+			type: "positional",
+			description: "Node id",
+			required: true
+		},
+		json: {
+			type: "boolean",
+			description: "Print JSON",
+			default: false
+		}
+	},
+	run: ({ args }) => {
+		const cwd = process.cwd();
+		if (refusedBuiltin([args.workflow], cwd)) return;
+		const result = explainNode(workflowArg(args.workflow, cwd).file, args.node, cwd);
+		if (!result.ok) {
+			for (const line of result.lines) process.stderr.write(`${line}\n`);
+			process.exitCode = 1;
+			return;
+		}
+		if (args.json) write(JSON.stringify(result.explanation, void 0, 2));
+		else for (const line of formatExplanation(result.explanation)) write(line);
+	}
+});
+const context = defineCommand({
+	meta: {
+		name: "context",
+		description: "Inspect the context Ork compiles for each node"
+	},
+	subCommands: { explain }
+});
+export { explainNode as n, context as t };

package/dist/{find-BVX-bL4u.mjs → find-BYLlszqj.mjs}

@@ -1,4 +1,4 @@
-import { mr as placeFor } from "./src-tsuZRu0H.mjs";
+import { Dr as placeFor } from "./src-Dr_fTSu-.mjs";
 import { randomUUID } from "node:crypto";
 // ../core/src/remote/find.ts
 /**

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 };