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

package/dist/{src-B9zWIVqo.mjs → src-CXBmaGwS.mjs}

@@ -1,4 +1,4 @@
-import { Bn as outcomeEnd, Et as parseReport, Gn as FEEDBACK_SEVERITIES, Gt as programFound, Hn as END_KINDS, Kn as FEEDBACK_TARGETS, Kt as startAt, Nn as countedTokens, Un as endFor, Wn as FEEDBACK_KINDS, Wt as lowerChild, _i as AGENT_DRIVERS, fr as maskSecrets, ur as MASK } from "./src-Dr_fTSu-.mjs";
+import { It as lowerChild, Jn as END_KINDS, Kn as outcomeEnd, Lt as programFound, Qn as FEEDBACK_TARGETS, Rt as startAt, Xn as FEEDBACK_KINDS, Yn as endFor, Zn as FEEDBACK_SEVERITIES, gr as MASK, un as FOLLOW_UP_KINDS, vr as maskSecrets, vt as parseReport, wi as AGENT_DRIVERS, zn as countedTokens } from "./src-DN-RPsil.mjs";
 import { n as holdGuard, r as orphanGuard } from "./orphan-guard-BFKg8VSd.mjs";
 import path from "node:path";
 import { z } from "zod";
@@ -9,13 +9,6 @@ import { createInterface } from "node:readline";
 import { execFile, spawn } from "node:child_process";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { createServer } from "node:http";
-// ../core/src/follow-ups/types.ts
-const FOLLOW_UP_KINDS = [
-	"change",
-	"message",
-	"task",
-	"check"
-];
 // ../runtime/src/hold.ts
 /**
 * Waits at a tool call while `hold` is held: "go" once it is released within
@@ -456,8 +449,10 @@ const classifyProviderError = (text, status) => {
 *   it can see (a turn cap, an exit code, a provider's error), and the report
 *   the session handed in decides the rest. The runner then writes the end in
 *   the node's numbers, its detail scrubbed with the feedback redactor. A
-*   session the driver could not run ends as `driverFailure` says, and one that
-*   reached its token cap as `tokenCapOutcome` says.
+*   session the driver could not run (or that was stopped, with what it had
+*   spent) ends as `driverFailure` says, one whose process died as
+*   `failureReason` explains, and one that reached its token cap as
+*   `tokenCapOutcome` says.
 */
 /** The end a report gives: done, a reported failure, or none handed in. */
 const reportEnd = (report) => {
@@ -482,9 +477,15 @@ const errorEnd = (text, fallback = "unknown", status) => endFor(classifyProvider
 */
 const settleEnd = (outcome, facts, scrub) => {
 	const end = outcome.report === null ? outcome.end ?? outcomeEnd(outcome) : reportEnd(outcome.report);
+	const { usage } = outcome;
+	const used = {
+		...facts,
+		usedTokens: countedTokens(usage),
+		...usage.costUsd > 0 ? { usedUsd: usage.costUsd } : {}
+	};
 	return {
 		...outcome,
-		end: endFor(end.kind, facts, end.detail, scrub)
+		end: endFor(end.kind, used, end.detail, scrub)
 	};
 };
 /**
@@ -517,6 +518,17 @@ const tokenCapOutcome = ({ budgetTokens }, usage, sessionId) => budgetTokens ===
 	usage,
 	errors: [`Reached the token budget (${String(budgetTokens)})`]
 };
+const REASON_LIMIT = 500;
+/** Noise a Node crash ends stderr with, or a stack frame: never the reason. */
+const isNoise = (line) => /^Node\.js v\d/u.test(line) || /^\s+at /u.test(line);
+/**
+* Why a process ended without a result: the last block of its stderr as one
+* masked, capped line (the reason reaches the terminal, which is not masked).
+*/
+const failureReason = (name, stderr, code) => {
+	const block = stderr.split("\n").filter((line) => !isNoise(line)).join("\n").split(/\n\s*\n/u).map((text) => text.trim().replaceAll(/\s*\n\s*/gu, " ")).findLast((text) => text !== "");
+	return block === void 0 ? `${name} exited with code ${String(code)}` : maskSecrets(block).slice(0, REASON_LIMIT);
+};
 /**
 * The kind of a failure to run the driver: its program missing, else what a
 * provider's words in it say, else a crash.
@@ -527,27 +539,32 @@ const failureKind = (error) => {
 	if (/\bENOENT\b/u.test(text)) return "tool_missing";
 	return classifyProviderError(text)?.kind ?? "driver_crashed";
 };
+const NOTHING_SPENT = {
+	usage: {
+		costUsd: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0,
+		turns: 0,
+		durationMs: 0
+	},
+	sessionId: ""
+};
 /**
 * A finished event for a session the driver could not run, ended as `kind` with
-* `message` (Ork's words or the tool's, masked) as its detail.
+* `message` (Ork's words or the tool's, masked) as its detail; a stopped one
+* keeps what it had `spent` (its tokens decoded so far, dollars $0).
 */
-const driverFailure = (message, kind, scope) => ({
+const driverFailure = (message, kind, scope, spent = NOTHING_SPENT) => ({
 	type: "session.finished",
 	outcome: {
 		subtype: "error_driver",
 		end: endFor(kind, scope.facts, kind === "interrupted" ? void 0 : message, scope.scrub),
-		sessionId: "",
+		sessionId: spent.sessionId,
 		report: null,
 		text: "",
-		usage: {
-			costUsd: 0,
-			inputTokens: 0,
-			outputTokens: 0,
-			cacheReadTokens: 0,
-			cacheWriteTokens: 0,
-			turns: 0,
-			durationMs: 0
-		},
+		usage: spent.usage,
 		errors: [message]
 	}
 });
@@ -608,7 +625,6 @@ const spawnLeg = (start) => {
 *   Windows the process ends with `ork`, whatever ends `ork` (the orphan
 *   guard).
 */
-const REASON_LIMIT = 500;
 /** Marks a session's start with the driver that runs it. */
 const withDriver = (event, driver) => event.type === "session.started" ? {
 	...event,
@@ -622,10 +638,11 @@ const settled = (outcome, input) => settleEnd(input.reported === void 0 ? outcom
 	...outcome,
 	report: input.reported()
 }, input.scope.facts, input.scope.scrub);
+/** What this leg `used`, with what the legs before it spent. */
+const withCarried = (input, used) => used === void 0 || input.carried === void 0 ? used ?? input.carried : input.adapter.usage.combine(input.carried, used);
 /** The session's end at its token cap, its earlier legs' usage included. */
 const tokenCapEnd = (input, used, sessionId) => {
-	const usage = used === void 0 || input.carried === void 0 ? used : input.adapter.usage.combine(input.carried, used);
-	const capped = tokenCapOutcome(input.scope.facts, usage, sessionId);
+	const capped = tokenCapOutcome(input.scope.facts, used === void 0 ? void 0 : withCarried(input, used), sessionId);
 	return capped === void 0 ? void 0 : {
 		type: "session.finished",
 		outcome: settled(capped, input)
@@ -645,37 +662,36 @@ const legStep = (decoded, input) => {
 	const events = [];
 	let ended;
 	for (const said of decoded.events) {
-		const event = said.type === "session.finished" ? {
+		if (said.type === "session.started" && carried !== void 0) continue;
+		if (said.type !== "session.finished") {
+			events.push(withDriver(said, adapter.driver));
+			continue;
+		}
+		const own = said.outcome.usage;
+		const usage = carried === void 0 ? own : adapter.usage.combine(carried, own);
+		const last = {
 			...said,
-			outcome: settled(said.outcome, input)
-		} : said;
-		if (event.type === "session.started" && carried !== void 0) continue;
-		if (event.type !== "session.finished") events.push(withDriver(event, adapter.driver));
-		else if (deferred) ended = {
+			outcome: settled({
+				...said.outcome,
+				usage
+			}, input)
+		};
+		const { sessionId, end } = last.outcome;
+		if (deferred) ended = {
 			kind: "deferred",
-			sessionId: event.outcome.sessionId,
-			usage: event.outcome.usage,
-			last: event
+			sessionId,
+			usage: own,
+			last
+		};
+		else if (input.withhold() && wentWell(end?.kind)) ended = {
+			kind: "continued",
+			sessionId,
+			usage: own,
+			last
 		};
 		else {
-			const usage = carried === void 0 ? event.outcome.usage : adapter.usage.combine(carried, event.outcome.usage);
-			const last = {
-				...event,
-				outcome: {
-					...event.outcome,
-					usage
-				}
-			};
-			if (input.withhold() && wentWell(event.outcome.end?.kind)) ended = {
-				kind: "continued",
-				sessionId: event.outcome.sessionId,
-				usage: event.outcome.usage,
-				last
-			};
-			else {
-				events.push(last);
-				ended = { kind: "finished" };
-			}
+			events.push(last);
+			ended = { kind: "finished" };
 		}
 	}
 	return ended === void 0 ? { events } : {
@@ -683,16 +699,6 @@ const legStep = (decoded, input) => {
 		ended
 	};
 };
-/** Noise a Node crash ends stderr with, or a stack frame: never the reason. */
-const isNoise = (line) => /^Node\.js v\d/u.test(line) || /^\s+at /u.test(line);
-/**
-* Why a process ended without a result: the last block of its stderr as one
-* masked, capped line (the reason reaches the terminal, which is not masked).
-*/
-const failureReason = (name, stderr, code) => {
-	const block = stderr.split("\n").filter((line) => !isNoise(line)).join("\n").split(/\n\s*\n/u).map((text) => text.trim().replaceAll(/\s*\n\s*/gu, " ")).findLast((text) => text !== "");
-	return block === void 0 ? `${name} exited with code ${String(code)}` : maskSecrets(block).slice(0, REASON_LIMIT);
-};
 /** Runs one process of a session, yielding its events; returns how it ended. */
 const runLeg = async function* (input) {
 	const child = spawnLeg(input);
@@ -728,11 +734,14 @@ const runLeg = async function* (input) {
 	if (input.adapter.command.input === void 0) child.stdin.end();
 	let outcome;
 	let sessionId = "";
+	/** What this leg has used so far, as the last usage step said. */
+	let used;
 	const { decoder } = input;
 	const decode = decoder?.decode ?? input.adapter.decode;
 	try {
 		for await (const line of createInterface({ input: child.stdout })) {
 			const decoded = decode(line);
+			used = decoded.usage ?? used;
 			const { events, ended } = legStep(decoded, input);
 			for (const event of decoded.events) if (event.type === "session.started") sessionId = event.sessionId;
 			yield* events;
@@ -760,11 +769,18 @@ const runLeg = async function* (input) {
 			reason: `could not start ${input.bin}: ${end.message}`,
 			end: failureKind(end)
 		};
-		if (stopped || end.signal !== null) return {
-			kind: "failed",
-			reason: "interrupted",
-			end: "interrupted"
-		};
+		if (stopped || end.signal !== null) {
+			const usage = withCarried(input, used);
+			return {
+				kind: "failed",
+				reason: "interrupted",
+				end: "interrupted",
+				...usage === void 0 ? {} : { spent: {
+					usage,
+					sessionId
+				} }
+			};
+		}
 		const reason = failureReason(input.adapter.command.bin, stderr, end.code);
 		return {
 			kind: "failed",
@@ -850,6 +866,7 @@ const releaseTool = defineTool({
 });
 // ../runtime/src/tools/delegate.ts
 const BRIEF = z.string().min(1).describe("Self-contained: the goal, the files that matter, and what done looks like. The child does not see your conversation.");
+const DESCRIPTION = z.string().exactOptional().describe("A few words naming this task; shown as the child's label.");
 /** What the leader reads back: each report without the usage details. */
 const reportLine = (report) => {
 	const { usage, ...output } = report.output;
@@ -875,7 +892,8 @@ const delegateTool = defineTool({
 		const ids = ports.ownership?.children.map((child) => child.id) ?? [];
 		return { tasks: z.array(z.strictObject({
 			child: z.enum(ids).describe(`The id of a node you own: ${ids.join(", ")}.`),
-			brief: BRIEF
+			brief: BRIEF,
+			description: DESCRIPTION
 		})).min(1) };
 	},
 	available: ({ ports }) => (ports.ownership?.children.length ?? 0) > 0,
@@ -891,7 +909,8 @@ const spawnWorkerTool = defineTool({
 		const ids = ports.ownership?.templates ?? [];
 		return { tasks: z.array(z.strictObject({
 			template: z.enum(ids).describe(`The id of a child worker you own: ${ids.join(", ")}.`),
-			brief: BRIEF
+			brief: BRIEF,
+			description: DESCRIPTION
 		})).min(1) };
 	},
 	available: ({ ports }) => ports.ownership !== void 0 && ports.ownership.templates.length > 0 && ports.ownership.workersLeft() > 0,
@@ -959,7 +978,7 @@ const followUpTool = defineTool({
 			text: z.string().min(1).max(4e3)
 		}).optional().describe("For a message: what the maintainer will send."),
 		steps: z.array(z.strictObject({
-			text: z.string().min(1),
+			text: z.string().trim().min(1),
 			command: z.string().optional().describe("Shown to the maintainer to copy; Ork never runs it.")
 		})).max(20).optional().describe("For a task or check: what to do, in order.")
 	},
@@ -1335,7 +1354,9 @@ const createSessionRuntime = (adapter, options = {}) => ({
 					}
 					const leg = yield* runLeg(legOf(legSpec, spent));
 					if (leg.kind === "failed") {
-						yield driverFailure(leg.reason, leg.end, scope);
+						const { spent: stopped } = leg;
+						if (stopped?.sessionId === "") stopped.sessionId = legSpec.resume ?? "";
+						yield driverFailure(leg.reason, leg.end, scope, stopped);
 						return;
 					}
 					if (leg.kind === "finished") return;

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

@@ -1,5 +1,5 @@
-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 { $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";
@@ -60,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) => {
@@ -83,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
@@ -552,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,
@@ -569,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 {
@@ -592,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);
 				}
 			};
 		},
@@ -601,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,
@@ -678,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
@@ -1730,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 {
@@ -1820,9 +1869,9 @@ const claudeExecutor = (options) => async (context) => {
 	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);
@@ -1851,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);
@@ -1864,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);
@@ -1897,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, {