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

package/dist/{__build_info__-B82-dGJY.mjs → install-23g_1ngs.mjs}

@@ -1,7 +1,6 @@
-import { $n as maskSecrets, A as isNewer, Cr as guardedBase, Mn as FEEDBACK_KINDS, Nn as FEEDBACK_SEVERITIES, Sr as estimateTokens, Tr as writePlainFile, Un as targetOf, Vn as fingerprint, j as parseVersion, k as compareVersions, mr as placeFor, pr as placeFiles, wr as plainPathInside, xr as LESSON_CAP_TOKENS, yr as inside, zn as publishPost } from "./src-tsuZRu0H.mjs";
+import { Gr as writePlainFile, Hr as estimateTokens, Nr as placeFiles, Pr as placeFor, Ur as guardedBase, Vr as LESSON_CAP_TOKENS, Wr as plainPathInside, Xn as FEEDBACK_KINDS, Zn as FEEDBACK_SEVERITIES, cr as targetOf, or as fingerprint, rr as publishPost, vr as maskSecrets, zr as inside } from "./src-DN-RPsil.mjs";
 import path from "node:path";
-import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { spawn } from "node:child_process";
 // ../core/src/feedback/actions.ts
 const ALLOWED = { ok: true };
@@ -363,174 +362,6 @@ const previewPost = (store, item, ask) => {
 		})
 	};
 };
-// ../core/src/remote/session.ts
-const chattable = (type) => type === "agent.leader" || type === "agent.worker";
-/** Reads `node`'s session from a run's events, and every node's last output. */
-const nodeSession = (events, node) => {
-	const session = {
-		known: false,
-		chattable: false,
-		running: false
-	};
-	const outputs = {};
-	for (const { event } of events) {
-		if (event.type === "run.started") {
-			const declared = event.nodes.find((n) => n.id === node);
-			if (declared !== void 0) {
-				session.known = true;
-				session.chattable = chattable(declared.type);
-			}
-		}
-		if (event.type === "node.finished") outputs[event.id] = event.output;
-		if (!("id" in event) || event.id !== node) continue;
-		if (event.type === "node.started") {
-			session.known = true;
-			session.chattable = chattable(event.nodeType);
-			session.running = true;
-		}
-		if (event.type === "node.finished") session.running = false;
-		if (event.type === "worktree" && event.action === "created") session.checkout = {
-			path: event.path,
-			...event.branch === void 0 ? {} : { branch: event.branch },
-			own: true,
-			owner: node
-		};
-		if (event.type !== "node.event") continue;
-		const inner = event.event;
-		if (inner.fork === true) continue;
-		if (inner.type === "session.started") {
-			session.sessionId = inner.sessionId;
-			if (inner.cwd !== void 0) session.cwd = inner.cwd;
-			if (inner.driver !== void 0) session.driver = inner.driver;
-			if (inner.model !== "") session.model = inner.model;
-		}
-		if (inner.type === "session.finished" && inner.outcome.sessionId !== "") session.sessionId = inner.outcome.sessionId;
-	}
-	return {
-		session,
-		outputs
-	};
-};
-/** The dist-tags every install follows, toward and after 1.0.0. */
-const CHANNEL_TAGS = [
-	"latest",
-	"alpha",
-	"beta",
-	"rc"
-];
-/** The dist-tag of snapshots from `main`, followed only by a canary. */
-const CANARY_TAG = "canary";
-const updateCachePath = (home = homedir()) => path.join(home, ".ork", "update-check.json");
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const text = (record, key) => {
-	const value = record[key];
-	return typeof value === "string" ? value : void 0;
-};
-const notifiedOf = (value) => {
-	if (!isRecord(value)) return void 0;
-	const version = text(value, "version");
-	const at = text(value, "at");
-	return version === void 0 || at === void 0 ? void 0 : {
-		version,
-		at
-	};
-};
-/** The cache, or `null` when there is none or it cannot be read. */
-const readUpdateCache = (file) => {
-	let parsed;
-	try {
-		parsed = JSON.parse(readFileSync(file, "utf8"));
-	} catch {
-		return null;
-	}
-	if (!isRecord(parsed)) return null;
-	const checkedAt = text(parsed, "checkedAt");
-	if (checkedAt === void 0) return null;
-	const latest = text(parsed, "latest");
-	const notified = notifiedOf(parsed["notified"]);
-	return {
-		checkedAt,
-		...latest === void 0 ? {} : { latest },
-		...notified === void 0 ? {} : { notified }
-	};
-};
-/** Writes the cache whole (a temporary file, then a rename). */
-const writeUpdateCache = (file, cache) => {
-	mkdirSync(path.dirname(file), { recursive: true });
-	const temporary = `${file}.${process.pid}.tmp`;
-	writeFileSync(temporary, `${JSON.stringify(cache, null, 2)}\n`);
-	renameSync(temporary, file);
-};
-const age = (iso, now) => {
-	const time = Date.parse(iso);
-	return Number.isNaN(time) ? Infinity : now.getTime() - time;
-};
-/** Whether it is time to ask the registry again. */
-const checkDue = (cache, now) => cache === null || age(cache.checkedAt, now) >= 864e5;
-/** Whether `version` is a canary snapshot: its pre-release starts `canary`. */
-const isCanary = (version) => parseVersion(version)?.pre[0]?.startsWith(CANARY_TAG) === true;
-/**
-* The newest version, by semver precedence, among the dist-tags `current`
-* follows: the channel tags, and `canary` too when `current` is a canary. A tag
-* whose value doesn't parse is skipped; `null` when none does.
-*/
-const newestTagged = (tags, current) => {
-	return (current !== void 0 && isCanary(current) ? [...CHANNEL_TAGS, "canary"] : CHANNEL_TAGS).flatMap((tag) => {
-		const value = tags[tag];
-		const version = typeof value === "string" ? parseVersion(value) : null;
-		return typeof value === "string" && version !== null ? [{
-			value,
-			version
-		}] : [];
-	}).reduce((best, candidate) => best === null || compareVersions(candidate.version, best.version) > 0 ? candidate : best, null)?.value ?? null;
-};
-/**
-* The newest version on the registry that the running version follows ({@link
-* newestTagged}), or `null` on any failure.
-*/
-const fetchLatest = async (name, options = {}) => {
-	const registry = (options.registry ?? "https://registry.npmjs.org").replace(/\/+$/u, "");
-	const get = options.fetch ?? globalThis.fetch;
-	try {
-		const response = await get(`${registry}/-/package/${name}/dist-tags`, {
-			headers: { accept: "application/json" },
-			signal: AbortSignal.timeout(options.timeoutMs ?? 5e3)
-		});
-		if (!response.ok) return null;
-		const tags = await response.json();
-		return isRecord(tags) ? newestTagged(tags, options.current) : null;
-	} catch {
-		return null;
-	}
-};
-/**
-* Asks the registry and records the answer. A failed check is recorded too, so
-* an offline machine is not asked again until the interval passes; the last
-* known version is kept. `options.current` is the running version.
-*/
-const refreshUpdateCache = async (file, name, now, options = {}) => {
-	const before = readUpdateCache(file);
-	const latest = await fetchLatest(name, options) ?? before?.latest;
-	const cache = {
-		...before,
-		checkedAt: now.toISOString(),
-		...latest === void 0 ? {} : { latest }
-	};
-	writeUpdateCache(file, cache);
-	return cache;
-};
-/** The newer version the cache knows of, if any. */
-const newerVersion = (cache, current) => cache?.latest !== void 0 && isNewer(cache.latest, current) ? cache.latest : null;
-/**
-* The version to tell the user about now: newer than theirs, and not already
-* told today. `null` when there is nothing to say.
-*/
-const pendingNotice = (cache, current, now) => {
-	const newer = newerVersion(cache, current);
-	if (newer === null) return null;
-	const told = cache?.notified;
-	return told?.version === newer && age(told.at, now) < 864e5 ? null : newer;
-};
 /**
 * Runs the command; resolves its exit code. Without `onOutput` it writes on the
 * terminal.
@@ -558,59 +389,4 @@ const runInstall = (argv, onOutput) => new Promise((resolve) => {
 		resolve(code ?? 1);
 	});
 });
-// ../core/src/update/switches.ts
-/**
-* @file The environment's say over the update check (ADR-038): the variables
-*   that turn it off (`ORK_NO_UPDATE_CHECK`, the common `NO_UPDATE_NOTIFIER`,
-*   and `CI`), and the registry to ask instead of npm's. The CLI adds its own
-*   rules about where a notice may go; the server behind `ork ui` uses only
-*   these.
-*/
-/** Turns the automatic check and its notice off. */
-const NO_UPDATE_ENV = "ORK_NO_UPDATE_CHECK";
-/** A registry to ask instead of npm's, e.g. a company mirror. */
-const UPDATE_REGISTRY_ENV = "ORK_UPDATE_REGISTRY";
-/** The variables that turn the check off, in the order they are looked at. */
-const UPDATE_SWITCHES = [
-	NO_UPDATE_ENV,
-	"NO_UPDATE_NOTIFIER",
-	"CI"
-];
-/** Set to anything but empty, `0` or `false`. */
-const isSwitchedOn = (value) => value !== void 0 && value !== "" && value !== "0" && value.toLowerCase() !== "false";
-/** The variable that turns the check off in `env`, or `null` when none does. */
-const updateSwitchOff = (env) => UPDATE_SWITCHES.find((name) => isSwitchedOn(env[name])) ?? null;
-/** The registry `ORK_UPDATE_REGISTRY` names, if it names one. */
-const registryOf = (env) => {
-	const registry = env[UPDATE_REGISTRY_ENV];
-	return registry === void 0 || registry === "" ? void 0 : registry;
-};
-/** The host of a registry that isn't an http(s) URL, past any `user:pass@`. */
-const hostOf = (registry) => registry.replace(/^[a-z][\w+.-]*:\/\//iu, "").replace(/^[^/?#]*@/u, "").split(/[/?#]/u)[0] ?? "";
-/**
-* The registry as it may be shown (on a page, in a message): an http(s) URL
-* without its user name and password, which a mirror's URL may carry; anything
-* else only as its host.
-*/
-const registryShown = (registry) => {
-	try {
-		const url = new URL(registry);
-		if (url.protocol === "http:" || url.protocol === "https:") {
-			if (url.username === "" && url.password === "") return registry;
-			url.username = "";
-			url.password = "";
-			return url.href;
-		}
-	} catch {}
-	return hostOf(registry);
-};
-// src/__build_info__.ts
-/**
-* @file The published package's name and version, bound to
-*   `packages/cli/package.json`. Do not edit by hand: `pnpm changesets:version`
-*   and `pnpm build` rewrite it (`tools/release/build-info.ts`), and a test
-*   fails when it is stale.
-*/
-const ORK_NAME = "@krapht/ork";
-const ORK_VERSION = "1.0.0-alpha.14";
-export { feedbackActions as C, placeOf as S, previewPost as _, registryShown as a, acceptItem as b, checkDue as c, pendingNotice as d, readUpdateCache as f, nodeSession as g, writeUpdateCache as h, registryOf as i, fetchLatest as l, updateCachePath as m, ORK_VERSION as n, updateSwitchOff as o, refreshUpdateCache as p, isSwitchedOn as r, runInstall as s, ORK_NAME as t, newerVersion as u, checkNote as v, openFixRun as w, lessonPlaceOf as x, recordNote as y };
+export { acceptItem as a, feedbackActions as c, recordNote as i, openFixRun as l, previewPost as n, lessonPlaceOf as o, checkNote as r, placeOf as s, runInstall as t };

package/dist/{limits-Dhe--wmX.mjs → limits-C_Xz_t3C.mjs}

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

package/dist/{mcp-CsmboyXv.mjs → mcp-CWng9I9n.mjs}

@@ -1,8 +1,8 @@
-import { A as isNewer } from "./src-tsuZRu0H.mjs";
-import { n as ORK_VERSION } from "./__build_info__-B82-dGJY.mjs";
-import { p as runMarkerIn } from "./src-C7z_6fhn.mjs";
-import { n as explainNode } from "./context-Y_I4Mofq.mjs";
-import { a as openMcp, c as refused, o as tool, s as answer } from "./src-8Mul0695.mjs";
+import { w as isNewer } from "./src-DN-RPsil.mjs";
+import { n as ORK_VERSION } from "./__build_info__-DcRdK0Du.mjs";
+import { p as runMarkerIn } from "./src-DHDQ0itC.mjs";
+import { n as explainNode } from "./context-BN9A2Nnu.mjs";
+import { a as openMcp, c as refused, o as tool, s as answer } from "./src-nXLIwDrt.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.14") ? tooOld(all, options.expects) : all;
+	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.16") ? tooOld(all, options.expects) : all;
 	const server = new McpServer({
 		name: "ork",
 		version: ORK_VERSION

package/dist/{once-CrwI-ZdN.mjs → once-lvwcWfVf.mjs}

@@ -1,7 +1,7 @@
-import "./src-tsuZRu0H.mjs";
-import { t as runOnce } from "./run-D8divGCs.mjs";
+import "./src-DN-RPsil.mjs";
+import { t as runOnce } from "./run-D_u9V_Ve.mjs";
 import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
-import { t as ago } from "./format-CvTE5CZQ.mjs";
+import { t as ago } from "./format-hiDvtNGM.mjs";
 import { spawn } from "node:child_process";
 import { defineCommand, parseArgs } from "citty";
 // src/commands/once.ts

package/dist/orphan-guard-BFKg8VSd.mjs

@@ -0,0 +1,58 @@
+import { Readable, Writable } from "node:stream";
+// ../core/src/machine/orphan-guard.ts
+/**
+* @file The orphan guard: a node's processes end with `ork`, whatever ends
+*   `ork` (SIGKILL, the OOM killer, a crash exit). A child started in its own
+*   process group (`detached: true`) under `sh` also starts a small watcher in
+*   that group, which reads a pipe that only `ork` holds open. `ork` never
+*   writes to it, so when `ork` dies the read sees EOF, and the watcher sends
+*   its own group (`kill 0`, never another's) SIGTERM, then SIGKILL after
+*   {@link KILL_AFTER_MS}. A line on the pipe instead lets the watcher exit
+*   quietly, and so does killing it, which is how a node that ends normally
+*   leaves its leftover background processes alone. POSIX only. Two uses:
+*
+*   - A shell that outlives the program (the tool runner's timing wrapper):
+*     `${orphanGuard(4)} w=$!; "$0" "$@" 4<&-; s=$?; kill -s KILL $w`, then
+*     spawn with a `"pipe"` at `stdio[4]` and call
+*     `holdGuard(child.stdio[4])`.
+*   - A shell that `exec`s the program (a session, so its pid stays the
+*     driver's): `${orphanGuard(3)} exec 3<&-; exec "$0" "$@"` (a bare `exec`
+*     closes the pipe: macOS's `sh` keeps a copy of one an `exec` command
+*     closes, which the driver would inherit), with a `"pipe"` at `stdio[3]`;
+*     nothing is left to kill the watcher, so call the function `holdGuard`
+*     returns once the driver has exited (on `exit`: the pipe holds `close`).
+*/
+/** How long the group gets to end after SIGTERM before SIGKILL. */
+const KILL_AFTER_MS = 2e3;
+/** The file descriptors a redirect can name in every POSIX shell. */
+const SHELL_FDS = [
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9
+];
+/**
+* Shell text that starts the watcher in the background on pipe `fd` (3 to 9);
+* it ends with `&`, so `$!` after it is the watcher's pid. The watcher holds no
+* other descriptor, so it never keeps the child's output pipes open.
+*/
+const orphanGuard = (fd) => {
+	const others = SHELL_FDS.filter((other) => other !== fd).map((other) => `${String(other)}>&-`).join(" ");
+	return `{ read -r _ork <&${String(fd)} || { trap '' TERM; kill -s TERM 0; sleep ${String(KILL_AFTER_MS / 1e3)}; kill -s KILL 0; }; } </dev/null >/dev/null 2>&1 ${others} & `;
+};
+/**
+* Keeps `ork`'s end of the watch pipe (`child.stdio[fd]`) open and drained, so
+* it never holds back the child's `close`; returns the release, which writes
+* the line that lets the watcher exit without touching its group.
+*/
+const holdGuard = (pipe) => {
+	pipe?.on("error", () => {});
+	if (pipe instanceof Readable) pipe.resume();
+	return () => {
+		if (pipe instanceof Writable && pipe.writable) pipe.write("\n");
+	};
+};
+export { holdGuard as n, orphanGuard as r, KILL_AFTER_MS as t };

package/dist/{pause-DssrYcda.mjs → pause-Cy11KrXK.mjs}

@@ -1,7 +1,7 @@
-import { U as openStore, _t as requestPause, gt as requestContinue } from "./src-tsuZRu0H.mjs";
-import { t as findRun } from "./find-BVX-bL4u.mjs";
+import { En as requestPause, L as openStore, Tn as requestContinue } from "./src-DN-RPsil.mjs";
+import { t as findRun } from "./find-mLYsR0uC.mjs";
 import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
-import { i as continueRefusal } from "./in-a-run-cL5N9gpH.mjs";
+import { i as continueRefusal } from "./in-a-run-a447hxq8.mjs";
 import { defineCommand } from "citty";
 // src/commands/pause.ts
 /**

package/dist/post-C9soCx7i.mjs

@@ -0,0 +1,46 @@
+import { ir as redact } from "./src-DN-RPsil.mjs";
+import { b as githubDraftRefusal } from "./__build_info__-DcRdK0Du.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;
+	const refused = githubDraftRefusal(f);
+	if (refused !== void 0 || draft === void 0) return {
+		ok: false,
+		error: refused?.error ?? "it has no draft"
+	};
+	if (!options.confirmed) return {
+		ok: false,
+		error: "posting to GitHub needs the maintainer's confirmation"
+	};
+	const body = redact(draft.text, {
+		roots: [f.project],
+		home: options.home
+	});
+	const on = /\/pull\/\d+/u.test(draft.to) ? "pr" : "issue";
+	const result = await options.gh([
+		on,
+		"comment",
+		draft.to,
+		"--body",
+		body
+	], { cwd: f.project });
+	if (!result.ok) return {
+		ok: false,
+		error: `gh failed: ${result.stderr.trim() || result.stdout.trim() || "no output"}`
+	};
+	const url = result.stdout.trim().split("\n").findLast((line) => line.startsWith("https://"));
+	const done = {
+		...f,
+		status: "done",
+		note: `posted${url === void 0 ? "" : ` as ${url}`}`,
+		updatedAt: options.now?.() ?? (/* @__PURE__ */ new Date()).toISOString()
+	};
+	options.rows.putFollowUp(done);
+	return {
+		ok: true,
+		followUp: done,
+		...url === void 0 ? {} : { url }
+	};
+};
+export { postFollowUpMessage as t };

package/dist/print-BaWiWf4v.mjs

@@ -0,0 +1,19 @@
+import { a as refuseIdsWithJson } from "./flags-CdgIH1L6.mjs";
+import { c as write } from "./output-B1kwo0YU.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-BRiyQzUo.mjs

@@ -0,0 +1,230 @@
+import { Ar as hasInRepoFiles, Br as projectRootOf, Fr as projectsHome, L as openStore, Lr as shownPath, Mr as newProjectId, Nr as placeFiles, jr as inRepoPlace } from "./src-DN-RPsil.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-DASRgsTQ.mjs → relay-C0M1TWMB.mjs}

@@ -1,4 +1,4 @@
-import { U as openStore, ft as addressOf, ht as unlinkNodes, mt as linkNodes } from "./src-tsuZRu0H.mjs";
+import { Cn as linkNodes, L as openStore, wn as unlinkNodes, xn as addressOf } from "./src-DN-RPsil.mjs";
 import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
 import { defineCommand } from "citty";
 // src/commands/relay.ts