@krapht/ork 0.3.0 → 1.0.0-alpha.0

package/dist/{output-Q2EdeVUt.mjs → output-B1V6ZJSx.mjs}

@@ -1,9 +1,9 @@
-import { Ct as FEEDBACK_SEVERITIES, G as usageQueries, J as text, K as eventOf, Ot as maskReplacer, St as FEEDBACK_KINDS, W as backfillUsage, kt as maskSecrets, q as inTransaction, qt as PROJECT_MODES, wt as FEEDBACK_TARGETS } from "./src-Cz1yOUTg.mjs";
-import { createInterface } from "node:readline/promises";
+import { $ as text, Bt as FEEDBACK_TARGETS, Q as inTransaction, Rt as FEEDBACK_KINDS, X as usageQueries, Xt as maskReplacer, Y as backfillUsage, Z as eventOf, Zt as maskSecrets, gn as PROJECT_MODES, yt as ownProcessStart, zt as FEEDBACK_SEVERITIES } from "./src-DHvWU4tX.mjs";
 import path from "node:path";
 import { mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { DatabaseSync } from "node:sqlite";
+import { createInterface } from "node:readline/promises";
 import { stripVTControlCharacters, styleText } from "node:util";
 // ../core/src/store/drafts.ts
 const rowOf = (row) => {
@@ -49,6 +49,11 @@ const choicesOf = (json) => {
 		return [choice];
 	});
 };
+/** A note as stored: masked, or null when blank. */
+const noteOf = (note) => {
+	const trimmed = note?.trim() ?? "";
+	return trimmed === "" ? null : maskSecrets(trimmed);
+};
 const kindOf = (value) => value === "permission" ? "permission" : "question";
 const statusOf$1 = (value) => value === "answered" || value === "withdrawn" ? value : "open";
 const decisionOf = (row) => {
@@ -66,17 +71,19 @@ const decisionOf = (row) => {
 		recommended: text(row, "recommended"),
 		context: text(row, "context"),
 		answer: text(row, "answer"),
-		answeredAt: text(row, "answered_at")
+		answeredAt: text(row, "answered_at"),
+		note: text(row, "note"),
+		owner: text(row, "owner")
 	};
 	for (const [key, value] of Object.entries(optional)) if (value !== "") Object.assign(record, { [key]: value });
 	const by = text(row, "answered_by");
-	if (by === "terminal" || by === "decide" || by === "ui") record.answeredBy = by;
+	if (by === "terminal" || by === "decide" || by === "ui" || by === "owner") record.answeredBy = by;
 	return record;
 };
 const decisionQueries = (db) => {
-	const insert = db.prepare(`INSERT INTO decisions (id, run_id, node, kind, question, options, recommended, context, opened_at, status)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'open')`);
-	const answer = db.prepare(`UPDATE decisions SET status = 'answered', answer = ?, answered_by = ?, answered_at = ?
+	const insert = db.prepare(`INSERT INTO decisions (id, run_id, node, kind, question, options, recommended, context, owner, opened_at, status)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'open')`);
+	const answer = db.prepare(`UPDATE decisions SET status = 'answered', answer = ?, answered_by = ?, answered_at = ?, note = ?
      WHERE id = ? AND status = 'open'`);
 	const withdraw = db.prepare("UPDATE decisions SET status = 'withdrawn', answered_at = ? WHERE id = ? AND status = 'open'");
 	const byId = db.prepare("SELECT * FROM decisions WHERE id = ?");
@@ -97,14 +104,14 @@ const decisionQueries = (db) => {
 				question: maskSecrets(decision.question),
 				...decision.context === void 0 ? {} : { context: maskSecrets(decision.context) }
 			};
-			insert.run(masked.id, masked.runId, masked.node, masked.kind, masked.question, JSON.stringify(masked.options), masked.recommended ?? null, masked.context ?? null, openedAt);
+			insert.run(masked.id, masked.runId, masked.node, masked.kind, masked.question, JSON.stringify(masked.options), masked.recommended ?? null, masked.context ?? null, masked.owner ?? null, openedAt);
 			return {
 				...masked,
 				openedAt,
 				status: "open"
 			};
 		},
-		answerDecision: (id, choice, by) => Number(answer.run(choice, by, (/* @__PURE__ */ new Date()).toISOString(), id).changes) === 1,
+		answerDecision: (id, choice, by, note) => Number(answer.run(choice, by, (/* @__PURE__ */ new Date()).toISOString(), noteOf(note), id).changes) === 1,
 		withdrawDecision: (id) => {
 			withdraw.run((/* @__PURE__ */ new Date()).toISOString(), id);
 		},
@@ -213,8 +220,10 @@ const recordOf$3 = (row) => {
 };
 const itemOf = (row) => {
 	const severities = strings(row, "severities");
+	const id = text(row, "fingerprint");
 	return {
-		id: text(row, "fingerprint"),
+		id,
+		merged: strings(row, "fingerprints").filter((f) => f !== id),
 		status: oneOf(STATUSES$1, text(row, "status"), "new"),
 		title: text(row, "title"),
 		target: oneOf(FEEDBACK_TARGETS, text(row, "target"), "workflow"),
@@ -229,16 +238,20 @@ const itemOf = (row) => {
 		models: strings(row, "models")
 	};
 };
-const ITEMS = `SELECT f.fingerprint, i.status,
-     (SELECT title FROM feedback WHERE fingerprint = f.fingerprint ORDER BY id LIMIT 1) AS title,
+/** Each record with the item it lists under: its own, or the one it merged into. */
+const ITEMS = `SELECT r.fingerprint, r.status,
+     (SELECT title FROM feedback WHERE fingerprint = r.fingerprint ORDER BY id LIMIT 1) AS title,
      MIN(f.target) AS target, MIN(f.kind) AS kind,
      json_group_array(DISTINCT f.severity) AS severities,
      json_group_array(DISTINCT f.source) AS sources,
      COUNT(*) AS count, MIN(f.at) AS first_seen, MAX(f.at) AS last_seen,
      json_group_array(DISTINCT f.run_id) AS runs,
      json_group_array(DISTINCT f.workflow) AS workflows,
-     json_group_array(DISTINCT f.model) AS models
-   FROM feedback f JOIN feedback_items i ON i.fingerprint = f.fingerprint`;
+     json_group_array(DISTINCT f.model) AS models,
+     json_group_array(DISTINCT f.fingerprint) AS fingerprints
+   FROM feedback f
+   JOIN feedback_items i ON i.fingerprint = f.fingerprint
+   JOIN feedback_items r ON r.fingerprint = COALESCE(i.merged_into, i.fingerprint)`;
 const feedbackQueries = (db) => {
 	const insert = db.prepare(`INSERT INTO feedback (run_id, seq, at, node, source, kind, target, severity,
        title, body, evidence, code, fingerprint, workflow, workflow_hash,
@@ -246,21 +259,51 @@ const feedbackQueries = (db) => {
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
 	const insertItem = db.prepare(`INSERT INTO feedback_items (fingerprint, status, updated_at)
      VALUES (?, 'new', ?) ON CONFLICT (fingerprint) DO NOTHING`);
-	const shown = db.prepare(`${ITEMS} WHERE i.status != 'dismissed' GROUP BY f.fingerprint ORDER BY last_seen DESC`);
-	const every = db.prepare(`${ITEMS} GROUP BY f.fingerprint ORDER BY last_seen DESC`);
-	const byPrefix = db.prepare(`${ITEMS} WHERE substr(f.fingerprint, 1, ?) = ? GROUP BY f.fingerprint ORDER BY last_seen DESC`);
-	const records = db.prepare("SELECT * FROM feedback WHERE fingerprint = ? ORDER BY id");
+	const shown = db.prepare(`${ITEMS} WHERE r.status != 'dismissed' GROUP BY r.fingerprint ORDER BY last_seen DESC`);
+	const every = db.prepare(`${ITEMS} GROUP BY r.fingerprint ORDER BY last_seen DESC`);
+	const byPrefix = db.prepare(`${ITEMS} WHERE r.fingerprint IN (
+       SELECT COALESCE(merged_into, fingerprint) FROM feedback_items
+       WHERE substr(fingerprint, 1, ?) = ?
+     ) GROUP BY r.fingerprint ORDER BY last_seen DESC`);
+	const records = db.prepare(`SELECT * FROM feedback
+     WHERE fingerprint = ? OR fingerprint IN (
+       SELECT fingerprint FROM feedback_items WHERE merged_into = ?
+     ) ORDER BY id`);
+	const rootOf = db.prepare("SELECT COALESCE(merged_into, fingerprint) AS root FROM feedback_items WHERE fingerprint = ?");
+	const mergeInto = db.prepare(`UPDATE feedback_items SET merged_into = ?, updated_at = ?
+     WHERE (fingerprint = ? OR merged_into = ?) AND fingerprint != ?`);
+	const exported = db.prepare(`SELECT f.* FROM feedback f
+     LEFT JOIN feedback_items i ON i.fingerprint = f.fingerprint
+     LEFT JOIN feedback_items r ON r.fingerprint = COALESCE(i.merged_into, f.fingerprint)
+     WHERE ? = 1 OR COALESCE(r.status, 'new') != 'dismissed' ORDER BY f.id`);
+	const known = db.prepare("SELECT 1 FROM feedback WHERE run_id = ? AND seq = ?");
+	const split = db.prepare("UPDATE feedback_items SET merged_into = NULL, updated_at = ? WHERE merged_into = ?");
 	const setStatus = db.prepare("UPDATE feedback_items SET status = ?, updated_at = ? WHERE fingerprint = ?");
+	/** Writes a record, its secrets masked, and its item when it's new. */
+	const insertRecord = (runId, seq, at, node, feedback) => {
+		const { origin } = feedback;
+		insert.run(runId, seq, at, node ?? null, feedback.source, feedback.kind, feedback.target, feedback.severity, maskSecrets(feedback.title), maskSecrets(feedback.body), JSON.stringify(feedback.evidence.map((e) => maskSecrets(e))), feedback.code ?? null, feedback.fingerprint, origin.workflow ?? null, origin.workflowHash ?? null, origin.nodeType ?? null, origin.model ?? null, origin.driver ?? null, origin.version ?? null, 1);
+		insertItem.run(feedback.fingerprint, at);
+	};
 	return {
-		insertFeedback: (runId, seq, at, node, feedback) => {
-			const { origin } = feedback;
-			insert.run(runId, seq, at, node ?? null, feedback.source, feedback.kind, feedback.target, feedback.severity, maskSecrets(feedback.title), maskSecrets(feedback.body), JSON.stringify(feedback.evidence.map((e) => maskSecrets(e))), feedback.code ?? null, feedback.fingerprint, origin.workflow ?? null, origin.workflowHash ?? null, origin.nodeType ?? null, origin.model ?? null, origin.driver ?? null, origin.version ?? null, 1);
-			insertItem.run(feedback.fingerprint, at);
-		},
+		insertFeedback: insertRecord,
 		feedbackItems: (filter = {}) => (filter.all === true ? every : shown).all().map((r) => itemOf(r)),
 		findFeedback: (prefix) => byPrefix.all(prefix.length, prefix).map((r) => itemOf(r)),
-		feedbackRecords: (fingerprint) => records.all(fingerprint).map((r) => recordOf$3(r)),
-		setFeedbackStatus: (fingerprint, status) => Number(setStatus.run(status, (/* @__PURE__ */ new Date()).toISOString(), fingerprint).changes) > 0
+		feedbackRecords: (fingerprint) => records.all(fingerprint, fingerprint).map((r) => recordOf$3(r)),
+		setFeedbackStatus: (fingerprint, status) => Number(setStatus.run(status, (/* @__PURE__ */ new Date()).toISOString(), fingerprint).changes) > 0,
+		mergeFeedback: (into, from) => {
+			const root = text(rootOf.get(into), "root");
+			if (root === "") return 0;
+			const at = (/* @__PURE__ */ new Date()).toISOString();
+			return inTransaction(db, () => from.filter((fingerprint) => fingerprint !== root).reduce((moved, fingerprint) => moved + Number(mergeInto.run(root, at, fingerprint, fingerprint, root).changes), 0));
+		},
+		splitFeedback: (fingerprint) => Number(split.run((/* @__PURE__ */ new Date()).toISOString(), fingerprint).changes),
+		exportFeedback: (filter = {}) => exported.all(filter.all === true ? 1 : 0).map((r) => recordOf$3(r)),
+		importFeedback: (record) => {
+			if (known.get(record.runId, record.seq) !== void 0) return false;
+			insertRecord(record.runId, record.seq, record.at, record.node, record.feedback);
+			return true;
+		}
 	};
 };
 // ../core/src/store/links.ts
@@ -681,9 +724,24 @@ const MIGRATIONS = [
      id INTEGER PRIMARY KEY CHECK (id = 1),
      pid INTEGER NOT NULL,
      at TEXT NOT NULL
-   );`
+   );`,
+	`ALTER TABLE feedback_items ADD COLUMN merged_into TEXT;
+   CREATE INDEX feedback_items_merged ON feedback_items (merged_into);`,
+	`ALTER TABLE runs ADD COLUMN process_start TEXT;`,
+	`ALTER TABLE runs ADD COLUMN skipped INTEGER;
+   ALTER TABLE runs ADD COLUMN failures_handled INTEGER;`,
+	`ALTER TABLE decisions ADD COLUMN note TEXT;`,
+	`ALTER TABLE decisions ADD COLUMN owner TEXT;`
 ];
 const versionOf = (db) => Number(db.prepare("PRAGMA user_version").get()?.["user_version"] ?? 0);
+/**
+* Refuses a database that is not at this Ork's schema version, newer or older,
+* for a reader that may not migrate it (a read-only open).
+*/
+const requireCurrent = (db, migrations = MIGRATIONS) => {
+	const version = versionOf(db);
+	if (version !== migrations.length) throw new Error(`The store is at schema version ${String(version)}; this Ork reads ${String(migrations.length)}.`);
+};
 /** Applies the migrations the database has not had yet. */
 const migrate = (db, migrations = MIGRATIONS) => {
 	for (const [index, step] of migrations.entries()) {
@@ -702,7 +760,9 @@ const migrate = (db, migrations = MIGRATIONS) => {
 *   project, `~/.ork/state.db`, in WAL mode so other `ork` processes read while
 *   a run writes. Events are stored with secrets masked, feedback records
 *   beside them, and the registered projects; the schema is versioned with
-*   `user_version`.
+*   `user_version`. Tab completion opens it read-only: no store created, no
+*   migration, a store at another version refused, and the database never
+*   changed (SQLite may still add the `-wal` and `-shm` files beside it).
 */
 /** `~/.ork/state.db`; `home` is `~` (tests pass a folder). */
 const storePath = (home = homedir()) => path.join(home, ".ork", "state.db");
@@ -728,10 +788,16 @@ const recordOf = (row) => {
 		costUsd: Number(row?.["cost_usd"]),
 		depth: Number(row?.["depth"] ?? 0)
 	};
+	const processStart = text(row, "process_start");
+	if (processStart !== "") record.processStart = processStart;
 	const parent = text(row, "parent");
 	if (parent !== "") record.parent = parent;
 	const finished = text(row, "finished_at");
 	if (finished !== "") record.finishedAt = finished;
+	const skipped = row?.["skipped"];
+	if (typeof skipped === "number") record.skipped = skipped;
+	const handled = row?.["failures_handled"];
+	if (typeof handled === "number") record.failuresHandled = handled;
 	return record;
 };
 /** The node an event is about, for filtering. */
@@ -740,8 +806,20 @@ const nodeOf = (event) => {
 	if ("node" in event && typeof event.node === "string") return event.node;
 	return null;
 };
-/** Opens (and creates) the store at `file`; `:memory:` for tests. */
-const openStore = (file = storePath()) => {
+/** A database opened for reading only, refused unless it is current. */
+const openReadOnly = (file) => {
+	const db = new DatabaseSync(file, { readOnly: true });
+	try {
+		db.exec("PRAGMA busy_timeout = 5000");
+		requireCurrent(db);
+		return db;
+	} catch (error) {
+		db.close();
+		throw error;
+	}
+};
+/** A database opened for writing: created, in WAL mode, migrated. */
+const openWritable = (file) => {
 	if (file !== ":memory:") mkdirSync(path.dirname(file), { recursive: true });
 	const db = new DatabaseSync(file);
 	db.exec("PRAGMA busy_timeout = 5000");
@@ -749,36 +827,48 @@ const openStore = (file = storePath()) => {
 	db.exec("PRAGMA synchronous = NORMAL");
 	db.exec("PRAGMA foreign_keys = ON");
 	migrate(db);
-	const insertRun = db.prepare(`INSERT INTO runs (id, workflow, file, project, status, pid, started_at, parent, depth)
-     VALUES (?, ?, ?, ?, 'running', ?, ?, ?, ?)`);
+	return db;
+};
+/**
+* Opens (and creates) the store at `file`; `:memory:` for tests. With
+* `readOnly`, it neither creates nor migrates, and throws when it can't read.
+*/
+const openStore = (file = storePath(), options = {}) => {
+	const ownStart = options.processStart ?? ownProcessStart;
+	const db = options.readOnly === true ? openReadOnly(file) : openWritable(file);
+	const insertRun = db.prepare(`INSERT INTO runs (id, workflow, file, project, status, pid, process_start, started_at, parent, depth)
+     VALUES (?, ?, ?, ?, 'running', ?, ?, ?, ?, ?)`);
 	const lastSeq = db.prepare("SELECT COALESCE(MAX(seq), 0) AS seq FROM events WHERE run_id = ?");
 	const insertEvent = db.prepare("INSERT INTO events (run_id, seq, at, type, node, data) VALUES (?, ?, ?, ?, ?, ?)");
-	const finishRun = db.prepare("UPDATE runs SET status = ?, finished_at = ?, cost_usd = ? WHERE id = ?");
-	const reopenRun = db.prepare("UPDATE runs SET status = 'running', pid = ?, finished_at = NULL WHERE id = ?");
+	const finishRun = db.prepare("UPDATE runs SET status = ?, finished_at = ?, cost_usd = ?, skipped = ?, failures_handled = ? WHERE id = ?");
+	const reopenRun = db.prepare("UPDATE runs SET status = 'running', pid = ?, process_start = ?, finished_at = NULL, skipped = NULL, failures_handled = NULL WHERE id = ?");
 	const addCost = db.prepare("UPDATE runs SET cost_usd = cost_usd + ? WHERE id = ?");
 	const byId = db.prepare("SELECT * FROM runs WHERE id = ?");
 	const byPrefix = db.prepare("SELECT * FROM runs WHERE substr(id, 1, ?) = ? ORDER BY started_at DESC, rowid DESC");
 	const allRuns = db.prepare("SELECT * FROM runs ORDER BY started_at DESC, rowid DESC LIMIT ?");
 	const projectRuns = db.prepare("SELECT * FROM runs WHERE project = ? ORDER BY started_at DESC, rowid DESC LIMIT ?");
 	const eventsAfter = db.prepare("SELECT seq, at, data FROM events WHERE run_id = ? AND seq > ? ORDER BY seq");
+	const runNodes = db.prepare("SELECT node FROM events WHERE run_id = ? AND node IS NOT NULL GROUP BY node ORDER BY MIN(seq)");
 	const { insertFeedback, recordUsage, recordPlanLimit, ...queries } = storeQueries(db);
 	return {
 		...queries,
 		begin: (run) => {
 			const startedAt = (/* @__PURE__ */ new Date()).toISOString();
 			const depth = run.parent === void 0 ? 0 : Number(byId.get(run.parent)?.["depth"] ?? 0) + 1;
-			insertRun.run(run.id, run.workflow, run.file, run.project, process.pid, startedAt, run.parent ?? null, depth);
+			const processStart = ownStart();
+			insertRun.run(run.id, run.workflow, run.file, run.project, process.pid, processStart ?? null, startedAt, run.parent ?? null, depth);
 			return {
 				...run,
 				depth,
 				status: "running",
 				pid: process.pid,
+				...processStart === void 0 ? {} : { processStart },
 				startedAt,
 				costUsd: 0
 			};
 		},
 		reopen: (runId) => {
-			reopenRun.run(process.pid, runId);
+			reopenRun.run(process.pid, ownStart() ?? null, runId);
 		},
 		append: (runId, event) => inTransaction(db, () => {
 			const at = (/* @__PURE__ */ new Date()).toISOString();
@@ -788,7 +878,10 @@ const openStore = (file = storePath()) => {
 			if (event.type === "node.event" && event.event.type === "session.finished") recordUsage(runId);
 			if (event.type === "node.event" && event.event.type === "plan.limit") recordPlanLimit(event.event, at);
 			if (event.type === "feedback.recorded") insertFeedback(runId, seq, at, event.node, event.feedback);
-			if (event.type === "run.finished") finishRun.run(event.result.status, at, event.result.costUsd, runId);
+			if (event.type === "run.finished") {
+				const { status, costUsd, skipped, failuresHandled } = event.result;
+				finishRun.run(status, at, costUsd, skipped ?? null, failuresHandled ?? null, runId);
+			}
 			return {
 				runId,
 				seq,
@@ -811,6 +904,7 @@ const openStore = (file = storePath()) => {
 			at: text(r, "at"),
 			event: eventOf(text(r, "data"))
 		})),
+		nodes: (runId) => runNodes.all(runId).map((r) => text(r, "node")),
 		close: () => {
 			db.close();
 		}

package/dist/{pause-DKACDfV1.mjs → pause-B_SL_yDz.mjs}

@@ -1,7 +1,7 @@
-import { B as requestContinue, V as requestPause } from "./src-Cz1yOUTg.mjs";
-import { t as findRun } from "./find-BcvhT6UN.mjs";
-import { a as write, c as openStore, i as style, o as writeErr } from "./output-Q2EdeVUt.mjs";
-import { r as continueRefusal } from "./in-a-run-BbLhZOFW.mjs";
+import { G as requestContinue, K as requestPause } from "./src-DHvWU4tX.mjs";
+import { t as findRun } from "./find-BKW-uGey.mjs";
+import { a as write, c as openStore, i as style, o as writeErr } from "./output-B1V6ZJSx.mjs";
+import { r as continueRefusal } from "./in-a-run-BPXX09Bs.mjs";
 import { defineCommand } from "citty";
 // src/commands/pause.ts
 /**

package/dist/{relay-CbK-Wme9.mjs → relay-o-Luee1c.mjs}

@@ -1,5 +1,5 @@
-import { F as linkNodes, M as addressOf, R as unlinkNodes } from "./src-Cz1yOUTg.mjs";
-import { a as write, c as openStore, i as style, o as writeErr } from "./output-Q2EdeVUt.mjs";
+import { B as linkNodes, L as addressOf, U as unlinkNodes } from "./src-DHvWU4tX.mjs";
+import { a as write, c as openStore, i as style, o as writeErr } from "./output-B1V6ZJSx.mjs";
 import { defineCommand } from "citty";
 // src/commands/relay.ts
 /**

package/dist/remove-DAZ7ZCzt.mjs

@@ -0,0 +1,194 @@
+import { ht as liveStatus, j as lines, k as git } from "./src-DHvWU4tX.mjs";
+import { n as listOrkWorktrees, t as createdWorktrees } from "./list-C7UEgmtd.mjs";
+import { i as keyOf, n as applyStep, r as cleanStep, s as stepPrunes } from "./clean-NnboOuz6.mjs";
+// ../core/src/worktree/words.ts
+/**
+* @file The plain words for what `ork worktrees` shows, in one place, so the
+*   CLI and the Worktrees panel say the same thing: an item's name, its merge
+*   state, its state as parts (each marked when it's work that removing would
+*   lose), a plan's line, and why an item can't be removed. The CLI colors
+*   them; the panel lays them out.
+*/
+/** An item's name: its branch, or its run and node when created detached. */
+const labelOf = (item) => item.branch ?? `${item.runId}/${item.nodeId}`;
+/** Merged into the current branch, not, or detached on no branch at all. */
+const mergeStateOf = (item) => {
+	if (item.branch === void 0 && item.checkedOut === void 0) return "detached";
+	return item.merged ? "merged" : "unmerged";
+};
+/** `3 commits`, `1 commit`. */
+const counted = (count, noun) => `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
+/**
+* An item's state, in order: where its worktree is when it isn't plain, the
+* workflow's own branch, uncommitted changes, unmerged or unreachable commits,
+* and the main checkout or another worktree holding the branch. `into` names
+* the branch "not merged" is measured against, when the words should say it.
+*/
+const stateParts = (item, into) => {
+	const parts = [];
+	const part = (text, risk = false) => {
+		parts.push({
+			text,
+			risk
+		});
+	};
+	if (item.path === null) part("no worktree");
+	else if (item.missing) part("missing (prunable)");
+	if (item.checkedOut !== void 0) part(`on the workflow's branch ${item.checkedOut}`);
+	if (item.dirty) part("uncommitted changes", true);
+	const state = mergeStateOf(item);
+	if (state === "unmerged") {
+		const where = into === void 0 ? "" : ` into ${into}`;
+		part(`${counted(item.ahead, "commit")} not merged${where}`);
+	}
+	if (state === "detached") {
+		if (item.ahead > 0) part(`${counted(item.ahead, "commit")} on no branch`, true);
+		else if (item.path !== null && !item.missing) part("nothing committed");
+	}
+	if (item.inMainCheckout) part("checked out in the main checkout");
+	if (item.heldBy !== void 0) part(`checked out in ${item.heldBy}`);
+	return parts;
+};
+/** What a step does, as a plan says it. */
+const planWhat = (step) => {
+	const actions = [
+		...step.removeWorktree ? ["remove worktree"] : [],
+		...stepPrunes(step) && !step.removeWorktree ? ["prune worktree"] : [],
+		...step.deleteBranch ? ["delete branch"] : []
+	];
+	return actions.length > 0 ? actions.join(" + ") : "keep";
+};
+/** `ork/r1/lead: remove worktree`, `r1/check (detached): keep (…)`. */
+const planLine = (step) => {
+	const { item } = step;
+	return {
+		text: `${item.branch === void 0 && item.checkedOut === void 0 ? `${labelOf(item)} (detached)` : labelOf(item)}: ${planWhat(step)}`,
+		...step.skip === void 0 ? {} : { reason: step.skip }
+	};
+};
+/**
+* Why an item can't be removed at all, even forced, if it can't: the main
+* checkout or a worktree Ork didn't create holds it, or its run is still
+* going.
+*/
+const removeRefusal = (item, live) => {
+	if (item.inMainCheckout) return "checked out in the main checkout; switch it to another branch first";
+	if (item.heldBy !== void 0) return `checked out in ${item.heldBy}, a worktree Ork didn't create; switch it to another branch first`;
+	return live ? `run ${item.runId} is still going; stop it first` : void 0;
+};
+// ../core/src/worktree/remove.ts
+/** The ids of the project's runs whose process is still going. */
+const liveRunIds = (store, root) => new Set(store.runs({ project: root }).filter((run) => liveStatus(run) === "running").map((run) => run.id));
+/**
+* Whether `root` is a repository with a commit, and the branch checked out
+* there, which "merged" means merged into (null when its HEAD is detached).
+*/
+const projectHead = async (root) => {
+	if ((await git(root, [
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		"HEAD"
+	])).code !== 0) return { ok: false };
+	const answer = await git(root, [
+		"symbolic-ref",
+		"--short",
+		"-q",
+		"HEAD"
+	]);
+	return {
+		ok: true,
+		branch: answer.code === 0 ? answer.stdout.trim() : null
+	};
+};
+/** What Ork created in the repo at `root`, from its runs' records and git. */
+const readWorktrees = async (store, root) => ({
+	items: await listOrkWorktrees(root, createdWorktrees(store, root)),
+	live: liveRunIds(store, root)
+});
+/**
+* The plan to remove one item, named by `keyOf`. A branch with no worktree is
+* removed by deleting it, so `deleteBranch` is implied there.
+*/
+const planRemove = ({ items, live }, key, deleteBranch) => {
+	const item = items.find((i) => keyOf(i) === key);
+	if (item === void 0) return {
+		ok: false,
+		error: `No Ork worktree or branch ${key}.`,
+		gone: true
+	};
+	const refusal = removeRefusal(item, live.has(item.runId));
+	if (refusal !== void 0) return {
+		ok: false,
+		error: `Can't remove ${labelOf(item)}: ${refusal}.`,
+		gone: false
+	};
+	const branches = item.branch !== void 0 && (deleteBranch || item.path === null);
+	const careful = cleanStep(item, {
+		branches,
+		force: false,
+		live
+	});
+	if (careful.skip === void 0) return {
+		ok: true,
+		plan: {
+			step: careful,
+			force: false
+		}
+	};
+	return {
+		ok: true,
+		plan: {
+			step: cleanStep(item, {
+				branches,
+				force: true,
+				live
+			}),
+			force: true
+		}
+	};
+};
+const out = async (cwd, args) => lines((await git(cwd, args)).stdout);
+/** What carrying out `plan` would lose, read from git. */
+const lostWork = async (root, { step }) => {
+	const { item } = step;
+	const inside = item.path !== null && !item.missing ? item.path : null;
+	const changes = inside !== null && item.dirty && step.removeWorktree ? await out(inside, ["status", "--porcelain"]) : [];
+	if (step.deleteBranch && item.branch !== void 0 && !item.merged) return {
+		changes,
+		commits: await out(root, [
+			"log",
+			"--oneline",
+			`HEAD..${item.branch}`
+		]),
+		commitsOn: "unmerged"
+	};
+	if (item.branch === void 0 && item.checkedOut === void 0 && inside !== null && item.ahead > 0 && step.removeWorktree) return {
+		changes,
+		commits: await out(inside, [
+			"log",
+			"--oneline",
+			"HEAD",
+			"--not",
+			"--branches",
+			"--tags",
+			"--remotes"
+		]),
+		commitsOn: "no branch"
+	};
+	return {
+		changes,
+		commits: [],
+		commitsOn: null
+	};
+};
+/**
+* Carries out a remove plan; what it did goes into `done` as it goes. The
+* caller has checked that a plan needing `force` was asked to force. It touches
+* only its own item, as each of clean's steps does.
+*/
+const applyRemove = async (root, { step, force }, done = []) => {
+	await applyStep(root, step, force, done);
+	return done;
+};
+export { readWorktrees as a, planLine as c, projectHead as i, removeRefusal as l, lostWork as n, labelOf as o, planRemove as r, mergeStateOf as s, applyRemove as t, stateParts as u };

package/dist/{send-C6yr04Fe.mjs → send-3B64fBNB.mjs}

@@ -1,6 +1,6 @@
-import { Ft as socketPath, It as wakeRun, gt as scriptContactsOf, rt as liveStatus } from "./src-Cz1yOUTg.mjs";
-import { c as openStore, o as writeErr } from "./output-Q2EdeVUt.mjs";
-import { u as inheritedScrubber } from "./src-DtN1k-B3.mjs";
+import { an as wakeRun, ht as liveStatus, kt as scriptContactsOf, rn as socketPath } from "./src-DHvWU4tX.mjs";
+import { c as openStore, o as writeErr } from "./output-B1V6ZJSx.mjs";
+import { u as inheritedScrubber } from "./src-C38BPzit.mjs";
 import { defineCommand } from "citty";
 // ../core/src/remote/send.ts
 /**