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

package/dist/{src-BfxkJOYm.mjs → src-C7z_6fhn.mjs}

@@ -1,4 +1,5 @@
-import { $t as endOf, Bt as lowerChild, Cr as TOOL_PREFIX, Ft as failedWith, Ht as envReadsOf, It as stoppedEnd, Lt as calledWorkflows, Mt as runScope, Nt as declaredProblem, Pt as endedWith, Rt as slotClock, Sr as INTEGRATIONS, Vt as startAt, Wt as declaredOutputOf, Xt as mcpNotText, Yt as MCP_FILE, Zt as serversIn, _n as parseTemplate, _r as isToolNode, ar as programsRunBy, at as planReason, bt as heldTimeout, dt as sessionDriver, en as outcomeEnd, gn as evaluate, gr as isClaudeNode, ir as beforeOf, lr as markValue, lt as planNodeSession, pt as reportSchemaFor, rn as endFor, tn as END_DETAIL_LIMIT, vn as renderTemplate, wr as integrationFor, xr as timeoutMs } from "./src-CdDTQLdQ.mjs";
+import { $t as countedTokens, Cn as MCP_FILE, Dn as endOf, Ft as reportSchemaFor, Gn as parseTemplate, Gr as isToolNode, Ht as heldTimeout, Kn as renderTemplate, Lr as markValue, Mr as beforeOf, Nr as programsRunBy, Nt as planNodeSession, On as outcomeEnd, Qr as integrationFor, Tn as serversIn, Wn as evaluate, Wr as isClaudeNode, Xr as INTEGRATIONS, Yr as timeoutMs, Zr as TOOL_PREFIX, an as stoppedEnd, en as runScope, gn as sessionDriver, ii as AGENT_DRIVERS, in as failedWith, jn as endFor, kn as END_DETAIL_LIMIT, kt as planReason, ln as lowerChild, mn as envReadsOf, nt as sessionRefusals, on as declaredProblem, rn as endedWith, sn as slotClock, tn as calledWorkflows, un as startAt, vn as declaredOutputOf, wn as mcpNotText } from "./src-tsuZRu0H.mjs";
+import { t as runOnce } from "./run-D8divGCs.mjs";
 import path from "node:path";
 import { accessSync, constants, lstatSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { spawn } from "node:child_process";
@@ -323,7 +324,7 @@ const forkPrompt = (question, passOn) => [
 /** The fork's report: one of the options or the pass-on, and a note. */
 const forkReportSchema = (ids) => {
 	const node = {
-		type: "claude.worker",
+		type: "agent.worker",
 		prompt: "",
 		output: { schema: {
 			choice: [...ids],
@@ -537,43 +538,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
@@ -586,7 +580,7 @@ const limitWatch = (context) => {
 			why = reason;
 		},
 		session: (asked) => {
-			const left = context.quota?.().leftUsd;
+			const { leftUsd: left, leftTokens } = context.quota?.() ?? {};
 			let refused;
 			return {
 				saw: (event) => {
@@ -594,7 +588,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";
 				}
@@ -628,6 +622,89 @@ const notStarted = (kind, reason, limited) => ({
 	}),
 	...limited === void 0 ? {} : { limited }
 });
+// ../nodes/src/session-driver.ts
+/**
+* @file The driver a Claude node's session starts on (core's `sessionDriver`),
+*   and, when its model names that driver (`command-code.deepseek/…`, RFC-015),
+*   the fit check on the value an item rendered: the run's own check before it
+*   started saw only the written model.
+*/
+/** What stops the node from running on `driver`, in one line, or nothing. */
+const refusalOn = (context, driver, drivers) => {
+	const id = context.template ?? context.id;
+	const node = context.workflow.nodes[id];
+	const descriptor = drivers.find((d) => d.id === driver);
+	if (node === void 0 || descriptor === void 0) return void 0;
+	const refusals = sessionRefusals(id, node, context.workflow, descriptor);
+	return refusals.length === 0 ? void 0 : refusals.map((r) => r.message).join("; ");
+};
+/** The session's driver, or the node's result when none fits. */
+const sessionDriverOf = (context, plan, options) => {
+	const driver = sessionDriver({
+		pinned: plan.pinned,
+		override: options.driver,
+		named: plan.driver,
+		ready: options.readyDriver
+	});
+	if (driver === void 0) return notStarted("tool_missing", "no agent driver is ready; see `ork doctor`");
+	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
@@ -870,6 +947,28 @@ const tokenize = (command) => {
 		args
 	};
 };
+/**
+* Runs `execute`, or, with `once: true`, skips it after a pass on these files:
+* `null` then, and `verify.skipped` is recorded. `shown` is the scrubbed
+* command.
+*/
+const runUnlessPassed = async ({ node, context, cwd, shown, environ, execute }) => {
+	if (node.once !== true) return execute();
+	const done = {};
+	const once = await runOnce({
+		cwd,
+		name: node.script === void 0 ? shown : `${shown}\n${node.script}`,
+		who: `${context.runId}/${context.id}`,
+		env: environ,
+		run: async () => {
+			done.run = await execute();
+			return done.run.exitCode;
+		}
+	});
+	if (!once.skipped) return done.run ?? execute();
+	context.skipped?.(shown, once.pass);
+	return null;
+};
 // ../nodes/src/tool-ends.ts
 /**
 * @file How a tool node ended (specs/runtime/session-ends.md): a node that
@@ -915,6 +1014,18 @@ const exitEnd = (output, run, context, program, signedOut) => {
 		output
 	}, end);
 };
+/** The result of a skipped check: it passed, and printed nothing this time. */
+const skippedCheck = (outputFile) => {
+	if (outputFile !== void 0) removeOutputFile(outputFile);
+	return endedWith({
+		ok: true,
+		output: {
+			exitCode: 0,
+			stdout: "",
+			stderr: ""
+		}
+	}, endFor("done"));
+};
 // ../nodes/src/tool-scrub.ts
 /**
 * @file Masking a secret in what a program prints. A plain search, so a value
@@ -1245,7 +1356,8 @@ const clearStateFiles = (runDir, warn) => {
 *   without a shell, checked against `allow` (or the integration's default),
 *   its arguments and observed output fields from the integration's adapter,
 *   long output kept in run files. It sees who it is and the node's `env:`
-*   (`tool-env.ts`), and may return JSON (`tool-output.ts`).
+*   (`tool-env.ts`), may return JSON (`tool-output.ts`), and may run once per
+*   set of files (`runUnlessPassed` in `tool-command.ts`).
 */
 /** How much of stdout and stderr a node's output keeps. */
 const OUTPUT_LIMIT = 65536;
@@ -1346,29 +1458,43 @@ const toolExecutor = (given, options = {}) => async (context) => {
 		...node.watch === void 0 ? {} : { [STATE_ENV]: prepareStateFile(context.runDir, context.id) }
 	};
 	const names = Object.keys(nodeEnv.values);
-	const release = await context.machine?.slot([command.program, ...command.args].join(" "), context.signal);
-	context.emit({
-		type: "tool.called",
-		id: context.id,
-		name: scrub(command.program),
-		input: {
-			command: scrub([
-				command.program,
-				...command.args,
-				...node.script === void 0 ? [] : ["<script>"]
-			].join(" ")),
-			...names.length === 0 ? {} : { env: names }
-		}
-	});
-	const scriptFile = node.script === void 0 ? void 0 : writeScriptFile(context.runDir, context.id, context.round, node.script);
-	const priority = context.machine?.priority;
-	const raw = await runner(command.program, scriptFile === void 0 ? command.args : [...command.args, scriptFile], {
+	const shown = scrub([
+		command.program,
+		...command.args,
+		...node.script === void 0 ? [] : ["<script>"]
+	].join(" "));
+	const execute = async () => {
+		const release = await context.machine?.slot([command.program, ...command.args].join(" "), context.signal);
+		context.emit({
+			type: "tool.called",
+			id: context.id,
+			name: scrub(command.program),
+			input: {
+				command: shown,
+				...names.length === 0 ? {} : { env: names }
+			}
+		});
+		const scriptFile = node.script === void 0 ? void 0 : writeScriptFile(context.runDir, context.id, context.round, node.script);
+		const priority = context.machine?.priority;
+		return runner(command.program, scriptFile === void 0 ? command.args : [...command.args, scriptFile], {
+			cwd,
+			signal: context.signal,
+			env,
+			...priority === void 0 ? {} : { priority }
+		}).finally(() => {
+			release?.();
+			if (scriptFile !== void 0) removeOutputFile(scriptFile);
+		});
+	};
+	const raw = await runUnlessPassed({
+		node,
+		context,
 		cwd,
-		signal: context.signal,
-		env,
-		...priority === void 0 ? {} : { priority }
-	}).finally(() => release?.());
-	if (scriptFile !== void 0) removeOutputFile(scriptFile);
+		shown,
+		environ,
+		execute
+	});
+	if (raw === null) return skippedCheck(outputFile);
 	const run = {
 		exitCode: raw.exitCode,
 		stdout: scrub(raw.stdout),
@@ -1597,7 +1723,7 @@ const checkedResult = (result, { check, resumes }) => {
 };
 // ../nodes/src/claude.ts
 /**
-* @file The Claude node type: runs a `claude.leader` or `claude.worker` as one
+* @file The Claude node type: runs an `agent.leader` or `agent.worker` as one
 *   session, planned with the run's outputs (and the brief its owner gave it),
 *   and turns its report into the node's output. A leader gets its children
 *   through the session's ports, and resumes its session on re-entry
@@ -1640,7 +1766,7 @@ const specFor = (spec, context) => {
 	};
 	return spec;
 };
-/** Runs a `claude.leader` or `claude.worker` as one session. */
+/** Runs an `agent.leader` or `agent.worker` as one session. */
 const claudeExecutor = (options) => async (context) => {
 	const planOptions = planOptionsOf(context, options.inPlace);
 	const before = beforeOf(context.node, context.workflow.defaults);
@@ -1664,9 +1790,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);
@@ -1676,12 +1801,8 @@ const claudeExecutor = (options) => async (context) => {
 		...servers.value
 	};
 	if (options.machineClaude === true) spec.machineClaude = true;
-	const driver = sessionDriver({
-		override: options.driver,
-		named: plan.driver,
-		ready: options.readyDriver
-	});
-	if (driver === void 0) return notStarted("tool_missing", "no agent driver is ready; see `ork doctor`");
+	const driver = sessionDriverOf(context, plan, options);
+	if (typeof driver !== "string") return driver;
 	const runtime = await options.runtimeFor(driver);
 	const ports = { human: context.owner === void 0 ? withdrawnOnStop(context) : ownerFirst(context, context.owner, {
 		runtimeFor: options.runtimeFor,
@@ -1701,6 +1822,7 @@ const claudeExecutor = (options) => async (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();
@@ -1719,6 +1841,7 @@ const claudeExecutor = (options) => async (context) => {
 			}
 		} finally {
 			context.reserveBudget?.(0);
+			context.reserveTokens?.(0);
 			disconnect?.();
 			context.signal.removeEventListener("abort", stop);
 		}
@@ -1734,8 +1857,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,
@@ -1824,6 +1951,7 @@ const gateExecutor = async (context) => {
 		nodeId: context.id,
 		question,
 		options,
+		waits: true,
 		signal: withdraw.signal,
 		onNote: (given) => {
 			note = given;
@@ -2143,8 +2271,8 @@ const builtinExecutors = (options) => {
 		steps: tool
 	});
 	const executors = {
-		"claude.leader": claude,
-		"claude.worker": claude,
+		"agent.leader": claude,
+		"agent.worker": claude,
 		"human.gate": gateExecutor,
 		"workflow.call": callExecutor,
 		"mcp.call": mcpCallExecutor(options.maskedNames === void 0 ? {} : { maskedNames: options.maskedNames })