@krapht/ork 0.1.0 → 0.3.0

package/dist/format-DqpObyMl.mjs

@@ -0,0 +1,553 @@
+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 { 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
+*   permission prompts on the terminal, one at a time, and denies or defers
+*   when no one is there. In a run it is the decision queue's local answerer,
+*   racing `ork decide`.
+*/
+const PREVIEW = 160;
+const NO_ONE_TO_PERMIT = "No one is at the terminal to approve this tool, so it is not allowed in this run.";
+const NO_ONE_TO_ASK = "no one (nobody is at the terminal; use your best judgment and say so in your report)";
+/** One line that shows what a tool is about to do. */
+const previewInput = (toolName, input) => {
+	const key = [
+		"command",
+		"file_path",
+		"path",
+		"url",
+		"pattern"
+	].find((k) => typeof input[k] === "string");
+	const line = (key === void 0 ? JSON.stringify(input) : `${key}: ${String(input[key])}`).replaceAll(/\s+/gu, " ").trim();
+	return line.length > PREVIEW ? `${toolName} ${line.slice(0, 159)}…` : `${toolName} ${line}`;
+};
+/** The option an answer names: its number, or its id. */
+const pickOption = (answer, options, recommended) => {
+	const value = answer.trim();
+	if (value === "") return recommended;
+	const index = Number(value);
+	if (Number.isInteger(index) && index >= 1 && index <= options.length) return options[index - 1]?.id;
+	return options.find((o) => o.id === value)?.id;
+};
+const optionLine = (option, index, recommended) => {
+	const label = option.label === void 0 ? "" : ` ${option.label}`;
+	const description = option.description === void 0 ? "" : style("dim", ` - ${option.description}`);
+	const mark = option.id === recommended ? style("green", " (recommended)") : "";
+	return `  ${String(index + 1)}) ${style("bold", option.id)}${label}${description}${mark}`;
+};
+/**
+* Answers permission prompts and `ask_user` questions on the terminal, one at a
+* time. Without a terminal it denies tools and leaves questions to the node. A
+* withdrawn prompt (answered elsewhere) rejects, which frees the turn.
+*/
+const createTerminalHuman = (io) => {
+	let rl;
+	let turn = Promise.resolve();
+	const say = (text) => {
+		io.output.write(`${text}\n`);
+	};
+	const prompt = (text, signal) => {
+		rl ??= createInterface({
+			input: io.input,
+			output: io.output
+		});
+		return signal === void 0 ? rl.question(text) : rl.question(text, { signal });
+	};
+	const choose = async (hint, options, recommended, signal) => {
+		const picked = pickOption(await prompt(`  Choose${hint}: `, signal), options, recommended);
+		if (picked !== void 0) return picked;
+		say(style("dim", "  Type an option's number or id."));
+		return choose(hint, options, recommended, signal);
+	};
+	const oneAtATime = (work) => {
+		const result = turn.then(work);
+		turn = result.catch(() => null);
+		return result;
+	};
+	return {
+		permit: ({ nodeId, toolName, input, signal }) => oneAtATime(async () => {
+			if (signal?.aborted === true) throw new Error("the prompt was withdrawn");
+			say(`${style(["yellow", "bold"], "?")} ${style("bold", nodeId)} wants to run ${previewInput(toolName, input)}`);
+			if (!io.interactive) {
+				say(style("dim", `  denied: ${NO_ONE_TO_PERMIT}`));
+				return {
+					allow: false,
+					message: NO_ONE_TO_PERMIT
+				};
+			}
+			const answer = (await prompt("  Allow? [y/N] ", signal)).trim().toLowerCase();
+			return answer === "y" || answer === "yes" ? { allow: true } : {
+				allow: false,
+				message: "The user did not allow this tool."
+			};
+		}),
+		ask: ({ nodeId, question, options, recommended, context, signal }) => oneAtATime(() => {
+			if (signal?.aborted === true) return Promise.reject(/* @__PURE__ */ new Error("the question was withdrawn"));
+			say(`${style(["yellow", "bold"], "?")} ${style("bold", nodeId)} asks: ${question}`);
+			if (context !== void 0) say(style("dim", `  ${context}`));
+			for (const [index, option] of options.entries()) say(optionLine(option, index, recommended));
+			if (!io.interactive) {
+				const answer = recommended ?? NO_ONE_TO_ASK;
+				say(style("dim", `  no terminal; answered ${answer}`));
+				return Promise.resolve(answer);
+			}
+			const fallback = options.findIndex((o) => o.id === recommended);
+			const hint = fallback === -1 ? "" : ` [${String(fallback + 1)}]`;
+			return choose(hint, options, recommended, signal);
+		}),
+		close: () => {
+			rl?.close();
+		}
+	};
+};
+// 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) => {
+	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 [`${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/format.ts
+/** Who answered a decision, as the log says it. */
+const ANSWERED_BY = {
+	terminal: "terminal",
+	decide: "ork decide",
+	ui: "ork ui"
+};
+const STATUS_MARK = {
+	pass: style("green", "✓"),
+	done: style("green", "✓"),
+	changes_requested: style("yellow", "!"),
+	fail: style("red", "✗")
+};
+const seconds = (ms) => `${(ms / 1e3).toFixed(1)}s`;
+const indent = (text) => text.trimEnd().split("\n").map((line) => `  ${line}`);
+/** The usage line: cost, tokens, turns and time. */
+const formatUsage = ({ usage }) => style("dim", [
+	cost(usage.costUsd),
+	`${String(usage.inputTokens)} in / ${String(usage.outputTokens)} out (${String(usage.cacheReadTokens)} cached)`,
+	`${String(usage.turns)} turns`,
+	seconds(usage.durationMs)
+].join(" · "));
+/** How a finished session reads on the terminal. */
+const formatOutcome = (nodeId, outcome) => {
+	const { report } = outcome;
+	if (report === null) return [
+		`${style("red", "✗")} ${style("bold", nodeId)} ended without a report (${outcome.subtype})`,
+		...outcome.errors.map((e) => `  ${style("red", e)}`),
+		`  ${formatUsage(outcome)}`
+	];
+	const lines = [`${STATUS_MARK[report.status] ?? "-"} ${style("bold", nodeId)} ${report.status}: ${report.summary}`];
+	if (report.branch !== void 0) lines.push(`  branch: ${report.branch}`);
+	for (const [name, file] of Object.entries(report.artifacts)) lines.push(`  ${name}: ${file}`);
+	for (const [name, value] of Object.entries(report.fields)) lines.push(`  ${name}: ${JSON.stringify(value)}`);
+	lines.push(`  ${formatUsage(outcome)}`);
+	return lines;
+};
+/** The transcript lines for one event; tool names come from `tools`. */
+const formatEvent = (nodeId, event, tools) => {
+	if (event.type === "session.started") return [style("dim", `▸ ${nodeId} (${event.model}, session ${event.sessionId})`)];
+	if (event.type === "assistant.text") return indent(event.text);
+	if (event.type === "tool.called") {
+		tools.set(event.id, event.name);
+		return [style("dim", `  · ${previewInput(event.name, event.input)}`)];
+	}
+	if (event.type === "tool.result") return event.isError ? [style("red", `  ✗ ${tools.get(event.id) ?? "tool"} failed`)] : [];
+	if (event.type === "plan.limit") return event.status === "allowed" ? [] : [style("yellow", `  ! plan: ${event.window.replaceAll("_", " ")} limit ${event.status === "rejected" ? "reached" : "is close"}`)];
+	return formatOutcome(nodeId, event.outcome);
+};
+/** A one-line verdict for a finished node, by what its type outputs. */
+const nodeVerdict = (output) => {
+	const { status, summary, exitCode, choice, answeredBy, count } = output;
+	if (typeof status === "string") return typeof summary === "string" && summary !== "" ? `${status}: ${summary}` : status;
+	if (typeof exitCode === "number") return `exit ${String(exitCode)}`;
+	if (typeof choice === "string") return `${choice} (${String(answeredBy)})`;
+	if (typeof count === "number") return `${String(count)} ran`;
+	return "done";
+};
+/** Transcript lines for one run event, prefixed with the node they are from. */
+const formatRunEvent = (event, width, tools) => {
+	const tag = (id) => style("cyan", `${id.padEnd(width)} │`);
+	if (event.type === "run.started") return [style("dim", `▸ run ${event.runId} of ${event.workflow} (starts at ${event.entries.join(", ")})`), ...event.settings?.trigger === void 0 ? [] : [style("dim", `  started by trigger ${event.settings.trigger}; untrusted inputs: ${(event.settings.untrusted ?? []).join(", ") || "none"}`)]];
+	if (event.type === "node.started") {
+		const round = event.round > 1 ? ` (round ${String(event.round)})` : "";
+		const owner = event.owner === void 0 ? "" : `, for ${event.owner}`;
+		return [`${tag(event.id)} ${style("dim", `${event.nodeType}${round}${owner}`)}`];
+	}
+	if (event.type === "node.event") {
+		const inner = event.event;
+		if (inner.type === "session.finished") return [];
+		if (inner.type === "session.started") return [`${tag(event.id)} ${style("dim", `${inner.model}, session ${inner.sessionId}`)}`];
+		return formatEvent(event.id, event.event, tools).map((line) => `${tag(event.id)} ${line.replace(/^ {2}/u, "")}`);
+	}
+	if (event.type === "node.finished") {
+		const mark = event.ok ? style("green", "✓") : style("red", "✗");
+		const spent = event.usage === void 0 ? "" : style("dim", ` · ${cost(event.usage.costUsd)}`);
+		return [`${tag(event.id)} ${mark} ${nodeVerdict(event.output)}${spent}`];
+	}
+	if (event.type === "node.skipped") return [`${tag(event.id)} ${style("dim", "- skipped")}`];
+	if (event.type === "loop.exhausted") return [`${style(["yellow", "bold"], "!")} the loop ${event.from} -> ${event.to} used all ${String(event.maxRounds)} rounds`];
+	if (event.type === "watch.started") return [`${tag(event.id)} ${style("dim", `watching until ${event.until}, every ${event.every}`)}`];
+	if (event.type === "watch.changed") return [`${tag(event.id)} ${style("dim", `look ${String(event.looks)}:`)} ${event.said}`];
+	if (event.type === "watch.ended") return [`${tag(event.id)} ${style("dim", `${event.outcome} after ${String(event.looks)} looks`)}`];
+	if (event.type === "edge.taken") return [];
+	if (event.type === "worktree") {
+		const detail = event.detail === void 0 ? "" : ` (${event.detail})`;
+		const line = `${event.action} ${event.branch ?? event.path}${detail}`;
+		return [`${tag(event.id)} ${event.action === "conflict" ? style("yellow", `! ${line}`) : style("dim", `⎇ ${line}`)}`];
+	}
+	if (event.type === "decision.opened") {
+		const what = event.kind === "permission" ? "asks to" : "asks:";
+		const question = event.kind === "permission" ? event.question.replace(/^Allow /u, "run ").replace(/\?$/u, "") : event.question;
+		return [`${tag(event.node)} ${style(["yellow", "bold"], "?")} ${what} ${question} ${style("dim", `(decision ${event.decision}; ork decide)`)}`];
+	}
+	if (event.type === "decision.answered") {
+		const by = ANSWERED_BY[event.by];
+		return [`${tag(event.node)} ${style("dim", `→ ${event.answer} (${by})`)}`];
+	}
+	if (event.type === "decision.withdrawn") return [`${tag(event.node)} ${style("dim", "→ question withdrawn")}`];
+	if (event.type === "run.command") {
+		const node = event.node === void 0 ? "" : ` --node ${event.node}`;
+		return [style(["yellow", "bold"], `! ork ${event.command}${node} received`)];
+	}
+	if (event.type === "node.held") {
+		const at = event.at === "tool" ? "its tool call waits for ork continue" : "it starts after ork continue";
+		return [`${tag(event.id)} ${style("yellow", `‖ paused: ${at}`)}`];
+	}
+	if (event.type === "node.released") return [`${tag(event.id)} ${style("dim", "▸ continues")}`];
+	if (event.type === "run.finished") return formatRunResult(event.result);
+	if (event.type === "run.resumed") {
+		const [one] = event.kept;
+		const kept = one === void 0 ? "every node runs again" : event.kept.length === 1 ? `${one} keeps its result` : `${event.kept.join(", ")} keep their results`;
+		return ["", style("dim", `▸ resumed: ${kept}`)];
+	}
+	if (event.type === "feedback.recorded") {
+		const { target, kind, title } = event.feedback;
+		const line = style("dim", `✎ feedback (${target}, ${kind}): ${title}`);
+		return [event.node === void 0 ? line : `${tag(event.node)} ${line}`];
+	}
+	if (event.type === "user.message") {
+		const note = event.delivered === "queued" ? " (for its next session)" : "";
+		return [`${tag(event.node)} ${style(["magenta", "bold"], "you:")} ${firstLine(event.body)}${style("dim", note)}`];
+	}
+	return formatBusEvent(event).map((line) => `${tag(event.node)} ${line}`);
+};
+const RUN_MARK = {
+	succeeded: style("green", "✓"),
+	failed: style("red", "✗"),
+	budget_exhausted: style("yellow", "!"),
+	quota_exhausted: style("yellow", "!"),
+	timed_out: style("yellow", "!"),
+	interrupted: style("yellow", "!")
+};
+/** The run summary: status, cost, what ran, branches to look at, and why. */
+const formatRunResult = (result) => {
+	const ran = result.nodes.filter((n) => n.runs > 0).length;
+	const skipped = result.nodes.length - ran;
+	const lines = ["", `${RUN_MARK[result.status]} run ${result.runId} ${result.status.replace("_", " ")} ${style("dim", `· ${cost(result.costUsd)} · ${String(ran)} ran, ${String(skipped)} skipped`)}`];
+	for (const kept of result.worktrees) lines.push(`  ${kept.id}: ${kept.branch ?? "detached"} ${style("dim", `at ${kept.path} (${kept.reason})`)}`);
+	for (const reason of result.reasons) lines.push(`  ${style("red", reason)}`);
+	return lines;
+};
+// src/runs/format.ts
+/**
+* @file How stored runs read on the terminal: the `ork ps` table and the `ork
+*   tree` ownership tree with each node's state, tokens and cost, and what is
+*   paused (ADR-041).
+*/
+const STATUS_STYLE = {
+	running: "cyan",
+	paused: "yellow",
+	succeeded: "green",
+	failed: "red",
+	crashed: "red",
+	budget_exhausted: "yellow",
+	quota_exhausted: "yellow",
+	timed_out: "yellow",
+	interrupted: "yellow"
+};
+/** `just now`, `5m ago`, `3h ago`, `2d ago`, then the date. */
+const ago = (iso, now = Date.now()) => {
+	const minutes = Math.floor((now - Date.parse(iso)) / 6e4);
+	if (minutes < 1) return "just now";
+	if (minutes < 60) return `${String(minutes)}m ago`;
+	if (minutes < 1440) return `${String(Math.floor(minutes / 60))}h ago`;
+	if (minutes < 10080) return `${String(Math.floor(minutes / 1440))}d ago`;
+	return iso.slice(0, 10);
+};
+/** `42s`, `3m12s`, `1h05m`. */
+const duration = (ms) => {
+	const s = Math.max(0, Math.round(ms / 1e3));
+	if (s < 60) return `${String(s)}s`;
+	if (s < 3600) return `${String(Math.floor(s / 60))}m${String(s % 60).padStart(2, "0")}s`;
+	return `${String(Math.floor(s / 3600))}h${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}m`;
+};
+/** The `ork ps` table; `withProject` adds each run's project. */
+const formatRuns = (runs, withProject, now = Date.now(), statusOf = liveStatus) => {
+	if (runs.length === 0) return ["No runs."];
+	const rows = runs.map((run) => {
+		const status = statusOf(run);
+		const end = run.finishedAt === void 0 ? now : Date.parse(run.finishedAt);
+		return {
+			id: run.id,
+			workflow: run.workflow,
+			status,
+			when: `${ago(run.startedAt, now)} · ${duration(end - Date.parse(run.startedAt))}`,
+			cost: cost(run.costUsd),
+			project: run.project
+		};
+	});
+	const width = (pick, title) => Math.max(title.length, ...rows.map((r) => pick(r).length));
+	const w = {
+		id: width((r) => r.id, "RUN"),
+		workflow: width((r) => r.workflow, "WORKFLOW"),
+		status: width((r) => r.status, "STATUS"),
+		when: width((r) => r.when, "STARTED"),
+		cost: width((r) => r.cost, "COST")
+	};
+	const header = [
+		"RUN".padEnd(w.id),
+		"WORKFLOW".padEnd(w.workflow),
+		"STATUS".padEnd(w.status),
+		"STARTED".padEnd(w.when),
+		"COST".padStart(w.cost),
+		...withProject ? ["PROJECT"] : []
+	].join("  ");
+	return [style("dim", header), ...rows.map((r) => [
+		style("bold", r.id.padEnd(w.id)),
+		r.workflow.padEnd(w.workflow),
+		style(STATUS_STYLE[r.status] ?? "reset", r.status.padEnd(w.status)),
+		style("dim", r.when.padEnd(w.when)),
+		r.cost.padStart(w.cost),
+		...withProject ? [style("dim", r.project)] : []
+	].join("  "))];
+};
+const STATE_MARK = {
+	waiting: style("dim", "·"),
+	running: style("cyan", "●"),
+	ok: style("green", "✓"),
+	failed: style("red", "✗"),
+	skipped: style("dim", "-")
+};
+/** `950`, `12.3k`, `1.2M`. */
+const count = (n) => {
+	if (n < 1e3) return String(n);
+	if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`;
+	return `${(n / 1e6).toFixed(1)}M`;
+};
+const stateText = (node) => {
+	if (node.state === "running") return node.runs > 1 ? `running (round ${String(node.runs)})` : "running";
+	if (node.state === "ok" || node.state === "failed") {
+		const verdict = nodeVerdict(node.output ?? {});
+		const line = verdict.length > 60 ? `${verdict.slice(0, 59)}…` : verdict;
+		return node.runs > 1 ? `${line} (${String(node.runs)} runs)` : line;
+	}
+	return node.state;
+};
+/** The ownership tree, one line per node, children under their owner. */
+const formatTree = (roots) => {
+	const lines = [];
+	const walk = (node, lead, branch) => {
+		lines.push({
+			label: `${lead}${branch}${node.id}`,
+			node
+		});
+		const next = lead + (branch === "├─ " ? "│  " : branch === "" ? "" : "   ");
+		node.children.forEach((child, index) => {
+			walk(child, next, index === node.children.length - 1 ? "└─ " : "├─ ");
+		});
+	};
+	for (const root of roots) walk(root, "", "");
+	const label = Math.max(...lines.map((l) => l.label.length));
+	const type = Math.max(...lines.map((l) => l.node.type.length));
+	return lines.map(({ label: text, node }) => {
+		const usage = node.inputTokens + node.outputTokens === 0 ? "" : style("dim", `  ${count(node.inputTokens)} in / ${count(node.outputTokens)} out · ${cost(node.costUsd)}`);
+		const state = node.held === true ? `${style("yellow", "‖")} paused` : `${STATE_MARK[node.state]} ${stateText(node)}`;
+		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 };

package/dist/in-a-run-BbLhZOFW.mjs

@@ -0,0 +1,22 @@
+import { p as runMarkerIn } from "./src-DtN1k-B3.mjs";
+// src/commands/in-a-run.ts
+/**
+* @file The commands that act as the user refuse a program or an agent in a run
+*   (ADR-047). The refusal names the variable it saw, for someone at their own
+*   terminal who inherited it. It stops accidents; it is not a boundary.
+*/
+const refusal = (why, env) => {
+	const marker = runMarkerIn(env);
+	return marker === null ? null : `${why} ${marker} is set here. If this is your own terminal, it inherited that from a program in a run (a tmux server started by one, say); open a shell without it.`;
+};
+/** Why `ork watch --accept` refuses here, or `null` when it may run. */
+const acceptRefusal = (env = process.env) => refusal("`ork watch --accept` approves code to run with nobody there, so a program or an agent in a run cannot use it.", env);
+/** Why `ork chat` refuses here, or `null` when it may run. */
+const chatRefusal = (env = process.env) => refusal("`ork chat` speaks as you, so a program or an agent in a run cannot use it. A program writes to a session with `ork send`.", env);
+/** Why `ork decide` will not answer here, or `null` when it may. */
+const decideRefusal = (env = process.env) => refusal("`ork decide` answers as you, so a program or an agent in a run cannot answer with it; `ork decide --list` still shows what is open.", env);
+/** Why `ork continue` refuses here, or `null` when it may run. */
+const continueRefusal = (env = process.env) => refusal("`ork continue` undoes a pause you set, so a program or an agent in a run cannot use it.", env);
+/** Whether `ork ui` may print its sign-in link, which acts as the user. */
+const mayShowSignIn = (env = process.env) => runMarkerIn(env) === null;
+export { mayShowSignIn as a, decideRefusal as i, chatRefusal as n, continueRefusal as r, acceptRefusal as t };

package/dist/limits-BKYAmqCR.mjs

@@ -0,0 +1,44 @@
+import { a as limitsNow, i as NOT_STARTED, o as limitsReport, r as capsHere } from "./src-Cz1yOUTg.mjs";
+// src/run/limits.ts
+/**
+* @file The limits across runs that apply here (RFC-007): the user's settings
+*   and the project's rules, read fresh for each command, and what a run does
+*   when one is spent.
+*/
+/**
+* What a run started here is held to. The files are read each time, so a cap
+* changed during a run of hours reaches it; one that breaks meanwhile keeps the
+* last it could read.
+*/
+const runLimits = (store, place, home) => {
+	const first = capsHere(home, place);
+	let { caps } = first;
+	return {
+		problems: first.problems,
+		now: () => {
+			const read = capsHere(home, place);
+			if (read.problems.length === 0) ({caps} = read);
+			return limitsNow(store, caps, /* @__PURE__ */ new Date());
+		}
+	};
+};
+/**
+* Whether what is left of a workflow can spend: a tool-only one, or a resume
+* with only tools to go, is not held back by a quota.
+*/
+const spendsAnything = (workflow, history) => Object.entries(workflow.nodes).some(([id, node]) => (node.type === "claude.leader" || node.type === "claude.worker" || node.type === "workflow.call") && history?.get(id)?.at(-1)?.ok !== true);
+/** Why a run won't start: a settings file it can't read, or a spent limit. */
+const limitsRefusal = (limits, workflow, history) => {
+	if (!spendsAnything(workflow, history)) return [];
+	if (limits.problems.length > 0) return limits.problems;
+	const { blocked } = limits.now();
+	return blocked === void 0 ? [] : [`${NOT_STARTED}${blocked}.`];
+};
+/** What `ork usage` shows. */
+const limitsHere = (store, place, home) => limitsReport(store, capsHere(home, place), /* @__PURE__ */ new Date());
+/** A line for `ork chat`, which counts and isn't stopped; `null` with no limit. */
+const chatNotice = (store, place, home) => {
+	const { blocked } = runLimits(store, place, home).now();
+	return blocked === void 0 ? null : `Note: ${blocked}. This chat counts towards it.`;
+};
+export { runLimits as i, limitsHere as n, limitsRefusal as r, chatNotice as t };