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

package/dist/format-Dnfv8zMT.mjs

@@ -1,427 +0,0 @@
-import { ht as liveStatus } from "./src-Dujmvv4s.mjs";
-import { i as style, n as cost } from "./output-BLQWD6MJ.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. After a choice it offers one optional line for a
-*   note, which Enter skips. 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 NOTE_PROMPT = "  Note for the run (optional, Enter to skip): ";
-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 });
-	};
-	/** The optional line after a choice, when the asker takes a note. */
-	const takeNote = async (onNote, signal) => {
-		if (onNote === void 0) return;
-		const note = (await prompt(NOTE_PROMPT, signal)).trim();
-		if (note !== "") onNote(note);
-	};
-	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, onNote }) => 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();
-			if (answer === "y" || answer === "yes") return { allow: true };
-			await takeNote(onNote, signal);
-			return {
-				allow: false,
-				message: "The user did not allow this tool."
-			};
-		}),
-		ask: ({ nodeId, question, options, recommended, context, signal, onNote }) => oneAtATime(async () => {
-			if (signal?.aborted === true) throw 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 answer;
-			}
-			const fallback = options.findIndex((o) => o.id === recommended);
-			const hint = fallback === -1 ? "" : ` [${String(fallback + 1)}]`;
-			const picked = await choose(hint, options, recommended, signal);
-			await takeNote(onNote, signal);
-			return picked;
-		}),
-		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-result.ts
-const RUN_MARK = {
-	succeeded: style("green", "✓"),
-	failed: style("red", "✗"),
-	budget_exhausted: style("yellow", "!"),
-	quota_exhausted: style("yellow", "!"),
-	timed_out: style("yellow", "!"),
-	interrupted: style("yellow", "!")
-};
-/** `1 failure handled`, `2 failures handled`. */
-const failuresHandled = (count) => `${String(count)} ${count === 1 ? "failure" : "failures"} handled`;
-/**
-* The run summary: status, cost, what ran, what was skipped and which failures
-* an edge handled, branches to look at, why, and mail to nodes that never ran.
-*/
-const formatRunResult = (result) => {
-	const ran = result.nodes.filter((n) => n.runs > 0).length;
-	const skipped = result.skipped ?? result.nodes.length - ran;
-	const handled = result.failuresHandled ?? 0;
-	const lines = ["", `${RUN_MARK[result.status]} run ${result.runId} ${result.status.replace("_", " ")} ${style("dim", `· ${cost(result.costUsd)} · ${String(ran)} ran, ${String(skipped)} skipped${handled === 0 ? "" : `, ${failuresHandled(handled)}`}`)}`];
-	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)}`);
-	for (const { node, messages } of result.unread ?? []) lines.push(`  ${style(["yellow", "bold"], "warning")} ${node} never ran, so ${messages === 1 ? "1 message" : `${String(messages)} messages`} to it went unread`);
-	return lines;
-};
-// src/run/format.ts
-/** Who answered a decision, as the log says it. */
-const ANSWERED_BY = {
-	terminal: "terminal",
-	decide: "ork decide",
-	ui: "ork ui",
-	owner: "its owner"
-};
-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") {
-		const fork = event.fork === true ? ", a fork to answer a question" : "";
-		return [style("dim", `▸ ${nodeId} (${event.model}, session ${event.sessionId}${fork})`)];
-	}
-	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 [];
-		const fork = inner.fork === true ? style("dim", "fork · ") : "";
-		if (inner.type === "session.started") {
-			const why = inner.fork === true ? ", to answer a question" : "";
-			return [`${tag(event.id)} ${fork}${style("dim", `${inner.model}, session ${inner.sessionId}${why}`)}`];
-		}
-		return formatEvent(event.id, event.event, tools).map((line) => `${tag(event.id)} ${fork}${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;
-		const where = event.owner === void 0 ? `decision ${event.decision}; ork decide` : `decision ${event.decision}, via ${event.owner}`;
-		return [`${tag(event.node)} ${style(["yellow", "bold"], "?")} ${what} ${question} ${style("dim", `(${where})`)}`];
-	}
-	if (event.type === "decision.answered") {
-		const by = event.by === "owner" && event.owner !== void 0 ? event.owner : ANSWERED_BY[event.by];
-		const said = event.note === void 0 ? "" : ` · said: ${event.note.replaceAll(/\s+/gu, " ")}`;
-		return [`${tag(event.node)} ${style("dim", `→ ${event.answer} (${by})${said}`)}`];
-	}
-	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}`);
-};
-// 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. A called run's
-* cost is dimmed and says its caller's, whose cost already counts it.
-*/
-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: run.parent === void 0 ? cost(run.costUsd) : `${cost(run.costUsd)} in ${run.parent}`,
-			called: run.parent !== void 0,
-			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.called ? style("dim", r.cost.padStart(w.cost)) : 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-pLAZeNys.mjs

@@ -1,22 +0,0 @@
-import { p as runMarkerIn } from "./src-DOcK8Jfp.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/list-BrH8KRSJ.mjs

@@ -1,110 +0,0 @@
-import { A as gitOk, j as lines, k as git } from "./src-Dujmvv4s.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 };