@krapht/ork 0.3.0 → 0.4.0

package/dist/clean-Dcr807be.mjs

@@ -0,0 +1,88 @@
+import { E as removeWorktree, O as gitOk } from "./src-CGqMati3.mjs";
+// ../core/src/worktree/clean.ts
+/**
+* @file What `ork worktrees clean` and `ork worktrees remove` do with what
+*   list.ts reads: the plan (what goes, what's kept and why), by one rule for
+*   every caller, and carrying it out. The CLI and the Worktrees panel both
+*   plan here, so neither removes what the other would keep.
+*/
+/** What names an item for `remove`: its branch, or its worktree's path. */
+const keyOf = (item) => item.branch ?? item.path ?? `${item.runId}/${item.nodeId}`;
+/** The reasons no `force` overrides: removing would break something. */
+const MAIN_CHECKOUT = "checked out in the main checkout";
+const RUN_GOING = "its run is still going";
+const kept = (item, skip) => ({
+	item,
+	removeWorktree: false,
+	deleteBranch: false,
+	skip
+});
+/** What clean does with one item. */
+const cleanStep = (item, options) => {
+	if (item.inMainCheckout) return kept(item, MAIN_CHECKOUT);
+	if (item.heldBy !== void 0) return kept(item, `checked out in ${item.heldBy}`);
+	if (options.live?.has(item.runId) === true) return kept(item, RUN_GOING);
+	if (item.dirty && !options.force) return kept(item, "uncommitted changes");
+	if (item.branch === void 0 && item.checkedOut === void 0 && item.ahead > 0 && !options.force) return kept(item, "commits on no branch");
+	const removable = item.path !== null && !item.missing;
+	if (options.branches && item.branch !== void 0 && !item.merged && !options.force) return {
+		item,
+		removeWorktree: removable,
+		deleteBranch: false,
+		skip: "branch not merged"
+	};
+	return {
+		item,
+		removeWorktree: removable,
+		deleteBranch: options.branches && item.branch !== void 0
+	};
+};
+/** Whether a step drops a worktree whose folder is gone, by its own path. */
+const stepPrunes = (step) => step.item.missing && step.item.path !== null && step.skip === void 0;
+/** Whether a step does anything. */
+const stepActs = (step) => step.removeWorktree || step.deleteBranch || stepPrunes(step);
+/**
+* What `ork worktrees clean` would do. A worktree with uncommitted changes, an
+* unmerged branch, or a detached worktree holding commits no branch has, is
+* kept unless `force`; one checked out in the main checkout or in a worktree
+* Ork didn't create, or whose run is still going, is kept even then.
+*/
+const planClean = (items, filter, options) => items.filter((item) => filter.runId === void 0 || item.runId === filter.runId).filter((item) => filter.key === void 0 || keyOf(item) === filter.key).filter((item) => !filter.merged || item.merged).map((item) => cleanStep(item, options));
+/**
+* Carries out one step; what it did goes into `done` as it goes. It touches
+* only its own item: a missing worktree is dropped by its own path (`git
+* worktree remove`), never by `git worktree prune`, which would drop every
+* missing worktree in the repository, the user's own included.
+*/
+const applyStep = async (root, step, force, done) => {
+	const { item } = step;
+	if (stepPrunes(step) && !step.removeWorktree && item.path !== null) {
+		await gitOk(root, [
+			"worktree",
+			"remove",
+			item.path
+		]);
+		done.push(`pruned ${item.path}`);
+	}
+	if (step.removeWorktree && item.path !== null) {
+		await removeWorktree(root, item.path, force);
+		done.push(`removed ${item.path}`);
+	}
+	if (step.deleteBranch && item.branch !== void 0) {
+		await gitOk(root, [
+			"branch",
+			force ? "-D" : "-d",
+			item.branch
+		]);
+		done.push(`deleted ${item.branch}`);
+	}
+};
+/**
+* Carries out a clean plan, step by step. What it did goes into `done` as it
+* goes, so a caller still has it when git fails halfway.
+*/
+const applyClean = async (root, steps, force, done = []) => {
+	for (const step of steps) await applyStep(root, step, force, done);
+	return done;
+};
+export { planClean as a, keyOf as i, applyStep as n, stepActs as o, cleanStep as r, stepPrunes as s, applyClean as t };

package/dist/{context-BFGC_C02.mjs → context-C_bksb0C.mjs}

@@ -1,55 +1,9 @@
-import { E as planNodeSession, Qt as placeFor, Zt as placeFiles, an as practiceInstructions, ct as checkWorkflowText, en as runDirOf, g as workflowTextHash, h as readProjectTriggers, lt as walkChecks, nn as workflowDirOf, on as resolvePractices, rn as inside, ut as walkSummary } from "./src-Cz1yOUTg.mjs";
-import { a as write, c as openStore, i as style, l as storePath, r as plain } from "./output-Q2EdeVUt.mjs";
+import { _n as inside, _t as walkChecks, b as readProjectTriggers, dn as placeFiles, fn as placeFor, gn as workflowDirOf, gt as checkWorkflowText, mn as runDirOf, ot as explainSession, vt as walkSummary, x as workflowTextHash, yn as LESSON_CAP_TOKENS } from "./src-CGqMati3.mjs";
+import { b as builtinWorkflowFile, x as isBuiltinArg, y as builtinProblem } from "./__build_info__-CtSVVuZE.mjs";
+import { a as write, c as openStore, i as style, l as storePath, o as writeErr, r as plain } from "./output-CXSJO00X.mjs";
 import { defineCommand } from "citty";
 import path from "node:path";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-// ../core/src/update/version.ts
-const VERSION = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/u;
-/** `1.2.3`, `v1.2.3-beta.1` and the like; `null` for anything else. */
-const parseVersion = (text) => {
-	const match = VERSION.exec(text.trim());
-	if (match === null) return null;
-	const [, major = "0", minor = "0", patch = "0", pre] = match;
-	return {
-		core: [
-			Number(major),
-			Number(minor),
-			Number(patch)
-		],
-		pre: pre === void 0 ? [] : pre.split(".")
-	};
-};
-const NUMERIC = /^\d+$/u;
-/** One pre-release identifier against another: numbers sort below words. */
-const compareIdentifier = (a, b) => {
-	const an = NUMERIC.test(a);
-	const bn = NUMERIC.test(b);
-	if (an && bn) return Number(a) - Number(b);
-	if (an !== bn) return an ? -1 : 1;
-	return a < b ? -1 : Number(a > b);
-};
-const comparePre = (a, b) => {
-	if (a.length === 0 || b.length === 0) return b.length - a.length;
-	for (let i = 0; i < Math.min(a.length, b.length); i += 1) {
-		const order = compareIdentifier(a[i] ?? "", b[i] ?? "");
-		if (order !== 0) return order;
-	}
-	return a.length - b.length;
-};
-/** Semver precedence: negative when `a` is older, 0 when equal. */
-const compareVersions = (a, b) => {
-	for (let i = 0; i < 3; i += 1) {
-		const order = (a.core[i] ?? 0) - (b.core[i] ?? 0);
-		if (order !== 0) return order;
-	}
-	return comparePre(a.pre, b.pre);
-};
-/** Whether `candidate` is newer than `current`; false when either is invalid. */
-const isNewer = (candidate, current) => {
-	const a = parseVersion(candidate);
-	const b = parseVersion(current);
-	return a !== null && b !== null && compareVersions(a, b) > 0;
-};
 // src/project/place.ts
 /**
 * @file Which project a folder belongs to, from the projects the store has
@@ -74,8 +28,9 @@ const fromCwd = (target, cwd) => inside(cwd, target) ? path.relative(cwd, target
 // src/workflows.ts
 /**
 * @file Finding workflow files: the project's workflows folder by default
-*   (`.ork/workflows/`, or an attached project's), directories expanded, and a
-*   workflow given by name.
+*   (`.ork/workflows/`, or an attached project's), directories expanded, a
+*   workflow given by name, and one of Ork's own by its `ork:` name, written
+*   into the project's run folder.
 */
 const WORKFLOW_DIR = path.join(".ork", "workflows");
 const WORKFLOW_SUFFIX = ".ork.yaml";
@@ -93,16 +48,32 @@ const findWorkflowFiles = (paths, cwd, workflows = path.join(cwd, WORKFLOW_DIR))
 	});
 };
 /**
-* A workflow given by path, or by name for one in the project's workflows
-* folder: `hello` is `.ork/workflows/hello.ork.yaml` when no file `hello`
-* exists.
+* A workflow given by path, by name for one in the project's workflows folder
+* (`hello` is `.ork/workflows/hello.ork.yaml` when no file `hello` exists), or
+* by its `ork:` name for one of Ork's own. An unknown `ork:` name comes back as
+* it is: commands refuse it first (`unknownBuiltin`).
 */
 const resolveWorkflowArg = (arg, cwd, workflows = path.join(cwd, WORKFLOW_DIR)) => {
+	if (isBuiltinArg(arg)) {
+		const file = builtinWorkflowFile(projectAt(cwd), arg);
+		return file === void 0 ? arg : fromCwd(file, cwd);
+	}
 	if (existsSync(path.resolve(cwd, arg)) || arg.endsWith(".ork.yaml")) return arg;
 	const named = path.join(workflows, `${arg}${WORKFLOW_SUFFIX}`);
 	return existsSync(named) ? fromCwd(named, cwd) : arg;
 };
 /**
+* Refuses an `ork:` name that isn't one of Ork's workflows, saying which are,
+* or whose file's place in the project is a link; true when it did, so the
+* command stops.
+*/
+const refusedBuiltin = (args, cwd) => {
+	const problems = args.filter((arg) => isBuiltinArg(arg)).flatMap((arg) => builtinProblem(projectAt(cwd), arg) ?? []);
+	for (const problem of problems) writeErr(problem);
+	if (problems.length > 0) process.exitCode = 1;
+	return problems.length > 0;
+};
+/**
 * A command's workflow argument, by path or by name in the project `cwd` is in,
 * with the project the file belongs to and a run's folder there.
 */
@@ -251,6 +222,7 @@ const validate = defineCommand({
 	},
 	run: async ({ args }) => {
 		const cwd = process.cwd();
+		if (refusedBuiltin(args._, cwd)) return;
 		const files = findWorkflowFiles(args._, cwd, placeFiles(projectAt(cwd)).workflows);
 		if (files.length === 0) {
 			write("No workflow files found. Run `ork init`, or pass a path.");
@@ -279,88 +251,28 @@ const validate = defineCommand({
 // src/commands/context.ts
 /**
 * @file `ork context explain <wf> <node>`: what one node's session would load,
-*   layer by layer. 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. Plans the session without
-*   writing anything.
+*   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.
 */
-/** A rough count, for comparing sizes: about four characters a token. */
-const tokens = (text) => Math.ceil(text.length / 4);
-/** Which project instruction file Claude Code reads from the checkout. */
-const instructionsOf = (stack, checkout) => {
-	if (stack.instructions === "ignore") return "left out (project.instructions: ignore)";
-	const has = (file) => existsSync(path.join(checkout, file));
-	if ([
-		"CLAUDE.md",
-		".claude/CLAUDE.md",
-		"CLAUDE.local.md"
-	].some((file) => has(file))) return "CLAUDE.md, loaded by Claude Code";
-	if (has("AGENTS.md")) return "AGENTS.md, loaded by Claude Code";
-	return "none in the project";
-};
-const skillLines = (stack, root) => stack.skills.map((skill) => {
-	const source = skill.text === void 0 ? path.relative(root, skill.dir) || "." : "built-in";
-	const line = {
-		name: skill.layer !== "project" ? `ork:${skill.name}` : skill.name,
-		layer: skill.layer,
-		source: source.startsWith("..") ? skill.dir : source,
-		state: skill.shadowedBy === void 0 && skill.ignored === void 0 ? "live" : "off",
-		tokens: tokens(skill.text ?? readFileSync(path.join(skill.dir, "SKILL.md"), "utf8"))
-	};
-	if (skill.shadowedBy !== void 0) line.why = `shadowed by the ${skill.shadowedBy} layer`;
-	else if (skill.ignored !== void 0) line.why = skill.ignored === "ignore" ? "project.skills: ignore" : "not in project.skills.allow";
-	return line;
-});
+/** 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 { root } = place;
-	const plan = planNodeSession(workflow, nodeId, {
-		cwd: root,
-		inputs: {},
-		inPlace: true,
-		workflowDir,
-		projectRoot: root,
+	const result = explainSession(workflow, graph, nodeId, {
+		root: place.root,
 		orkDir: place.dir,
+		workflowDir,
 		...home === void 0 ? {} : { home }
 	});
-	if (!plan.ok) return {
+	return result.ok ? result : {
 		ok: false,
-		lines: [plan.error]
-	};
-	const { context } = plan;
-	const practices = practiceInstructions(resolvePractices(workflow, nodeId), root);
-	const names = ["caveman", "ponytail"].filter((n) => !practices.skipped.includes(n));
-	const ref = graph?.agents.get(nodeId);
-	const role = ref === void 0 ? void 0 : workflow.agents?.[ref.name]?.instructions;
-	return {
-		ok: true,
-		explanation: {
-			node: nodeId,
-			type: workflow.nodes[nodeId]?.type ?? "",
-			workflow: workflow.name,
-			...ref === void 0 ? {} : { agent: {
-				name: ref.name,
-				where: ref.where,
-				tokens: tokens(role ?? "")
-			} },
-			instructions: instructionsOf(context, root),
-			skills: skillLines(context, root),
-			files: context.files.map((f) => ({
-				layer: f.layer,
-				name: f.name,
-				tokens: tokens(f.text)
-			})),
-			practices: practices.text.map((text, index) => ({
-				name: names[index] ?? "practice",
-				tokens: tokens(text)
-			})),
-			skippedPractices: practices.skipped,
-			appendedTokens: tokens(plan.spec.systemAppend)
-		}
+		lines: [result.error]
 	};
 };
 const approx = (count) => style("dim", `≈${count.toLocaleString("en")} tokens`);
@@ -368,7 +280,7 @@ 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}`)}`,
+		`${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}`,
@@ -383,7 +295,10 @@ const formatExplanation = (e) => {
 	}
 	lines.push("", style("bold", "Context files"));
 	if (e.files.length === 0) lines.push(style("dim", "  none"));
-	for (const f of e.files) lines.push(`  ${f.layer.padEnd(8)}  ${f.name}  ${approx(f.tokens)}`);
+	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")}`);
@@ -399,7 +314,7 @@ const explain = defineCommand({
 	args: {
 		workflow: {
 			type: "positional",
-			description: "A workflow file, or the name of one in the project's workflows (.ork/workflows/)",
+			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: {
@@ -415,6 +330,7 @@ const explain = defineCommand({
 	},
 	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`);
@@ -432,4 +348,4 @@ const context = defineCommand({
 	},
 	subCommands: { explain }
 });
-export { validate as a, warningLines as c, workflowArg as d, projectAt as f, loadWorkflow as i, WORKFLOW_DIR as l, explainNode as n, validateFile as o, isNewer as p, formatReport as r, walkLoaded as s, context as t, WORKFLOW_SUFFIX as u };
+export { validate as a, warningLines as c, refusedBuiltin as d, workflowArg as f, loadWorkflow as i, WORKFLOW_DIR as l, registeredProjects as m, explainNode as n, validateFile as o, projectAt as p, formatReport as r, walkLoaded as s, context as t, WORKFLOW_SUFFIX as u };

package/dist/{find-BcvhT6UN.mjs → find-DptmbhGd.mjs}

@@ -1,4 +1,4 @@
-import { Qt as placeFor } from "./src-Cz1yOUTg.mjs";
+import { fn as placeFor } from "./src-CGqMati3.mjs";
 import { randomUUID } from "node:crypto";
 // ../core/src/remote/find.ts
 /**

package/dist/{format-DqpObyMl.mjs → format-J-a21Yvn.mjs}

@@ -1,166 +1,6 @@
-import { C as gitOk, S as git, rt as liveStatus, w as lines, x as removeWorktree } from "./src-Cz1yOUTg.mjs";
-import { i as style, n as cost } from "./output-Q2EdeVUt.mjs";
+import { lt as liveStatus } from "./src-CGqMati3.mjs";
+import { i as style, n as cost } from "./output-CXSJO00X.mjs";
 import { createInterface } from "node:readline/promises";
-import { existsSync } from "node:fs";
-// ../core/src/worktree/list.ts
-/**
-* @file What `ork worktrees` shows and cleans: every worktree and branch Ork's
-*   runs recorded creating, whatever the project's git rules named them, and
-*   any `ork/*` branch besides, with their state read from git itself.
-*/
-/**
-* The worktrees the project's runs recorded creating, oldest run first; one
-* entry per branch or folder, from the latest run that created it.
-*/
-const createdWorktrees = (store, project) => {
-	const byName = /* @__PURE__ */ new Map();
-	for (const run of store.runs({ project }).toReversed()) for (const { event } of store.events(run.id)) {
-		if (event.type !== "worktree" || event.action !== "created") continue;
-		byName.set(event.branch ?? event.path, {
-			runId: run.id,
-			nodeId: event.id,
-			path: event.path,
-			...event.branch === void 0 ? {} : { branch: event.branch }
-		});
-	}
-	return [...byName.values()];
-};
-const parsePorcelain = (text) => text.split("\n\n").map((block) => lines(block)).map((fields) => {
-	const value = (key) => fields.find((f) => f.startsWith(`${key} `))?.slice(key.length + 1);
-	return {
-		path: value("worktree") ?? "",
-		branch: (value("branch") ?? "").replace(/^refs\/heads\//u, ""),
-		prunable: fields.some((f) => f.startsWith("prunable"))
-	};
-}).filter((entry) => entry.path !== "");
-/** The `ork/<run>/<node>` branches of runs that recorded nothing. */
-const prefixed = (branch) => {
-	const [, runId = "", ...rest] = branch.split("/");
-	return {
-		runId,
-		nodeId: rest.join("/"),
-		path: "",
-		branch
-	};
-};
-/** How many commits a detached worktree holds that no branch, tag or remote has. */
-const onNoBranch = async (entry) => entry === void 0 ? "0" : (await git(entry.path, [
-	"rev-list",
-	"--count",
-	"HEAD",
-	"--not",
-	"--branches",
-	"--tags",
-	"--remotes"
-])).stdout;
-/** One created worktree or branch, with its state read from git. */
-const stateOf = async (root, entries, item) => {
-	const { branch } = item;
-	const entry = branch === void 0 ? entries.find((e) => e.path === item.path) : entries.find((e) => e.branch === branch);
-	const missing = entry !== void 0 && (entry.prunable || !existsSync(entry.path));
-	const status = entry === void 0 || missing ? "" : (await git(entry.path, ["status", "--porcelain"])).stdout;
-	const checkedOut = branch === void 0 && entry !== void 0 && entry.branch !== "" ? entry.branch : void 0;
-	const on = branch ?? checkedOut;
-	const counted = on === void 0 ? await onNoBranch(entry === void 0 || missing ? void 0 : entry) : (await git(root, [
-		"rev-list",
-		"--count",
-		`HEAD..${on}`
-	])).stdout;
-	const ahead = Number(counted);
-	return {
-		...branch === void 0 ? {} : { branch },
-		...checkedOut === void 0 ? {} : { checkedOut },
-		runId: item.runId,
-		nodeId: item.nodeId,
-		path: entry?.path ?? null,
-		missing,
-		dirty: lines(status).length > 0,
-		ahead: Number.isNaN(ahead) ? 0 : ahead,
-		merged: on !== void 0 && ahead === 0,
-		inMainCheckout: entry?.path === root
-	};
-};
-/**
-* Every worktree and branch Ork's runs created in the repository at `root`,
-* with its state: those the runs recorded (`created`, whatever the project's
-* git rules named them), and any `ork/` branch besides. A recorded one that git
-* no longer has is left out.
-*/
-const listOrkWorktrees = async (root, created = []) => {
-	const entries = parsePorcelain(await gitOk(root, [
-		"worktree",
-		"list",
-		"--porcelain"
-	]));
-	const branches = lines(await gitOk(root, [
-		"for-each-ref",
-		"--format=%(refname:short)",
-		"refs/heads/"
-	]));
-	const recordedBranches = new Set(created.flatMap((c) => c.branch ?? []));
-	const items = [...created.filter((c) => c.branch === void 0 ? entries.some((e) => e.path === c.path) : branches.includes(c.branch)), ...branches.filter((b) => b.startsWith("ork/") && !recordedBranches.has(b)).map((b) => prefixed(b))];
-	return Promise.all(items.map((item) => stateOf(root, entries, item)));
-};
-const cleanStep = (item, options) => {
-	if (item.inMainCheckout) return {
-		item,
-		removeWorktree: false,
-		deleteBranch: false,
-		skip: "checked out in the main checkout"
-	};
-	if (item.dirty && !options.force) return {
-		item,
-		removeWorktree: false,
-		deleteBranch: false,
-		skip: "uncommitted changes"
-	};
-	if (item.branch === void 0 && item.checkedOut === void 0 && item.ahead > 0 && !options.force) return {
-		item,
-		removeWorktree: false,
-		deleteBranch: false,
-		skip: "commits on no branch"
-	};
-	const removable = item.path !== null && !item.missing;
-	if (options.branches && item.branch !== void 0 && !item.merged && !options.force) return {
-		item,
-		removeWorktree: removable,
-		deleteBranch: false,
-		skip: "branch not merged"
-	};
-	return {
-		item,
-		removeWorktree: removable,
-		deleteBranch: options.branches && item.branch !== void 0
-	};
-};
-/**
-* What `ork worktrees clean` would do. A worktree with uncommitted changes, an
-* unmerged branch, or a detached worktree holding commits no branch has, is
-* kept unless `force`.
-*/
-const planClean = (items, filter, options) => items.filter((item) => filter.runId === void 0 || item.runId === filter.runId).filter((item) => !filter.merged || item.merged).map((item) => cleanStep(item, options));
-/** Carries out a clean plan, then prunes stale worktree entries. */
-const applyClean = async (root, steps, force) => {
-	const done = [];
-	await gitOk(root, ["worktree", "prune"]);
-	for (const step of steps) {
-		const { item } = step;
-		if (step.removeWorktree && item.path !== null) {
-			await removeWorktree(root, item.path, force);
-			done.push(`removed ${item.path}`);
-		}
-		if (step.deleteBranch && item.branch !== void 0) {
-			await gitOk(root, [
-				"branch",
-				force ? "-D" : "-d",
-				item.branch
-			]);
-			done.push(`deleted ${item.branch}`);
-		}
-	}
-	await gitOk(root, ["worktree", "prune"]);
-	return done;
-};
 // src/human.ts
 /**
 * @file The terminal `HumanChannel`: answers `ask_user` questions, gates and
@@ -550,4 +390,4 @@ const formatTree = (roots) => {
 		return `${text.padEnd(label)}  ${style("dim", node.type.padEnd(type))}  ${state}${usage}`;
 	});
 };
-export { formatRunEvent as a, createdWorktrees as c, formatEvent as i, listOrkWorktrees as l, formatRuns as n, createTerminalHuman as o, formatTree as r, applyClean as s, ago as t, planClean as u };
+export { formatRunEvent as a, formatEvent as i, formatRuns as n, createTerminalHuman as o, formatTree as r, ago as t };

package/dist/{in-a-run-BbLhZOFW.mjs → in-a-run-D1Qc5Mit.mjs}

@@ -1,4 +1,4 @@
-import { p as runMarkerIn } from "./src-DtN1k-B3.mjs";
+import { p as runMarkerIn } from "./src-UWkk1sl9.mjs";
 // src/commands/in-a-run.ts
 /**
 * @file The commands that act as the user refuse a program or an agent in a run

package/dist/{limits-BKYAmqCR.mjs → limits-BDZCmGEu.mjs}

@@ -1,4 +1,4 @@
-import { a as limitsNow, i as NOT_STARTED, o as limitsReport, r as capsHere } from "./src-Cz1yOUTg.mjs";
+import { a as limitsNow, i as NOT_STARTED, o as limitsReport, r as capsHere } from "./src-CGqMati3.mjs";
 // src/run/limits.ts
 /**
 * @file The limits across runs that apply here (RFC-007): the user's settings

package/dist/list-ZvY2OcLq.mjs

@@ -0,0 +1,110 @@
+import { D as git, O as gitOk, k as lines } from "./src-CGqMati3.mjs";
+import { existsSync } from "node:fs";
+// ../core/src/worktree/list.ts
+/**
+* @file What `ork worktrees` shows: every worktree and branch Ork's runs
+*   recorded creating, whatever the project's git rules named them, and any
+*   `ork/*` branch besides, with their state read from git itself. What clean
+*   and remove do with them is clean.ts.
+*/
+/**
+* The worktrees the project's runs recorded creating, oldest run first; one
+* entry per branch or folder, from the latest run that created it.
+*/
+const createdWorktrees = (store, project) => {
+	const byName = /* @__PURE__ */ new Map();
+	for (const run of store.runs({ project }).toReversed()) for (const { event } of store.events(run.id)) {
+		if (event.type !== "worktree" || event.action !== "created") continue;
+		byName.set(event.branch ?? event.path, {
+			runId: run.id,
+			nodeId: event.id,
+			path: event.path,
+			...event.branch === void 0 ? {} : { branch: event.branch }
+		});
+	}
+	return [...byName.values()];
+};
+const parsePorcelain = (text) => text.split("\n\n").map((block) => lines(block)).map((fields) => {
+	const value = (key) => fields.find((f) => f.startsWith(`${key} `))?.slice(key.length + 1);
+	return {
+		path: value("worktree") ?? "",
+		branch: (value("branch") ?? "").replace(/^refs\/heads\//u, ""),
+		prunable: fields.some((f) => f.startsWith("prunable"))
+	};
+}).filter((entry) => entry.path !== "");
+/**
+* The `ork/<run>/<node>` branches of runs that recorded nothing; with no path
+* recorded, the worktree is whichever has the branch checked out.
+*/
+const prefixed = (branch) => {
+	const [, runId = "", ...rest] = branch.split("/");
+	return {
+		runId,
+		nodeId: rest.join("/"),
+		path: "",
+		branch
+	};
+};
+/** How many commits a detached worktree holds that no branch, tag or remote has. */
+const onNoBranch = async (entry) => entry === void 0 ? "0" : (await git(entry.path, [
+	"rev-list",
+	"--count",
+	"HEAD",
+	"--not",
+	"--branches",
+	"--tags",
+	"--remotes"
+])).stdout;
+/** One created worktree or branch, with its state read from git. */
+const stateOf = async (root, entries, item) => {
+	const { branch } = item;
+	const entry = branch === void 0 || item.path !== "" ? entries.find((e) => e.path === item.path) : entries.find((e) => e.branch === branch);
+	const holder = branch === void 0 ? void 0 : entries.find((e) => e.branch === branch && e.path !== entry?.path);
+	const missing = entry !== void 0 && (entry.prunable || !existsSync(entry.path));
+	const status = entry === void 0 || missing ? "" : (await git(entry.path, ["status", "--porcelain"])).stdout;
+	const checkedOut = branch === void 0 && entry !== void 0 && entry.branch !== "" ? entry.branch : void 0;
+	const on = branch ?? checkedOut;
+	const counted = on === void 0 ? await onNoBranch(entry === void 0 || missing ? void 0 : entry) : (await git(root, [
+		"rev-list",
+		"--count",
+		`HEAD..${on}`
+	])).stdout;
+	const ahead = Number(counted);
+	const changes = lines(status).length;
+	return {
+		...branch === void 0 ? {} : { branch },
+		...checkedOut === void 0 ? {} : { checkedOut },
+		runId: item.runId,
+		nodeId: item.nodeId,
+		path: entry?.path ?? null,
+		missing,
+		dirty: changes > 0,
+		changes,
+		ahead: Number.isNaN(ahead) ? 0 : ahead,
+		merged: on !== void 0 && ahead === 0,
+		inMainCheckout: entry?.path === root || holder?.path === root,
+		...holder === void 0 || holder.path === root ? {} : { heldBy: holder.path }
+	};
+};
+/**
+* Every worktree and branch Ork's runs created in the repository at `root`,
+* with its state: those the runs recorded (`created`, whatever the project's
+* git rules named them), and any `ork/` branch besides. A recorded one that git
+* no longer has is left out.
+*/
+const listOrkWorktrees = async (root, created = []) => {
+	const entries = parsePorcelain(await gitOk(root, [
+		"worktree",
+		"list",
+		"--porcelain"
+	]));
+	const branches = lines(await gitOk(root, [
+		"for-each-ref",
+		"--format=%(refname:short)",
+		"refs/heads/"
+	]));
+	const recordedBranches = new Set(created.flatMap((c) => c.branch ?? []));
+	const items = [...created.filter((c) => c.branch === void 0 ? entries.some((e) => e.path === c.path) : branches.includes(c.branch)), ...branches.filter((b) => b.startsWith("ork/") && !recordedBranches.has(b)).map((b) => prefixed(b))];
+	return Promise.all(items.map((item) => stateOf(root, entries, item)));
+};
+export { listOrkWorktrees as n, createdWorktrees as t };