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

package/dist/brief-BvMtIFio.mjs

@@ -0,0 +1,58 @@
+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-BVrT43GO.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-BRSOObAv.mjs}

@@ -1,4 +1,4 @@
-import { Cr as guardedBase, Tr as writePlainFile, pr as placeFiles, wr as plainPathInside } from "./src-tsuZRu0H.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--ywde-56.mjs → completion-Cgb2qPPh.mjs}

@@ -1,9 +1,10 @@
-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 { 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-B30QkwTk.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-BN9A2Nnu.mjs

@@ -0,0 +1,106 @@
+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-Bvl2Fquu.mjs";
+import { a as formatReport, t as loadWorkflow } from "./validate-BVrT43GO.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-mLYsR0uC.mjs}

@@ -1,4 +1,4 @@
-import { mr as placeFor } from "./src-tsuZRu0H.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 };