@krapht/ork 1.0.0-alpha.1 → 1.0.0-alpha.11

package/dist/{decide-CoIJh34e.mjs → decide-B6PnKeqo.mjs}

@@ -1,4 +1,4 @@
-import { An as guardedBase, Mn as writePlainFile, an as wakeRun, bn as placeFiles, ht as liveStatus, jn as plainPathInside, rn as socketPath } from "./src-hrj2h0IZ.mjs";
+import { Bn as placeFiles, Cn as wakeRun, Qn as writePlainFile, Xn as guardedBase, Zn as plainPathInside, xn as socketPath, xt as liveStatus } from "./src-D6_xjm-x.mjs";
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { createHash } from "node:crypto";
@@ -69,7 +69,7 @@ const builtinWorkflowFile = (place, arg) => {
 *   An answer goes to the store (the first one wins), then the run is woken on
 *   its socket so it picks the answer up at once (specs/messaging.md).
 */
-/** Open decisions whose run is still live, oldest first. */
+/** Open decisions whose run is still live, oldest first, ANDing the filter. */
 const pendingDecisions = (store, filter) => {
 	const live = /* @__PURE__ */ new Map();
 	return store.decisions({
@@ -78,7 +78,7 @@ const pendingDecisions = (store, filter) => {
 	}).filter((decision) => {
 		if (!live.has(decision.runId)) {
 			const [run] = store.lookup(decision.runId);
-			live.set(decision.runId, run !== void 0 && liveStatus(run) === "running");
+			live.set(decision.runId, run !== void 0 && liveStatus(run) === "running" && (filter.workflow === void 0 || run.workflow === filter.workflow));
 		}
 		return live.get(decision.runId) === true;
 	});

package/dist/{find-rBBk7Jui.mjs → find-BicBbGMg.mjs}

@@ -1,4 +1,4 @@
-import { xn as placeFor } from "./src-hrj2h0IZ.mjs";
+import { Vn as placeFor } from "./src-D6_xjm-x.mjs";
 import { randomUUID } from "node:crypto";
 // ../core/src/remote/find.ts
 /**

package/dist/format-lWhN-jYR.mjs

@@ -0,0 +1,286 @@
+import { Ct as runStatus, Tt as slotWaitsOf, kt as isItem, xt as liveStatus } from "./src-D6_xjm-x.mjs";
+import { C as widthOf, b as termOf, i as style, n as cost, u as apply, x as cut } from "./output-CM95njYt.mjs";
+import { i as statusChip, n as chip, t as CHIP_LABELS } from "./chips-BA7SrrH5.mjs";
+// src/run/view.ts
+/**
+* @file How a run's lines are drawn: the terminal kit's {@link Term} for the
+*   stream they go to, and what a transcript has to remember between events (a
+*   node's worktree, to show its paths relative to it). Plain, a view draws
+*   today's line-based transcript; rich, it draws chips and cuts to the width.
+*/
+/** A view for `stream` (stdout when not given), as `env` sets it. */
+const createView = (stream = process.stdout, env = process.env) => ({
+	term: termOf(stream, env),
+	roots: /* @__PURE__ */ new Map()
+});
+/** Styles text for `term`: no escape codes when it is plain. */
+const styler = (term) => (format, text) => apply(term, format, text);
+// 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, term = createView().term) => {
+	const style = styler(term);
+	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 [`${term.rich ? chip(term, CHIP_LABELS.ask, "accent") : 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/items-ran.ts
+/**
+* @file How a fan-out's finished line counts its items: only the ones that
+*   started.
+*/
+/** How many of a fan-out's items started; a skipped one never did. */
+const itemsRan = (count, statuses) => {
+	const ran = Array.isArray(statuses) ? statuses.filter((status) => status !== "skipped").length : count;
+	return ran === count ? `${String(count)} ran` : `${String(ran)} of ${String(count)} ran`;
+};
+// src/run/verdict.ts
+/**
+* @file The one-line verdict of a finished node: its report's status, unless
+*   the node failed or its work did not merge.
+*/
+/** Whether a finished node's work did not merge into its owner. */
+const hasConflict = (output) => {
+	const { merge } = output;
+	return typeof merge === "object" && merge !== null && "ok" in merge && merge.ok === false;
+};
+/**
+* A one-line verdict for a finished node, by what its type outputs. A node that
+* failed reads `fail` even when its report said `pass` (a hook refused its
+* commit); a child that did not merge says so.
+*/
+const nodeVerdict = (output, ok = true, error) => {
+	const { status, summary, exitCode, choice, answeredBy, count } = output;
+	if (typeof status === "string") {
+		if (!ok && (status === "pass" || status === "done")) return error === void 0 ? "fail" : `fail: ${firstLine(error)}`;
+		const label = hasConflict(output) ? `${status}, merge conflict` : status;
+		return typeof summary === "string" && summary !== "" ? `${label}: ${summary}` : label;
+	}
+	if (typeof exitCode === "number") return `exit ${String(exitCode)}`;
+	if (typeof choice === "string") return `${choice} (${String(answeredBy)})`;
+	if (typeof count === "number") return itemsRan(count, output["statuses"]);
+	return "done";
+};
+// src/term/table.ts
+/**
+* @file Aligned columns for the listing commands: each column as wide as its
+*   widest cell, a two-space gap, the last column left unpadded. Rich, a cell
+*   may be a chip and a table wider than the screen cuts its flexible columns
+*   with `…`; plain, nothing is cut or styled, as the listings always printed.
+*/
+/** A dimmed header cell. */
+const header = (text) => ({
+	text,
+	look: (s) => style("dim", s)
+});
+const GAP = "  ";
+/** A flexible column is never cut under this many columns. */
+const MIN_FLEX = 8;
+/** The text a cell shows, and its columns. */
+const shown = (term, cell) => term.rich && cell.chip !== void 0 ? cell.chip.label : cell.text;
+const widthOfCell = (term, cell) => widthOf(shown(term, cell)) + (term.rich && cell.chip !== void 0 ? 2 : 0);
+/** The lines of a table, one per row (a header is a row the caller passes). */
+const table = (term, columns, rows, indent = "") => {
+	const widths = columns.map((_, c) => Math.max(0, ...rows.map((row) => widthOfCell(term, row[c] ?? { text: "" }))));
+	if (term.rich) {
+		const gaps = 2 * (columns.length - 1);
+		let over = indent.length + widths.reduce((a, b) => a + b, 0) + gaps - term.width;
+		columns.forEach((column, c) => {
+			const width = widths[c] ?? 0;
+			if (over <= 0 || column.flex !== true || width <= MIN_FLEX) return;
+			const next = Math.max(MIN_FLEX, width - over);
+			over -= width - next;
+			widths[c] = next;
+		});
+	}
+	const last = columns.length - 1;
+	return rows.map((row) => indent + columns.map((column, c) => {
+		const cell = row[c] ?? { text: "" };
+		const width = widths[c] ?? 0;
+		const look = cell.look ?? ((s) => s);
+		if (term.rich && cell.chip !== void 0) {
+			const used = widthOfCell(term, cell);
+			const pad = " ".repeat(Math.max(0, width - used));
+			return column.align === "right" ? pad + chip(term, cell.chip.label, cell.chip.role) : chip(term, cell.chip.label, cell.chip.role) + (c === last ? "" : pad);
+		}
+		const text = cut(shown(term, cell), width);
+		const pad = " ".repeat(Math.max(0, width - widthOf(text)));
+		if (column.align === "right") return look(pad + text);
+		return c === last ? look(text) : look(text + pad);
+	}).join(GAP));
+};
+// 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`;
+};
+const dim = (s) => style("dim", s);
+/**
+* A run's status as `ork ps` reads it: `waiting for slot` for a running run
+* with a command waiting for a machine-wide slot; `events` are a running
+* run's.
+*/
+const listedStatus = (run, events) => {
+	const status = runStatus(run, events);
+	return status === "running" && slotWaitsOf(events).length > 0 ? "waiting for slot" : status;
+};
+/**
+* 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, term = termOf(process.stdout)) => {
+	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 rowOf = (r) => {
+		const cells = [
+			{
+				text: r.id,
+				look: (s) => style("bold", s)
+			},
+			{ text: r.workflow },
+			{
+				text: r.status,
+				chip: statusChip(r.status),
+				look: (s) => style(STATUS_STYLE[r.status] ?? "reset", s)
+			},
+			{
+				text: r.when,
+				look: dim
+			},
+			r.called ? {
+				text: r.cost,
+				look: dim
+			} : { text: r.cost }
+		];
+		if (withProject) cells.push({
+			text: r.project,
+			look: dim
+		});
+		return cells;
+	};
+	const heads = [
+		"RUN",
+		"WORKFLOW",
+		"STATUS",
+		"STARTED",
+		"COST"
+	].map((text) => header(text));
+	if (withProject) heads.push(header("PROJECT"));
+	const columns = [
+		{},
+		{ flex: true },
+		{},
+		{},
+		{ align: "right" }
+	];
+	if (withProject) columns.push({ flex: true });
+	return table(term, columns, [heads, ...rows.map((row) => rowOf(row))]);
+};
+/** Marks are made when used, so `--plain` (set after load) is read. */
+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 ?? {}, node.state === "ok");
+		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, now = Date.now()) => {
+	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)}`;
+		const spent = isItem(node) && node.startedAt !== void 0 ? style("dim", `  ${duration((node.finishedAt === void 0 ? now : Date.parse(node.finishedAt)) - Date.parse(node.startedAt))}`) : "";
+		return `${text.padEnd(label)}  ${style("dim", node.type.padEnd(type))}  ${state}${spent}${usage}`;
+	});
+};
+export { header as a, nodeVerdict as c, createView as d, styler as f, listedStatus as i, firstLine as l, formatRuns as n, table as o, formatTree as r, hasConflict as s, ago as t, formatBusEvent as u };

package/dist/{in-a-run-DdAakpRR.mjs → in-a-run-CgkVouyG.mjs}

@@ -1,4 +1,4 @@
-import { p as runMarkerIn } from "./src-BxUJPGa5.mjs";
+import { p as runMarkerIn } from "./src-9iGkjnsy.mjs";
 // src/commands/in-a-run.ts
 /**
 * @file The commands that act as the user refuse a program or an agent in a run

package/dist/{limits-BPM9wUlV.mjs → limits-jZQp9ZJC.mjs}

@@ -1,4 +1,4 @@
-import { a as limitsNow, i as NOT_STARTED, o as limitsReport, r as capsHere } from "./src-hrj2h0IZ.mjs";
+import { it as limitsReport, nt as NOT_STARTED, r as capsHere, rt as limitsNow } from "./src-D6_xjm-x.mjs";
 // src/run/limits.ts
 /**
 * @file The limits across runs that apply here (RFC-007): the user's settings

package/dist/{list-Bv5Lxu7z.mjs → list-CEaJ07jd.mjs}

@@ -1,4 +1,4 @@
-import { A as gitOk, j as lines, k as git } from "./src-hrj2h0IZ.mjs";
+import { A as lines, O as git, k as gitOk } from "./src-D6_xjm-x.mjs";
 import { existsSync } from "node:fs";
 // ../core/src/worktree/list.ts
 /**
@@ -56,7 +56,7 @@ const onNoBranch = async (entry) => entry === void 0 ? "0" : (await git(entry.pa
 	"--remotes"
 ])).stdout;
 /** One created worktree or branch, with its state read from git. */
-const stateOf = async (root, entries, item) => {
+const stateOf = async (root, entries, item, recorded) => {
 	const { branch } = item;
 	const entry = branch === void 0 || item.path !== "" ? entries.find((e) => e.path === item.path) : entries.find((e) => e.branch === branch);
 	const holder = branch === void 0 ? void 0 : entries.find((e) => e.branch === branch && e.path !== entry?.path);
@@ -76,6 +76,7 @@ const stateOf = async (root, entries, item) => {
 		...checkedOut === void 0 ? {} : { checkedOut },
 		runId: item.runId,
 		nodeId: item.nodeId,
+		recorded,
 		path: entry?.path ?? null,
 		missing,
 		dirty: changes > 0,
@@ -104,7 +105,13 @@ const listOrkWorktrees = async (root, created = []) => {
 		"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 items = [...created.filter((c) => c.branch === void 0 ? entries.some((e) => e.path === c.path) : branches.includes(c.branch)).map((item) => ({
+		item,
+		recorded: true
+	})), ...branches.filter((b) => b.startsWith("ork/") && !recordedBranches.has(b)).map((b) => ({
+		item: prefixed(b),
+		recorded: false
+	}))];
+	return Promise.all(items.map(({ item, recorded }) => stateOf(root, entries, item, recorded)));
 };
 export { listOrkWorktrees as n, createdWorktrees as t };

package/dist/{mcp-DM30MFBw.mjs → mcp-DYgVA9f5.mjs}

@@ -1,8 +1,8 @@
-import { h as isNewer } from "./src-hrj2h0IZ.mjs";
-import { n as ORK_VERSION } from "./__build_info__-D9lSlMFy.mjs";
-import { a as openMcp, c as refused, o as tool, s as answer } from "./src-B0TT7DBi.mjs";
-import { n as explainNode } from "./context-6x3kXREO.mjs";
-import { p as runMarkerIn } from "./src-BxUJPGa5.mjs";
+import { u as isNewer } from "./src-D6_xjm-x.mjs";
+import { n as ORK_VERSION } from "./__build_info__-CIchF6nr.mjs";
+import { p as runMarkerIn } from "./src-9iGkjnsy.mjs";
+import { n as explainNode } from "./context-BaNshWr9.mjs";
+import { a as openMcp, c as refused, o as tool, s as answer } from "./src-B6KvTm7B.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.1") ? tooOld(all, options.expects) : all;
+	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.11") ? tooOld(all, options.expects) : all;
 	const server = new McpServer({
 		name: "ork",
 		version: ORK_VERSION