@krapht/ork 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/verdict-B592j1W3.mjs

@@ -0,0 +1,84 @@
+import { D as apply, v as termOf } from "./output-DXZbnFt_.mjs";
+import { r as chip, t as CHIP_LABELS } from "./chips-CP_pgKlj.mjs";
+// src/run/view.ts
+/**
+* @file How a run's lines are drawn: the terminal kit's {@link Term} for the
+*   stream they go to, and what a transcript has to remember between events (a
+*   node's worktree, to show its paths relative to it). Plain, a view draws
+*   today's line-based transcript; rich, it draws chips and cuts to the width.
+*/
+/** A view for `stream` (stdout when not given), as `env` sets it. */
+const createView = (stream = process.stdout, env = process.env) => ({
+	term: termOf(stream, env),
+	roots: /* @__PURE__ */ new Map()
+});
+/** Styles text for `term`: no escape codes when it is plain. */
+const styler = (term) => (format, text) => apply(term, format, text);
+// src/run/format-bus.ts
+/** The first line of a message body, cut to fit one terminal line. */
+const firstLine = (body) => {
+	const [line = ""] = body.trim().split("\n");
+	return line.length > 100 ? `${line.slice(0, 99)}…` : line;
+};
+/** Messages, owner questions and claims, without the node prefix. */
+const formatBusEvent = (event, term = createView().term) => {
+	const style = styler(term);
+	if (event.type === "claim.taken") return [style("dim", `⚑ claimed ${event.resource}`)];
+	if (event.type === "claim.refused") {
+		const held = event.held === event.resource ? "" : ` (it holds ${event.held})`;
+		return [style("yellow", `⚑ ${event.resource} is ${event.holder}'s${held}`)];
+	}
+	if (event.type === "claim.released") return [style("dim", `⚑ released ${event.resource}`)];
+	if (event.type === "message.sent") {
+		const how = event.via === void 0 ? "" : ` (${event.via})`;
+		return [style("dim", `✉ to ${event.to}${how}: ${firstLine(event.body)}`)];
+	}
+	if (event.type === "message.received") {
+		const how = event.via === void 0 ? "" : ` (${event.via})`;
+		return [style("dim", `✉ from ${event.from}${how}: ${firstLine(event.body)}`)];
+	}
+	if (event.type === "call.started") return [style("dim", `↳ started ${event.workflow} as run ${event.run}`)];
+	if (event.type === "link.notice") return [style("dim", `↔ ${event.text}`)];
+	if (event.type === "message.read") return [];
+	if (event.type === "owner.asked") return [`${term.rich ? chip(term, CHIP_LABELS.ask, "accent") : style(["yellow", "bold"], "?")} asked as the owner of ${event.about}: ${event.text} ${style("dim", `(${event.question})`)}`];
+	if (event.type === "owner.answered") return [style("dim", `→ ${event.answer} (owner)`)];
+	return [style("dim", "→ its session ended first; asking you")];
+};
+// src/run/items-ran.ts
+/**
+* @file How a fan-out's finished line counts its items: only the ones that
+*   started.
+*/
+/** How many of a fan-out's items started; a skipped one never did. */
+const itemsRan = (count, statuses) => {
+	const ran = Array.isArray(statuses) ? statuses.filter((status) => status !== "skipped").length : count;
+	return ran === count ? `${String(count)} ran` : `${String(ran)} of ${String(count)} ran`;
+};
+// src/run/verdict.ts
+/**
+* @file The one-line verdict of a finished node: its report's status, unless
+*   the node failed or its work did not merge.
+*/
+/** Whether a finished node's work did not merge into its owner. */
+const hasConflict = (output) => {
+	const { merge } = output;
+	return typeof merge === "object" && merge !== null && "ok" in merge && merge.ok === false;
+};
+/**
+* A one-line verdict for a finished node, by what its type outputs. A node that
+* failed reads `fail` even when its report said `pass` (a hook refused its
+* commit); a child that did not merge says so.
+*/
+const nodeVerdict = (output, ok = true, error) => {
+	const { status, summary, exitCode, choice, answeredBy, count } = output;
+	if (typeof status === "string") {
+		if (!ok && (status === "pass" || status === "done")) return error === void 0 ? "fail" : `fail: ${firstLine(error)}`;
+		const label = hasConflict(output) ? `${status}, merge conflict` : status;
+		return typeof summary === "string" && summary !== "" ? `${label}: ${summary}` : label;
+	}
+	if (typeof exitCode === "number") return `exit ${String(exitCode)}`;
+	if (typeof choice === "string") return `${choice} (${String(answeredBy)})`;
+	if (typeof count === "number") return itemsRan(count, output["statuses"]);
+	return "done";
+};
+export { createView as a, formatBusEvent as i, nodeVerdict as n, styler as o, firstLine as r, hasConflict as t };

package/dist/{watch-CtbgDAcz.mjs → watch-DV3ixCYj.mjs}

@@ -1,9 +1,10 @@
-import { $n as timeoutMs, S as readProjectTriggers, T as watchingPid, Wn as CheckReportSchema, Xn as isToolNode, b as triggerStanding, bn as placeFiles, ht as liveStatus, ot as detachRun, v as triggersReport, w as takeWatchLock, x as declaredTriggers, xt as stillTheSameProcess, y as createWatcher } from "./src-Dujmvv4s.mjs";
-import { n as newRunId } from "./find-D6Gj1sxg.mjs";
-import { a as write, c as openStore, i as style, o as writeErr, r as plain, t as confirm } from "./output-BLQWD6MJ.mjs";
-import { i as runLimits, r as limitsRefusal } from "./limits-B1-DYc3d.mjs";
-import { c as toolExecutor, o as spawnTool, s as mcpCallExecutor } from "./src-DOcK8Jfp.mjs";
-import { t as acceptRefusal } from "./in-a-run-pLAZeNys.mjs";
+import { A as triggerStanding, F as watchingPid, Kr as placeFiles, M as readProjectTriggers, O as triggersReport, Oi as timeoutMs, P as takeWatchLock, Pn as liveStatus, R as openStore, Un as stillTheSameProcess, gr as runGh, j as declaredTriggers, k as createWatcher, pt as detachRun, wi as isToolNode, xn as startFollowUpChecks, yi as CheckReportSchema } from "./src-BuF9Lbow.mjs";
+import { c as toolExecutor, o as spawnTool, s as mcpCallExecutor } from "./src-k0A_QpST.mjs";
+import { n as newRunId } from "./find-Ct5CNl1J.mjs";
+import { a as plain, c as write, l as writeErr, s as style, t as confirm, v as termOf, x as widthOf, y as cut } from "./output-DXZbnFt_.mjs";
+import { r as chip, t as CHIP_LABELS } from "./chips-CP_pgKlj.mjs";
+import { i as runLimits, r as limitsRefusal } from "./limits-BD6RZRCS.mjs";
+import { t as acceptRefusal } from "./in-a-run-D_wg4iJi.mjs";
 import path from "node:path";
 import { mkdirSync } from "node:fs";
 import { homedir } from "node:os";
@@ -63,7 +64,7 @@ const lookAt = async (options) => {
 	});
 	return result.ok ? resultOf(result.output["json"]) : {
 		ok: false,
-		error: result.error ?? "the check failed"
+		error: [result.error ?? "the check failed", result.end?.detail].filter((part) => part !== void 0).join(": ")
 	};
 };
 // src/watch/report.ts
@@ -73,10 +74,21 @@ const STANDING = {
 	changed: "off: changed since it was accepted",
 	invalid: "off: has an error"
 };
-const brokenLines = (broken) => broken.map(({ file, message }) => `${style("red", "✗")} ${plain(file)}: ${plain(message)}`);
-const statusLines = (report) => {
+/** A failure's mark: a `FAIL` chip when rich, else the red `✗`. */
+const failMark = (term) => term.rich ? chip(term, CHIP_LABELS.fail, "danger") : style("red", "✗");
+/** A warning's mark: a `WARN` chip when rich, else the yellow `!`. */
+const warnMark = (term) => term.rich ? chip(term, CHIP_LABELS.warn, "warn") : style("yellow", "!");
+/** A trigger's standing, rich: a chip and what it adds. */
+const standingChip = (term, standing) => {
+	const live = standing === "live";
+	const label = live ? "LIVE" : "OFF";
+	const text = STANDING[standing] ?? standing;
+	return `${chip(term, label, live ? "ok" : standing === "invalid" ? "danger" : "warn")}${live ? "" : ` ${text.replace(/^off: /u, "")}`}`;
+};
+const brokenLines = (broken, term = termOf(process.stdout)) => broken.map(({ file, message }) => `${failMark(term)} ${plain(file)}: ${plain(message)}`);
+const statusLines = (report, term = termOf(process.stdout)) => {
 	const head = report.pid === void 0 ? "ork watch isn't running. Start it with `ork watch`, or `ork watch --detach`." : `ork watch is running (process ${String(report.pid)}).`;
-	const broken = brokenLines(report.broken);
+	const broken = brokenLines(report.broken, term);
 	if (report.triggers.length === 0) return [
 		head,
 		...broken,
@@ -86,11 +98,11 @@ const statusLines = (report) => {
 		head,
 		...broken,
 		...report.triggers.flatMap((status) => [
-			`${style("bold", plain(status.trigger))} ${style("dim", plain(`${status.project} → ${status.run}, every ${status.every}`))}`,
-			`  ${STANDING[status.standing] ?? status.standing}${status.lookedAt === void 0 ? "" : `, last looked ${status.lookedAt}`}`,
+			term.rich ? `${style("bold", plain(status.trigger))} ${style("dim", cut(plain(`${status.project} → ${status.run}, every ${status.every}`), Math.max(8, term.width - widthOf(status.trigger) - 1)))}` : `${style("bold", plain(status.trigger))} ${style("dim", plain(`${status.project} → ${status.run}, every ${status.every}`))}`,
+			`  ${term.rich ? standingChip(term, status.standing) : STANDING[status.standing] ?? status.standing}${status.lookedAt === void 0 ? "" : `, last looked ${status.lookedAt}`}`,
 			...status.error === void 0 ? [] : [`  last look: ${plain(status.error)}`],
 			...status.held === void 0 ? [] : [`  waiting: ${plain(status.held)}`],
-			...status.problems.map((problem) => `  ${style("red", "✗")} ${plain(problem)}`)
+			...status.problems.map((problem) => `  ${failMark(term)} ${plain(problem)}`)
 		])
 	];
 };
@@ -120,22 +132,26 @@ const checkLines = (item) => {
 const workflowLines = ({ workflow, workflowFile }) => {
 	if (workflow === null) return [];
 	const budget = workflow.limits?.budgetUsd;
-	return [`  workflow: ${plain(workflowFile)}${budget === void 0 ? "" : `, up to $${String(budget)} a run`}`, ...Object.entries(workflow.nodes).map(([id, node]) => `    ${plain(id)}: ${plain(node.type)}`)];
+	const tokens = workflow.limits?.budgetTokens;
+	const caps = [...budget === void 0 ? [] : [`$${String(budget)}`], ...tokens === void 0 ? [] : [`${String(tokens)} tokens`]];
+	return [`  workflow: ${plain(workflowFile)}${caps.length === 0 ? "" : `, up to ${caps.join(" and ")} a run`}`, ...Object.entries(workflow.nodes).map(([id, node]) => `    ${plain(id)}: ${plain(node.type)}`)];
 };
 const STANDS = {
 	new: "new",
 	changed: "changed since you accepted it, here or in the workflow it starts"
 };
-const acceptLines = (item, standing) => [
+const acceptLines = (item, standing, term = termOf(process.stdout)) => [
 	`${style("bold", plain(item.id))} ${style("dim", plain(item.place.root))}`,
 	`  ${STANDS[standing] ?? standing}`,
 	...checkLines(item),
 	`  starts: ${plain(item.trigger.run)}, looking every ${item.trigger.every}, with up to ${String(item.trigger.maxRunsPerDay ?? 10)} runs a day`,
 	...workflowLines(item),
-	...item.diagnostics.filter(({ severity }) => severity === "warning").map(({ message }) => `  ${style("yellow", "!")} ${plain(message)}`)
+	...item.diagnostics.filter(({ severity }) => severity === "warning").map(({ message }) => `  ${warnMark(term)} ${plain(message)}`)
 ];
 /** The triggers `--accept` can't offer, so they aren't silently left out. */
-const unacceptableLines = (item) => [`${style("bold", plain(item.id))} ${style("dim", plain(item.place.root))}`, ...item.diagnostics.filter(({ severity }) => severity === "error").map(({ message }) => `  ${style("red", "✗")} ${plain(message)}`)];
+const unacceptableLines = (item, term = termOf(process.stdout)) => [`${style("bold", plain(item.id))} ${style("dim", plain(item.place.root))}`, ...item.diagnostics.filter(({ severity }) => severity === "error").map(({ message }) => `  ${failMark(term)} ${plain(message)}`)];
+/** What `ork watch` says when follow-ups come due. */
+const dueLines = (due) => due.map((f) => `▸ follow-up due (${plain(f.for)}): ${plain(f.title)}${f.note === void 0 ? "" : ` (${plain(f.note)})`}, \`ork follow-ups show ${f.id}\``);
 // src/watch/start.ts
 /**
 * @file Starting a trigger's run (RFC-011): an ordinary run in the background,
@@ -259,7 +275,19 @@ const watchLoop = async (store) => {
 	const timer = setInterval(() => {
 		watcher.tick();
 	}, TICK_MS);
+	const stopChecks = startFollowUpChecks({
+		rows: store,
+		gh: runGh,
+		projects: () => store.projects().map((project) => project.root),
+		onDue: (due) => {
+			for (const line of dueLines(due)) write(line);
+		},
+		onError: (error) => {
+			writeErr(`follow-ups: ${error}`);
+		}
+	});
 	await stopped;
+	stopChecks();
 	clearInterval(timer);
 	stopping.abort();
 	await watcher.settled();

package/dist/{workflows-D1_WVukk.mjs → workflows-QLjBhGNS.mjs}

@@ -1,8 +1,8 @@
-import { Cn as runDirOf, En as inside, bn as placeFiles, xn as placeFor } from "./src-Dujmvv4s.mjs";
-import { i as builtinWorkflowFile, r as builtinProblem, s as isBuiltinArg } from "./decide-CGyx9rv7.mjs";
-import { c as openStore, l as storePath, o as writeErr } from "./output-BLQWD6MJ.mjs";
+import { Kr as placeFiles, Qr as inside, R as openStore, Yr as runDirOf, qr as placeFor, z as storePath } from "./src-BuF9Lbow.mjs";
+import { a as isBuiltinArg, n as builtinWorkflowFile, t as builtinProblem } from "./builtin-files-YYAnbZGD.mjs";
+import { l as writeErr } from "./output-DXZbnFt_.mjs";
 import path from "node:path";
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 // src/project/place.ts
 /**
 * @file Which project a folder belongs to, from the projects the store has
@@ -40,6 +40,7 @@ const WORKFLOW_SUFFIX = ".ork.yaml";
 * that folder.
 */
 const findWorkflowFiles = (paths, cwd, workflows = path.join(cwd, WORKFLOW_DIR)) => {
+	if (paths.length === 0 && !existsSync(workflows)) return [];
 	return (paths.length > 0 ? paths : [fromCwd(workflows, cwd)]).flatMap((target) => {
 		const absolute = path.resolve(cwd, target);
 		if (existsSync(absolute) && statSync(absolute).isDirectory()) return readdirSync(absolute).filter((name) => name.endsWith(WORKFLOW_SUFFIX)).toSorted().map((name) => path.join(target, name));
@@ -85,4 +86,28 @@ const workflowArg = (arg, cwd) => {
 		runDir: (runId) => runDirOf(place, runId)
 	};
 };
-export { resolveWorkflowArg as a, registeredProjects as c, refusedBuiltin as i, WORKFLOW_SUFFIX as n, workflowArg as o, findWorkflowFiles as r, projectAt as s, WORKFLOW_DIR as t };
+/**
+* The `name:` line of a workflow file, read without parsing it (it may be
+* broken).
+*/
+const nameOf = (file) => {
+	try {
+		return /^name:\s*["']?([^\s"'#]+)/mu.exec(readFileSync(file, "utf8"))?.[1];
+	} catch {
+		return;
+	}
+};
+/**
+* The text for a workflow argument that is no file: the workflows the project
+* has, by file name (and `name:` when it differs), and that a file name or path
+* is what the command takes. Empty-handed when the folder is missing.
+*/
+const missingWorkflowText = (arg, workflows) => {
+	const listed = (existsSync(workflows) ? readdirSync(workflows).filter((name) => name.endsWith(WORKFLOW_SUFFIX)).toSorted() : []).map((file) => {
+		const name = nameOf(path.join(workflows, file));
+		const stem = file.slice(0, -9);
+		return name === void 0 || name === stem ? file : `${file} (${name})`;
+	});
+	return `no workflow file ${arg}; a file name or path is meant, not a workflow name (${listed.length === 0 ? "this project has no workflows" : `this project's workflows: ${listed.join(", ")}`})`;
+};
+export { refusedBuiltin as a, projectAt as c, missingWorkflowText as i, registeredProjects as l, WORKFLOW_SUFFIX as n, resolveWorkflowArg as o, findWorkflowFiles as r, workflowArg as s, WORKFLOW_DIR as t };

package/dist/worktrees-D3ubG_Qw.mjs

@@ -0,0 +1,302 @@
+import { $t as planClean, Qt as keyOf, R as openStore, Xt as applyClean, Yt as worktreeListTable, a as planRemove, c as repoRoot, d as mergeStateOf, en as stepActs, f as planLine, i as lostWork, l as isDetached, m as stateParts, nn as inspectProject, r as applyRemove, s as readWorktrees, u as labelOf } from "./src-BuF9Lbow.mjs";
+import { t as applyFilters } from "./apply-Mb0fNpCX.mjs";
+import { c as write, k as paint, l as writeErr, s as style, t as confirm, v as termOf, y as cut } from "./output-DXZbnFt_.mjs";
+import { r as chip } from "./chips-CP_pgKlj.mjs";
+import { c as refuseUnknownFlags, i as readListArgs, n as filterArgs, o as resolveRun, r as projectScope } from "./flags-C90N4J1i.mjs";
+import { t as printList } from "./print-DzugGZQB.mjs";
+import { r as withStore } from "./project-records-CtkmlsHN.mjs";
+import path from "node:path";
+import { existsSync, realpathSync } from "node:fs";
+import { defineCommand } from "citty";
+// src/project/go-ahead.ts
+/**
+* @file The question `ork worktrees clean` and `remove` ask before they act:
+*   skipped with `--yes`, impossible without a terminal (so `--yes` is needed),
+*   and a no says so rather than leaving the command silent.
+*/
+/** Whether to carry on; says why not when it won't. */
+const goAhead = async (yes, verb, terminal = process.stdin.isTTY, ask = confirm) => {
+	if (yes) return true;
+	if (!terminal) {
+		writeErr(`Pass --yes to ${verb} without a terminal.`);
+		process.exitCode = 1;
+		return false;
+	}
+	if (await ask("Go ahead?")) return true;
+	write("Cancelled.");
+	return false;
+};
+// src/project/worktrees.ts
+/**
+* @file What `ork worktrees` reads across projects, and prints: each worktree
+*   or branch a run left, with its state read from git, the plan `ork worktrees
+*   clean` or `remove` would carry out, and what a forced remove would lose.
+*   The words are core's (worktree/words.ts), which the Worktrees panel says
+*   too; this only colors them.
+*/
+/** One line of state: its merge state, then what clean would care about. */
+const worktreeState = (item, term = termOf(process.stdout)) => {
+	const merge = mergeStateOf(item);
+	const head = merge === "merged" ? [term.rich ? chip(term, "MERGED", "ok") : style("green", "merged")] : merge === "detached" ? ["detached"] : [];
+	const parts = stateParts(item).map((part) => part.risk ? paint(term, "warn", part.text) : part.text);
+	return [...head, ...parts].join(" · ");
+};
+/** A name as the list shows it, saying when it's detached. */
+const nameOf = (item) => isDetached(item) ? `${labelOf(item)} (detached)` : labelOf(item);
+const formatWorktrees = (items, term = termOf(process.stdout)) => {
+	if (items.length === 0) return ["No Ork worktrees or branches."];
+	const width = Math.max(...items.map((i) => nameOf(i).length));
+	return items.flatMap((item) => [`${style("bold", nameOf(item).padEnd(width))}  ${worktreeState(item, term)}`, ...item.path === null ? [] : [`  ${style("dim", term.rich ? cut(item.path, term.width - 2) : item.path)}`]]);
+};
+const formatPlan = (steps) => steps.map((step) => {
+	const { text, reason } = planLine(step);
+	return `  ${text}${reason === void 0 ? "" : style("dim", ` (${reason})`)}`;
+});
+/** What a forced remove loses, as git prints it, under a heading each. */
+const formatLost = (lost) => [...lost.changes.length === 0 ? [] : ["Uncommitted changes:", ...lost.changes.map((line) => `  ${line}`)], ...lost.commits.length === 0 ? [] : [lost.commitsOn === "no branch" ? "Commits on no branch:" : "Commits not merged:", ...lost.commits.map((line) => `  ${line}`)]];
+/** What a forced clean loses, item by item: the same lines `remove` prints. */
+const formatLosses = (losses) => losses.flatMap(({ item, lost }) => {
+	const lines = formatLost(lost);
+	return lines.length === 0 ? [] : [`Loses in ${labelOf(item)}:`, ...lines];
+});
+/** What Ork created in each registered project's repository still on disk. */
+const inProjects = async (roots) => {
+	const store = openStore();
+	try {
+		return (await Promise.all([...new Set(roots)].filter((root) => existsSync(root)).map(async (root) => {
+			try {
+				return (await readWorktrees(store, root)).items;
+			} catch (error) {
+				writeErr(`Skipped ${root}: ${error instanceof Error ? error.message : String(error)}`);
+				return [];
+			}
+		}))).flat();
+	} finally {
+		store.close();
+	}
+};
+// src/commands/worktrees.ts
+/**
+* @file `ork worktrees` (or `ork wt`): lists the worktrees and branches runs
+*   left behind (those the runs recorded creating, whatever the project's git
+*   rules named them, and any `ork/` branch), with their state read from git;
+*   cleans them up safely after showing the plan and asking; and removes one,
+*   the twin of the Worktrees panel's Remove…. The plans are core's, so the
+*   panel keeps and removes exactly what these do.
+*/
+/**
+* The repo this folder is in, and what Ork created there; null outside one. A
+* repo with no commit has nothing of Ork's, which only a read says as an empty
+* list.
+*/
+const here = async (emptyWithoutCommit = false) => {
+	const cwd = process.cwd();
+	const root = (await inspectProject(cwd))?.root ?? null;
+	if (root === null) {
+		const bare = emptyWithoutCommit ? await repoRoot(cwd) : null;
+		if (bare !== null) return {
+			root: bare,
+			items: [],
+			live: /* @__PURE__ */ new Set(),
+			runs: []
+		};
+		writeErr("Not in a git repository with a commit.");
+		process.exitCode = 1;
+		return null;
+	}
+	const store = openStore();
+	try {
+		return {
+			root,
+			runs: store.runs({ project: root }).map((run) => run.id),
+			...await readWorktrees(store, root)
+		};
+	} finally {
+		store.close();
+	}
+};
+const realOr = (target) => {
+	try {
+		return realpathSync(target);
+	} catch {
+		return target;
+	}
+};
+const done = (lines) => {
+	for (const line of lines) write(`${style("green", "✓")} ${line}`);
+};
+const show = async (args) => {
+	const request = readListArgs(worktreeListTable, args);
+	if (request === void 0) return;
+	const projects = withStore((store) => store.projects());
+	const scope = projectScope(request.filter, projects);
+	if (scope === void 0) return;
+	const filter = withStore((store) => resolveRun(store, request.filter));
+	if (filter === void 0) return;
+	let items;
+	if (scope === "here") {
+		const found = await here(true);
+		if (found === null) return;
+		items = found.items;
+	} else items = await inProjects(scope === "all" ? projects.map((p) => p.root) : [scope.root]);
+	const shown = applyFilters(worktreeListTable, items, filter).slice(0, request.limit);
+	printList(shown, worktreeListTable, args, (rows) => {
+		for (const line of formatWorktrees(rows)) write(line);
+	});
+};
+const listArgs = filterArgs(worktreeListTable);
+const list = defineCommand({
+	meta: {
+		name: "list",
+		description: "List Ork's worktrees and branches (the default)"
+	},
+	plugins: [refuseUnknownFlags],
+	args: listArgs,
+	run: ({ args }) => show(args)
+});
+const yes = {
+	type: "boolean",
+	description: "Do not ask",
+	default: false
+};
+const clean = defineCommand({
+	meta: {
+		name: "clean",
+		description: "Remove Ork's worktrees (merged ones by default); never one with uncommitted changes unless --force, nor one whose run is still going"
+	},
+	args: {
+		run: {
+			type: "string",
+			description: "Only this run's worktrees"
+		},
+		all: {
+			type: "boolean",
+			description: "Include worktrees whose branch is not merged",
+			default: false
+		},
+		branches: {
+			type: "boolean",
+			description: "Also delete the branches",
+			default: false
+		},
+		force: {
+			type: "boolean",
+			description: "Remove uncommitted changes and unmerged branches too",
+			default: false
+		},
+		yes
+	},
+	run: async ({ args }) => {
+		const [name] = args._;
+		if (name !== void 0) {
+			writeErr(`\`clean\` takes no name (got ${name}); to remove one worktree: ork worktrees remove ${name}`);
+			process.exitCode = 1;
+			return;
+		}
+		const found = await here();
+		if (found === null) return;
+		const filter = { merged: !args.all };
+		if (args.run !== void 0) {
+			const runId = found.runs.find((id) => id === args.run);
+			if (runId === void 0) {
+				writeErr(`No run ${args.run} in this project.`);
+				process.exitCode = 1;
+				return;
+			}
+			filter.runId = runId;
+		}
+		const steps = planClean(found.items, filter, {
+			branches: args.branches,
+			force: args.force,
+			live: found.live
+		});
+		const acting = steps.filter((s) => stepActs(s));
+		if (acting.length === 0) {
+			for (const line of formatPlan(steps)) write(line);
+			if (steps.length === 0) write("Nothing to clean.");
+			return;
+		}
+		write("Plan:");
+		for (const line of formatPlan(steps)) write(line);
+		if (args.force) {
+			const losses = await Promise.all(acting.map(async (step) => ({
+				item: step.item,
+				lost: await lostWork(found.root, {
+					step,
+					force: true
+				})
+			})));
+			for (const line of formatLosses(losses)) write(line);
+		}
+		if (!await goAhead(args.yes, "clean")) return;
+		done(await applyClean(found.root, acting, args.force));
+	}
+});
+const remove = defineCommand({
+	meta: {
+		name: "remove",
+		description: "Remove one of Ork's worktrees, by its branch or its path; --force when that loses work"
+	},
+	args: {
+		target: {
+			type: "positional",
+			description: "The branch, or the worktree's path",
+			required: true
+		},
+		branch: {
+			type: "boolean",
+			description: "Also delete the branch",
+			default: false
+		},
+		force: {
+			type: "boolean",
+			description: "Remove even when that loses uncommitted changes or commits",
+			default: false
+		},
+		yes
+	},
+	run: async ({ args }) => {
+		const found = await here();
+		if (found === null) return;
+		const byPath = path.resolve(args.target);
+		const paths = /* @__PURE__ */ new Set([byPath, realOr(byPath)]);
+		const item = found.items.find((i) => keyOf(i) === args.target || labelOf(i) === args.target || i.path !== null && paths.has(i.path));
+		const planned = planRemove(found, item === void 0 ? args.target : keyOf(item), args.branch);
+		if (!planned.ok) {
+			writeErr(planned.error);
+			process.exitCode = 1;
+			return;
+		}
+		const { plan } = planned;
+		write("Plan:");
+		for (const line of formatPlan([plan.step])) write(line);
+		if (plan.force) {
+			for (const line of formatLost(await lostWork(found.root, plan))) write(line);
+			if (!args.force) {
+				writeErr("That loses work; pass --force to remove it anyway.");
+				process.exitCode = 1;
+				return;
+			}
+		}
+		if (!await goAhead(args.yes, "remove")) return;
+		done(await applyRemove(found.root, plan));
+	}
+});
+const worktrees = defineCommand({
+	meta: {
+		name: "worktrees",
+		description: "Track and clean up the git worktrees Ork creates for runs"
+	},
+	args: listArgs,
+	subCommands: {
+		list,
+		clean,
+		remove
+	},
+	run: async ({ args, rawArgs }) => {
+		const [first] = rawArgs;
+		if (first === "list" || first === "clean" || first === "remove") return;
+		await show(args);
+	}
+});
+export { worktrees };

package/dist/yolo-BSH1E_kE.mjs

@@ -0,0 +1,33 @@
+import { l as writeErr, s as style, t as confirm } from "./output-DXZbnFt_.mjs";
+// src/run/yolo.ts
+/**
+* @file `--yolo` on `ork run` and `ork resume` (specs/cli/running-and-runs.md):
+*   the warning, then a y/N on the terminal, No by default. With `--yes` it is
+*   agreed to without the question; with no terminal only `--yes` agrees, as
+*   nobody is there to answer. A detached start asks before it detaches, and
+*   hands its copy `--yes`, as a yolo run does to the runs it calls.
+*/
+const YOLO_WARNING = [
+	"Yolo: every tool call this run's agents make runs without asking you,",
+	"except what a node's deny list refuses. Agents can edit, delete and run",
+	"anything your user can. Questions, gates and budgets still stop the run."
+].join("\n");
+const YOLO_NEEDS_YES = "--yolo needs a yes: run it on a terminal, or add --yes.";
+/**
+* Whether the run may start yolo: prints the warning, then takes `--yes` or the
+* person's answer. False means nothing starts; the caller exits 1.
+*/
+const agreedToYolo = async (o) => {
+	if (!o.yes && !o.terminal) {
+		writeErr(YOLO_NEEDS_YES);
+		return false;
+	}
+	writeErr(style("yellow", YOLO_WARNING));
+	if (o.yes) return true;
+	const yes = await (o.ask ?? confirm)("Run with no permission prompts?");
+	if (!yes) writeErr("Not started.");
+	return yes;
+};
+/** `rawArgs` for a detached copy of an agreed yolo start: with `--yes`. */
+const withYes = (rawArgs) => rawArgs.includes("--yes") || rawArgs.includes("-y") ? [...rawArgs] : [...rawArgs, "--yes"];
+export { YOLO_NEEDS_YES, YOLO_WARNING, agreedToYolo, withYes };

package/package.json

@@ -1,14 +1,18 @@
 {
   "name": "@krapht/ork",
-  "version": "1.0.0-alpha.2",
-  "description": "Orchestrate Claude agents on your machine: hierarchical, serializable workflows with a CLI and a localhost UI.",
+  "version": "1.0.0-alpha.21",
+  "description": "Orchestrate coding agents (Claude Code, OpenCode, Command Code) on your machine: hierarchical, serializable workflows with a CLI and a localhost UI.",
   "keywords": [
-    "claude",
     "agents",
+    "coding-agents",
     "orchestration",
     "workflow",
     "cli",
-    "ai-engineering"
+    "ai-engineering",
+    "claude",
+    "claude-code",
+    "opencode",
+    "command-code"
   ],
   "license": "MIT",
   "repository": {
@@ -38,8 +42,6 @@
     "provenance": true
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.316",
-    "@anthropic-ai/sdk": "1.3.0",
     "@modelcontextprotocol/sdk": "1.32.2",
     "citty": "0.2.2",
     "yaml": "2.9.1",
@@ -49,13 +51,13 @@
     "@krapht/ork-core": "0.0.0",
     "@krapht/ork-integrations": "0.0.0",
     "@krapht/ork-nodes": "0.0.0",
-    "@krapht/ork-runtime-claude": "0.0.0",
+    "@krapht/ork-runtime": "0.0.0",
     "@krapht/ork-schema": "0.0.0",
     "@krapht/ork-server": "0.0.0",
     "@krapht/ork-ui": "0.0.0",
     "tsdown": "0.23.4"
   },
   "scripts": {
-    "build": "pnpm --filter @krapht/ork-ui build && node ../../tools/release/build-info.ts && node ../../tools/release/plugin-skills.ts && node ../../tools/release/builtin-workflows.ts && tsdown && cp ../../LICENSE ../../THIRD_PARTY_NOTICES.md . && cp -R ../ui/dist dist/ui"
+    "build": "pnpm --filter @krapht/ork-ui build && node ../../tools/release/build-info.ts && node ../../tools/release/plugin-skills.ts && node ../../tools/release/builtin-workflows.ts && node ../../tools/release/issues-workflow.ts && tsdown && cp ../../LICENSE ../../THIRD_PARTY_NOTICES.md . && cp -R ../ui/dist dist/ui"
   }
 }