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

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

@@ -113,68 +113,6 @@ complete -c ork -f -a '(__ork_complete)'
 };
 /** The shells there is a script for. */
 const SHELLS = Object.keys(SHELL_SCRIPTS);
-// 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));
 // src/help-groups.ts
 const HELP_GROUPS = [
 	{
@@ -373,4 +311,4 @@ const groupedEntries = (entries) => {
 		entries: other
 	}].filter((group) => group.entries.length > 0);
 };
-export { findEntry as a, subcommandsOf as c, SHELL_SCRIPTS as d, argsOf as i, COMPLETE_COMMAND as l, groupedEntries as n, publicArgs as o, argInfoOf as r, resolved as s, groupOf as t, SHELLS as u };
+export { SHELL_SCRIPTS as a, SHELLS as i, groupedEntries as n, COMPLETE_COMMAND as r, groupOf as t };

package/dist/in-a-run-D_9GlAlS.mjs

@@ -0,0 +1,27 @@
+import { R as storePath } from "./src-DLsFsmOD.mjs";
+import { g as storeGuarded, h as runMarkerIn } from "./src-DmmrX2_C.mjs";
+// src/commands/in-a-run.ts
+/**
+* @file The commands that act as the user refuse a program or an agent in a run
+*   (ADR-047), in the stores that run guards: the store of a nested run under a
+*   temp HOME is not guarded unless an enclosing run lists it. The refusal
+*   names the variable it saw, for someone at their own terminal who inherited
+*   it. It stops accidents; it is not a boundary.
+*/
+const refusal = (why, env, store) => {
+	const marker = runMarkerIn(env);
+	return marker === null || !storeGuarded(env, store) ? null : `${why} ${marker} is set here. If this is your own terminal, it inherited that from a program in a run (a tmux server started by one, say); open a shell without it.`;
+};
+/** Why `ork watch --accept` refuses here, or `null` when it may run. */
+const acceptRefusal = (env = process.env, store = storePath()) => refusal("`ork watch --accept` approves code to run with nobody there, so a program or an agent in a run cannot use it.", env, store);
+/** Why `ork chat` refuses here, or `null` when it may run. */
+const chatRefusal = (env = process.env, store = storePath()) => refusal("`ork chat` speaks as you, so a program or an agent in a run cannot use it. A program writes to a session with `ork send`.", env, store);
+/** Why `ork decide` will not answer here, or `null` when it may. */
+const decideRefusal = (env = process.env, store = storePath()) => refusal("`ork decide` answers as you, so a program or an agent in a run cannot answer with it; `ork decide --list` still shows what is open.", env, store);
+/** Why `ork continue` refuses here, or `null` when it may run. */
+const continueRefusal = (env = process.env, store = storePath()) => refusal("`ork continue` undoes a pause you set, so a program or an agent in a run cannot use it.", env, store);
+/** Whether `ork ui` may print its sign-in link, which acts as the user. */
+const mayShowSignIn = (env = process.env, store = storePath()) => !storeGuarded(env, store);
+/** Why `ork attach` will not answer here, or `null` when it may. */
+const attachRefusal = (env = process.env, store = storePath()) => refusal("`ork attach` answers as you, so a program or an agent in a run cannot use it; `ork logs` still shows the run.", env, store);
+export { decideRefusal as a, continueRefusal as i, attachRefusal as n, mayShowSignIn as o, chatRefusal as r, acceptRefusal as t };

package/dist/{install-DWtXTq4y.mjs → install-PVlV2QPq.mjs}

@@ -1,4 +1,4 @@
-import { Dr as placeFor, Er as placeFiles, Fr as estimateTokens, Gn as FEEDBACK_SEVERITIES, Ir as guardedBase, Lr as plainPathInside, Mr as inside, Pr as LESSON_CAP_TOKENS, Rr as writePlainFile, Wn as FEEDBACK_KINDS, Zn as publishPost, er as fingerprint, fr as maskSecrets, nr as targetOf } from "./src-Dr_fTSu-.mjs";
+import { Br as inside, Fr as placeFor, Gr as plainPathInside, Hr as LESSON_CAP_TOKENS, Kr as writePlainFile, Pr as placeFiles, Qn as FEEDBACK_SEVERITIES, Ur as estimateTokens, Wr as guardedBase, Zn as FEEDBACK_KINDS, ir as publishPost, lr as targetOf, sr as fingerprint, yr as maskSecrets } from "./src-DLsFsmOD.mjs";
 import path from "node:path";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { spawn } from "node:child_process";

package/dist/{limits-B1qzS4cX.mjs → limits-CHqBO7wb.mjs}

@@ -1,4 +1,4 @@
-import { C as capsHere, bt as limitsReport, vt as NOT_STARTED, yt as limitsNow } from "./src-Dr_fTSu-.mjs";
+import { _ as capsHere, dt as NOT_STARTED, ft as limitsNow, pt as limitsReport } from "./src-DLsFsmOD.mjs";
 // src/run/limits.ts
 /**
 * @file The limits across runs that apply here (RFC-007): the user's settings

package/dist/{mcp-BOrVkyhN.mjs → mcp-D38Ajb0b.mjs}

@@ -1,8 +1,8 @@
-import { A as isNewer } from "./src-Dr_fTSu-.mjs";
-import { n as ORK_VERSION } from "./__build_info__-Bsb1kjgF.mjs";
-import { p as runMarkerIn } from "./src-DcrhgipG.mjs";
-import { n as explainNode } from "./context-BNqDw9z1.mjs";
-import { a as openMcp, c as refused, o as tool, s as answer } from "./src-DQKz2eOH.mjs";
+import { w as isNewer } from "./src-DLsFsmOD.mjs";
+import { n as ORK_VERSION } from "./__build_info__-C1Nm0hlJ.mjs";
+import { h as runMarkerIn } from "./src-DmmrX2_C.mjs";
+import { n as explainNode } from "./context-Dq-VM_sq.mjs";
+import { a as openMcp, c as refused, o as tool, s as answer } from "./src-DOjTY2ET.mjs";
 import { z } from "zod";
 import { defineCommand } from "citty";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -43,7 +43,7 @@ const orkMcpServer = (options = {}) => {
 		...options.script === void 0 ? {} : { script: options.script }
 	});
 	const all = [...opened.tools, explainTool(opened, options.home)];
-	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.15") ? tooOld(all, options.expects) : all;
+	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.17") ? tooOld(all, options.expects) : all;
 	const server = new McpServer({
 		name: "ork",
 		version: ORK_VERSION

package/dist/{once-C1fL3GVo.mjs → once-DuUzpzL2.mjs}

@@ -1,7 +1,7 @@
-import "./src-Dr_fTSu-.mjs";
-import { t as runOnce } from "./run-CiPsW9Kf.mjs";
+import "./src-DLsFsmOD.mjs";
+import { t as runOnce } from "./run-BfxdsQJk.mjs";
 import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
-import { t as ago } from "./format-C8MsFj8_.mjs";
+import { t as ago } from "./format-DQc9A_ei.mjs";
 import { spawn } from "node:child_process";
 import { defineCommand, parseArgs } from "citty";
 // src/commands/once.ts

package/dist/parse-BzWpMN-a.mjs

@@ -0,0 +1,107 @@
+// ../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;
+};
+export { parseLimit as n, agoTime as r, parseFilters as t };

package/dist/{pause-DOMK-R8V.mjs → pause-Bx3ePGrn.mjs}

@@ -1,7 +1,7 @@
-import { U as openStore, bn as requestPause, yn as requestContinue } from "./src-Dr_fTSu-.mjs";
-import { t as findRun } from "./find-BYLlszqj.mjs";
+import { Dn as requestPause, En as requestContinue, L as openStore } from "./src-DLsFsmOD.mjs";
+import { t as findRun } from "./find-k489laBa.mjs";
 import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
-import { i as continueRefusal } from "./in-a-run-Bp0k0J09.mjs";
+import { i as continueRefusal } from "./in-a-run-D_9GlAlS.mjs";
 import { defineCommand } from "citty";
 // src/commands/pause.ts
 /**

package/dist/{post-BzA6Qobq.mjs → post-2CaJz_mV.mjs}

@@ -1,11 +1,13 @@
-import { Qn as redact } from "./src-Dr_fTSu-.mjs";
+import { ar as redact } from "./src-DLsFsmOD.mjs";
+import { b as githubDraftRefusal } from "./__build_info__-C1Nm0hlJ.mjs";
 // ../core/src/follow-ups/post.ts
 /** Posts `f`'s draft as a GitHub comment once `confirmed`, and marks it done. */
 const postFollowUpMessage = async (f, options) => {
 	const draft = f.draft;
-	if (f.kind !== "message" || draft?.channel !== "github") return {
+	const refused = githubDraftRefusal(f);
+	if (refused !== void 0 || draft === void 0) return {
 		ok: false,
-		error: "only a message drafted for the github channel is posted; send the others yourself"
+		error: refused?.error ?? "it has no draft"
 	};
 	if (!options.confirmed) return {
 		ok: false,

package/dist/print-n2qetUHc.mjs

@@ -0,0 +1,19 @@
+import { c as write } from "./output-B1kwo0YU.mjs";
+import { a as refuseIdsWithJson } from "./flags-B4ZZWspN.mjs";
+// src/list/print.ts
+/**
+* Prints `rows`: `--ids` their ids (`table.id`) comma-separated; `--json` the
+* rows (or `json(rows)`); else `human(rows)`, which also says what an empty
+* list is. `--ids` with `--json` is refused (said, exit code set).
+*/
+const printList = (rows, table, args, human, json = (shown) => shown) => {
+	if (refuseIdsWithJson(args)) return;
+	if (args.ids === true) {
+		const id = table.id;
+		if (id !== void 0 && rows.length > 0) write(rows.map((row) => id(row)).join(","));
+		return;
+	}
+	if (args.json === true) write(JSON.stringify(json(rows), void 0, 2));
+	else human(rows);
+};
+export { printList as t };

package/dist/project-records-Cune1l6I.mjs

@@ -0,0 +1,230 @@
+import { Ir as projectsHome, L as openStore, Mr as inRepoPlace, Nr as newProjectId, Pr as placeFiles, Rr as shownPath, Vr as projectRootOf, jr as hasInRepoFiles } from "./src-DLsFsmOD.mjs";
+import { C as termOf, c as write, l as writeErr, s as style, w as cut } from "./output-B1kwo0YU.mjs";
+import { n as chip } from "./chips-BqcT58qr.mjs";
+import path from "node:path";
+import { existsSync, mkdirSync, realpathSync, statSync } from "node:fs";
+import { defineCommand } from "citty";
+// src/project/register.ts
+/**
+* @file Registering projects (ADR-035): `ork register` attaches a repository
+*   from outside it, with its workflows, rules and runs in
+*   `~/.ork/projects/<id>/` and nothing written into the repository; `ork init`
+*   records an in-repo project, whose files are its `.ork/`.
+*/
+const ID = /^[a-z0-9][a-z0-9._-]*$/u;
+/** The git root of `target`'s main clone, or why there is none. */
+const cloneOf = (target) => {
+	if (!existsSync(target)) return {
+		ok: false,
+		error: `${target} does not exist`
+	};
+	const root = projectRootOf(realpathSync(target));
+	const dotGit = path.join(root, ".git");
+	if (!existsSync(dotGit)) return {
+		ok: false,
+		error: `${target} is not in a git repository`
+	};
+	if (statSync(dotGit).isFile()) return {
+		ok: false,
+		error: `${root} is a git worktree; register the main clone instead`
+	};
+	return {
+		ok: true,
+		root
+	};
+};
+/**
+* Attaches the repository at `target`: creates `~/.ork/projects/<id>/workflows`
+* and records the project. Registering it again returns the same project.
+*/
+const registerProject = (store, target, options = {}) => {
+	const clone = cloneOf(target);
+	if (!clone.ok) return clone;
+	const { root } = clone;
+	const projects = store.projects();
+	const existing = projects.find((p) => p.root === root);
+	if (existing?.mode === "attached") return {
+		ok: true,
+		project: existing,
+		created: false
+	};
+	if (existing !== void 0 || hasInRepoFiles(root)) return {
+		ok: false,
+		error: `${root} keeps Ork's files in its own .ork/ (in-repo), so it is not attached`
+	};
+	const taken = projects.map((p) => p.id);
+	if (options.id !== void 0) {
+		if (!ID.test(options.id)) return {
+			ok: false,
+			error: `--id \`${options.id}\` must be lowercase letters, digits, ".", "_" or "-"`
+		};
+		if (taken.includes(options.id)) return {
+			ok: false,
+			error: `a project is already registered as ${options.id}`
+		};
+	}
+	const id = options.id ?? newProjectId(root, taken);
+	const project = {
+		id,
+		root,
+		mode: "attached",
+		dir: path.join(projectsHome(options.home), id)
+	};
+	mkdirSync(placeFiles(project).workflows, { recursive: true });
+	return {
+		ok: true,
+		project: store.addProject(project),
+		created: true
+	};
+};
+/**
+* Records the in-repo project at `cwd`'s git root, if it is not registered yet;
+* an attached one stays attached (`ork init` must not take it over).
+*/
+const recordInRepo = (store, cwd) => {
+	const root = projectRootOf(realpathSync(cwd));
+	const projects = store.projects();
+	const existing = projects.find((p) => p.root === root);
+	if (existing?.mode === "attached") return {
+		ok: false,
+		error: `${root} is attached: its workflows are in ${shownPath(existing.dir, root)}, and Ork writes nothing into the repository`
+	};
+	if (existing !== void 0) return {
+		ok: true,
+		project: existing,
+		created: false
+	};
+	const project = {
+		...inRepoPlace(root),
+		id: newProjectId(root, projects.map((p) => p.id))
+	};
+	return {
+		ok: true,
+		project: store.addProject(project),
+		created: true
+	};
+};
+/**
+* Points a registered project at its clone's new place, after the clone was
+* moved or renamed; its runs follow, and an in-repo project's `.ork/` with it.
+*/
+const relocateProject = (store, id, target) => {
+	const projects = store.projects();
+	const project = projects.find((p) => p.id === id);
+	if (project === void 0) return {
+		ok: false,
+		error: `No project is registered as ${id}.`
+	};
+	const clone = cloneOf(target);
+	if (!clone.ok) return clone;
+	const { root } = clone;
+	const other = projects.find((p) => p.root === root && p.id !== id);
+	if (other !== void 0) return {
+		ok: false,
+		error: `${root} is already registered as ${other.id}`
+	};
+	const dir = project.mode === "in-repo" ? inRepoPlace(root).dir : project.dir;
+	store.moveProject(id, {
+		root,
+		mode: project.mode,
+		dir
+	});
+	return {
+		ok: true,
+		project: {
+			...project,
+			root,
+			dir
+		},
+		created: false
+	};
+};
+/**
+* One project's lines for `ork projects`; rich, its mode and a missing clone
+* are chips, its id is padded to `idWidth` and its root is cut to the screen.
+*/
+const formatProject = (project, term = termOf(process.stdout), idWidth = 0) => {
+	const missing = !existsSync(project.root);
+	if (!term.rich) {
+		const gone = missing ? style("yellow", " (missing)") : "";
+		return [`${style("bold", project.id)}  ${style("dim", project.mode)}  ${project.root}${gone}`, style("dim", `  files: ${shownPath(project.dir, project.root)}`)];
+	}
+	const mode = chip(term, project.mode.toUpperCase(), "muted");
+	const gone = missing ? ` ${chip(term, "MISSING", "warn")}` : "";
+	const room = term.width - (idWidth + 2 + project.mode.length + 2 + 2) - (missing ? 10 : 0);
+	return [`${style("bold", project.id.padEnd(idWidth))}  ${mode}  ${cut(project.root, Math.max(8, room))}${gone}`, style("dim", cut(`  files: ${shownPath(project.dir, project.root)}`, term.width))];
+};
+/** Every project's lines, their ids aligned when rich. */
+const formatProjects = (projects, term = termOf(process.stdout)) => {
+	const idWidth = term.rich ? Math.max(0, ...projects.map((p) => p.id.length)) : 0;
+	return projects.flatMap((p) => formatProject(p, term, idWidth));
+};
+/** What `ork register` prints: the project, and where its files go. */
+const formatRegistered = (project, created) => {
+	const files = placeFiles(project);
+	const shown = (file) => shownPath(file, project.root);
+	return [
+		`${style("green", created ? "registered" : "already registered")} ${project.id} → ${project.root}`,
+		`\nWorkflows: ${shown(files.workflows)}/ · rules: ${shown(files.rules)} · runs: ${shown(files.runs)}/`,
+		`Nothing is written into ${project.root}. In it, ${style("bold", "ork run <name>")} finds the workflows above.`
+	];
+};
+// src/commands/project-records.ts
+/**
+* @file `ork projects`' subcommands on one project's record (ADR-035): `forget`
+*   drops it and keeps its files and runs; `move` points it at its clone's new
+*   place after the clone was moved or renamed, and its runs follow.
+*/
+/** Runs `use` with the store open, and closes it. */
+const withStore = (use) => {
+	const store = openStore();
+	try {
+		return use(store);
+	} finally {
+		store.close();
+	}
+};
+const id = {
+	type: "positional",
+	description: "The project's id",
+	required: true
+};
+const forget = defineCommand({
+	meta: {
+		name: "forget",
+		description: "Forget a registered project; its files and runs are kept"
+	},
+	args: { id },
+	run: ({ args }) => {
+		if (withStore((store) => store.forgetProject(args.id))) {
+			write(`${style("green", "forgot")} ${args.id} (its files are kept)`);
+			return;
+		}
+		writeErr(`No project is registered as ${args.id}.`);
+		process.exitCode = 1;
+	}
+});
+const move = defineCommand({
+	meta: {
+		name: "move",
+		description: "Point a registered project at its clone's new place, after moving or renaming it"
+	},
+	args: {
+		id,
+		path: {
+			type: "positional",
+			description: "Where the clone is now",
+			required: true
+		}
+	},
+	run: ({ args }) => {
+		const result = withStore((store) => relocateProject(store, args.id, args.path));
+		if (result.ok) {
+			write(`${style("green", "moved")} ${args.id} → ${result.project.root}`);
+			return;
+		}
+		writeErr(result.error);
+		process.exitCode = 1;
+	}
+});
+export { formatRegistered as a, formatProjects as i, move as n, recordInRepo as o, withStore as r, registerProject as s, forget as t };

package/dist/{relay-OWuu4fib.mjs → relay-D7RN4m68.mjs}

@@ -1,4 +1,4 @@
-import { U as openStore, _n as linkNodes, hn as addressOf, vn as unlinkNodes } from "./src-Dr_fTSu-.mjs";
+import { L as openStore, Sn as addressOf, Tn as unlinkNodes, wn as linkNodes } from "./src-DLsFsmOD.mjs";
 import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
 import { defineCommand } from "citty";
 // src/commands/relay.ts

package/dist/{run-CiPsW9Kf.mjs → run-BfxdsQJk.mjs}

@@ -1,4 +1,4 @@
-import { Jt as gitOk, qt as git } from "./src-Dr_fTSu-.mjs";
+import { $t as git, en as gitOk } from "./src-DLsFsmOD.mjs";
 import path from "node:path";
 import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";