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

package/dist/{limits-B1-DYc3d.mjs → limits-VQqsBoQk.mjs}

@@ -1,4 +1,4 @@
-import { a as limitsNow, i as NOT_STARTED, o as limitsReport, r as capsHere } from "./src-Dujmvv4s.mjs";
+import { _t as limitsReport, gt as limitsNow, ht as NOT_STARTED, v as capsHere } from "./src-8cOPOgrT.mjs";
 // src/run/limits.ts
 /**
 * @file The limits across runs that apply here (RFC-007): the user's settings
@@ -26,7 +26,7 @@ const runLimits = (store, place, home) => {
 * 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);
+const spendsAnything = (workflow, history) => Object.entries(workflow.nodes).some(([id, node]) => (node.type === "agent.leader" || node.type === "agent.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 [];

package/dist/{mcp-DE_EmyVm.mjs → mcp-wGfkMCVF.mjs}

@@ -1,8 +1,8 @@
-import { h as isNewer } from "./src-Dujmvv4s.mjs";
-import { n as ORK_VERSION } from "./__build_info__-fy6L1Mrd.mjs";
-import { a as openMcp, c as refused, o as tool, s as answer } from "./src-BbyEoMn4.mjs";
-import { n as explainNode } from "./context-DT8MfEIR.mjs";
-import { p as runMarkerIn } from "./src-DOcK8Jfp.mjs";
+import { T as isNewer } from "./src-8cOPOgrT.mjs";
+import { h as runMarkerIn } from "./src-I_RyKu6_.mjs";
+import { n as ORK_VERSION } from "./__build_info__-D6mXC4cD.mjs";
+import { n as explainNode } from "./context-CGPh12HV.mjs";
+import { a as openMcp, c as refused, o as tool, s as answer } from "./src-CmEvHdju.mjs";
 import { z } from "zod";
 import { defineCommand } from "citty";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -43,7 +43,7 @@ const orkMcpServer = (options = {}) => {
 		...options.script === void 0 ? {} : { script: options.script }
 	});
 	const all = [...opened.tools, explainTool(opened, options.home)];
-	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.2") ? tooOld(all, options.expects) : all;
+	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.20") ? tooOld(all, options.expects) : all;
 	const server = new McpServer({
 		name: "ork",
 		version: ORK_VERSION

package/dist/once-BHxSdZz_.mjs

@@ -0,0 +1,112 @@
+import "./src-8cOPOgrT.mjs";
+import { n as OncePathspecError, t as runOnce } from "./run-Bvvg-fiF.mjs";
+import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
+import { t as ago } from "./format-BB4E-T6x.mjs";
+import { spawn } from "node:child_process";
+import { defineCommand, parseArgs } from "citty";
+// src/commands/once.ts
+/**
+* @file `ork once -- <command>`: runs a command unless the same check already
+*   passed on identical files, and records a pass (specs/check-once.md). The
+*   command's own output and exit code are `ork once`'s; a hit prints one line
+*   and exits 0. Everything after `--` is the command, so its flags are never
+*   Ork's.
+*/
+const args = {
+	as: {
+		type: "string",
+		description: "The check's name (default: the command's text)"
+	},
+	covers: {
+		type: "string",
+		description: "Also record the pass for this name (repeat for more)"
+	},
+	on: {
+		type: "string",
+		description: "A git pathspec the check depends on; only matching files key it (repeat for more)"
+	},
+	"with-head": {
+		type: "boolean",
+		description: "Key the check by HEAD too (for checks relative to it)"
+	},
+	force: {
+		type: "boolean",
+		description: "Run even after a pass"
+	}
+};
+/** The command's exit code: a signal or a program that can't start is 1. */
+const exitCodeOf = (command) => new Promise((resolve) => {
+	const [program = "", ...rest] = command;
+	const child = spawn(program, rest, { stdio: "inherit" });
+	child.on("error", (error) => {
+		writeErr(`Cannot run ${program}: ${error.message}`);
+		resolve(1);
+	});
+	child.on("close", (code) => {
+		resolve(code ?? 1);
+	});
+});
+/**
+* Every use of a repeatable flag, `--flag v` or `--flag=v`: citty keeps only
+* the last. Not `run.ts`'s `flagValues`, which would load the run command's
+* imports on every `ork once`.
+*/
+const valuesOf = (before, flag) => before.flatMap((arg, index) => {
+	if (arg.startsWith(`${flag}=`)) return [arg.slice(flag.length + 1)];
+	if (arg !== flag) return [];
+	const next = before[index + 1];
+	return [next === void 0 || next.startsWith("--") ? void 0 : next];
+});
+/** The values of `flag`, or `undefined` when one of its uses has none. */
+const listOf = (before, flag) => {
+	const values = valuesOf(before, flag);
+	return values.every((value) => value !== void 0 && value !== "") ? values.filter((value) => value !== void 0) : void 0;
+};
+const once = defineCommand({
+	meta: {
+		name: "once",
+		description: "Run a command unless the same check already passed on these files: ork once [flags] -- <command…>"
+	},
+	args,
+	run: async ({ rawArgs }) => {
+		const split = rawArgs.indexOf("--");
+		const command = split === -1 ? [] : rawArgs.slice(split + 1);
+		if (command.length === 0) {
+			writeErr("Say what to run after --: ork once [--as <name>] [--covers <name>]… [--on <pathspec>]… [--with-head] [--force] -- <command…>");
+			process.exitCode = 1;
+			return;
+		}
+		const before = rawArgs.slice(0, split);
+		const given = parseArgs(before, args);
+		const covers = listOf(before, "--covers");
+		const on = listOf(before, "--on");
+		if (covers === void 0 || on === void 0) {
+			writeErr(`${covers === void 0 ? "--covers needs a name" : "--on needs a pathspec"}: ork once [--covers <name>]… [--on <pathspec>]… -- <command…>`);
+			process.exitCode = 1;
+			return;
+		}
+		const run = process.env["ORK_RUN"];
+		const node = process.env["ORK_NODE"];
+		const result = await runOnce({
+			cwd: process.cwd(),
+			name: given["as"] ?? command.join(" "),
+			covers,
+			on,
+			withHead: given["with-head"] === true,
+			force: given["force"] === true,
+			...run === void 0 || node === void 0 ? {} : { who: `${run}/${node}` },
+			run: () => exitCodeOf(command)
+		}).catch((error) => {
+			if (!(error instanceof OncePathspecError)) throw error;
+			writeErr(error.message);
+			return null;
+		});
+		if (result === null) {
+			process.exitCode = 1;
+			return;
+		}
+		if (result.skipped) write(`${style("green", "✓")} check already passed on these files · ${ago(result.pass.at)} · ${result.pass.who}`);
+		process.exitCode = result.code;
+	}
+});
+export { once };

package/dist/orphan-guard-BFKg8VSd.mjs

@@ -0,0 +1,58 @@
+import { Readable, Writable } from "node:stream";
+// ../core/src/machine/orphan-guard.ts
+/**
+* @file The orphan guard: a node's processes end with `ork`, whatever ends
+*   `ork` (SIGKILL, the OOM killer, a crash exit). A child started in its own
+*   process group (`detached: true`) under `sh` also starts a small watcher in
+*   that group, which reads a pipe that only `ork` holds open. `ork` never
+*   writes to it, so when `ork` dies the read sees EOF, and the watcher sends
+*   its own group (`kill 0`, never another's) SIGTERM, then SIGKILL after
+*   {@link KILL_AFTER_MS}. A line on the pipe instead lets the watcher exit
+*   quietly, and so does killing it, which is how a node that ends normally
+*   leaves its leftover background processes alone. POSIX only. Two uses:
+*
+*   - A shell that outlives the program (the tool runner's timing wrapper):
+*     `${orphanGuard(4)} w=$!; "$0" "$@" 4<&-; s=$?; kill -s KILL $w`, then
+*     spawn with a `"pipe"` at `stdio[4]` and call
+*     `holdGuard(child.stdio[4])`.
+*   - A shell that `exec`s the program (a session, so its pid stays the
+*     driver's): `${orphanGuard(3)} exec 3<&-; exec "$0" "$@"` (a bare `exec`
+*     closes the pipe: macOS's `sh` keeps a copy of one an `exec` command
+*     closes, which the driver would inherit), with a `"pipe"` at `stdio[3]`;
+*     nothing is left to kill the watcher, so call the function `holdGuard`
+*     returns once the driver has exited (on `exit`: the pipe holds `close`).
+*/
+/** How long the group gets to end after SIGTERM before SIGKILL. */
+const KILL_AFTER_MS = 2e3;
+/** The file descriptors a redirect can name in every POSIX shell. */
+const SHELL_FDS = [
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9
+];
+/**
+* Shell text that starts the watcher in the background on pipe `fd` (3 to 9);
+* it ends with `&`, so `$!` after it is the watcher's pid. The watcher holds no
+* other descriptor, so it never keeps the child's output pipes open.
+*/
+const orphanGuard = (fd) => {
+	const others = SHELL_FDS.filter((other) => other !== fd).map((other) => `${String(other)}>&-`).join(" ");
+	return `{ read -r _ork <&${String(fd)} || { trap '' TERM; kill -s TERM 0; sleep ${String(KILL_AFTER_MS / 1e3)}; kill -s KILL 0; }; } </dev/null >/dev/null 2>&1 ${others} & `;
+};
+/**
+* Keeps `ork`'s end of the watch pipe (`child.stdio[fd]`) open and drained, so
+* it never holds back the child's `close`; returns the release, which writes
+* the line that lets the watcher exit without touching its group.
+*/
+const holdGuard = (pipe) => {
+	pipe?.on("error", () => {});
+	if (pipe instanceof Readable) pipe.resume();
+	return () => {
+		if (pipe instanceof Writable && pipe.writable) pipe.write("\n");
+	};
+};
+export { holdGuard as n, orphanGuard as r, KILL_AFTER_MS as t };

package/dist/output-B1kwo0YU.mjs

@@ -0,0 +1,439 @@
+import { stripVTControlCharacters, styleText } from "node:util";
+import { createInterface } from "node:readline/promises";
+// src/term/keys.ts
+/** What a `ESC [ …` or `ESC O …` sequence names. */
+const SEQUENCES = {
+	"[A": "up",
+	"[B": "down",
+	"[C": "right",
+	"[D": "left",
+	"[H": "home",
+	"[F": "end",
+	"[1~": "home",
+	"[4~": "end",
+	"[7~": "home",
+	"[8~": "end",
+	"[3~": "delete",
+	OA: "up",
+	OB: "down",
+	OC: "right",
+	OD: "left",
+	OH: "home",
+	OF: "end"
+};
+const CONTROLS = {
+	"\r": "enter",
+	"\n": "enter",
+	"": "backspace",
+	"\b": "backspace",
+	"": "ctrl-c",
+	"": "ctrl-d",
+	"
": "ctrl-a",
+	"": "ctrl-e",
+	"": "ctrl-u"
+};
+/** The keys in one chunk of input; what it does not know it skips. */
+const parseKeys = (chunk) => {
+	const keys = [];
+	const chars = Array.from(chunk);
+	for (let i = 0; i < chars.length; i += 1) {
+		const char = chars[i] ?? "";
+		if (char === "\x1B") {
+			if (i === chars.length - 1) {
+				keys.push({ name: "escape" });
+				continue;
+			}
+			let end = i + (chars[i + 1] === "O" ? 3 : 2);
+			while (chars[i + 1] === "[" && end < chars.length + 1 && !/[A-Za-z~]/u.test(chars[end - 1] ?? "")) end += 1;
+			const name = SEQUENCES[chars.slice(i + 1, end).join("")];
+			if (name !== void 0) keys.push({ name });
+			i = end - 1;
+			continue;
+		}
+		const name = CONTROLS[char];
+		if (name !== void 0) keys.push({ name });
+		else if (char >= " ") keys.push({
+			name: "char",
+			text: char
+		});
+	}
+	return keys;
+};
+/**
+* Reads keys from `input` in raw mode, calling `onKey` for each, until the
+* returned function is called, which restores the mode and pauses the input.
+*/
+const readKeys = (input, onKey) => {
+	const wasRaw = input.isRaw === true;
+	input.setRawMode?.(true);
+	input.resume();
+	const onData = (chunk) => {
+		for (const key of parseKeys(String(chunk))) onKey(key);
+	};
+	input.on("data", onData);
+	return () => {
+		input.off("data", onData);
+		input.setRawMode?.(wasRaw);
+		input.pause();
+	};
+};
+// src/term/layout.ts
+/**
+* @file Layout for plain text: its width, wrapped to a width, cut to one line
+*   with `…`, and hung under a lead. `wrap`, `cut` and `hang` take text before
+*   it is styled (they would cut inside an escape code), so style each piece
+*   after laying it out; `widthOf` and `rowsOf` ignore escape codes. Width
+*   counts one column per code point: wide characters (CJK, emoji) may overrun
+*   a line (specs/gaps.md).
+*/
+/** The columns of `text`, escape codes not counted. */
+const widthOf = (text) => Array.from(stripVTControlCharacters(text)).length;
+/** `text` of one line within `width`, with `…` where it was cut. */
+const cut = (text, width) => {
+	const chars = Array.from(text);
+	return chars.length <= width ? text : `${chars.slice(0, Math.max(0, width - 1)).join("")}…`;
+};
+/** A word that is over `width` is split into pieces of `width`. */
+const pieces = (word, width) => {
+	const chars = Array.from(word);
+	const out = [];
+	for (let i = 0; i < chars.length; i += width) out.push(chars.slice(i, i + width).join(""));
+	return out;
+};
+/**
+* `text` wrapped to lines of at most `width` columns, at spaces; each line
+* break in `text` stays, and a blank line stays blank. A word longer than the
+* width is split.
+*/
+const wrap = (text, width) => text.split("\n").flatMap((paragraph) => {
+	const words = paragraph.split(/ +/u).filter((word) => word !== "");
+	const lines = [];
+	let line = "";
+	for (const word of words.flatMap((w) => pieces(w, width))) if (line === "") line = word;
+	else if (widthOf(line) + 1 + widthOf(word) <= width) line += ` ${word}`;
+	else {
+		lines.push(line);
+		line = word;
+	}
+	lines.push(line);
+	return lines;
+});
+/**
+* `text` wrapped under `lead`: the first line starts with `lead`, the others
+* with spaces as wide as `lead` (a hanging indent), all within `width`.
+*/
+const hang = (lead, text, width) => {
+	const indent = " ".repeat(widthOf(lead));
+	return wrap(text, Math.max(1, width - indent.length)).map((line, index) => (index === 0 ? lead : indent).concat(line));
+};
+/** How many terminal rows `line` takes at `width` (at least one). */
+const rowsOf = (line, width) => Math.max(1, Math.ceil(widthOf(line) / width));
+const DEFAULT_WIDTH = 80;
+const DEFAULT_ROWS = 24;
+/** Whether `ORK_PLAIN` is on: set, and not `0` or `false`. */
+const orkPlain = (value) => value !== void 0 && ![
+	"",
+	"0",
+	"false"
+].includes(value.toLowerCase());
+/** Whether the environment asks for plain output (not the stream). */
+const plainEnv = (env = process.env) => (env["NO_COLOR"] ?? "") !== "" || orkPlain(env["ORK_PLAIN"]) || env["TERM"] === "dumb";
+/** How to write to `stream`, given `env`. */
+const termOf = (stream, env = process.env) => ({
+	rich: stream.isTTY === true && !plainEnv(env),
+	width: Math.max(20, stream.columns ?? DEFAULT_WIDTH),
+	rows: stream.rows ?? DEFAULT_ROWS
+});
+/** Whether a prompt can take keys and redraw: rich output, a raw-mode input. */
+const canKey = (input, output, env = process.env) => termOf(output, env).rich && input.isTTY === true && typeof input.setRawMode === "function";
+/**
+* Takes the global `--plain` flag out of `argv` (up to a `--`, after which
+* words belong to a program). It sets `ORK_PLAIN=1` in `env`, which every child
+* Ork starts then inherits.
+*/
+const takePlainFlag = (argv, env = process.env) => {
+	const end = argv.indexOf("--");
+	const head = end === -1 ? argv : argv.slice(0, end);
+	if (!head.includes("--plain")) return [...argv];
+	env["ORK_PLAIN"] = "1";
+	return [...head.filter((word) => word !== "--plain"), ...argv.slice(head.length)];
+};
+// src/term/line.ts
+/**
+* @file The plain way to ask: one prompt, one line read. It is what every kit
+*   prompt falls back to (not a terminal, `NO_COLOR`, `--plain`), so scripts
+*   and tests that feed lines keep working, and what a screen reader sees.
+*/
+/**
+* Prints `prompt` and reads one line; `undefined` when the input ends first
+* (Ctrl-D, a closed pipe). An aborted `signal` rejects.
+*/
+const readLine = async (io, prompt, signal) => {
+	if (io.readLine !== void 0) return io.readLine(prompt, signal);
+	const rl = createInterface({
+		input: io.input,
+		output: io.output,
+		...plainEnv(io.env) ? { terminal: false } : {}
+	});
+	const { promise: ended, resolve: end } = Promise.withResolvers();
+	rl.once("close", () => {
+		end();
+	});
+	try {
+		const answer = await Promise.race([signal === void 0 ? rl.question(prompt) : rl.question(prompt, { signal }), ended]);
+		return typeof answer === "string" ? answer : void 0;
+	} finally {
+		rl.close();
+	}
+};
+/** Ends a rich prompt on Ctrl-C: the caller's hook, else `SIGINT`. */
+const interrupt = (io) => {
+	if (io.interrupt === void 0) process.kill(process.pid, "SIGINT");
+	else io.interrupt();
+};
+/** The error a withdrawn prompt rejects with: the signal's own, if it is one. */
+const withdrawn = (signal) => signal?.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("the prompt was withdrawn");
+// src/term/screen.ts
+/**
+* @file A redrawn region of the terminal: a prompt draws its lines, and draws
+*   them again, moving the cursor up over its own lines and clearing down,
+*   never the screen. When it is done it leaves one line (or none). The cursor
+*   is hidden while a region is open unless a prompt places it, and is always
+*   restored by {@link Region.finish}. While a region is open, a line another
+*   part of the program prints (a run's transcript, from parallel nodes) goes
+*   through {@link printAbove}, which erases the region, prints the line and
+*   draws the region again, so the rows the region counts stay true.
+*/
+const UP = (n) => n > 0 ? `\u001B[${String(n)}A` : "";
+const CLEAR_DOWN = "\r\x1B[J";
+const HIDE = "\x1B[?25l";
+const SHOW = "\x1B[?25h";
+/** The regions drawn now, the newest last. */
+const open = /* @__PURE__ */ new Set();
+/**
+* Prints `text` above the open region, if one is drawn: `true`, and the caller
+* writes nothing. `false` when no region is open, and the caller writes as
+* usual.
+*/
+const printAbove = (text) => {
+	const region = [...open].at(-1);
+	if (region === void 0) return false;
+	region.above(text);
+	return true;
+};
+/** A region at the cursor of `out`; `term` gives the width, read live. */
+const createRegion = (out, term) => {
+	/** Rows between the cursor and the region's first row. */
+	let up = 0;
+	let last = {
+		lines: [],
+		column: void 0
+	};
+	const erase = () => `${UP(up)}${CLEAR_DOWN}`;
+	const draw = (lines, column) => {
+		open.add(region);
+		const width = term().width;
+		last = {
+			lines,
+			column
+		};
+		const rows = lines.reduce((sum, line) => sum + rowsOf(line, width), 0);
+		const placed = column === void 0 ? HIDE : `${SHOW}\r${column > 0 ? `\u001B[${String(column)}C` : ""}`;
+		out.write(`${erase()}${lines.join("\n")}${placed}`);
+		up = Math.max(0, rows - 1);
+	};
+	const region = {
+		draw,
+		redraw: () => {
+			draw(last.lines, last.column);
+		},
+		above: (text) => {
+			out.write(`${erase()}${text}\n`);
+			up = 0;
+			draw(last.lines, last.column);
+		},
+		finish: (line) => {
+			out.write(`${erase()}${line === void 0 ? "" : `${line}\n`}${SHOW}`);
+			up = 0;
+			last = {
+				lines: [],
+				column: void 0
+			};
+			open.delete(region);
+		}
+	};
+	return region;
+};
+// src/term/theme.ts
+/**
+* @file The terminal kit's one theme: a role says what a piece of text means
+*   (accent, ok, warn, danger, muted), and the theme gives it a look that reads
+*   on dark and light terminals: the 16 ANSI colors only, and a fixed
+*   foreground on every chip background. Nothing is said by color alone: a chip
+*   carries words and a mark a symbol. In plain mode every call returns the
+*   text unstyled.
+*/
+/** The text look of each role. */
+const TEXT = {
+	accent: "cyan",
+	ok: "green",
+	warn: "yellow",
+	danger: "red",
+	muted: "dim"
+};
+/** The chip look of each role: a background and the foreground fixed on it. */
+const CHIP = {
+	accent: ["bgCyan", "black"],
+	ok: ["bgGreen", "black"],
+	warn: ["bgYellow", "black"],
+	danger: ["bgRed", "whiteBright"],
+	muted: ["bgWhite", "black"]
+};
+/** The backgrounds a node chip takes, by a hash of its id. */
+const NODE_PALETTE = [
+	["bgCyan", "black"],
+	["bgGreen", "black"],
+	["bgYellow", "black"],
+	["bgMagenta", "whiteBright"],
+	["bgBlue", "whiteBright"],
+	["bgWhite", "black"]
+];
+/** `text` in `format` when the terminal is rich, else as is. */
+const apply = (term, format, text) => term.rich ? styleText(format, text, { validateStream: false }) : text;
+/** `text` in a role's color. */
+const paint = (term, role, text) => apply(term, TEXT[role], text);
+/** `text` in bold. */
+const bold = (term, text) => apply(term, "bold", text);
+// src/term/confirm.ts
+/**
+* @file The yes-or-no prompt: on a terminal, `Yes` and `No` that ←/→ (or `h`
+*   `l`, Space) move between, `y` and `n` answer at once, Enter takes the one
+*   shown, and Esc is no; it collapses to one line. Plain mode asks `question
+*   [y/N] ` and reads a line: anything but yes is no (the default, for an empty
+*   line), and a closed input is no.
+*/
+/**
+* Asks a yes-or-no question; `null` on Ctrl-C, after the terminal was restored
+* and the interrupt sent, for a caller that must not carry on as if it were
+* no.
+*/
+const confirmOrStop = async (io, options) => {
+	const { question, signal } = options;
+	const fallback = options.default === true;
+	if (signal?.aborted === true) throw withdrawn(signal);
+	if (!canKey(io.input, io.output, io.env)) {
+		const answer = (await readLine(io, `  ${question} ${fallback ? "[Y/n]" : "[y/N]"} `, signal) ?? "").trim().toLowerCase();
+		return answer === "" ? fallback : ["y", "yes"].includes(answer);
+	}
+	const term = () => termOf(io.output, io.env);
+	const region = createRegion(io.output, term);
+	return new Promise((resolve, reject) => {
+		let yes = fallback;
+		const render = () => {
+			const t = term();
+			const asked = hang(" ? ", question, t.width).map((line, i) => i === 0 ? ` ${paint(t, "accent", "?")} ${bold(t, line.slice(3))}` : line);
+			const pick = (label, on) => on ? apply(t, "inverse", ` ${label} `) : ` ${label} `;
+			const keys = paint(t, "muted", "y/n · ←/→ · Enter");
+			region.draw([...asked, `   ${pick("Yes", yes)} ${pick("No", !yes)}  ${keys}`]);
+		};
+		const finish = (answer) => {
+			stop();
+			io.output.off("resize", render);
+			signal?.removeEventListener("abort", onAbort);
+			const t = term();
+			const mark = answer ? paint(t, "ok", "✓") : paint(t, "danger", "✗");
+			region.finish(cut(` ${mark} ${question} · ${answer ? "Yes" : "No"}`, t.width));
+			resolve(answer);
+		};
+		const onAbort = () => {
+			stop();
+			io.output.off("resize", render);
+			region.finish();
+			reject(withdrawn(signal));
+		};
+		const stop = readKeys(io.input, (key) => {
+			if (key.name === "enter") finish(yes);
+			else if (key.name === "escape") finish(false);
+			else if (key.name === "ctrl-c") {
+				stop();
+				io.output.off("resize", render);
+				signal?.removeEventListener("abort", onAbort);
+				region.finish();
+				resolve(null);
+				interrupt(io);
+			} else if (key.name === "left" || key.name === "right") {
+				yes = !yes;
+				render();
+			} else if (key.name === "char") {
+				const c = key.text.toLowerCase();
+				if (c === "y") finish(true);
+				else if (c === "n") finish(false);
+				else if (c === "h" || c === "l" || c === " ") {
+					yes = !yes;
+					render();
+				}
+			}
+		});
+		io.output.on("resize", render);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		render();
+	});
+};
+/** Asks a yes-or-no question; Ctrl-C (after restoring the terminal) is no. */
+const confirm$1 = async (io, options) => await confirmOrStop(io, options) === true;
+// src/output.ts
+/**
+* @file Terminal output helpers: styled text that turns plain when stdout is
+*   not a TTY or `NO_COLOR` is set, and a yes-or-no question on the terminal
+*   (through the terminal kit).
+*/
+/**
+* Styles text for stdout; plain when stdout is not a TTY, `NO_COLOR` is set, or
+* `--plain` (`ORK_PLAIN`) was given. The environment is read on each call:
+* `--plain` is set after the modules load.
+*/
+const style = (format, text) => plainEnv() ? text : styleText(format, text, { stream: process.stdout });
+/**
+* Text from outside, fit for a terminal: escape sequences could hide a line on
+* the very screen a person judges from, and a line break could forge one.
+*/
+const plain = (text) => stripVTControlCharacters(text).replaceAll(/[\p{Cc}\p{Bidi_Control}]/gu, " ");
+/** A line to stdout; above a prompt that is open on the same terminal. */
+const write = (text) => {
+	if (process.stdout.isTTY && printAbove(text)) return;
+	process.stdout.write(`${text}\n`);
+};
+const writeErr = (text) => {
+	if (process.stderr.isTTY && printAbove(text)) return;
+	process.stderr.write(`${text}\n`);
+};
+/** What to run to follow, steer or stop the detached run `id` (ADR-081). */
+const detachHint = (id) => `ork attach ${id} · ork logs ${id} -f · ork tree ${id} · ork decide · ork stop ${id}`;
+/** What a run spent: `$0.0312`, or `$0.00` for nothing. */
+const cost = (usd) => usd === 0 ? "$0.00" : `$${usd.toFixed(4)}`;
+/**
+* A dollar total that misses sessions on a driver with no dollars (RFC-015),
+* said so, with the counted tokens beside it: `$1.2000 (partial) · 3.0k
+* tokens`. A complete total reads as `cost` does.
+*/
+const costOf = (usd, partial, tokens) => {
+	if (partial !== true) return cost(usd);
+	const units = tokens === void 0 ? "" : ` · ${shortCount(tokens)} tokens`;
+	return `${cost(usd)} (partial)${units}`;
+};
+/** `950`, `12.3k`, `1.2M`. */
+const shortCount = (n) => {
+	if (n < 1e3) return String(n);
+	if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`;
+	return `${(n / 1e6).toFixed(1)}M`;
+};
+/**
+* Asks a yes-or-no question on the terminal (stderr), through the kit's confirm
+* prompt; anything but yes is no. A trailing `[y/N]` in `question` is dropped:
+* the prompt adds its own.
+*/
+const confirm = (question) => confirm$1({
+	input: process.stdin,
+	output: process.stderr
+}, { question: question.replace(/\s*\[y\/N\]\s*$/u, "") });
+export { termOf as C, wrap as D, widthOf as E, readKeys as O, takePlainFlag as S, hang as T, interrupt as _, plain as a, canKey as b, write as c, CHIP as d, NODE_PALETTE as f, createRegion as g, paint as h, detachHint as i, writeErr as l, bold as m, cost as n, shortCount as o, apply as p, costOf as r, style as s, confirm as t, confirmOrStop as u, readLine as v, cut as w, plainEnv as x, withdrawn as y };

package/dist/outputs-text-CNTJ7Qq_.mjs

@@ -0,0 +1,19 @@
+import { stripVTControlCharacters } from "node:util";
+const OUTPUT_MAX_CHARS = 2e3;
+/** Escapes stripped, other control characters (not line breaks, tabs) blanked. */
+const scrub = (value) => stripVTControlCharacters(value).replaceAll(/[^\P{Cc}\n\t]|\p{Bidi_Control}/gu, " ");
+/**
+* The declared outputs in key order, each scrubbed and cut to
+* {@link OUTPUT_MAX_LINES} lines and {@link OUTPUT_MAX_CHARS} characters; empty
+* when there are none.
+*/
+const outputsText = (outputs) => Object.entries(outputs ?? {}).map(([name, value]) => {
+	const clean = scrub(value.replaceAll("\r\n", "\n")).trimEnd();
+	const text = clean.split("\n").slice(0, 20).join("\n").slice(0, OUTPUT_MAX_CHARS);
+	return {
+		name,
+		text,
+		cut: text.length < clean.length
+	};
+});
+export { outputsText as t };