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

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

@@ -1,12 +1,13 @@
-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 { $r as programsRunBy, At as endedWith, Dt as runScope, Et as heldTimeout, Gn as endOf, It as lowerChild, Kn as outcomeEnd, Mt as stoppedEnd, Nt as declaredProblem, Ot as calledWorkflows, Pt as slotClock, Qr as beforeOf, Rt as startAt, Y as sessionRefusals, Yn as endFor, _i as TOOL_PREFIX, _t as planNodeSession, cn as mcpNotText, di as isToolNode, dr as renderTemplate, gi as INTEGRATIONS, hi as timeoutMs, in as sessionDriver, jt as failedWith, ln as serversIn, lr as evaluate, mt as planReason, on as declaredOutputOf, qn as END_DETAIL_LIMIT, ri as markValue, sn as MCP_FILE, tn as envReadsOf, ui as isClaudeNode, ur as parseTemplate, vi as integrationFor, wi as AGENT_DRIVERS, yt as reportSchemaFor, zn as countedTokens } from "./src-DN-RPsil.mjs";
+import { t as runOnce } from "./run-D_u9V_Ve.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
@@ -59,7 +60,9 @@ const callExecutor = (context) => {
 // ../nodes/src/claude-plan.ts
 /**
 * @file What a Claude node's session is planned with, read from the node's
-*   context.
+*   context, and what it is told beyond its plan: the note of a sent-back input
+*   on re-entry, a resumed leader's message, and the turn for messages that
+*   came in as it finished.
 */
 /** The plan options every session of a node starts from. */
 const planOptionsOf = (context, inPlace) => {
@@ -82,6 +85,30 @@ const planOptionsOf = (context, inPlace) => {
 	if (context.claims !== void 0) planOptions.claims = context.claims;
 	return planOptions;
 };
+const MAX_INPUT = 8192;
+const inputJson = (input) => JSON.stringify(input ?? {}, void 0, 2);
+/** What a sent-back input is whole, for `read_input`, when its note cuts it. */
+const wholeInput = (input) => {
+	const json = inputJson(input);
+	return json.length > MAX_INPUT ? json : void 0;
+};
+/** A re-entry's note of what was sent back; `read_input` has a cut rest. */
+const reentryNote = (round, input) => {
+	const json = inputJson(input);
+	const cut = json.length > MAX_INPUT;
+	const body = cut ? `${json.slice(0, MAX_INPUT)}\n…` : json;
+	const rest = cut ? `\n\nThat is the first ${String(MAX_INPUT)} of its ${String(json.length)} characters. Call read_input for all of it before you act on it.` : "";
+	return `\n\n## Round ${String(round)}\n\nThe workflow sent this task back to you with:\n\n\`\`\`json\n${body}\n\`\`\`${rest}`;
+};
+/**
+* What a resumed leader is told: it already has its brief and its earlier work,
+* so only the new round, and the new task when its owner sent one.
+*/
+const resumeMessage = (round, input, brief) => [brief === void 0 ? sentBack(round, input) : `## New task from \`${brief.from}\`\n\n${brief.text}`, "End with a new structured report."].join("\n\n");
+/** A first-round resume is a session the run was cut off in (`ork resume`). */
+const sentBack = (round, input) => round === 1 ? "Ork was stopped while you worked on this task, and the run is resumed. Your earlier turns are above: check what you finished, and carry on from there." : `The workflow sent your task back to you.${reentryNote(round, input)}`;
+/** What a session is told when messages came in as it finished. */
+const lateMessage = (count) => `[ork] ${String(count)} message${count === 1 ? "" : "s"} came in while you finished. Call read_inbox, act on ${count === 1 ? "it" : "them"} if needed, and end with a new structured report.`;
 // ../nodes/src/claude-result.ts
 /**
 * @file A finished session as a node's result: its report is the output, held
@@ -551,12 +578,13 @@ const leftOf = (caps, used, quotaLeft) => least(...caps.map((cap) => cap === voi
 * 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.
+* is, and the turn does not start. `turnsAtLeast` lifts the turns left to that
+* many (a failed check's resume: `CHECK_RETRY_TURNS`).
 */
-const lateLimits = (spec, used, runLeft, quotaLeft, tokensLeft = {}) => {
+const lateLimits = (spec, used, runLeft, quotaLeft, tokensLeft = {}, turnsAtLeast = 0) => {
 	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;
+	const maxTurns = spec.maxTurns === void 0 ? void 0 : Math.max(spec.maxTurns - used.turns, turnsAtLeast);
 	if ([
 		budgetUsd,
 		budgetTokens,
@@ -568,18 +596,36 @@ const lateLimits = (spec, used, runLeft, quotaLeft, tokensLeft = {}) => {
 		...maxTurns === void 0 ? {} : { maxTurns }
 	};
 };
+const reached = (cap, used) => cap !== void 0 && used >= cap;
+/**
+* Why the run's budget stopped a session that reached its cap, if it did. A
+* unit blames the run when the session reached it, or when it is the only cap
+* the session had; otherwise the node's own cap in the other unit may have
+* stopped it. A resumed turn's dollars are its own: its cost is the session's
+* total (ADR-046) while its cap is what was left, so `priorCostUsd` comes off,
+* read as `ownSpend` reads it (a lower total counted again from zero).
+*/
+const runSpent = (run, asked, outcome, priorCostUsd) => {
+	const total = outcome.usage.costUsd;
+	const turnCostUsd = total < priorCostUsd ? total : total - priorCostUsd;
+	if (run.tokens !== void 0 && (reached(asked.budgetTokens, countedTokens(outcome.usage)) || asked.budgetUsd === void 0)) return `the run's budget of ${String(run.tokens)} tokens is spent`;
+	return run.usd !== void 0 && (reached(asked.budgetUsd, turnCostUsd) || asked.budgetTokens === void 0) ? `the run's budget of $${String(run.usd)} is spent` : void 0;
+};
 /**
 * 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
-* and that gave no report. A node that still succeeded is left alone.
+* and that gave no report. A session whose cap was the run's budget and that
+* ran into it stops the run as `budget_exhausted` (`run`, from `runCapsOf`). A
+* node that still succeeded is left alone.
 */
-const limitWatch = (context) => {
+const limitWatch = (context, run = {}) => {
 	let why;
+	let runWhy;
 	return {
 		stoppedBy: (reason) => {
 			why = reason;
 		},
-		session: (asked) => {
+		session: (asked, priorCostUsd = 0) => {
 			const { leftUsd: left, leftTokens } = context.quota?.() ?? {};
 			let refused;
 			return {
@@ -591,6 +637,7 @@ const limitWatch = (context) => {
 					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";
+					else if (spent) runWhy = runSpent(run, asked, outcome, priorCostUsd);
 				}
 			};
 		},
@@ -600,6 +647,11 @@ const limitWatch = (context) => {
 				...endedWith(result, endFor("plan_limit", {}, why)),
 				limited: why
 			};
+			if (runWhy !== void 0) return {
+				...result,
+				limited: runWhy,
+				stopsAs: "budget_exhausted"
+			};
 			const { end } = result;
 			return end?.kind === "plan_limit" ? {
 				...result,
@@ -677,9 +729,31 @@ const startWith = async (context, left, own, reserve) => {
 * `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);
+const budgetToStart = (context) => startWith(context, () => budgetNow(context), ownCaps(context).usd, context.reserveBudget);
+/** The node's own caps: its `budgetUsd` and `budgetTokens`, else the defaults'. */
+const ownCaps = (context) => isClaudeNode(context.node) ? {
+	usd: context.node.budgetUsd ?? context.workflow.defaults?.budgetUsd,
+	tokens: context.node.budgetTokens ?? context.workflow.defaults?.budgetTokens
+} : {};
+/**
+* Where the run's budget, not the node's own cap, caps the node's first
+* session: the run has a budget in that unit, and what `startBudgets` left the
+* session is below the node's own cap, or it has none. A later turn of the
+* session keeps them: both its caps go down by what it used, and the run's by
+* what others used too.
+*/
+const runCapsOf = (context, planOptions) => {
+	const own = ownCaps(context);
+	const limits = context.workflow.limits;
+	const caps = {};
+	const usd = planOptions.budgetLeftUsd;
+	if (context.budgetLeftNow?.() !== void 0 && limits?.budgetUsd !== void 0 && usd !== void 0 && usd < (own.usd ?? Infinity)) caps.usd = limits.budgetUsd;
+	const tokens = planOptions.budgetLeftTokens;
+	if (context.tokensLeftNow?.() !== void 0 && limits?.budgetTokens !== void 0 && tokens !== void 0 && tokens < (own.tokens ?? Infinity)) caps.tokens = limits.budgetTokens;
+	return caps;
+};
 /** `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);
+const tokensToStart = (context) => startWith(context, () => tokensNow(context), ownCaps(context).tokens, 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
@@ -1729,30 +1803,6 @@ const checkedResult = (result, { check, resumes }) => {
 *   through the session's ports, and resumes its session on re-entry
 *   (ADR-019).
 */
-const MAX_INPUT = 8192;
-const inputJson = (input) => JSON.stringify(input ?? {}, void 0, 2);
-/** What a sent-back input is whole, for `read_input`, when its note cuts it. */
-const wholeInput = (input) => {
-	const json = inputJson(input);
-	return json.length > MAX_INPUT ? json : void 0;
-};
-/** A re-entry's note of what was sent back; `read_input` has a cut rest. */
-const reentryNote = (round, input) => {
-	const json = inputJson(input);
-	const cut = json.length > MAX_INPUT;
-	const body = cut ? `${json.slice(0, MAX_INPUT)}\n…` : json;
-	const rest = cut ? `\n\nThat is the first ${String(MAX_INPUT)} of its ${String(json.length)} characters. Call read_input for all of it before you act on it.` : "";
-	return `\n\n## Round ${String(round)}\n\nThe workflow sent this task back to you with:\n\n\`\`\`json\n${body}\n\`\`\`${rest}`;
-};
-/**
-* What a resumed leader is told: it already has its brief and its earlier work,
-* so only the new round, and the new task when its owner sent one.
-*/
-const resumeMessage = (round, input, brief) => [brief === void 0 ? sentBack(round, input) : `## New task from \`${brief.from}\`\n\n${brief.text}`, "End with a new structured report."].join("\n\n");
-/** A first-round resume is a session the run was cut off in (`ork resume`). */
-const sentBack = (round, input) => round === 1 ? "Ork was stopped while you worked on this task, and the run is resumed. Your earlier turns are above: check what you finished, and carry on from there." : `The workflow sent your task back to you.${reentryNote(round, input)}`;
-/** What a session is told when messages came in as it finished. */
-const lateMessage = (count) => `[ork] ${String(count)} message${count === 1 ? "" : "s"} came in while you finished. Call read_inbox, act on ${count === 1 ? "it" : "them"} if needed, and end with a new structured report.`;
 /** A re-entered leader resumes; anyone else starts with the full brief. */
 const specFor = (spec, context) => {
 	if (context.resume !== void 0) return {
@@ -1816,11 +1866,12 @@ 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);
+	const watch = limitWatch(context, runCapsOf(context, planOptions));
+	const run = async (asked, prior = 0) => {
+		const watching = watch.session(asked, prior);
 		context.reserveBudget?.(asked.budgetUsd);
 		context.reserveTokens?.(asked.budgetTokens);
 		const session = runtime.start(asked, ports);
@@ -1849,7 +1900,7 @@ const claudeExecutor = (options) => async (context) => {
 		return outcome;
 	};
 	const first = await run(spec);
-	const limitsAfter = ({ sessionId, usage }) => {
+	const limitsAfter = ({ sessionId, usage }, turnsAtLeast = 0) => {
 		const quota = context.quota?.();
 		if (quota?.blocked !== void 0) {
 			watch.stoppedBy(quota.blocked);
@@ -1862,14 +1913,14 @@ const claudeExecutor = (options) => async (context) => {
 		}, context.budgetLeftNow?.(), quota?.leftUsd, {
 			run: context.tokensLeftNow?.(),
 			quota: quota?.leftTokens
-		});
+		}, turnsAtLeast);
 	};
 	const resumeWith = (outcome, prompt, limits) => run({
 		...spec,
 		...limits,
 		resume: outcome.sessionId,
 		prompt
-	});
+	}, outcome.usage.costUsd);
 	const lateTurn = (current) => {
 		const late = context.mailbox?.pending() ?? 0;
 		const limits = limitsAfter(current);
@@ -1895,7 +1946,7 @@ const claudeExecutor = (options) => async (context) => {
 		},
 		late: lateTurn,
 		resume: async (current, check) => {
-			const limits = limitsAfter(current);
+			const limits = limitsAfter(current, 20);
 			if (limits === null) return null;
 			await context.hold?.wait("start", context.signal);
 			return context.signal.aborted ? null : resumeWith(current, checkFailedMessage(check, {
@@ -2143,20 +2194,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) => {
@@ -2197,10 +2251,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);