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

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

@@ -1,8 +1,8 @@
-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 beforeOf, At as endedWith, Bn as countedTokens, Dt as runScope, Et as heldTimeout, It as lowerChild, Jn as END_DETAIL_LIMIT, Kn as endOf, Mt as stoppedEnd, Nt as declaredProblem, Ot as calledWorkflows, Pt as slotClock, R as storePath, Rt as startAt, Ti as AGENT_DRIVERS, Xn as endFor, Y as sessionRefusals, _i as INTEGRATIONS, _t as planNodeSession, an as sessionDriver, cn as MCP_FILE, di as isClaudeNode, dr as parseTemplate, ei as programsRunBy, fi as isToolNode, fr as renderTemplate, gi as timeoutMs, ii as markValue, jt as failedWith, ln as mcpNotText, mt as planReason, nn as envReadsOf, qn as outcomeEnd, sn as declaredOutputOf, un as serversIn, ur as evaluate, vi as TOOL_PREFIX, yi as integrationFor, yt as reportSchemaFor } from "./src-DLsFsmOD.mjs";
+import { t as runOnce } from "./run-BfxdsQJk.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 { accessSync, constants, lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { Readable } from "node:stream";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -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
@@ -1027,6 +1100,62 @@ const skippedCheck = (outputFile) => {
 		}
 	}, endFor("done"));
 };
+// ../nodes/src/run-marker.ts
+/**
+* @file The marker a run leaves on its sessions and programs (ADR-047), and the
+*   stores it guards: the commands that act as the user refuse in the stores of
+*   the runs that started a process, and everywhere under a marker that lists
+*   none, which an older `ork` sets.
+*/
+/** Set for a program in a run. */
+const RUN_ENV = "ORK_RUN";
+/** Set for a Claude session. It says no more than that: no run, no node. */
+const SESSION_ENV = "ORK_SESSION";
+/**
+* The stores whose runs started a session or program, as a JSON array of real
+* paths: the commands that act as the user refuse only in these.
+*/
+const GUARDED_STORES_ENV = "ORK_GUARDED_STORES";
+/**
+* The variable that says a program in a run or a session started this process,
+* or `null` when none does.
+*/
+const runMarkerIn = (env) => ["ORK_RUN", "ORK_SESSION"].find((name) => env[name] !== void 0) ?? null;
+/** The stores `env` lists, or `undefined` when it lists none or garbles it. */
+const listIn = (env) => {
+	const text = env[GUARDED_STORES_ENV];
+	if (text === void 0) return void 0;
+	try {
+		const value = JSON.parse(text);
+		return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+	} catch {
+		return;
+	}
+};
+/** A store file's real path, so a symlinked `~/.ork` is the same store. */
+const realStore = (store) => {
+	try {
+		return realpathSync(store);
+	} catch {
+		return path.resolve(store);
+	}
+};
+/**
+* The stores a run that started this process is in: `null` when no run did, and
+* `"all"` when one did but listed none (an older `ork`), which fails closed.
+*/
+const guardedStoresIn = (env) => runMarkerIn(env) === null ? null : listIn(env) ?? "all";
+/** Whether a run in `store` (a store file) started this process. */
+const storeGuarded = (env, store) => {
+	const guarded = guardedStoresIn(env);
+	return guarded === "all" || guarded !== null && guarded.includes(realStore(store));
+};
+/**
+* What a run in `store` (default: the user's) tells its sessions and programs:
+* the stores it inherited, and its own. Nothing when it inherited "all", so
+* that holds.
+*/
+const guardOf = (env, store = storePath()) => guardedStoresIn(env) === "all" ? {} : { [GUARDED_STORES_ENV]: JSON.stringify([.../* @__PURE__ */ new Set([...listIn(env) ?? [], realStore(store)])]) };
 // ../nodes/src/tool-scrub.ts
 /**
 * @file Masking a secret in what a program prints. A plain search, so a value
@@ -1190,16 +1319,13 @@ const scrubberOf = (values) => {
 const OUTPUT_ENV = "ORK_OUTPUT";
 /** A file a `watch:` node's program keeps between looks (RFC-011). */
 const STATE_ENV = "ORK_STATE";
-/** Set for a program in a run. */
-const RUN_ENV = "ORK_RUN";
-/** Set for a Claude session. It says no more than that: no run, no node. */
-const SESSION_ENV = "ORK_SESSION";
 /** The variables a caller's run reads, for a run it calls to mask too. */
 const MASKED_ENV = "ORK_MASKED";
 /** Every variable Ork sets itself; a workflow's `env:` cannot set them. */
 const IDENTITY_KEYS = /* @__PURE__ */ new Set([
 	RUN_ENV,
 	SESSION_ENV,
+	GUARDED_STORES_ENV,
 	MASKED_ENV,
 	"ORK_NODE",
 	"ORK_ROUND",
@@ -1218,20 +1344,21 @@ const IDENTITY_KEYS = /* @__PURE__ */ new Set([
 */
 const withoutIdentity = (env) => Object.fromEntries(Object.entries(env).flatMap(([key, value]) => value === void 0 || IDENTITY_KEYS.has(key) ? [] : [[key, value]]));
 /**
-* What a Claude session runs with: no identity, only the marker that stops its
-* Bash from speaking as the user through `ork chat`.
+* What a Claude session of a run in `store` (default: the user's) runs with: no
+* identity, only the marker that stops its Bash from speaking as the user
+* through `ork chat`, and the stores it must not do that in.
 */
-const sessionEnv = (env) => ({
+const sessionEnv = (env, store) => ({
 	...withoutIdentity(env),
-	[SESSION_ENV]: "1"
+	[SESSION_ENV]: "1",
+	...guardOf(env, store)
 });
 /**
-* The variable that says a program in a run or a session started this process,
-* or `null` when none does.
+* Who a node's program is, and the stores its run guards (none listed without
+* `store`, which guards every one). It is attribution, not a boundary.
 */
-const runMarkerIn = (env) => ["ORK_RUN", SESSION_ENV].find((name) => env[name] !== void 0) ?? null;
-/** Who a node's program is. It is attribution, not a security boundary. */
-const identityOf = (context, orkBin) => ({
+const identityOf = (context, orkBin, environ = {}, store) => ({
+	...store === void 0 ? {} : guardOf(environ, store),
 	[RUN_ENV]: context.runId,
 	ORK_NODE: context.id,
 	ORK_ROUND: String(context.round),
@@ -1453,7 +1580,7 @@ const toolExecutor = (given, options = {}) => async (context) => {
 	const outputFile = node.output?.format === "json" ? prepareOutputFile(context.runDir, context.id, context.round) : void 0;
 	const env = {
 		...nodeEnv.values,
-		...identityOf(context, options.orkBin),
+		...identityOf(context, options.orkBin, environ, options.store),
 		...maskedEnv(namesToMask(context.workflow, environ, options.maskedNames)),
 		...outputFile === void 0 ? {} : { [OUTPUT_ENV]: outputFile },
 		...node.watch === void 0 ? {} : { [STATE_ENV]: prepareStateFile(context.runDir, context.id) }
@@ -1730,30 +1857,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 +1923,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 +1954,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 +1967,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 +2000,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, {
@@ -2271,6 +2374,7 @@ const spawnTool = (program, args, { cwd, signal, env, priority }) => {
 const builtinExecutors = (options) => {
 	const tool = toolExecutor(options.tools ?? spawnTool, {
 		...options.orkBin === void 0 ? {} : { orkBin: options.orkBin },
+		...options.store === void 0 ? {} : { store: options.store },
 		...options.maskedNames === void 0 ? {} : { maskedNames: options.maskedNames }
 	});
 	const claude = claudeExecutor({
@@ -2411,4 +2515,4 @@ const missingPrograms = (workflow, installed = (program) => onPath(program)) =>
 	}
 	return [...missing.values()];
 };
-export { namedMcpEntries as _, builtinExecutors as a, toolExecutor as c, maskedEnv as d, maskedNamesOfRun as f, clearOutputFiles as g, sessionEnv as h, onPath as i, clearStateFiles as l, runScrubber as m, missingProgramMessage as n, spawnTool as o, runMarkerIn as p, missingPrograms as r, mcpCallExecutor as s, envProblems as t, inheritedScrubber as u, resultOf as v };
+export { clearOutputFiles as _, builtinExecutors as a, toolExecutor as c, maskedEnv as d, maskedNamesOfRun as f, storeGuarded as g, runMarkerIn as h, onPath as i, clearStateFiles as l, sessionEnv as m, missingProgramMessage as n, spawnTool as o, runScrubber as p, missingPrograms as r, mcpCallExecutor as s, envProblems as t, inheritedScrubber as u, namedMcpEntries as v, resultOf as y };

package/dist/{store-oKJ-cCf3.mjs → store-DACH768X.mjs}

@@ -1,4 +1,4 @@
-import { U as openStore } from "./src-Dr_fTSu-.mjs";
+import { L as openStore } from "./src-DLsFsmOD.mjs";
 // src/store.ts
 /**
 * @file Opening the user's store (`~/.ork/state.db`) for the length of one