@krapht/ork 1.0.0-alpha.13 → 1.0.0-alpha.15

package/dist/{src-D93tHZ5B.mjs → src-DcrhgipG.mjs}

@@ -1,12 +1,13 @@
-import { $t as serversIn, At as endedWith, Dr as integrationFor, Er as TOOL_PREFIX, Ht as envReadsOf, It as lowerChild, Kt as declaredOutputOf, Lt as startAt, M as sessionRefusals, Mt as stoppedEnd, Nr as AGENT_DRIVERS, Nt as calledWorkflows, Ot as runScope, Pt as slotClock, Qt as mcpNotText, Tr as INTEGRATIONS, Wt as sessionDriver, Zt as MCP_FILE, an as endFor, bn as renderTemplate, br as isToolNode, cr as programsRunBy, fr as markValue, gt as heldTimeout, jt as failedWith, kt as declaredProblem, lt as reportSchemaFor, nn as outcomeEnd, rn as END_DETAIL_LIMIT, rt as planReason, sr as beforeOf, st as planNodeSession, tn as endOf, vn as evaluate, wr as timeoutMs, yn as parseTemplate, yr as isClaudeNode } from "./src-BeR6f70A.mjs";
-import { t as runOnce } from "./run-CQIfq918.mjs";
+import { $t as sessionDriver, Bn as outcomeEnd, Bt as stoppedEnd, Dt as reportSchemaFor, Ft as runScope, Gr as beforeOf, Ht as slotClock, It as calledWorkflows, Kr as programsRunBy, Kt as startAt, Nn as countedTokens, Pt as heldTimeout, Rt as endedWith, Tt as planNodeSession, Un as endFor, Vn as END_DETAIL_LIMIT, Vt as declaredProblem, Wt as lowerChild, Xr as markValue, Xt as envReadsOf, _i as AGENT_DRIVERS, ar as renderTemplate, ci as timeoutMs, di as integrationFor, ii as isToolNode, in as serversIn, ir as parseTemplate, li as INTEGRATIONS, nn as MCP_FILE, nt as sessionRefusals, ri as isClaudeNode, rn as mcpNotText, rr as evaluate, tn as declaredOutputOf, ui as TOOL_PREFIX, xt as planReason, zn as endOf, zt as failedWith } from "./src-Dr_fTSu-.mjs";
+import { t as runOnce } from "./run-CiPsW9Kf.mjs";
+import { n as holdGuard, r as orphanGuard, t as KILL_AFTER_MS } from "./orphan-guard-BFKg8VSd.mjs";
 import path from "node:path";
 import { accessSync, constants, lstatSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { spawn } from "node:child_process";
+import { Readable } from "node:stream";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { Readable } from "node:stream";
 // ../nodes/src/call.ts
 /**
 * @file The `workflow.call` node type (RFC-004): renders what the node asks for
@@ -538,43 +539,36 @@ const afterLateTurn = (first, later) => {
 		errors: first.errors
 	};
 };
+/** The least of the limits that are set; `undefined` with none. */
+const least = (...limits) => {
+	const known = limits.filter((limit) => limit !== void 0);
+	return known.length === 0 ? void 0 : Math.min(...known);
+};
+/** A cap less what this activation used, beside what a quota says is left. */
+const leftOf = (caps, used, quotaLeft) => least(...caps.map((cap) => cap === void 0 ? void 0 : cap - used), quotaLeft);
 /**
-* What another turn of a session may use. `spent` and `turns` are this
-* activation's, which neither the node's cap nor the run's budget has counted.
-* The quota has: the ledger took it as the session finished, so what it says is
-* left is left. `null` when nothing is, and the turn does not start.
+* What another turn of a session may use. `spent`, `tokens` (counted, RFC-015)
+* and `turns` are this activation's, which neither the node's cap nor the run's
+* budget has counted. The quota has: the ledger took it as the session
+* finished, so what it says is left is left. The run's tokens left have too:
+* only the node's own `budgetTokens` takes `tokens` off. `null` when nothing
+* is, and the turn does not start.
 */
-const lateLimits = (spec, { spent, turns }, runLeft, quotaLeft) => {
-	const budgets = [...[spec.budgetUsd, runLeft].flatMap((limit) => limit === void 0 ? [] : [limit - spent]), ...quotaLeft === void 0 ? [] : [quotaLeft]];
-	const budgetUsd = budgets.length === 0 ? void 0 : Math.min(...budgets);
-	if (budgetUsd !== void 0 && budgetUsd <= 0) return null;
-	const maxTurns = spec.maxTurns === void 0 ? void 0 : spec.maxTurns - turns;
-	if (maxTurns !== void 0 && maxTurns <= 0) return null;
+const lateLimits = (spec, used, runLeft, quotaLeft, tokensLeft = {}) => {
+	const budgetUsd = leftOf([spec.budgetUsd, runLeft], used.spent, quotaLeft);
+	const budgetTokens = leftOf([spec.budgetTokens], used.tokens ?? 0, least(tokensLeft.run, tokensLeft.quota));
+	const maxTurns = spec.maxTurns === void 0 ? void 0 : spec.maxTurns - used.turns;
+	if ([
+		budgetUsd,
+		budgetTokens,
+		maxTurns
+	].some((left) => (left ?? 1) <= 0)) return null;
 	return {
 		...budgetUsd === void 0 ? {} : { budgetUsd },
+		...budgetTokens === void 0 ? {} : { budgetTokens },
 		...maxTurns === void 0 ? {} : { maxTurns }
 	};
 };
-/** What a session may spend as it starts: the least of the budget and any quota. */
-const budgetNow = (context) => {
-	if (context.budgetLeftNow === void 0) return context.budgetLeftUsd;
-	const known = [context.budgetLeftNow(), context.quota?.().leftUsd].flatMap((left) => left === void 0 ? [] : [left]);
-	return known.length === 0 ? void 0 : Math.min(...known);
-};
-/**
-* What a node's first session may spend, set aside from the run's budget in the
-* same step that reads it (ADR-077), so a node starting beside it is never
-* offered the same part: the least of what is left and the node's own
-* `budgetUsd`. With nothing left, it waits for a worker running beside it to
-* finish, as long as one may.
-*/
-const budgetToStart = async (context) => {
-	const left = budgetNow(context);
-	if (left !== void 0 && left <= 0) return await context.budgetFreed?.(context.signal) === true ? budgetToStart(context) : left;
-	const own = isClaudeNode(context.node) ? context.node.budgetUsd ?? context.workflow.defaults?.budgetUsd : void 0;
-	context.reserveBudget?.(own === void 0 || left === void 0 ? left : Math.min(own, left));
-	return left;
-};
 /**
 * Whether a limit across runs, rather than the node's work, ended a node: a
 * session whose cap was a quota's and that ran into it, or one its plan refused
@@ -587,7 +581,7 @@ const limitWatch = (context) => {
 			why = reason;
 		},
 		session: (asked) => {
-			const left = context.quota?.().leftUsd;
+			const { leftUsd: left, leftTokens } = context.quota?.() ?? {};
 			let refused;
 			return {
 				saw: (event) => {
@@ -595,7 +589,7 @@ const limitWatch = (context) => {
 				},
 				ended: (outcome) => {
 					if (refused !== void 0 && (outcome?.report ?? null) === null) why = refused;
-					const capped = left !== void 0 && asked.budgetUsd !== void 0 && asked.budgetUsd >= left;
+					const capped = left !== void 0 && asked.budgetUsd !== void 0 && asked.budgetUsd >= left || leftTokens !== void 0 && asked.budgetTokens !== void 0 && asked.budgetTokens >= leftTokens;
 					const spent = outcome !== null && outcomeEnd(outcome).kind === "budget_limit";
 					if (capped && spent) why = context.quota?.().blocked ?? "a session reached what was left of a quota";
 				}
@@ -657,6 +651,61 @@ const sessionDriverOf = (context, plan, options) => {
 	const unfit = plan.pinned === void 0 ? void 0 : refusalOn(context, driver, options.drivers ?? AGENT_DRIVERS);
 	return unfit === void 0 ? driver : notStarted("invalid_node", unfit);
 };
+// ../nodes/src/start-budgets.ts
+/** What a session may spend as it starts: the least of the budget and any quota. */
+const budgetNow = (context) => context.budgetLeftNow === void 0 ? context.budgetLeftUsd : least(context.budgetLeftNow(), context.quota?.().leftUsd);
+/** The counted tokens a session may use as it starts: the run's and a quota's. */
+const tokensNow = (context) => least(context.tokensLeftNow?.(), context.quota?.().leftTokens);
+/**
+* What is `left` now, with `own` (the node's cap) set aside through `reserve`
+* in the same step; with nothing left, it waits for a worker's reserve to
+* free.
+*/
+const startWith = async (context, left, own, reserve) => {
+	const now = left();
+	if (now !== void 0 && now <= 0) {
+		context.reserveBudget?.(0);
+		context.reserveTokens?.(0);
+		return await context.budgetFreed?.(context.signal) === true ? startWith(context, left, own, reserve) : now;
+	}
+	reserve?.(own === void 0 || now === void 0 ? now : Math.min(own, now));
+	return now;
+};
+/**
+* What a node's first session may spend, set aside from the run's budget in the
+* same step that reads it (ADR-077), so a node starting beside it is never
+* offered the same part: the least of what is left and the node's own
+* `budgetUsd`. With nothing left, it waits for a worker running beside it to
+* finish, as long as one may.
+*/
+const budgetToStart = (context) => startWith(context, () => budgetNow(context), isClaudeNode(context.node) ? context.node.budgetUsd ?? context.workflow.defaults?.budgetUsd : void 0, context.reserveBudget);
+/** `budgetToStart` in counted tokens: the run's `budgetTokens` and a quota's. */
+const tokensToStart = (context) => startWith(context, () => tokensNow(context), isClaudeNode(context.node) ? context.node.budgetTokens ?? context.workflow.defaults?.budgetTokens : void 0, context.reserveTokens);
+/**
+* What a node's first session may spend, in dollars and in counted tokens, set
+* into `planOptions`; the node's result instead when nothing is left of
+* either.
+*/
+const startBudgets = async (context, planOptions) => {
+	const usd = await budgetToStart(context);
+	if (usd !== void 0 && usd <= 0) return notStarted("budget_limit", "nothing is left of the run's budget");
+	if (usd !== void 0) planOptions.budgetLeftUsd = usd;
+	const waited = { done: false };
+	const tokens = await tokensToStart({
+		...context,
+		budgetFreed: async (signal) => {
+			waited.done = true;
+			return await context.budgetFreed?.(signal) ?? false;
+		}
+	});
+	if (tokens !== void 0 && tokens <= 0) return notStarted("budget_limit", "nothing is left of the run's tokens");
+	if (waited.done) {
+		context.reserveTokens?.(0);
+		return startBudgets(context, planOptions);
+	}
+	if (tokens !== void 0) planOptions.budgetLeftTokens = tokens;
+	return null;
+};
 // ../nodes/src/tool-output.ts
 /**
 * @file A tool node's structured result (`output: { format: json }`): the file
@@ -1742,9 +1791,8 @@ const claudeExecutor = (options) => async (context) => {
 	}
 	const blocked = context.quota?.().blocked;
 	if (blocked !== void 0) return notStarted("plan_limit", blocked, blocked);
-	const budget = await budgetToStart(context);
-	if (budget !== void 0 && budget <= 0) return notStarted("budget_limit", "nothing is left of the run's budget");
-	if (budget !== void 0) planOptions.budgetLeftUsd = budget;
+	const refused = await startBudgets(context, planOptions);
+	if (refused !== null) return refused;
 	const plan = planNodeSession(context.workflow, context.id, planOptions);
 	if (!plan.ok) return notStarted("invalid_node", plan.error);
 	const servers = namedMcpEntries(context.projectRoot, plan.mcp);
@@ -1769,12 +1817,14 @@ const claudeExecutor = (options) => async (context) => {
 	if (context.mailbox !== void 0) ports.mailbox = context.mailbox;
 	if (context.claims !== void 0) ports.claims = context.claims;
 	if (context.feedback !== void 0) ports.feedback = context.feedback;
+	if (context.followUps !== void 0) ports.followUps = context.followUps;
 	const whole = context.round > 1 ? wholeInput(context.input) : void 0;
 	if (whole !== void 0) ports.input = whole;
 	const watch = limitWatch(context);
 	const run = async (asked) => {
 		const watching = watch.session(asked);
 		context.reserveBudget?.(asked.budgetUsd);
+		context.reserveTokens?.(asked.budgetTokens);
 		const session = runtime.start(asked, ports);
 		const stop = () => {
 			session.interrupt();
@@ -1793,6 +1843,7 @@ const claudeExecutor = (options) => async (context) => {
 			}
 		} finally {
 			context.reserveBudget?.(0);
+			context.reserveTokens?.(0);
 			disconnect?.();
 			context.signal.removeEventListener("abort", stop);
 		}
@@ -1808,8 +1859,12 @@ const claudeExecutor = (options) => async (context) => {
 		}
 		return lateLimits(spec, {
 			spent: context.ownSpend?.(sessionId, usage.costUsd) ?? usage.costUsd,
-			turns: usage.turns
-		}, context.budgetLeftNow?.(), quota?.leftUsd);
+			turns: usage.turns,
+			tokens: countedTokens(usage)
+		}, context.budgetLeftNow?.(), quota?.leftUsd, {
+			run: context.tokensLeftNow?.(),
+			quota: quota?.leftTokens
+		});
 	};
 	const resumeWith = (outcome, prompt, limits) => run({
 		...spec,
@@ -2090,20 +2145,23 @@ const mcpCallExecutor = (options = {}) => async (context) => {
 *   whatever it started: SIGTERM, then SIGKILL for what ignores that. A stop or
 *   a timeout therefore leaves nothing running, and an escaped process that
 *   keeps the output pipes open cannot hold the node. Off Windows it runs under
-*   `sh`, whose `times` says the CPU the program and its children used, and at
-*   the project's priority: `low` starts it below Ork's own (nice, and on macOS
+*   `sh`, whose `times` says the CPU the program and its children used, beside
+*   the orphan guard, which ends the group when `ork` dies, and at the
+*   project's priority: `low` starts it below Ork's own (nice, and on macOS
 *   utility QoS).
 */
-/** How long a program may take to end after SIGTERM. */
-const KILL_AFTER_MS = 2e3;
 /** How long to wait for the pipes to close after SIGKILL. */
 const CLOSE_AFTER_MS = 500;
+/** The fd of the orphan guard's pipe from `ork`. */
+const WATCH_FD = 4;
 /**
-* Runs `$0 "$@"`, then writes the shell's `times` to fd 3: its children's user
-* and system time, the program's whole tree that it waited for. A program that
+* Runs `$0 "$@"` beside the orphan guard, which ends the group if `ork` dies,
+* and stops the guard once the program ends, so its leftovers live on as
+* before. Then writes the shell's `times` to fd 3: its children's user and
+* system time, the program's whole tree that it waited for. A program that
 * isn't there says so on fd 3, as spawn's ENOENT would.
 */
-const TIMED = String.raw`command -v "$0" >/dev/null 2>&1 || { echo ork-missing >&3; exit 127; }; "$0" "$@" 3>&-; s=$?; times >&3; exit $s`;
+const TIMED = String.raw`command -v "$0" >/dev/null 2>&1 || { echo ork-missing >&3; exit 127; }; ${orphanGuard(WATCH_FD)}w=$!; "$0" "$@" 3>&- ${String(WATCH_FD)}<&-; s=$?; kill -s KILL $w 2>/dev/null; times >&3; exit $s`;
 const MISSING = "ork-missing";
 /** The children's line of `times` (`0m1.250s 0m0.300s`), in milliseconds. */
 const cpuOfTimes = (text) => {
@@ -2144,10 +2202,12 @@ const spawnTool = (program, args, { cwd, signal, env, priority }) => {
 				"ignore",
 				"pipe",
 				"pipe",
+				"pipe",
 				"pipe"
 			]
 		});
 		lowerChild(priority, child.pid);
+		holdGuard(child.stdio[WATCH_FD]);
 		const fd3 = child.stdio[3];
 		if (fd3 instanceof Readable) fd3.setEncoding("utf8").on("data", (chunk) => {
 			times.push(chunk);