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

package/dist/ui/index.html

@@ -19,7 +19,7 @@
       href="/favicon.svg"
       type="image/svg+xml"
     />
-    <script type="module" crossorigin src="/assets/index-CWwm8HTG.js"></script>
+    <script type="module" crossorigin src="/assets/index-D-_uPI2v.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/theme-CdXvqTQ6.js">
     <link rel="stylesheet" crossorigin href="/assets/index-BPIbqRRb.css">
   </head>

package/dist/{ui-D2Ydofq0.mjs → ui-CNO1M0qT.mjs}

@@ -1,7 +1,7 @@
-import { n as ORK_VERSION, t as ORK_NAME } from "./__build_info__-Da73_nBs.mjs";
-import { a as style, o as write, s as writeErr } from "./output-CnRzrbUM.mjs";
-import { o as mayShowSignIn } from "./in-a-run-BYjTXaST.mjs";
-import { i as uiFilePath, l as newToken, n as startServer, r as runningServer, t as DEFAULT_PORT } from "./src-CGJGL1sZ.mjs";
+import { n as ORK_VERSION, t as ORK_NAME } from "./__build_info__-B82-dGJY.mjs";
+import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
+import { o as mayShowSignIn } from "./in-a-run-cL5N9gpH.mjs";
+import { i as uiFilePath, l as newToken, n as startServer, r as runningServer, t as DEFAULT_PORT } from "./src-8Mul0695.mjs";
 import path from "node:path";
 import { constants } from "node:os";
 import { spawn } from "node:child_process";

package/dist/{usage-6WIowblz.mjs → usage-BVXi0iFY.mjs}

@@ -1,137 +1,9 @@
-import { Gn as runDirOf, Un as placeFor, _t as liveStatus, it as usd, w as openStore } from "./src-BeR6f70A.mjs";
-import { n as listOrkWorktrees, t as createdWorktrees } from "./list-BUb5Uc3H.mjs";
-import { n as usageReport, t as USAGE_DIMENSIONS } from "./report-CEN8VoUb.mjs";
-import { a as style, n as cost, o as write, s as writeErr, t as confirm, x as termOf } from "./output-CnRzrbUM.mjs";
-import { n as chip, t as CHIP_LABELS } from "./chips-CyeB_rhR.mjs";
-import { n as limitsHere } from "./limits-C5QKZNLT.mjs";
-import { a as header, o as table } from "./format-C60TFpRe.mjs";
-import { existsSync, rmSync } from "node:fs";
+import { At as usd, G as applyPrune, K as planPrune, S as usageReport, U as openStore, mr as placeFor, x as USAGE_DIMENSIONS } from "./src-tsuZRu0H.mjs";
+import { C as termOf, c as write, l as writeErr, n as cost, o as shortCount, r as costOf, s as style, t as confirm } from "./output-B1kwo0YU.mjs";
+import { n as chip, t as CHIP_LABELS } from "./chips-BqcT58qr.mjs";
+import { n as limitsHere } from "./limits-Dhe--wmX.mjs";
+import { a as header, o as table } from "./format-CvTE5CZQ.mjs";
 import { defineCommand } from "citty";
-// ../core/src/store/prune.ts
-/**
-* @file `ork prune` (ADR-046): which runs may lose their transcript, and doing
-*   it. A run goes with the runs it called or was called by, or not at all, and
-*   not while it is live, is linked, or has a worktree or branch left: those
-*   read the run's events. The usage ledger and feedback records stay.
-*/
-const messageOf = (error) => error instanceof Error ? error.message : String(error);
-/**
-* The runs in a project that still have a worktree or branch. With its folder
-* gone, or no longer a repository, there is nothing left to clean up; any other
-* failure says nothing about them, so it rejects.
-*/
-const runsWithWorktrees = (store) => async (root) => {
-	if (!existsSync(root)) return /* @__PURE__ */ new Set();
-	try {
-		const found = await listOrkWorktrees(root, createdWorktrees(store, root));
-		return new Set(found.map((w) => w.runId));
-	} catch (error) {
-		if (/not a git repository/iu.test(messageOf(error))) return /* @__PURE__ */ new Set();
-		throw error;
-	}
-};
-/** The run at the top of a run's chain of calls. */
-const callRootOf = (run, byId) => {
-	let top = run;
-	const seen = /* @__PURE__ */ new Set([run.id]);
-	while (top.parent !== void 0) {
-		const parent = byId.get(top.parent);
-		if (parent === void 0 || seen.has(parent.id)) break;
-		seen.add(parent.id);
-		top = parent;
-	}
-	return top.id;
-};
-/** Sorts the runs before the cutoff into those to remove and those to keep. */
-const planPrune = async (store, filter, worktreesOf = runsWithWorktrees(store)) => {
-	const all = store.runs();
-	const byId = new Map(all.map((run) => [run.id, run]));
-	const inScope = (run) => filter.project === void 0 || run.project === filter.project;
-	const old = (run) => (store.lastEventAt(run.id) ?? run.finishedAt ?? run.startedAt) < filter.before;
-	const trees = /* @__PURE__ */ new Map();
-	for (const run of all) {
-		const root = callRootOf(run, byId);
-		trees.set(root, [...trees.get(root) ?? [], run]);
-	}
-	const projects = [...new Set(all.filter((r) => old(r) && inScope(r)).map((r) => r.project))];
-	const withWorktrees = new Map(await Promise.all(projects.map(async (project) => {
-		try {
-			return [project, await worktreesOf(project)];
-		} catch (error) {
-			return [project, messageOf(error)];
-		}
-	})));
-	/** Why this run itself cannot go, or `null` when it can. */
-	const blocker = (run) => {
-		if (liveStatus(run) === "running") return "it is still running";
-		const worktrees = withWorktrees.get(run.project);
-		if (typeof worktrees === "string") return `cannot tell whether it has a worktree left: ${worktrees}`;
-		if (worktrees?.has(run.id) === true) return "it has a worktree or branch left (ork worktrees clean)";
-		if (store.links({
-			run: run.id,
-			live: true
-		}).length > 0) return "it has a live link";
-		return null;
-	};
-	const plan = {
-		remove: [],
-		keep: []
-	};
-	for (const tree of trees.values()) {
-		const held = tree.map((run) => {
-			if (!inScope(run)) return `run ${run.id} of its call is in another project (--all)`;
-			if (!old(run)) return `run ${run.id} of its call is newer`;
-			const why = blocker(run);
-			return why === null ? null : `run ${run.id} of its call stays: ${why}`;
-		}).find((why) => why !== null);
-		for (const run of tree) {
-			if (!inScope(run) || !old(run)) continue;
-			if (held === void 0) plan.remove.push(run);
-			else plan.keep.push({
-				run,
-				reason: blocker(run) ?? held
-			});
-		}
-	}
-	return plan;
-};
-const SAFE_ID = /^[\w-]+$/u;
-/** Forgets the plan's runs and removes their folders. */
-const applyPrune = (store, plan) => {
-	const outcome = {
-		removed: 0,
-		folders: 0,
-		failed: []
-	};
-	const places = store.projects();
-	for (const run of plan.remove) {
-		if (!store.deleteRun(run.id)) {
-			outcome.failed.push({
-				run: run.id,
-				reason: "it is running again"
-			});
-			continue;
-		}
-		outcome.removed += 1;
-		if (!SAFE_ID.test(run.id)) continue;
-		const place = places.find((p) => p.root === run.project) ?? placeFor(run.project, places);
-		const folder = runDirOf(place, run.id);
-		if (!existsSync(folder)) continue;
-		try {
-			rmSync(folder, {
-				recursive: true,
-				force: true
-			});
-			outcome.folders += 1;
-		} catch (error) {
-			outcome.failed.push({
-				run: run.id,
-				reason: `its folder stays, at ${folder}: ${messageOf(error)}`
-			});
-		}
-	}
-	return outcome;
-};
 // src/runs/usage.ts
 /**
 * @file How usage reads on the terminal (`ork usage`, specs/usage.md), and the
@@ -181,11 +53,7 @@ const sinceTime = (text, now) => {
 /** `--until`: the last day it includes. */
 const untilTime = (text) => dayTime(text, 1);
 /** `950`, `12.3k`, `4.5M`. */
-const tokens = (count) => {
-	if (count < 1e3) return String(count);
-	if (count < 1e6) return `${(count / 1e3).toFixed(1)}k`;
-	return `${(count / 1e6).toFixed(1)}M`;
-};
+const tokens = shortCount;
 const percent = (share) => `${String(Math.round(share * 100))}%`;
 const counted = (count, noun) => `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
 const TITLES = {
@@ -239,8 +107,8 @@ const shortTime = (iso) => new Date(iso).toLocaleString(void 0, {
 /** A warning line: a `WARN` chip when rich, else the line in yellow. */
 const warned = (term, text) => term.rich ? `  ${chip(term, CHIP_LABELS.warn, "warn")} ${text}` : style("yellow", `  ${text}`);
 /** The limits across runs, above a report; nothing with none set. */
-const formatLimits = ({ problems, caps, plan }, term = termOf(process.stdout)) => {
-	if (problems.length === 0 && caps.length === 0 && plan.length === 0) return [];
+const formatLimits = ({ problems, caps, tokenCaps = [], plan }, term = termOf(process.stdout)) => {
+	if (problems.length === 0 && caps.length === 0 && tokenCaps.length === 0 && plan.length === 0) return [];
 	return [
 		style("bold", "Limits"),
 		...problems.map((problem) => warned(term, problem)),
@@ -248,6 +116,10 @@ const formatLimits = ({ problems, caps, plan }, term = termOf(process.stdout)) =
 			const line = `  ${cap.project === void 0 ? "all projects" : "this project"}, this ${cap.window}: ${usd(cap.spentUsd)} of ${usd(cap.capUsd)}, resets ${shortTime(cap.resetsAt)}`;
 			return cap.leftUsd <= 0 ? warned(term, line.trimStart()) : line;
 		}),
+		...tokenCaps.map((cap) => {
+			const line = `  ${cap.project === void 0 ? "all projects" : "this project"}, this ${cap.window}: ${tokens(cap.spentTokens)} of ${tokens(cap.capTokens)} tokens, resets ${shortTime(cap.resetsAt)}`;
+			return cap.leftTokens <= 0 ? warned(term, line.trimStart()) : line;
+		}),
 		...plan.map((limit) => warned(term, `Claude plan's ${limit.window.replaceAll("_", " ")} limit ${limit.status === "rejected" ? "was reached" : "is close"}${limit.resetsAt === void 0 ? "" : `, resets ${shortTime(limit.resetsAt)}`}`)),
 		""
 	];
@@ -256,7 +128,7 @@ const formatLimits = ({ problems, caps, plan }, term = termOf(process.stdout)) =
 const formatUsage = (report, scope, by, term = termOf(process.stdout)) => {
 	const { totals } = report;
 	if (totals.sessions === 0) return [`No Claude sessions in ${scope}.`];
-	const lines = [`${style("bold", cost(totals.costUsd))} in ${scope}`, `${counted(totals.runs, "run")} · ${counted(totals.sessions, "session")} · ${counted(totals.turns, "turn")} · ${tokens(totals.inputTokens + totals.cacheReadTokens + totals.cacheWriteTokens)} in / ${tokens(totals.outputTokens)} out · ${percent(totals.cacheHitRate)} from cache`];
+	const lines = [`${style("bold", costOf(totals.costUsd, totals.partial, totals.tokens))} in ${scope}`, `${counted(totals.runs, "run")} · ${counted(totals.sessions, "session")} · ${counted(totals.turns, "turn")} · ${tokens(totals.inputTokens + totals.cacheReadTokens + totals.cacheWriteTokens)} in / ${tokens(totals.outputTokens)} out · ${percent(totals.cacheHitRate)} from cache`];
 	for (const dimension of by === void 0 ? OVERVIEW : [by]) {
 		const groups = report.groups[dimension];
 		const shown = by === void 0 ? dimension === "day" ? groups.slice(-10) : groups.slice(0, OVERVIEW_ROWS) : groups;

package/dist/{verdict-CIy8tAyX.mjs → verdict-CMvPCpWC.mjs}

@@ -1,5 +1,5 @@
-import { d as apply, x as termOf } from "./output-CnRzrbUM.mjs";
-import { n as chip, t as CHIP_LABELS } from "./chips-CyeB_rhR.mjs";
+import { C as termOf, p as apply } from "./output-B1kwo0YU.mjs";
+import { n as chip, t as CHIP_LABELS } from "./chips-BqcT58qr.mjs";
 // src/run/view.ts
 /**
 * @file How a run's lines are drawn: the terminal kit's {@link Term} for the

package/dist/{watch-uOU_WeBI.mjs → watch-DVNIciHp.mjs}

@@ -1,10 +1,10 @@
-import { Hn as placeFiles, Q as detachRun, _ as declaredTriggers, _t as liveStatus, b as takeWatchLock, br as isToolNode, g as triggerStanding, h as createWatcher, hr as CheckReportSchema, m as triggersReport, v as readProjectTriggers, w as openStore, wr as timeoutMs, wt as stillTheSameProcess, x as watchingPid } from "./src-BeR6f70A.mjs";
-import { n as newRunId } from "./find-CjsNYAAf.mjs";
-import { S as cut, a as style, i as plain, o as write, s as writeErr, t as confirm, w as widthOf, x as termOf } from "./output-CnRzrbUM.mjs";
-import { n as chip, t as CHIP_LABELS } from "./chips-CyeB_rhR.mjs";
-import { c as toolExecutor, o as spawnTool, s as mcpCallExecutor } from "./src-D93tHZ5B.mjs";
-import { i as runLimits, r as limitsRefusal } from "./limits-C5QKZNLT.mjs";
-import { t as acceptRefusal } from "./in-a-run-BYjTXaST.mjs";
+import { B as watchingPid, Br as CheckReportSchema, F as triggerStanding, Gr as isToolNode, I as declaredTriggers, L as readProjectTriggers, N as triggersReport, P as createWatcher, U as openStore, Ut as liveStatus, Xt as stillTheSameProcess, Yr as timeoutMs, pr as placeFiles, wt as detachRun, z as takeWatchLock } from "./src-tsuZRu0H.mjs";
+import { n as newRunId } from "./find-BVX-bL4u.mjs";
+import { C as termOf, E as widthOf, a as plain, c as write, l as writeErr, s as style, t as confirm, w as cut } from "./output-B1kwo0YU.mjs";
+import { n as chip, t as CHIP_LABELS } from "./chips-BqcT58qr.mjs";
+import { c as toolExecutor, o as spawnTool, s as mcpCallExecutor } from "./src-C7z_6fhn.mjs";
+import { i as runLimits, r as limitsRefusal } from "./limits-Dhe--wmX.mjs";
+import { t as acceptRefusal } from "./in-a-run-cL5N9gpH.mjs";
 import path from "node:path";
 import { mkdirSync } from "node:fs";
 import { homedir } from "node:os";
@@ -132,7 +132,9 @@ 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",

package/dist/{workflows-7tQdMnrA.mjs → workflows-B30QkwTk.mjs}

@@ -1,6 +1,6 @@
-import { Gn as runDirOf, Hn as placeFiles, Jn as inside, T as storePath, Un as placeFor, w as openStore } from "./src-BeR6f70A.mjs";
-import { a as isBuiltinArg, n as builtinWorkflowFile, t as builtinProblem } from "./builtin-files-n6o6oWpB.mjs";
-import { s as writeErr } from "./output-CnRzrbUM.mjs";
+import { U as openStore, W as storePath, gr as runDirOf, mr as placeFor, pr as placeFiles, yr as inside } from "./src-tsuZRu0H.mjs";
+import { a as isBuiltinArg, n as builtinWorkflowFile, t as builtinProblem } from "./builtin-files-Bdq23IIi.mjs";
+import { l as writeErr } from "./output-B1kwo0YU.mjs";
 import path from "node:path";
 import { existsSync, readdirSync, statSync } from "node:fs";
 // src/project/place.ts

package/dist/{worktrees-ZCII298F.mjs → worktrees-DD4_TpkH.mjs}

@@ -1,8 +1,6 @@
-import { D as inspectProject, w as openStore } from "./src-BeR6f70A.mjs";
-import { a as planClean, i as keyOf, o as stepActs, t as applyClean } from "./clean-Bh4KZgzc.mjs";
-import { a as readWorktrees, c as mergeStateOf, d as stateParts, l as planLine, n as lostWork, o as repoRoot, r as planRemove, s as labelOf, t as applyRemove } from "./remove-BkFWGVYo.mjs";
-import { S as cut, a as style, o as write, p as paint, s as writeErr, t as confirm, x as termOf } from "./output-CnRzrbUM.mjs";
-import { n as chip } from "./chips-CyeB_rhR.mjs";
+import { U as openStore, Y as inspectProject, _ as keyOf, a as planRemove, c as repoRoot, d as planLine, h as applyClean, i as lostWork, l as labelOf, p as stateParts, r as applyRemove, s as readWorktrees, u as mergeStateOf, v as planClean, y as stepActs } from "./src-tsuZRu0H.mjs";
+import { C as termOf, c as write, h as paint, l as writeErr, s as style, t as confirm, w as cut } from "./output-B1kwo0YU.mjs";
+import { n as chip } from "./chips-BqcT58qr.mjs";
 import path from "node:path";
 import { realpathSync } from "node:fs";
 import { defineCommand } from "citty";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krapht/ork",
-  "version": "1.0.0-alpha.13",
+  "version": "1.0.0-alpha.14",
   "description": "Orchestrate Claude agents on your machine: hierarchical, serializable workflows with a CLI and a localhost UI.",
   "keywords": [
     "claude",
@@ -54,6 +54,6 @@
     "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"
   }
 }

package/dist/clean-Bh4KZgzc.mjs

@@ -1,91 +0,0 @@
-import { O as removeWorktree, zt as gitOk } from "./src-BeR6f70A.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 NOT_ORKS = "not created by Ork";
-const kept = (item, skip) => ({
-	item,
-	removeWorktree: false,
-	deleteBranch: false,
-	skip
-});
-/** What clean does with one item. */
-const cleanStep = (item, options) => {
-	if (!item.recorded) return kept(item, NOT_ORKS);
-	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, whose run is still going, or an `ork/` branch no run
-* recorded creating, 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/decide-DuIHACvH.mjs

@@ -1,50 +0,0 @@
-import { Cn as socketPath, Tn as wakeRun, _t as liveStatus } from "./src-BeR6f70A.mjs";
-// ../core/src/remote/decide.ts
-/**
-* @file The open decisions of live runs, and answering one from another process
-*   (`ork decide`, the local server), with the person's note if they gave one.
-*   An answer goes to the store (the first one wins), then the run is woken on
-*   its socket so it picks the answer up at once (specs/messaging.md).
-*/
-/** Open decisions whose run is still live, oldest first, ANDing the filter. */
-const pendingDecisions = (store, filter) => {
-	const live = /* @__PURE__ */ new Map();
-	return store.decisions({
-		...filter,
-		status: "open"
-	}).filter((decision) => {
-		if (!live.has(decision.runId)) {
-			const [run] = store.lookup(decision.runId);
-			live.set(decision.runId, run !== void 0 && liveStatus(run) === "running" && (filter.workflow === void 0 || run.workflow === filter.workflow));
-		}
-		return live.get(decision.runId) === true;
-	});
-};
-/**
-* Answers an open decision with one of its options, and wakes its run. `home`
-* is `~`, where the sockets are (tests pass a folder); `by` says who answered;
-* `note` is what they said with it, if anything (blank is nothing).
-*/
-const answerDecision = async (store, id, choice, home, by = "decide", note) => {
-	const decision = store.decision(id);
-	if (decision === void 0) return {
-		ok: false,
-		error: `No decision \`${id}\`.`
-	};
-	if (!decision.options.some((o) => o.id === choice)) return {
-		ok: false,
-		error: `\`${choice}\` is not an option of \`${id}\`: \`${decision.options.map((o) => o.id).join("`, `")}\``
-	};
-	if (!store.answerDecision(id, choice, by, note)) {
-		const now = store.decision(id);
-		return {
-			ok: false,
-			error: now?.status === "answered" ? `${id} was already answered: ${now.answer ?? ""} (${now.answeredBy ?? ""})` : `${id} was withdrawn`
-		};
-	}
-	return {
-		ok: true,
-		woke: await wakeRun(socketPath(decision.runId, home))
-	};
-};
-export { pendingDecisions as n, answerDecision as t };

package/dist/list-BUb5Uc3H.mjs

@@ -1,117 +0,0 @@
-import { Bt as lines, Rt as git, zt as gitOk } from "./src-BeR6f70A.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, recorded) => {
-	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,
-		recorded,
-		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)).map((item) => ({
-		item,
-		recorded: true
-	})), ...branches.filter((b) => b.startsWith("ork/") && !recordedBranches.has(b)).map((b) => ({
-		item: prefixed(b),
-		recorded: false
-	}))];
-	return Promise.all(items.map(({ item, recorded }) => stateOf(root, entries, item, recorded)));
-};
-export { listOrkWorktrees as n, createdWorktrees as t };