@krapht/ork 0.2.0 → 0.4.0

package/dist/format-J-a21Yvn.mjs

@@ -0,0 +1,393 @@
+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";
+// 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, formatEvent as i, formatRuns as n, createTerminalHuman as o, formatTree as r, ago as t };

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

@@ -0,0 +1,22 @@
+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
+*   (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-BDZCmGEu.mjs

@@ -0,0 +1,44 @@
+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
+*   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 };

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 };

package/dist/mcp-CHVKKg3B.mjs

@@ -0,0 +1,91 @@
+import { m as isNewer } from "./src-CGqMati3.mjs";
+import { n as ORK_VERSION } from "./__build_info__-CtSVVuZE.mjs";
+import { a as openMcp, c as refused, o as tool, s as answer } from "./src-CpDKIulI.mjs";
+import { n as explainNode } from "./context-C_bksb0C.mjs";
+import { p as runMarkerIn } from "./src-UWkk1sl9.mjs";
+import { defineCommand } from "citty";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+// src/commands/mcp.ts
+/**
+* @file `ork mcp`: Ork's tools for Claude Code over stdio (RFC-012), on the
+*   same handlers as `ork ui`'s API and the same checks as `ork validate`. They
+*   read, check a draft, explain a node's context, and start a run; none
+*   answers a decision or acts on a run. Inside a run nothing starts another,
+*   and an `ork` older than its caller expects says so on every call. It opens
+*   no port and holds no token, and stdout carries only the protocol.
+*/
+const INSTRUCTIONS = "Ork runs workflows of Claude sessions and programs on this machine. These tools read what Ork has (projects, workflows, the workflow format, runs, their events and cost, the decisions waiting on a person), check a workflow as `ork validate` does, and explain what a node's session loads. None answers a decision: a person does, in `ork ui` or their own terminal.";
+const STARTS = " `start_run` starts a run in the background.";
+const explainTool = (opened, home) => tool("explain_context", "What one node's session would load, as `ork context explain` shows it: its agent, instructions, skills and files, layer by layer, with their tokens.", {
+	project: z.string().min(1),
+	workflow: z.string().min(1).describe("A workflow's name, or a path"),
+	node: z.string().min(1)
+}, ({ project, workflow, node }) => {
+	const found = opened.fileOf(project, workflow);
+	if ("error" in found) return refused(found.error);
+	const result = explainNode(found.file, node, found.project.root, home);
+	return result.ok ? answer(result.explanation) : refused(result.lines.join("\n"));
+});
+/** Every call refused, when this `ork` is older than its caller needs. */
+const tooOld = (tools, expects) => tools.map((each) => ({
+	...each,
+	call: () => Promise.resolve(refused(`This needs Ork ${expects} or newer, and this is ${ORK_VERSION}. Ask the person to upgrade, with \`ork upgrade\`.`))
+}));
+/** The server with Ork's tools on it, for stdio here and in tests. */
+const orkMcpServer = (options = {}) => {
+	const start = runMarkerIn(options.env ?? process.env) === null;
+	const opened = openMcp({
+		version: ORK_VERSION,
+		start,
+		...options.home === void 0 ? {} : { home: options.home },
+		...options.script === void 0 ? {} : { script: options.script }
+	});
+	const all = [...opened.tools, explainTool(opened, options.home)];
+	const tools = options.expects !== void 0 && isNewer(options.expects, "0.4.0") ? tooOld(all, options.expects) : all;
+	const server = new McpServer({
+		name: "ork",
+		version: ORK_VERSION
+	}, { instructions: start ? `${INSTRUCTIONS}${STARTS}` : INSTRUCTIONS });
+	for (const each of tools) server.registerTool(each.name, {
+		description: each.description,
+		inputSchema: z.strictObject(each.shape),
+		annotations: {
+			readOnlyHint: each.readOnly,
+			openWorldHint: false
+		}
+	}, async (args) => {
+		const { text, isError } = await each.call(args);
+		return {
+			content: [{
+				type: "text",
+				text
+			}],
+			...isError === true ? { isError } : {}
+		};
+	});
+	return {
+		server,
+		close: opened.close
+	};
+};
+const mcp = defineCommand({
+	meta: {
+		name: "mcp",
+		description: "Serve Ork's tools to Claude Code over stdio (MCP)"
+	},
+	args: { expects: {
+		type: "string",
+		description: "The oldest Ork the caller works with, such as a plugin"
+	} },
+	run: async ({ args }) => {
+		const { server, close } = orkMcpServer(args.expects === void 0 ? {} : { expects: args.expects });
+		const transport = new StdioServerTransport();
+		transport.onclose = () => {
+			close();
+		};
+		await server.connect(transport);
+	}
+});
+export { mcp };