@krapht/ork 1.0.0-alpha.12 → 1.0.0-alpha.14

package/dist/{store-B2OaE4ID.mjs → store-CleF7KeS.mjs}

@@ -1,8 +1,7 @@
-import { $t as endOf, C as openStore, En as maskSecrets, S as isNodeEvent, en as outcomeEnd, nn as END_KINDS, tt as followEvents, xt as liveStatus, zt as slotWaitLine } from "./src-CdDTQLdQ.mjs";
-import { n as pendingDecisions, t as answerDecision } from "./decide-DlbyctOE.mjs";
-import { E as readKeys, S as cut, T as wrap, _ as withdrawn, a as style, c as confirmOrStop, d as apply, f as bold, g as readLine, h as interrupt, i as plain, m as createRegion, n as cost, p as paint, v as canKey, w as widthOf, x as termOf, y as plainEnv } from "./output-CnRzrbUM.mjs";
-import { n as chip, r as nodeChip, t as CHIP_LABELS } from "./chips-CyeB_rhR.mjs";
-import { a as createView, i as formatBusEvent, n as nodeVerdict, o as styler, r as firstLine, t as hasConflict } from "./verdict-CIy8tAyX.mjs";
+import { $n as maskSecrets, An as END_KINDS, Dn as endOf, H as isNodeEvent, On as outcomeEnd, Tt as followEvents, U as openStore, cn as slotWaitLine, ct as followRunTree, lt as answerDecision, nn as lockWaitLine, ut as pendingDecisions } from "./src-tsuZRu0H.mjs";
+import { C as termOf, D as wrap, E as widthOf, O as readKeys, _ as interrupt, a as plain, b as canKey, g as createRegion, h as paint, m as bold, n as cost, p as apply, r as costOf, s as style, u as confirmOrStop, v as readLine, w as cut, x as plainEnv, y as withdrawn } from "./output-B1kwo0YU.mjs";
+import { n as chip, r as nodeChip, t as CHIP_LABELS } from "./chips-BqcT58qr.mjs";
+import { a as createView, i as formatBusEvent, n as nodeVerdict, o as styler, r as firstLine, t as hasConflict } from "./verdict-CMvPCpWC.mjs";
 import { createInterface } from "node:readline/promises";
 // ../core/src/control/queue.ts
 const PERMISSION_OPTIONS = [{
@@ -219,66 +218,6 @@ const createDecisionQueue = (options) => {
 		}
 	};
 };
-// ../core/src/remote/follow-tree.ts
-/**
-* Calls `onEvent` for each event of `root` and of the runs it called, once
-* each. A called run's stored events come right after the `call.started` that
-* started it; live events as they arrive. Ends when the root ends or `signal`
-* aborts.
-*/
-const followRunTree = async (store, root, onEvent, options = {}) => {
-	/** Every run followed, with its call path, in the order found. */
-	const paths = /* @__PURE__ */ new Map([[root, []]]);
-	/** Each run's last event seen, for the catch-up once the root ends. */
-	const seqs = /* @__PURE__ */ new Map();
-	const followers = [];
-	/** Ends the called runs' following once the root's has ended. */
-	const halt = new AbortController();
-	const signal = options.signal === void 0 ? halt.signal : AbortSignal.any([options.signal, halt.signal]);
-	const handle = (run, path) => (stored) => {
-		seqs.set(run, stored.seq);
-		onEvent({
-			run,
-			path,
-			stored
-		});
-		const { event } = stored;
-		if (event.type === "call.started" && !paths.has(event.run)) follow(event.run, [...path, event.node]);
-	};
-	const follow = (run, path) => {
-		paths.set(run, path);
-		followers.push(followEvents(store, run, handle(run, path), {
-			...options,
-			follow: true,
-			after: seqs.get(run) ?? 0,
-			signal
-		}));
-	};
-	/** Waits for every follower, including those started while waiting. */
-	const settle = async () => {
-		while (followers.length > 0) await Promise.all(followers.splice(0));
-	};
-	const end = await followEvents(store, root, handle(root, []), {
-		...options,
-		follow: true
-	});
-	halt.abort();
-	await settle();
-	if (end !== "aborted") {
-		for (const [run, path] of [...paths].slice(1)) followers.push(followEvents(store, run, handle(run, path), {
-			follow: false,
-			after: seqs.get(run) ?? 0
-		}));
-		await settle();
-	}
-	return {
-		end,
-		stillRunning: [...paths.keys()].slice(1).filter((id) => {
-			const [run] = store.lookup(id);
-			return run !== void 0 && liveStatus(run) === "running";
-		})
-	};
-};
 // src/human-card.ts
 /** Lines of context a card shows before `d` (or `--verbose`) shows the rest. */
 const CONTEXT_LINES = 6;
@@ -696,8 +635,9 @@ const parked = (signal) => new Promise((_, reject) => {
 });
 /**
 * 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.
+* time. Without a terminal it denies tools and leaves questions to the node,
+* but a gate's question (`waits`) waits for `ork decide` or the UI. A withdrawn
+* prompt (answered elsewhere) rejects, which frees the turn.
 */
 const createTerminalHuman = (io) => {
 	let rl;
@@ -743,12 +683,17 @@ const createTerminalHuman = (io) => {
 		if (noted.kind === "interrupted") await parked(signal);
 		if (noted.kind === "text" && noted.value !== "") onNote(noted.value);
 	};
+	/** Says where a waiting question is answered, and waits until withdrawn. */
+	const waitElsewhere = (q) => {
+		say(paint(term(), "muted", `  no terminal; ${plain(q.nodeId)} waits for ork decide or ork ui`));
+		return parked(q.signal);
+	};
 	const oneAtATime = (work) => {
 		const result = turn.then(work);
 		turn = result.catch(() => null);
 		return result;
 	};
-	const asking = (q, place) => oneAtATime(async () => {
+	const asking = (q, place) => !io.interactive && q.waits === true ? waitElsewhere(q) : oneAtATime(async () => {
 		const { signal } = q;
 		if (signal?.aborted === true) throw new Error("the question was withdrawn");
 		const t = term();
@@ -863,6 +808,21 @@ const formatFinished = (event, tag, verbose, term = createView().term, rest = ta
 	if (!(!event.ok && end.kind !== "reported_failure" && (event.end !== void 0 || end.kind !== "unknown"))) return [`${tag} ${mark} ${nodeVerdict(event.output, event.ok, event.error)}${spent}`];
 	return [`${tag} ${mark} ${endHeadline(end)}${spent}`, ...endLines(end, verbose, term).map((line) => `${rest} ${line}`)];
 };
+// src/run/format-machine.ts
+/**
+* @file How a node's waits for the machine read in `ork logs`: a slot for a
+*   heavy command (ADR-080) and a lock (RFC-016), each naming who holds it.
+*/
+/** Whether `event` is a slot's or a lock's. */
+const isMachineEvent = (event) => event.type.startsWith("slot.") || event.type.startsWith("lock.");
+/** A slot or lock event's line, after its node's tag. */
+const machineLine = (event, style) => {
+	if (event.type === "slot.waiting") return style("yellow", `‖ ${slotWaitLine(event.holders)}`);
+	if (event.type === "slot.taken") return style("dim", "▸ got a check slot");
+	if (event.type === "lock.waiting") return style("yellow", `‖ ${lockWaitLine(event.lock, event.holders)}`);
+	if (event.type === "lock.taken") return style("dim", `▸ holds ${event.lock}`);
+	return style("dim", `▸ let ${event.lock} go`);
+};
 // src/run/format-outcome.ts
 /**
 * @file How a finished session reads on the terminal: its report or its end,
@@ -966,7 +926,7 @@ const formatRunResult = (result, term = createView().term) => {
 	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 = ["", `${mark} run ${result.runId} ${result.status.replace("_", " ")} ${style("dim", `· ${cost(result.costUsd)} · ${String(ran)} ran, ${String(skipped)} skipped${handled === 0 ? "" : `, ${failuresHandled(handled)}`}`)}`];
+	const lines = ["", `${mark} run ${result.runId} ${result.status.replace("_", " ")} ${style("dim", `· ${costOf(result.costUsd, result.partial, result.tokens)} · ${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`);
@@ -1019,11 +979,6 @@ const toolLines = (name, input, view, room, verbose, node) => {
 	return [`${styledHead}${style("dim", cut(first.trim(), Math.max(1, room - headWidth - more.length)))}${style("dim", more)}`];
 };
 // src/run/format.ts
-/**
-* @file How runs read on the terminal: session events and run events with node
-*   chips or prefixes; the node result is `format-outcome.ts`'s, a tool call
-*   `format-tool.ts`'s and the run summary `format-result.ts`'s.
-*/
 /** A line's 2-column indent, after any style codes that open it. */
 const INDENT = /^((?:\u001B\[[0-9;]*m)*) {2}/u;
 /** Who answered a decision, as the log says it. */
@@ -1052,6 +1007,8 @@ const formatEvent = (nodeId, event, tools, verbose = false, view = createView(),
 	return formatOutcome(nodeId, event.outcome, verbose, term);
 };
 const items = (count) => `${String(count)} ${count === 1 ? "item" : "items"}`;
+/** A `once: true` check that did not run, and the pass it stands on. */
+const skippedLine = ({ check, at, who }) => `${check}: already passed on these files · ${at} · ${who}`;
 /** Transcript lines for one run event, prefixed with the node they are from. */
 const formatRunEvent = (event, width, tools, terminal = false, verbose = false, view = createView()) => {
 	const { term } = view;
@@ -1118,8 +1075,8 @@ const formatRunEvent = (event, width, tools, terminal = false, verbose = false,
 		return [`${tag(event.id)} ${style("yellow", `‖ paused: ${at}`)}`];
 	}
 	if (event.type === "node.released") return [`${tag(event.id)} ${style("dim", "▸ continues")}`];
-	if (event.type === "slot.waiting") return [`${tag(event.id)} ${style("yellow", `‖ ${slotWaitLine(event.holders)}`)}`];
-	if (event.type === "slot.taken") return [`${tag(event.id)} ${style("dim", "▸ got a check slot")}`];
+	if (isMachineEvent(event)) return [`${tag(event.id)} ${machineLine(event, style)}`];
+	if (event.type === "verify.skipped") return [`${tag(event.id)} ${style("dim", `✓ ${skippedLine(event)}`)}`];
 	if (event.type === "each.listed") {
 		const round = event.round > 1 ? ` (round ${String(event.round)})` : "";
 		return [`${tag(event.node)} ${style("dim", `${items(event.count)}${round}`)}`];

package/dist/ui/THIRD_PARTY_LICENSES.txt

@@ -1200,6 +1200,24 @@ SOFTWARE.
 
 ------------------------------------------------------------------------
 
+yaml 2.9.1 (ISC)
+
+Copyright Eemeli Aro <eemeli@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+
+------------------------------------------------------------------------
+
 zod 4.6.7 (MIT)
 
 MIT License