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

package/dist/{src-Df6KOIDC.mjs → src-CdDTQLdQ.mjs}

@@ -3,7 +3,7 @@ import { LineCounter, YAMLMap, YAMLSeq, isAlias, isCollection, isMap, isNode, is
 import { z } from "zod";
 import { closeSync, cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
-import { homedir, tmpdir } from "node:os";
+import { constants as constants$1, homedir, setPriority, tmpdir } from "node:os";
 import { createConnection, createServer } from "node:net";
 import { createInterface } from "node:readline";
 import { execFile, execFileSync, spawn } from "node:child_process";
@@ -86,6 +86,7 @@ const aws = defineIntegration({
 		region: z.string().optional()
 	},
 	args: ({ profile, region }) => [...profile === void 0 ? [] : ["--profile", profile], ...region === void 0 ? [] : ["--region", region]],
+	signedOut: ({ stderr }) => /Unable to locate credentials|ExpiredToken|InvalidClientTokenId|Token has expired|aws sso login|SSO session .* expired/iu.test(stderr),
 	doctor: async (exec, env) => {
 		if (!(await exec("aws", ["--version"])).ok) return {
 			name: "aws",
@@ -227,7 +228,7 @@ const installedCli = (id, program, login, rest) => ({
 		const unproven = rest.proven ? "" : ", unproven: not yet proven on a real session";
 		if (!version.ok) return {
 			name,
-			status: rest.proven ? "warn" : "skip",
+			status: "skip",
 			detail: `${program} CLI not found${unproven}`,
 			...rest.proven ? { hint: `Install ${program} to use the ${id} driver.` } : {}
 		};
@@ -247,7 +248,7 @@ const AGENT_DRIVERS = [
 	claudeCode,
 	installedCli("open-code", "opencode", "opencode auth login", {
 		label: "the `opencode` CLI",
-		proven: false,
+		proven: true,
 		onePerCheckout: false,
 		capabilities: {
 			questions: true,
@@ -255,13 +256,13 @@ const AGENT_DRIVERS = [
 			price: true,
 			midTurnMessages: false,
 			reportSchema: false,
-			turnLimit: false,
+			turnLimit: true,
 			mcpServers: true
 		}
 	}),
 	installedCli("command-code", "cmd", "cmd login", {
 		label: "the `cmd` CLI of Command Code",
-		proven: false,
+		proven: true,
 		onePerCheckout: true,
 		capabilities: {
 			questions: true,
@@ -299,6 +300,7 @@ const gh = defineIntegration({
 	program: "gh",
 	options: {},
 	args: () => [],
+	signedOut: ({ exitCode, stderr }) => exitCode === 4 || /\bgh auth login\b/u.test(stderr),
 	doctor: async (exec) => {
 		if (!(await exec("gh", ["--version"])).ok) return {
 			name: "gh",
@@ -542,13 +544,14 @@ const DriverSchema = z.enum(DRIVER_IDS, { error: (issue) => retiredDriverHint(is
 /** `opus`, `sonnet`, `haiku`, or a full model id such as `claude-opus-5-5`. */
 const ModelSchema = z.string().min(1);
 /** How hard the model thinks; Claude Code's own default when unset. */
-const EffortSchema = z.enum([
+const EFFORTS = [
 	"low",
 	"medium",
 	"high",
 	"xhigh",
 	"max"
-]).describe("Reasoning effort. Default: Claude Code's for the model.");
+];
+const EffortSchema = z.enum(EFFORTS).describe("Reasoning effort. Default: Claude Code's for the model.");
 const IsolationSchema = z.enum([
 	"worktree",
 	"continue",
@@ -718,13 +721,20 @@ const TOOL_NODE_SCHEMAS = INTEGRATIONS.map((i) => toolNodeSchema(i));
 const base = nodeBaseFields;
 /** A Claude node's output field that is not a list: a rule or JSON Schema. */
 const NotListSchema = z.unknown().refine((value) => typeof value !== "object" || value === null || !("list" in value), { message: LIST_RULE_HINT });
+const NODE_EFFORT_HINT = "expected low, medium, high, xhigh or max, or {{item.<field>}}";
+/**
+* A Claude node's effort: a level, or on a `forEach` node a template reading
+* its item (`{{item.effort}}`), which the compiler checks and each item
+* renders.
+*/
+const NodeEffortSchema = z.union([EffortSchema, z.string().regex(/\{\{.*\}\}/su, { error: NODE_EFFORT_HINT })], { error: NODE_EFFORT_HINT }).describe("Reasoning effort, or {{item.<field>}} on a forEach node. Default: Claude Code's for the model.");
 /**
 * What an agent brings to the node it fills, and what a plain Claude node sets
 * itself. A node's own value wins over its agent's.
 */
 const agentSettings = {
 	model: ModelSchema.optional(),
-	effort: EffortSchema.optional(),
+	effort: NodeEffortSchema.optional(),
 	driver: DriverSchema.optional(),
 	skills: z.array(z.string()).optional().describe("Node-layer skills (highest precedence)."),
 	context: z.array(z.string()).optional().describe("Node-layer context files."),
@@ -1076,6 +1086,8 @@ const RulesSchema = z.strictObject({
 	permissions: ToolRulesSchema.optional().describe("Tool rules every Claude node gets on top of its own, e.g. deny: ['Bash(git push *)']."),
 	links: z.enum(["on", "off"]).optional().describe("Default: on, the user can link a running node to a node of another run. off: its nodes get no message tools unless they have someone to write to, and cannot be linked.")
 });
+/** The OS priority Ork starts a run's sessions and tool commands at. */
+const PrioritySchema = z.enum(["low", "normal"]);
 const ProjectSchema = z.strictObject({
 	schemaVersion: z.literal(1),
 	...RulesSchema.shape,
@@ -1083,7 +1095,9 @@ const ProjectSchema = z.strictObject({
 	quotas: QuotasSchema.optional().describe("Most this project may spend on this machine. The user's own caps apply too."),
 	calls: z.strictObject({ accept: z.array(z.string()).describe("The registered projects whose workflows may call this one's.") }).optional().describe("Default: any registered project may call this one's workflows."),
 	context: z.array(z.string()).optional().describe("Context files every node reads, relative to the project root; they come before the workflow's."),
-	experimental: z.array(z.string()).optional().describe("Experimental features this project turns on.")
+	experimental: z.array(z.string()).optional().describe("Experimental features this project turns on."),
+	heavy: z.array(z.string().min(1)).optional().describe("The project's full-suite commands, as Bash permission patterns without Bash(…), e.g. pnpm check. A node with verify: may not run them in its session; vitest run does not cover vitest run <files>."),
+	priority: PrioritySchema.optional().describe("Default: low, sessions and tool commands start at a lower OS priority. normal: as the ork process.")
 });
 /** `~/.ork/settings.yaml`: the user's own settings, and never a credential. */
 const UserSettingsSchema = z.strictObject({
@@ -3213,7 +3227,7 @@ const filesOf = (dir, name) => ({
 	markdown: path.join(dir, `${name}.md`),
 	sidecar: path.join(dir, `${name}${AGENT_SIDECAR_SUFFIX}`)
 });
-const write = (name, agent, options, mode) => {
+const write$1 = (name, agent, options, mode) => {
 	if (!AgentNameSchema.safeParse(name).success) return {
 		ok: false,
 		error: `\`${name}\` is not an agent name (lowercase letters, digits, '-' and '_')`
@@ -3253,7 +3267,7 @@ const write = (name, agent, options, mode) => {
 	};
 };
 /** Creates an agent in Ork's folder for the scope; never overwrites. */
-const createAgent = (name, agent, options) => write(name, agent, options, "create");
+const createAgent = (name, agent, options) => write$1(name, agent, options, "create");
 /** Deletes an agent from Ork's folder for the scope. */
 const deleteAgent = (name, options) => {
 	const dir = agentFolder(options);
@@ -4824,6 +4838,359 @@ const FEEDBACK_SEVERITIES = [
 	"medium",
 	"high"
 ];
+// ../core/src/runtime/ends.ts
+/**
+* @file How a node ended, as one of a closed set of kinds (specs/runtime/
+*   session-ends.md): the registry that gives each kind its label, Ork's own
+*   message, who should act and what to do, and `endFor`, which builds an end
+*   with its raw detail scrubbed and capped. ends-legacy.ts reads one from runs
+*   stored before ends existed.
+*/
+/** The most of a detail kept, in characters. */
+const END_DETAIL_LIMIT = 4096;
+const RETRY = "This may pass: `ork resume` tries again.";
+const usd$1 = (n) => `$${Number.isInteger(n) ? String(n) : n.toFixed(2)}`;
+const paren = (value) => value === void 0 ? "" : ` (${value})`;
+const colon = (reason) => reason === void 0 ? "" : `: ${reason}`;
+const info = (label, actor, message, hint, flags = {}) => ({
+	label,
+	message,
+	actor,
+	transient: flags.transient ?? false,
+	stopsRun: flags.stopsRun ?? false,
+	hint,
+	docsAnchor: label.toLowerCase().replaceAll(" ", "-")
+});
+/** Each kind's label, message, actor, flags, hint and docs anchor. */
+const END_KINDS = {
+	done: info("Done", null, () => "finished", ""),
+	reported_failure: info("Reported failure", "agent", () => "reported that it failed", "Read its summary, fix what it names, and run it again."),
+	no_report: info("No report", "agent", () => "ended without handing in a report", "Check that its brief says what to report; its session is in the Logs panel."),
+	invalid_report: info("Invalid report", "agent", (f) => `handed in a report that breaks its declared output${colon(f.reason)}`, "Check that its brief asks for every field its `output.schema` declares."),
+	turn_limit: info("Turn limit", "workflow", (f) => `reached its turn limit${paren(f.maxTurns === void 0 ? void 0 : String(f.maxTurns))}`, "Raise its `maxTurns`, or give it a smaller task."),
+	budget_limit: info("Budget limit", "workflow", (f) => `reached its budget${paren(f.budgetUsd === void 0 ? void 0 : usd$1(f.budgetUsd))}`, "Raise `budgetUsd` on the node or `limits.budgetUsd` on the workflow, then `ork resume`."),
+	timed_out: info("Timed out", "workflow", (f) => `reached its timeout${paren(f.timeout)}`, "Raise its `timeout`, or give it a smaller task."),
+	context_too_long: info("Context too long", "workflow", () => "outgrew its model's context", "Give it a smaller task or less context, or a model with a larger context."),
+	plan_limit: info("Plan limit", "account", (f) => `ran into a usage limit${paren(f.window?.replaceAll("_", " "))}`, `Wait until the limit resets. ${RETRY}`, {
+		transient: true,
+		stopsRun: true
+	}),
+	rate_limited: info("Rate limited", "provider", () => "was asked by its provider to slow down", RETRY, { transient: true }),
+	provider_unavailable: info("Provider unavailable", "provider", () => "could not reach its provider, or the provider was overloaded", RETRY, { transient: true }),
+	auth: info("Not signed in", "account", () => "could not sign in to its provider", "Sign in to the driver's tool again (`ork doctor` says how), then `ork resume`."),
+	out_of_credits: info("Out of credits", "account", () => "found no credit left on its account", "Add credit to the account, or use another, then `ork resume`."),
+	model_unavailable: info("Model unavailable", "account", () => "asked for something its model or provider can't serve", "Use another model or driver for the node."),
+	interrupted: info("Interrupted", "user", () => "was stopped", "`ork resume` goes on from where it stopped."),
+	tool_missing: info("Tool missing", "account", (f) => `could not start ${f.program ?? "its program"}: it isn't installed`, "Install it (`ork doctor` checks the drivers), then `ork resume`."),
+	command_failed: info("Command failed", "workflow", (f) => `${f.program ?? "its command"} exited with ${f.exitCode === void 0 ? "an error" : String(f.exitCode)}`, "Its output is under Details."),
+	invalid_output: info("Invalid output", "workflow", (f) => `gave JSON that breaks its declared output${colon(f.reason)}`, "Make the command print what its `output.schema` declares."),
+	invalid_node: info("Invalid node", "workflow", (f) => `could not start${colon(f.reason)}`, "Fix the node in the workflow file (`ork validate` checks it)."),
+	driver_crashed: info("Driver crashed", "ork", () => "lost its driver in a way Ork can't read", "Its last output is under Details; Ork files it as a bug."),
+	unknown: info("Unknown", "ork", () => "ended for a reason Ork doesn't recognize", "Its detail is under Details; Ork files it as a bug, so a rule can be added.")
+};
+/**
+* An end of `kind`, its message from `facts`. The detail is scrubbed (with the
+* feedback redactor when `scrub` is given, secrets masked always) and capped.
+*/
+const endFor = (kind, facts = {}, detail, scrub) => {
+	const end = {
+		kind,
+		message: END_KINDS[kind].message(facts)
+	};
+	if (detail === void 0 || detail.trim() === "") return end;
+	const clean = scrub === void 0 ? maskSecrets(detail) : redact(detail, scrub);
+	end.detail = clean.length > 4096 ? `${clean.slice(0, 4095)}…` : clean;
+	return end;
+};
+// ../core/src/runtime/ends-legacy.ts
+/**
+* @file The legacy readers of how a node ended: a run stored before ends
+*   existed gets a kind from the text it kept (specs/runtime/session-ends.md),
+*   and the stored event is never rewritten.
+*/
+/**
+* Text Ork stored before ends existed, to a kind, in the plan's precedence:
+* interrupt, plan limit, budget, timeout, turn limit, provider error, missing
+* tool, failed command, crash. Frozen: old runs' text never changes, so this is
+* not the live provider classifier.
+*/
+const LEGACY_TEXT = [
+	["interrupted", /\bstopped by the user\b|\bthe node was stopped\b|\bstopped while watching\b|\bwas interrupted\b|\bended interrupted\b|\bthe gate was withdrawn\b/u],
+	["plan_limit", /\bClaude plan's .* limit was reached\b|\bquota of \$[\d.]+ is spent\b|\bended quota_exhausted\b/u],
+	["budget_limit", /\(error_max_budget_usd\)|\bmaximum budget\b|\bnothing is left of the run's budget\b|\bbudget of \$[\d.]+ is spent\b|\bended budget_exhausted\b/u],
+	["timed_out", /\btimed out after\b|\bno one answered the gate\b|\btimeout of \S+ passed\b|\bended timed_out\b/u],
+	["turn_limit", /\(error_max_turns\)|\bmaximum number of turns\b/iu],
+	["context_too_long", /\bprompt is too long\b|\bcontext[ _](?:length|window)\b/iu],
+	["rate_limited", /\brate_limit_error\b|\brate.?limit(?:ed)?\b|\b(?:status|HTTP)\W{0,3}429\b/iu],
+	["out_of_credits", /\bcredit balance\b|\binsufficient[ _](?:credit|funds|quota)\b/iu],
+	["auth", /\bauthentication_error\b|\binvalid (?:x-)?api.?key\b|\bnot logged in\b|\/login\b|\b(?:status|HTTP)\W{0,3}401\b/iu],
+	["provider_unavailable", /\boverloaded(?:_error)?\b|\b(?:status|HTTP)\W{0,3}5\d\d\b|\bapi_error\b|\bECONNRESET\b|\bETIMEDOUT\b|\bENOTFOUND\b|\bfetch failed\b/u],
+	["model_unavailable", /\bassistant message prefill\b|\bInvalid `signature` in `thinking` block\b|\bnot_found_error\b|\binvalid_request_error\b/u],
+	["tool_missing", /\bENOENT\b|\bcommand not found\b|\bno agent driver is ready\b/u],
+	["invalid_output", /\$ORK_OUTPUT\b|\bthe JSON result is\b/u],
+	["command_failed", /\bexited with \d+|^[\w.-]+ [\w-]+ failed: /u],
+	["driver_crashed", /\bthe session ended without a result\b/u]
+];
+const textKind = (text) => LEGACY_TEXT.find(([, pattern]) => pattern.test(text))?.[0] ?? null;
+/** What `fieldProblems` writes (run/declared.ts). */
+const DECLARED_PROBLEM = /\bis missing, expected\b|\bis .+, expected\b|^the result isn't a JSON object$/u;
+const WITHOUT_REPORT = /^ended without a report \(([\w-]+)\): ([\s\S]*)$/u;
+/** A driver's subtype, read with the session's error text. */
+const subtypeKind = (subtype, text) => {
+	if (subtype === "error_max_turns") return "turn_limit";
+	if (subtype === "error_max_budget_usd") return "budget_limit";
+	if (subtype === "error_max_structured_output_retries") return "invalid_report";
+	const said = textKind(text);
+	if (said !== null) return said;
+	if (subtype === "error_driver") return "driver_crashed";
+	return text === "no valid report" || subtype === "success" ? "no_report" : "unknown";
+};
+/**
+* How a finished node ended: its own `end`, or, for an event stored before ends
+* existed, a kind read from its `error` text (`unknown` when nothing matches),
+* with that text as the detail.
+*/
+const endOf = (finished) => {
+	if (finished.end !== void 0) return finished.end;
+	if (finished.ok) return endFor("done");
+	const error = finished.error ?? "";
+	return endFor(legacyKind(error, finished.output), {}, error);
+};
+const legacyKind = (error, output) => {
+	if ("artifacts" in output) return DECLARED_PROBLEM.test(error) ? "invalid_report" : "reported_failure";
+	const without = WITHOUT_REPORT.exec(error);
+	if (without !== null) return subtypeKind(without[1] ?? "", without[2] ?? "");
+	return textKind(error) ?? "unknown";
+};
+/**
+* How a session ended: its `end`, or, for an outcome stored before ends existed
+* (or a driver that does not set one yet), one read from its subtype, report
+* and errors.
+*/
+const outcomeEnd = (outcome) => {
+	if (outcome.end !== void 0) return outcome.end;
+	const { report } = outcome;
+	if (report !== null && outcome.subtype === "success") return endFor(report.status === "fail" ? "reported_failure" : "done");
+	const text = outcome.errors[0] ?? (report === null ? "no valid report" : "");
+	return endFor(subtypeKind(outcome.subtype, text), {}, outcome.errors.join("\n"));
+};
+// ../core/src/feedback/end-signals.ts
+/**
+* @file The feedback a node's end files (specs/feedback.md,
+*   specs/runtime/session-ends.md), by who should act on it: Ork's own bug, the
+*   workflow's, or the agent's context. An account's, a provider's or the
+*   user's end is a setup hint on the screen, not feedback.
+*/
+/**
+* Ends that are a node's work saying no, not a problem to act on: an agent that
+* reports `fail`, a command that exits non-zero. Neither is filed.
+*/
+const ANSWERS = /* @__PURE__ */ new Set(["reported_failure", "command_failed"]);
+/**
+* The feedback a node's end files, by who should act on it: Ork's own bug (with
+* the scrubbed detail, so a rule can be added), the workflow's, or the agent's
+* context. An account's, a provider's or the user's is not feedback.
+*/
+const endSignal = (node, end) => {
+	const info = END_KINDS[end.kind];
+	if (ANSWERS.has(end.kind)) return null;
+	const base = {
+		code: `end.${end.kind}`,
+		title: `${node} ${end.message}`,
+		body: info.hint,
+		...end.detail === void 0 ? {} : { evidence: [end.detail] }
+	};
+	if (info.actor === "ork") return {
+		...base,
+		kind: "bug",
+		target: "ork",
+		severity: "medium"
+	};
+	if (info.actor === "workflow") return {
+		...base,
+		kind: "workflow",
+		target: "workflow",
+		severity: "low"
+	};
+	return info.actor === "agent" ? {
+		...base,
+		kind: "context-gap",
+		target: "workflow",
+		severity: "low"
+	} : null;
+};
+// ../core/src/feedback/signals.ts
+const ORK_TOOL = "mcp__ork__";
+/**
+* An observer for one run's events: give it each event, and record what it
+* returns, in order (the event, its origin filled in when it is feedback, then
+* any feedback it signals).
+*/
+const createSignals = (options = {}) => {
+	let workflow;
+	const nodeTypes = /* @__PURE__ */ new Map();
+	const sessions = /* @__PURE__ */ new Map();
+	const tools = /* @__PURE__ */ new Map();
+	const asked = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const originOf = (node) => {
+		const origin = {};
+		if (workflow !== void 0) origin.workflow = workflow;
+		if (options.workflowHash !== void 0) origin.workflowHash = options.workflowHash;
+		const type = node === void 0 ? void 0 : nodeTypes.get(node);
+		if (type !== void 0) origin.nodeType = type;
+		const session = node === void 0 ? void 0 : sessions.get(node);
+		if (session !== void 0) origin.model = session.model;
+		if (session?.driver !== void 0) origin.driver = session.driver;
+		if (options.version !== void 0) origin.version = options.version;
+		return origin;
+	};
+	const record = (node, signal) => {
+		const print = fingerprint(signal);
+		if (seen.has(print)) return [];
+		seen.add(print);
+		return [{
+			type: "feedback.recorded",
+			...node === void 0 ? {} : { node },
+			feedback: {
+				source: "system",
+				kind: signal.kind,
+				target: signal.target,
+				severity: signal.severity,
+				title: signal.title,
+				body: signal.body,
+				evidence: signal.evidence ?? [],
+				code: signal.code,
+				fingerprint: print,
+				origin: originOf(node)
+			}
+		}];
+	};
+	const answered = (question, answer) => {
+		if (question.kind === "permission") {
+			if (answer !== "deny") return null;
+			const tool = question.question.replace(/^Allow /u, "").replace(/\?$/u, "");
+			return [question.node, {
+				code: "permission.denied",
+				kind: "friction",
+				target: "workflow",
+				severity: "low",
+				title: `${question.node} was denied ${tool}`,
+				body: "Allow it in the node's `tools.allow` if it needs it, or tell it in its prompt not to use it.",
+				evidence: [tool]
+			}];
+		}
+		if (question.recommended === void 0 || answer === question.recommended) return null;
+		return [question.node, {
+			code: "recommendation.overridden",
+			kind: "context-gap",
+			target: "workflow",
+			severity: "low",
+			title: `The answer to ${question.node}'s question was not the one it recommended`,
+			body: `Asked: ${question.question} Recommended: ${question.recommended}. Answered: ${answer}.`
+		}];
+	};
+	/** The feedback an event signals, if any, and the node it is about. */
+	const signalOf = (event) => {
+		if (event.type === "loop.exhausted") return [event.from, {
+			code: "loop.exhausted",
+			kind: "workflow",
+			target: "workflow",
+			severity: "medium",
+			title: `The loop ${event.from} -> ${event.to} ran out of its ${String(event.maxRounds)} rounds`,
+			body: "Raise `maxRounds`, or make what the loop's nodes are asked to fix clearer so it settles sooner."
+		}];
+		if (event.type === "run.finished" && event.result.status === "budget_exhausted") return [void 0, {
+			code: "budget.exhausted",
+			kind: "workflow",
+			target: "workflow",
+			severity: "medium",
+			title: "The run's budget ran out",
+			body: `The run stopped after spending $${event.result.costUsd.toFixed(4)}. Raise \`limits.budgetUsd\`, or give nodes cheaper models or smaller budgets.`
+		}];
+		if (event.type === "decision.answered") {
+			const question = asked.get(event.decision);
+			return question === void 0 ? null : answered(question, event.answer);
+		}
+		if (event.type === "node.event" && event.event.type === "tool.result") {
+			const name = tools.get(`${event.id}\0${event.event.id}`);
+			if (!event.event.isError || name?.startsWith(ORK_TOOL) !== true) return null;
+			const tool = name.slice(10);
+			if (tool === "report") return [event.id, {
+				code: "report.rejected",
+				kind: "context-gap",
+				target: "workflow",
+				severity: "low",
+				title: `${event.id}'s report was not accepted`,
+				body: END_KINDS.invalid_report.hint,
+				evidence: [name]
+			}];
+			return [event.id, {
+				code: "tool.error",
+				kind: "bug",
+				target: "ork",
+				severity: "medium",
+				title: `Ork's ${tool} tool returned an error`,
+				body: `A call to \`${tool}\` failed; the node's events show the call.`,
+				evidence: [name]
+			}];
+		}
+		if (event.type === "node.finished" && nodeTypes.get(event.id) === "human.gate" && event.output["answeredBy"] === "timeout") return [event.id, {
+			code: "gate.timeout",
+			kind: "workflow",
+			target: "workflow",
+			severity: "low",
+			title: `The gate ${event.id} timed out and took its default`,
+			body: "No one answered in time. Lengthen its `timeout`, or keep it if the default was right."
+		}];
+		if (event.type === "node.finished" && !event.ok) {
+			const signal = endSignal(event.id, endOf(event));
+			return signal === null ? null : [event.id, signal];
+		}
+		return null;
+	};
+	/** Keeps what later events and origins need. */
+	const observe = (event) => {
+		if (event.type === "run.started") workflow = event.workflow;
+		if (event.type === "node.started") nodeTypes.set(event.id, event.nodeType);
+		if (event.type === "decision.opened") {
+			const question = {
+				node: event.node,
+				kind: event.kind,
+				question: event.question
+			};
+			if (event.recommended !== void 0) question.recommended = event.recommended;
+			asked.set(event.decision, question);
+		}
+		if (event.type !== "node.event") return;
+		const inner = event.event;
+		if (inner.type === "session.started" && inner.fork !== true) sessions.set(event.id, {
+			model: inner.model,
+			...inner.driver === void 0 ? {} : { driver: inner.driver }
+		});
+		if (inner.type === "tool.called") tools.set(`${event.id}\0${inner.id}`, inner.name);
+	};
+	return (event) => {
+		observe(event);
+		if (event.type === "feedback.recorded") {
+			if (seen.has(event.feedback.fingerprint)) return [];
+			seen.add(event.feedback.fingerprint);
+			const origin = {
+				...originOf(event.node),
+				...event.feedback.origin
+			};
+			return [{
+				...event,
+				feedback: {
+					...event.feedback,
+					origin
+				}
+			}];
+		}
+		const signal = signalOf(event);
+		return signal === null ? [event] : [event, ...record(...signal)];
+	};
+};
 // ../core/src/project/mcp-file.ts
 /**
 * @file The project's `.mcp.json`, the file Claude Code reads too, so a server
@@ -4937,6 +5304,48 @@ const checkMcpServers = (workflow, options) => {
 		});
 	});
 };
+// ../core/src/project/heavy.ts
+/**
+* @file A project's rules for the machine its runs share: the heavy commands
+*   (its full-suite checks), denied to the session of a node with `verify:`
+*   since Ork runs that check, and the OS priority, each with Ork's default.
+*/
+/** A `heavy` pattern as the Bash rule that denies it to a session. */
+const heavyRule = (pattern) => `Bash(${pattern})`;
+/**
+* The nodes, with the heavy commands denied to each Claude node that has
+* `verify:`; other nodes are left as they are. A pattern without `*` matches
+* only that command, so `vitest run` leaves `vitest run <files>` allowed.
+*/
+const withoutHeavy = (nodes, heavy) => {
+	if (heavy.length === 0) return nodes;
+	const rules = heavy.map((pattern) => heavyRule(pattern));
+	return Object.fromEntries(Object.entries(nodes).map(([id, node]) => isClaudeNode(node) && "verify" in node && node.verify !== void 0 ? [id, {
+		...node,
+		tools: {
+			...node.tools,
+			deny: [.../* @__PURE__ */ new Set([...node.tools?.deny ?? [], ...rules])]
+		}
+	}] : [id, node]));
+};
+const words = (text) => text.trim().replaceAll(/\s+/gu, " ");
+/**
+* Whether `command` matches a `heavy` pattern, in the permission patterns'
+* syntax: `*` is any text, a trailing ` *` (or `:*`) also matches nothing, and
+* a pattern without `*` matches only that command.
+*/
+const matchesPattern = (pattern, command) => {
+	const tail = words(pattern).replace(/:\*$/u, " *");
+	const open = tail.endsWith(" *");
+	const body = (open ? tail.slice(0, -2) : tail).split("*").map((part) => part.replaceAll(/[.+?^${}()|[\]\\]/gu, "\\$&")).join(".*");
+	return new RegExp(`^${body}${open ? "(?: .*)?" : ""}$`, "su").test(words(command));
+};
+/** Whether `command` is one of the project's heavy commands. */
+const isHeavy = (heavy, command) => heavy.some((pattern) => matchesPattern(pattern, command));
+const machineRulesOf = (project) => ({
+	heavy: project?.heavy ?? [],
+	priority: project?.priority ?? "low"
+});
 // ../core/src/project/templates.ts
 /**
 * @file Git name templates (`ork/{run}/{node}`, `{inputs.type}/{inputs.slug}`):
@@ -5028,7 +5437,8 @@ const dropUndefined = (value) => Object.fromEntries(Object.entries(value).filter
 /**
 * The workflow with its project's rules under it: git rules key by key and
 * defaults key by key, practices one by one (the workflow's win), permissions
-* added together, and the project's context files before the workflow's.
+* added together, the project's context files before the workflow's, and its
+* heavy commands denied to nodes with `verify:`.
 */
 const applyProject = (workflow, options) => {
 	const { project } = options;
@@ -5062,6 +5472,7 @@ const applyProject = (workflow, options) => {
 	});
 	return dropUndefined({
 		...workflow,
+		nodes: withoutHeavy(workflow.nodes, project.heavy ?? []),
 		defaults: Object.keys(defaults).length === 0 ? void 0 : defaults,
 		rules: Object.keys(rules).length === 0 ? void 0 : rules,
 		layers: Object.keys(layers).length === 0 ? void 0 : layers
@@ -6046,6 +6457,122 @@ const gatherProblems = (id, node) => {
 		return isList(rule) ? [] : [error("output.gather", `\`${field}\` isn't declared as a list (\`{ type: array }\` or \`{ list: … }\`), so its rounds can't be added together`, [...path, index])];
 	});
 };
+// ../core/src/graph/item-settings.ts
+/**
+* @file A fanned node's `model` and `effort` from its item (`{{item.model}}`):
+*   the compiler's checks (only on a `forEach` node, reading only `item`, and
+*   every written item's value), and the rendering each item's session plan
+*   uses, which checks an item from `from:` when it runs.
+*/
+const FIELDS$1 = ["model", "effort"];
+/**
+* The parts of a template that reads something, or `null` for a plain value (or
+* one that does not parse, which the compiler reports).
+*/
+const templateOf$1 = (text) => {
+	const parsed = parseTemplate(text);
+	if (!parsed.ok) return null;
+	return parsed.parts.some((part) => typeof part !== "string") ? parsed.parts : null;
+};
+const isEffort = (text) => EFFORTS.includes(text);
+/** Checks what one item's template rendered to. */
+const checkRendered = (field, template, rendered) => {
+	const text = rendered.trim();
+	if (text === "") return {
+		ok: true,
+		value: void 0
+	};
+	return (field === "effort" ? isEffort(text) : /^[^\s{}"]+$/u.test(text)) ? {
+		ok: true,
+		value: text
+	} : {
+		ok: false,
+		error: `\`${field}: ${template}\` gave \`${text}\`, which is not ${field === "effort" ? `an effort level (${EFFORTS.join(", ")})` : "a model name"}`
+	};
+};
+/**
+* A node's `model` or `effort` for one item: a plain value as written, a
+* template rendered with the item. Without an item, a template renders empty.
+*/
+const itemSetting = (field, value, scope) => {
+	if (value === void 0) return {
+		ok: true,
+		value: void 0
+	};
+	const parts = templateOf$1(value);
+	if (parts === null) return {
+		ok: true,
+		value
+	};
+	return checkRendered(field, value, renderTemplate(parts, scope));
+};
+/** `itemSetting` for `effort`, as an effort level. */
+const itemEffort = (value, scope) => {
+	const given = itemSetting("effort", value, scope);
+	if (!given.ok) return given;
+	if (given.value === void 0) return {
+		ok: true,
+		value: void 0
+	};
+	return isEffort(given.value) ? {
+		ok: true,
+		value: given.value
+	} : {
+		ok: false,
+		error: `\`effort\` is \`${given.value}\``
+	};
+};
+/** A `model` or `effort` template's problems on one node. */
+const checkNodeField = (workflow, says, id, field) => {
+	const node = workflow.nodes[id];
+	const value = node === void 0 ? void 0 : Reflect.get(node, field);
+	if (node === void 0 || typeof value !== "string") return [];
+	const path = [
+		"nodes",
+		id,
+		field
+	];
+	const parsed = parseTemplate(value);
+	if (!parsed.ok) return [error("template.syntax", `${parsed.message} at column ${parsed.offset + 1}`, path)];
+	if (parsed.parts.every((part) => typeof part === "string")) return [];
+	const each = forEachOf$1(node);
+	if (each === void 0) return [error(`${field}.template`, `\`${field}\` may be a template only on a node with \`forEach\`, reading its item, e.g. \`{{item.${field}}}\``, path)];
+	const reads = parsed.parts.flatMap((part) => typeof part === "string" ? [] : collectPaths(part.expr));
+	const outside = reads.filter(([root]) => root !== "item");
+	if (outside.length > 0) return outside.map((segments) => error(`${field}.template`, `\`${describePath(segments)}\`: a \`${field}\` template reads only the item, e.g. \`{{item.${field}}}\``, path));
+	const scope = { fields: itemFieldsOf(node, says) };
+	const fields = reads.flatMap((segments) => checkItemRead(segments, scope, path));
+	if (fields.length > 0 || !("items" in each)) return fields;
+	return each.items.flatMap((item, index) => {
+		const given = checkRendered(field, value, renderTemplate(parsed.parts, {
+			inputs: {},
+			nodes: {},
+			item,
+			index
+		}));
+		return given.ok ? [] : [error(`${field}.item`, `item ${String(index)}: ${given.error}`, [
+			"nodes",
+			id,
+			"forEach",
+			"items",
+			index
+		])];
+	});
+};
+/**
+* `model` and `effort` templates: only on a `forEach` node, reading only
+* `item`, and every written item's value a model name or an effort level.
+* `defaults:` belong to no node, so they take no template.
+*/
+const checkItemSettings = (workflow, edges) => {
+	const says = nodeSays(workflow.nodes, edges);
+	const defaults = FIELDS$1.flatMap((field) => {
+		const value = workflow.defaults?.[field];
+		return value !== void 0 && templateOf$1(value) !== null ? [error(`${field}.template`, `\`defaults.${field}\` applies to every node, so it can't read an item; set the template on the \`forEach\` node`, ["defaults", field])] : [];
+	});
+	const nodes = Object.entries(workflow.nodes).flatMap(([id, node]) => isClaudeNode(node) ? FIELDS$1.flatMap((field) => checkNodeField(workflow, says, id, field)) : []);
+	return [...defaults, ...nodes];
+};
 // ../core/src/graph/script.ts
 /**
 * @file Checks on the programs a workflow declares (RFC-006): a tool node's and
@@ -6111,7 +6638,7 @@ const statusProblems = (id, node) => {
 };
 /** Per-type checks that need the rest of the graph. */
 const checkNodes = (workflow, edges) => {
-	const diagnostics = checkScripts(workflow);
+	const diagnostics = [...checkScripts(workflow), ...checkItemSettings(workflow, edges)];
 	for (const [id, node] of Object.entries(workflow.nodes)) {
 		const path = ["nodes", id];
 		const incoming = edges.filter((e) => e.to === id);
@@ -6646,6 +7173,140 @@ const compileWorkflow = (authored, options = {}) => {
 		diagnostics
 	};
 };
+// ../core/src/machine/priority.ts
+/**
+* @file Starting a child at the project's priority (`priority:`): `low`, the
+*   default, starts it below Ork's own (under `nice`; on macOS also utility QoS
+*   through `taskpolicy`), so the user's own apps come first; `normal` leaves
+*   it. Only children: the `ork` process itself stays at normal priority.
+*/
+/** MacOS's tool for a program's QoS. */
+const TASKPOLICY = "/usr/sbin/taskpolicy";
+/** The POSIX tool that starts a program at a lower priority. */
+const NICE = "/usr/bin/nice";
+/** How far `nice` lowers a `low` child: the same as `PRIORITY_BELOW_NORMAL`. */
+const NICE_STEP = String(constants$1.priority.PRIORITY_BELOW_NORMAL);
+/**
+* Whether `bin` is a program `spawn` would find, so a wrapper can't hide its
+* absence.
+*/
+const found = (bin, env) => bin.includes("/") ? existsSync(bin) : (env["PATH"] ?? "").split(path.delimiter).some((dir) => dir !== "" && existsSync(path.join(dir, bin)));
+/**
+* What to spawn for `bin args` at `priority`. For `low`, when the program is
+* there: under `nice`, so it and what it starts run lower from the first
+* instruction, and on macOS under utility QoS as well; else the program itself,
+* which {@link lowerChild} lowers once it has started.
+*/
+const startAt = (priority, bin, args, env = process.env) => {
+	if (priority !== "low" || !found(bin, env)) return [bin, [...args]];
+	const niced = existsSync(NICE) ? [
+		NICE,
+		"-n",
+		NICE_STEP,
+		bin
+	] : [bin];
+	const [first = bin, ...rest] = process.platform === "darwin" && existsSync(TASKPOLICY) ? [
+		TASKPOLICY,
+		"-c",
+		"utility",
+		...niced
+	] : niced;
+	return [first, [...rest, ...args]];
+};
+/**
+* Lowers a started child's priority for `low` where {@link startAt} had no
+* `nice` to start it under (Windows), best effort; what it starts later
+* inherits it. Under `nice` it does nothing: `nice` lowers relative to the
+* priority it finds, so lowering here too could land first and the two add up.
+*/
+const lowerChild = (priority, pid) => {
+	if (priority !== "low" || pid === void 0 || existsSync(NICE)) return;
+	try {
+		setPriority(pid, constants$1.priority.PRIORITY_BELOW_NORMAL);
+	} catch {}
+};
+// ../core/src/run/machine.ts
+/**
+* @file A node's share of the machine (the `machine` of its context): the
+*   project's priority for its commands, and a machine-wide slot around each
+*   heavy one. A wait is never silent: `slot.waiting` names who holds the
+*   slots, `slot.taken` ends it, and the node's clock (its owners' and the
+*   run's too) stands still meanwhile, so a timeout counts from the slot.
+*/
+/** A wait for a slot, as `ork logs`, `ork tree` and the UI say it. */
+const slotWaitLine = (holders) => holders.length === 0 ? "waiting for a check slot" : `waiting for a check slot, held by ${holders.join(", ")}`;
+const none = () => {};
+/** The port for one activation; none for a run that shares nothing. */
+const machinePort = (options, runId, id, clock) => {
+	const { machine } = options;
+	if (machine === void 0) return void 0;
+	const { rules, ledger } = machine;
+	return {
+		priority: rules.priority,
+		slot: async (command, signal) => {
+			if (ledger === void 0 || !isHeavy(rules.heavy, command)) return none;
+			let waited = false;
+			const release = await clock.waitFor(id, () => ledger.take({
+				run: runId,
+				node: id,
+				pid: process.pid
+			}, {
+				signal,
+				onWait: (holders) => {
+					waited = true;
+					options.onEvent({
+						type: "slot.waiting",
+						id,
+						holders: holders.map((held) => `${held.run}/${held.node}`)
+					});
+				}
+			}));
+			if (release === null) return none;
+			if (waited) options.onEvent({
+				type: "slot.taken",
+				id
+			});
+			return release;
+		}
+	};
+};
+/**
+* A step's clock that also stands still while its command waits for a slot, and
+* the machine port that tells it so; for a step's own timeout.
+*/
+const slotClock = (base, machine) => {
+	let waiting = 0;
+	const listeners = /* @__PURE__ */ new Set();
+	const tell = () => {
+		for (const listener of listeners) listener();
+	};
+	return {
+		clock: {
+			held: () => waiting > 0 || base?.held() === true,
+			watch: (listener) => {
+				listeners.add(listener);
+				const unwatch = base?.watch(listener);
+				return () => {
+					listeners.delete(listener);
+					unwatch?.();
+				};
+			}
+		},
+		machine: machine === void 0 ? void 0 : {
+			...machine,
+			slot: async (command, signal) => {
+				waiting += 1;
+				tell();
+				try {
+					return await machine.slot(command, signal);
+				} finally {
+					waiting -= 1;
+					tell();
+				}
+			}
+		}
+	};
+};
 // ../core/src/project/calls.ts
 /**
 * @file `ork validate`'s check of `workflow.call` nodes against what they call
@@ -7055,6 +7716,66 @@ const createLoops = (options) => {
 		overList
 	};
 };
+// ../core/src/run/ended.ts
+/**
+* @file A node's result as it ended (specs/runtime/session-ends.md): one place
+*   that sets `end`, makes a failure's `error` its message and marks a
+*   transient kind, and that the engine's modules build ends through.
+*/
+/**
+* The result as it ended: a failure's `error` is the end's message (what the
+* run summary lists), and a transient kind marks it `transient`.
+*/
+const endedWith = (result, end) => ({
+	...result,
+	end,
+	...result.ok ? {} : { error: end.message },
+	...END_KINDS[end.kind].transient ? { transient: true } : {}
+});
+/** The reason a run's signal is aborted with when `timeout` passed. */
+const runTimedOut = (timeout) => timeout === void 0 ? { kind: "timed_out" } : {
+	kind: "timed_out",
+	timeout
+};
+const isTimedOut = (reason) => typeof reason === "object" && reason !== null && "kind" in reason && reason.kind === "timed_out";
+/**
+* The end of a node its run's signal stopped: `timed_out` when the run's
+* timeout aborted it, `interrupted` otherwise.
+*/
+const stoppedEnd = (signal, detail) => {
+	const reason = signal.reason;
+	if (!isTimedOut(reason)) return endFor("interrupted", {}, detail);
+	const facts = reason.timeout === void 0 ? {} : { timeout: reason.timeout };
+	return endFor("timed_out", facts, detail);
+};
+/** A failure that ended as `end`, its message the output's summary. */
+const failedWith = (end, output) => endedWith({
+	ok: false,
+	output: output ?? {
+		status: "fail",
+		summary: end.message
+	}
+}, end);
+/**
+* The result with its end's detail scrubbed with the feedback redactor (the
+* run's `roots` and the home folder), as a session's is
+* (specs/runtime/session-ends.md), whichever node type set it.
+*/
+const scrubbedEnd = (result, roots) => {
+	const { end } = result;
+	if (end?.detail === void 0) return result;
+	const detail = redact(end.detail, {
+		roots,
+		home: homedir()
+	});
+	return {
+		...result,
+		end: {
+			...end,
+			detail
+		}
+	};
+};
 // ../core/src/run/declared.ts
 /**
 * @file Holding a node to what it declares of its output (RFC-010): a missing
@@ -7127,903 +7848,923 @@ const declaredProblem = (declared, value) => {
 * still masks to the record is the file's, with its real values.
 */
 const unmasked = (forEach, recorded) => "items" in forEach && JSON.stringify(forEach.items, maskReplacer) === JSON.stringify(recorded) ? [...forEach.items] : recorded;
-// ../core/src/run/contacts.ts
-const SESSION_TYPES$5 = /* @__PURE__ */ new Set(["claude.leader", "claude.worker"]);
-const isSession$1 = (node) => SESSION_TYPES$5.has(node?.type ?? "");
-const isTool = (node) => node?.type.startsWith("tool.") ?? false;
-const channelPeersOf = (id, channels) => channels.flatMap(([a, b]) => {
-	if (a === id) return [b];
-	return b === id ? [a] : [];
-});
-/** Every declared node, with its owner, as a run records them. */
-const declaredNodes = (graph) => [...graph.nodes.values()].map(({ id, node }) => node.parent === void 0 ? {
-	id,
-	type: node.type
-} : {
-	id,
-	type: node.type,
-	parent: node.parent
-});
-/** Whom a session may write to, by how it knows them. */
-const contactsOf = (id, nodes, channels) => {
-	const byId = new Map(nodes.map((node) => [node.id, node]));
+// ../core/src/run/slots.ts
+/**
+* @file Session slots: at most `limits.concurrency` Claude sessions run at
+*   once. Queued activations take a free slot when the scheduler pumps;
+*   delegated children and leaders returning from `delegate` wait for one and
+*   are served first, so a leader waiting on its children never holds a slot
+*   they need.
+*/
+/** Only a Claude session takes a slot; tools and gates are not limited. */
+const needsSlot = (node) => isClaudeNode(node);
+/** A call spends through its run, so it needs budget as a session does. */
+const spendsBudget = (node) => needsSlot(node) || node.type === "workflow.call";
+const createSlots = (limit, onFree) => {
+	let used = 0;
+	const waiting = [];
 	return {
-		owner: byId.get(id)?.parent,
-		children: nodes.filter((node) => node.parent === id && isSession$1(node)).map((node) => node.id),
-		channels: channelPeersOf(id, channels).filter((peer) => !isTool(byId.get(peer)))
+		limit,
+		tryTake: () => {
+			if (used >= limit || waiting.length > 0) return false;
+			used += 1;
+			return true;
+		},
+		take: () => {
+			if (used < limit && waiting.length === 0) {
+				used += 1;
+				return Promise.resolve();
+			}
+			const { promise, resolve } = Promise.withResolvers();
+			waiting.push(resolve);
+			return promise;
+		},
+		release: () => {
+			const next = waiting.shift();
+			if (next === void 0) {
+				used -= 1;
+				onFree();
+			} else next();
+		}
 	};
 };
-/** Whom a program in the tool node `id` may write to. */
-const scriptContactsOf = (id, nodes, channels) => {
-	const byId = new Map(nodes.map((node) => [node.id, node]));
-	const owner = byId.get(id)?.parent;
-	return [.../* @__PURE__ */ new Set([...owner !== void 0 && isSession$1(byId.get(owner)) ? [owner] : [], ...channelPeersOf(id, channels).filter((peer) => isSession$1(byId.get(peer)))])];
+// ../core/src/run/fan-out.ts
+/** The node's `forEach`, whatever its type; `undefined` when it has none. */
+const forEachOf = (node) => node !== void 0 && "forEach" in node ? node.forEach : void 0;
+/** The list a node runs over, or why there isn't one. */
+const listOf = (forEach, scope) => {
+	if ("items" in forEach) return {
+		ok: true,
+		list: forEach.items
+	};
+	const read = templateValue(forEach.from, scope);
+	if (!read.ok) return read;
+	const { value } = read;
+	if (Array.isArray(value)) return {
+		ok: true,
+		list: value
+	};
+	const name = String(templatePath(forEach.from)?.at(-1) ?? forEach.from);
+	return {
+		ok: false,
+		error: declaredProblem({ [name]: { list: {} } }, { [name]: value }) ?? `${name} is not a list`
+	};
 };
-/** Whether a program in a tool node may write to the session `id`. */
-const hearsFromScripts = (id, nodes, channels) => nodes.some((node) => isTool(node) && scriptContactsOf(node.id, nodes, channels).includes(id));
-// ../core/src/usage/spend.ts
-/** What a report would add to the session's earlier ones, counting nothing. */
-const unreported = (reported, key, total) => {
-	if (total <= 0) return 0;
-	const before = reported.get(key) ?? 0;
-	return total < before ? total : total - before;
+/** The output a `from` list comes from, whose freshness resume asks about. */
+const sourceOf = (forEach, scope) => {
+	if (!("from" in forEach)) return void 0;
+	const [root, id] = templatePath(forEach.from) ?? [];
+	return root === "nodes" ? scope.nodes[String(id)]?.output : void 0;
 };
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /**
-* What a report adds to the session's earlier ones, keeping the total in
-* `reported`. A zero says nothing, so it is ignored; a lower total is a session
-* that started counting again, so all of it is new.
+* What `results` keeps of an item: its declared fields (a program's are under
+* `json`), its summary, Ork's own branch and worktree, and how a program
+* failed. The full output stays in the item's own `node.finished`.
 */
-const ownSpend = (reported, key, total) => {
-	const own = unreported(reported, key, total);
-	if (total > 0) reported.set(key, total);
-	return own;
+const entryOf = (declared, { ok, output, error }) => {
+	const json = isRecord$1(output["json"]) ? output["json"] : {};
+	const fields = Object.keys(declared ?? {}).map((field) => [field, Object.hasOwn(json, field) ? json[field] : output[field]]);
+	const own = [
+		"summary",
+		"branch",
+		"worktree",
+		"merge"
+	].map((field) => [field, output[field]]);
+	const failed = !ok && typeof output["exitCode"] === "number" ? [["exitCode", output["exitCode"]], ["error", error]] : [];
+	return Object.fromEntries([
+		...fields,
+		...own,
+		...failed
+	].filter(([, value]) => value !== void 0));
+};
+/** Whether an item passed but its work could not reach its owner. */
+const mergeFailed = ({ output }) => isRecord$1(output["merge"]) && output["merge"]["ok"] === false;
+const statusOf$2 = (result) => {
+	if (mergeFailed(result)) return "fail";
+	const { ok, output } = result;
+	const status = output["status"];
+	if (typeof status === "string") return status;
+	return ok ? "pass" : "fail";
+};
+/** Why a fan-out did not succeed, naming the first item that failed. */
+const whyNot = (count, failures, skipped) => {
+	const parts = [`${String(failures.length)} of ${String(count)} items failed`];
+	const [first] = failures;
+	if (first !== void 0) parts[0] = `${parts[0] ?? ""}; first, ${first}`;
+	if (skipped > 0) parts.push(`${String(skipped)} not started`);
+	return parts.join("; ");
 };
 /**
-* What a run's events say it spent, for `ork resume`. The total is what its
-* nodes recorded. A session's report counts once its node finished, or when
-* `ork chat` made it outside any node: a session cut off before its node
-* finished has recorded nothing, so its next total counts the part that was cut
-* off. A leader's fork is never resumed, so its report counts when it comes,
-* whether or not its leader finished.
+* Waits until the item may start: not while it is held, and without keeping a
+* session slot through a pause, which would stop other nodes.
 */
-const earlierSpend = (events) => {
-	const reported = /* @__PURE__ */ new Map();
-	const open = /* @__PURE__ */ new Map();
-	const forks = /* @__PURE__ */ new Map();
-	let total = 0;
-	for (const event of events) if (event.type === "node.started") open.set(event.id, null);
-	else if (event.type === "node.finished") {
-		total += event.usage?.costUsd ?? 0;
-		const last = open.get(event.id);
-		if (last !== null && last !== void 0) ownSpend(reported, last.key, last.cost);
-		open.delete(event.id);
-	} else if (event.type === "node.event" && event.event.type === "session.finished") {
-		const { sessionId, usage } = event.event.outcome;
-		const key = `${event.id}/${sessionId}`;
-		if (event.event.fork === true) {
-			const own = ownSpend(reported, key, usage.costUsd);
-			total += own;
-			forks.set(event.id, (forks.get(event.id) ?? 0) + own);
-		} else if (open.has(event.id)) open.set(event.id, {
-			key,
-			cost: usage.costUsd
-		});
-		else ownSpend(reported, key, usage.costUsd);
+const awaitTurn = async (hold, slots, signal) => {
+	for (;;) {
+		await hold.wait("start", signal);
+		if (slots === null) return;
+		await slots.take();
+		if (!hold.held() || signal.aborted) return;
+		slots.release();
 	}
-	return {
-		total,
-		reported,
-		forks
-	};
 };
-// ../core/src/run/reserves.ts
-const createReserves = () => {
-	const held = /* @__PURE__ */ new Map();
-	const waiters = /* @__PURE__ */ new Set();
-	const wake = () => {
-		const woken = [...waiters];
-		waiters.clear();
-		for (const resolve of woken) resolve();
-	};
-	return {
-		/** All that is set aside now. */
-		total: () => [...held.values()].reduce((sum, reserve) => sum + reserve.usd, 0),
-		/**
-		* `id` sets aside `usd` (nothing, or 0, lets it go). `waitable` is false
-		* for a leader, whose children must never wait on it.
-		*/
-		reserve: (id, usd, waitable) => {
-			const before = held.get(id)?.usd ?? 0;
-			if (usd === void 0 || usd <= 0) held.delete(id);
-			else held.set(id, {
-				usd,
-				waitable
+const createFanOut = (deps) => {
+	const { holds, slots, stops, nodeOf, perform, options } = deps;
+	return async (activation, forEach, round) => {
+		const { id, input } = activation;
+		const scope = deps.scope();
+		const recorded = options.replay?.listed?.(id, round, sourceOf(forEach, scope)) ?? null;
+		const listed = recorded === null ? listOf(forEach, scope) : {
+			ok: true,
+			list: unmasked(forEach, recorded)
+		};
+		if (!listed.ok) return failedWith(endFor("invalid_node", { reason: listed.error }));
+		let { list } = listed;
+		const recordList = () => {
+			options.onEvent({
+				type: "each.listed",
+				node: id,
+				round,
+				count: list.length,
+				list,
+				...recorded === null && options.replay !== void 0 ? { anew: true } : {}
 			});
-			if ((usd ?? 0) < before) wake();
-		},
-		/** The node ended: whatever it still held is let go. */
-		drop: (id) => {
-			if (held.delete(id)) wake();
-		},
-		/**
-		* Waits until a reserve shrinks. `false` at once when no other node holds
-		* one worth waiting on, or when `signal` aborts.
-		*/
-		freed: (id, signal) => {
-			if (![...held].some(([other, reserve]) => other !== id && reserve.waitable) || signal.aborted) return Promise.resolve(false);
-			return new Promise((resolve) => {
-				const done = (freed) => () => {
-					waiters.delete(onFree);
-					signal.removeEventListener("abort", onAbort);
-					resolve(freed);
-				};
-				const onFree = done(true);
-				const onAbort = done(false);
-				waiters.add(onFree);
-				signal.addEventListener("abort", onAbort, { once: true });
+		};
+		recordList();
+		const signal = stops.signalFor(id);
+		if ("maxItems" in forEach && list.length > forEach.maxItems) {
+			options.onEvent({
+				type: "each.exceeded",
+				node: id,
+				round,
+				count: list.length,
+				maxItems: forEach.maxItems
 			});
+			const chosen = await deps.loops.overList(id, list, forEach.maxItems, round, signal);
+			if (chosen === null) {
+				const reason = `the list of ${id} has ${String(list.length)} items, over maxItems ${String(forEach.maxItems)}`;
+				return stops.ended(id, {
+					...failedWith(endFor("invalid_node", { reason }), {
+						status: "fail",
+						summary: reason
+					}),
+					limited: reason,
+					stopsAs: "failed"
+				});
+			}
+			const narrowed = chosen.length !== list.length;
+			list = chosen;
+			if (narrowed) recordList();
 		}
+		const node = nodeOf(activation);
+		const session = node !== void 0 && needsSlot(node);
+		const spends = node !== void 0 && spendsBudget(node);
+		const declared = node === void 0 ? void 0 : declaredOutputOf(node);
+		const results = list.map(() => ({}));
+		const statuses = list.map(() => "skipped");
+		const failures = [];
+		/** How the first item that failed ended: the fanned node's own end. */
+		let firstEnd;
+		const mayStart = () => !signal.aborted && !deps.isStopped() && (forEach.onFailure !== "stop" || failures.length === 0);
+		const runItem = async (index) => {
+			const itemId = `${id}.${String(index)}`;
+			const hold = holds.forNode(itemId, id);
+			await awaitTurn(hold, session ? slots : null, signal);
+			try {
+				if (!mayStart() || spends && deps.budgetSpent()) return;
+				const result = await perform({
+					id: itemId,
+					input,
+					template: id,
+					item: {
+						of: id,
+						index,
+						value: list[index]
+					},
+					round
+				});
+				results[index] = entryOf(declared, result);
+				statuses[index] = statusOf$2(result);
+				if (!result.ok) {
+					firstEnd ??= endOf(result);
+					failures.push(`${itemId}: ${result.error ?? "failed"}`);
+				} else if (mergeFailed(result)) failures.push(`${itemId}: its work could not be merged`);
+			} finally {
+				if (session) slots.release();
+			}
+		};
+		let next = 0;
+		const worker = async () => {
+			while (next < list.length && mayStart()) {
+				const index = next;
+				next += 1;
+				await runItem(index);
+			}
+		};
+		const lanes = Math.min(forEach.maxParallel ?? slots.limit, list.length);
+		await Promise.all(Array.from({ length: lanes }, () => worker()));
+		const skipped = statuses.filter((status) => status === "skipped").length;
+		const ok = failures.length === 0 && skipped === 0;
+		const gathered = {
+			ok,
+			output: {
+				items: list,
+				results,
+				statuses,
+				count: list.length
+			},
+			...ok ? {} : { error: whyNot(list.length, failures, skipped) },
+			...ok || firstEnd === void 0 ? {} : { end: firstEnd },
+			...!ok && deps.isStopped() ? { limited: deps.reasons[0] ?? "the run stopped" } : {}
+		};
+		return {
+			...stops.ended(id, gathered),
+			output: gathered.output
+		};
 	};
 };
-// ../core/src/run/spending.ts
-/**
-* A result with only what this activation spent (ADR-046): a session's report
-* holds its total so far, while its tokens are this process's own. `reported`
-* holds each session's total.
-*/
-const withOwnSpend = (id, result, reported) => {
-	const { sessionId, usage } = result;
-	if (sessionId === void 0 || usage === void 0) return result;
-	const own = {
-		...usage,
-		costUsd: ownSpend(reported, `${id}/${sessionId}`, usage.costUsd)
-	};
-	return {
-		...result,
-		usage: own,
-		output: "usage" in result.output ? {
-			...result.output,
-			usage: own
-		} : result.output
-	};
-};
-/** A run's spending so far; a resumed run starts from what it had spent. */
-const createSpend = (budgetUsd, earlier, limits) => {
-	const reported = new Map(earlier?.reported);
-	let spent = earlier?.total ?? 0;
-	/** What running sessions last reported, not yet in `spent`, by `node/session`. */
-	const inFlight = /* @__PURE__ */ new Map();
-	const committed = () => spent + [...inFlight.values()].reduce((sum, cost) => sum + cost, 0);
-	/** Caps running sessions were given (ADR-077): out of what is offered. */
-	const reserves = createReserves();
-	const budgetLeft = () => budgetUsd === void 0 ? void 0 : budgetUsd - committed() - reserves.total();
-	return {
-		total: () => spent,
-		/** A node sets aside its session's cap; nothing or 0 lets it go. */
-		reserve: reserves.reserve,
-		/** Waits until another node's reserve frees; `false` when none can. */
-		freed: reserves.freed,
-		/** What a session has spent in this activation, from its total so far. */
-		ownOf: (id, sessionId, total) => unreported(reported, `${id}/${sessionId}`, total),
-		/** A running session said what it has spent so far. */
-		report: (id, sessionId, total) => {
-			const key = `${id}/${sessionId}`;
-			inFlight.set(key, unreported(reported, key, total));
-		},
-		/** The node ended: `count` has what its sessions last reported. */
-		settled: (id) => {
-			for (const key of inFlight.keys()) if (key.startsWith(`${id}/`)) inFlight.delete(key);
-			reserves.drop(id);
-		},
-		/** What a session may spend: the least of the budget and any quota. */
-		left: () => {
-			const known = [budgetLeft(), limits?.().leftUsd].filter((left) => left !== void 0);
-			return known.length === 0 ? void 0 : Math.min(...known);
-		},
-		budgetLeft,
-		/** What the limits across runs allow now. */
-		quota: () => limits?.() ?? {},
-		/**
-		* What stops anything new from starting: a quota first, as a budget can be
-		* raised.
-		*/
-		spentOut: () => {
-			const blocked = limits?.().blocked;
-			if (blocked !== void 0) return {
-				status: "quota_exhausted",
-				reason: blocked
-			};
-			return budgetUsd !== void 0 && committed() >= budgetUsd ? {
-				status: "budget_exhausted",
-				reason: `the run's budget of $${String(budgetUsd)} is spent`
-			} : null;
-		},
-		/**
-		* Counts a result, and gives it back with only its own spend. A replayed
-		* result is as stored, and already in what the run started from.
-		*/
-		count: (id, result, replayed) => {
-			if (replayed) return result;
-			const own = withOwnSpend(id, result, reported);
-			spent += own.usage?.costUsd ?? 0;
-			return own;
+// ../core/src/run/delegation.ts
+/** Node types a leader can hand work to. */
+const DELEGABLE = /* @__PURE__ */ new Set(["claude.leader", "claude.worker"]);
+/** A child a leader delegated to: waits for a slot, runs, reports back. */
+const createRunChild = (hooks) => async (child, brief) => {
+	await hooks.slots.take();
+	try {
+		await hooks.holds.forNode(child.id, child.template).wait("start", hooks.signal);
+		if (hooks.isStopped() || hooks.budgetSpent()) {
+			const why = `not started: ${hooks.reasons[0] ?? "the run stopped"}`;
+			const end = hooks.budgetSpent() ? endFor("budget_limit", {}, why) : stoppedEnd(hooks.signal, why);
+			return failedWith(end, {
+				status: "fail",
+				summary: why
+			});
 		}
-	};
-};
-/** A run's spending, from what the scheduler is given. */
-const spendOf = (budgetUsd, options) => createSpend(budgetUsd, options.replay?.earlier, options.limits);
-// ../core/src/run/gather.ts
-const asList = (value) => Array.isArray(value) ? value : [];
-/** `before` then `now`, leaving out an entry already there. */
-const joined = (before, now) => {
-	const seen = /* @__PURE__ */ new Set();
-	const out = [];
-	for (const entry of [...asList(before), ...asList(now)]) {
-		const key = JSON.stringify(entry);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		out.push(entry);
+		return await hooks.perform({
+			...child,
+			input: void 0,
+			brief
+		});
+	} finally {
+		hooks.slots.release();
 	}
-	return out;
-};
-/**
-* `result` with each gathered field holding every round's entries so far.
-* `previous` is the node's output from its last round, already gathered.
-*/
-const joinRounds = (fields, previous, result) => {
-	if (fields.length === 0 || previous === void 0) return result;
-	const output = { ...result.output };
-	for (const field of fields) output[field] = joined(previous[field], result.output[field]);
-	return {
-		...result,
-		output
-	};
-};
-/** `result` with `node`'s `output.gather` fields joined to its earlier rounds. */
-const gatherRounds = (node, previous, result) => joinRounds(gatheredFieldsOf(node), previous, result);
-/**
-* What `activation`'s rounds reported so far, to gather onto. A spawned
-* instance gathers nothing earlier: its id (`impl-2`) is reused by a different
-* worker in the leader's next round. A delegated child that hasn't run since a
-* resume starts from what it reported before it, since its leader's recorded
-* rounds are handed back whole and never run it again.
-*/
-const previousOf = (activation, current, replay) => {
-	const { brief, template, id } = activation;
-	if (brief !== void 0 && template !== void 0) return void 0;
-	if (current !== void 0 || brief === void 0) return current;
-	return replay?.lastOutput?.(id);
-};
-/** Gathers each activation's result onto what its node reported before. */
-const createGatherer = (outputs, replay, nodeOf) => (activation, result) => gatherRounds(nodeOf(activation), previousOf(activation, outputs[activation.id], replay), result);
-// ../core/src/run/results.ts
-/** Control nodes pass their input through; a join's input is its output. */
-const passThrough = (input) => ({
-	output: input ?? {},
-	ok: true
-});
-const recordRun = (entry, result) => {
-	entry.runs += 1;
-	entry.ok = result.ok;
-	entry.output = result.output;
-	entry.costUsd += result.usage?.costUsd ?? 0;
-	if (result.error === void 0) delete entry.error;
-	else entry.error = result.error;
-};
-const startedEvent = (activation, nodeType, round, agent) => {
-	const event = {
-		type: "node.started",
-		id: activation.id,
-		nodeType,
-		round
-	};
-	if (activation.brief !== void 0) event.owner = activation.brief.from;
-	if (agent !== void 0) event.agent = agent;
-	const { item } = activation;
-	if (item !== void 0) event.item = {
-		of: item.of,
-		index: item.index
-	};
-	return event;
-};
-const finishedEvent = (id, round, result) => {
-	const event = {
-		type: "node.finished",
-		id,
-		round,
-		ok: result.ok,
-		output: result.output
-	};
-	if (result.usage !== void 0) event.usage = result.usage;
-	if (result.error !== void 0) event.error = result.error;
-	return event;
 };
-const failure = (error) => ({
+const rejected = (child, error) => ({
+	child,
+	ok: false,
 	output: {
 		status: "fail",
 		summary: error
 	},
-	ok: false,
 	error
 });
-/** The node's entry in the run summary, created on first use. */
-const summaryOf = (summaries, id) => {
-	const existing = summaries.get(id);
-	if (existing !== void 0) return existing;
-	const created = {
-		id,
-		runs: 0,
-		ok: null,
-		output: null,
-		costUsd: 0
+const reportOf = (child, result) => {
+	const report = {
+		child,
+		ok: result.ok,
+		output: result.output
 	};
-	summaries.set(id, created);
-	return created;
+	if (result.error !== void 0) report.error = result.error;
+	return report;
 };
-/** A run's summary; a resumed run's leaders keep their forks' spend (ADR-063). */
-const createSummaries = (earlier) => {
-	const summaries = /* @__PURE__ */ new Map();
-	const summary = (id) => summaryOf(summaries, id);
-	for (const [id, costUsd] of earlier?.forks ?? []) summary(id).costUsd += costUsd;
-	return {
-		summaries,
-		summary
+const createOwnership = (hooks) => {
+	const { graph, leader } = hooks;
+	const owner = graph.nodes.get(leader);
+	const isFanned = (id) => forEachOf(graph.nodes.get(id)?.node) !== void 0;
+	const children = (owner?.children ?? []).flatMap((id) => {
+		const node = graph.nodes.get(id)?.node;
+		if (node === void 0 || !DELEGABLE.has(node.type) || isFanned(id)) return [];
+		const child = {
+			id,
+			type: node.type
+		};
+		if (node.description !== void 0) child.description = node.description;
+		return [child];
+	});
+	const templates = children.filter((c) => c.type === "claude.worker").map((c) => c.id);
+	const leaderNode = owner?.node;
+	const maxWorkers = leaderNode?.type === "claude.leader" ? leaderNode.maxWorkers ?? 0 : 0;
+	const spawned = [];
+	/** Runs the accepted jobs in parallel; the slot goes to them meanwhile. */
+	const runJobs = async (jobs) => {
+		const accepted = jobs.filter((j) => "brief" in j);
+		const notes = [];
+		if (accepted.length > 0) {
+			const problem = await hooks.checkpoint();
+			if (problem !== null) notes.push(`Your uncommitted work could not be committed (${problem}); the children started from your branch's last commit.`);
+			const released = hooks.releaseClaims().map((r) => `\`${r}\``);
+			if (released.length > 0) notes.push(`Your claims on ${released.join(", ")} were released while your children worked; claim again before you edit.`);
+		}
+		hooks.lend();
+		try {
+			return {
+				reports: await Promise.all(jobs.map(async (job) => {
+					if (!("brief" in job)) return job;
+					const child = { id: job.id };
+					if (job.template !== void 0) child.template = job.template;
+					const result = await hooks.runChild(child, {
+						from: leader,
+						text: job.brief
+					});
+					return reportOf(job.id, result);
+				})),
+				notes
+			};
+		} finally {
+			await hooks.reclaim();
+		}
 	};
-};
-/** The tighter of the workflow's budget and what a caller left it, if any. */
-const runBudget = (graph, settings) => {
-	const limits = [graph.workflow.limits?.budgetUsd, settings?.budgetCap].filter((limit) => limit !== void 0);
-	return limits.length === 0 ? {} : { budgetUsd: Math.min(...limits) };
-};
-/** The `run.started` event: the workflow, its entries, nodes and inputs. */
-const runStartedEvent = (graph, runId, options) => ({
-	type: "run.started",
-	runId,
-	workflow: graph.workflow.name,
-	entries: graph.entries,
-	nodes: declaredNodes(graph),
-	edges: graph.edges.map(({ from, to, when, maxRounds }) => ({
-		from,
-		to,
-		...when === void 0 ? {} : { when },
-		...maxRounds === void 0 ? {} : { maxRounds }
-	})),
-	channels: graph.channels,
-	inputs: options.inputs,
-	...options.settings === void 0 ? {} : { settings: options.settings },
-	...runBudget(graph, options.settings),
-	...options.orkVersion === void 0 ? {} : { ork: options.orkVersion }
-});
-/** The unread mail of nodes that never ran; a node that ran saw its notice. */
-const unreadOf = (nodes, unread) => {
-	const ran = new Set(nodes.filter((node) => node.runs > 0).map((node) => node.id));
-	const left = [...unread ?? []].filter(([node]) => !ran.has(node)).map(([node, messages]) => ({
-		node,
-		messages
-	}));
-	return left.length === 0 ? {} : { unread: left };
-};
-/**
-* The run's result: failed when any reason was given, unless it stopped. A
-* skipped node or a handled failure leaves it `succeeded`, and is counted.
-*/
-const runResult = (run) => ({
-	runId: run.runId,
-	status: run.stopped ?? (run.reasons.length > 0 ? "failed" : "succeeded"),
-	costUsd: run.costUsd,
-	nodes: run.nodes,
-	reasons: run.reasons,
-	worktrees: run.worktrees,
-	...run.outputs === void 0 ? {} : { outputs: run.outputs },
-	skipped: run.nodes.filter((node) => node.runs === 0).length,
-	failuresHandled: run.failuresHandled,
-	...unreadOf(run.nodes, run.unread)
-});
-/** A workflow's `outputs`, rendered as the run ends. */
-const renderOutputs = (outputs, scope) => outputs === void 0 ? void 0 : Object.fromEntries(Object.entries(outputs).map(([name, text]) => {
-	const template = parseTemplate(text);
-	return [name, template.ok ? renderTemplate(template.parts, scope) : text];
-}));
-/** Closes the run's worktrees; a failure is one more reason, not a crash. */
-const closeWorkspace = (workspace, reasons) => (workspace?.close() ?? Promise.resolve([])).catch((error) => {
-	reasons.push(`cleaning up worktrees: ${String(error)}`);
-	return [];
-});
-// ../core/src/run/slots.ts
-/**
-* @file Session slots: at most `limits.concurrency` Claude sessions run at
-*   once. Queued activations take a free slot when the scheduler pumps;
-*   delegated children and leaders returning from `delegate` wait for one and
-*   are served first, so a leader waiting on its children never holds a slot
-*   they need.
-*/
-/** Only a Claude session takes a slot; tools and gates are not limited. */
-const needsSlot = (node) => isClaudeNode(node);
-/** A call spends through its run, so it needs budget as a session does. */
-const spendsBudget = (node) => needsSlot(node) || node.type === "workflow.call";
-const createSlots = (limit, onFree) => {
-	let used = 0;
-	const waiting = [];
-	return {
-		limit,
-		tryTake: () => {
-			if (used >= limit || waiting.length > 0) return false;
-			used += 1;
-			return true;
-		},
-		take: () => {
-			if (used < limit && waiting.length === 0) {
-				used += 1;
-				return Promise.resolve();
+	const delegate = (tasks) => {
+		const seen = /* @__PURE__ */ new Set();
+		const jobs = tasks.map((task) => {
+			if (!children.some((c) => c.id === task.child)) {
+				const names = children.map((c) => c.id).join(", ");
+				return rejected(task.child, `not one of your children (${names === "" ? "you have none" : names})`);
 			}
-			const { promise, resolve } = Promise.withResolvers();
-			waiting.push(resolve);
-			return promise;
-		},
-		release: () => {
-			const next = waiting.shift();
-			if (next === void 0) {
-				used -= 1;
-				onFree();
-			} else next();
-		}
+			if (seen.has(task.child) || hooks.isRunning(task.child)) return rejected(task.child, templates.includes(task.child) && maxWorkers > 0 ? "already running; use spawn_worker for another instance" : "already running");
+			seen.add(task.child);
+			return {
+				id: task.child,
+				brief: task.brief
+			};
+		});
+		return runJobs(jobs);
 	};
-};
-// ../core/src/run/fan-out.ts
-/** The node's `forEach`, whatever its type; `undefined` when it has none. */
-const forEachOf = (node) => node !== void 0 && "forEach" in node ? node.forEach : void 0;
-/** The list a node runs over, or why there isn't one. */
-const listOf = (forEach, scope) => {
-	if ("items" in forEach) return {
-		ok: true,
-		list: forEach.items
+	const nextInstance = (template) => {
+		for (let n = 2;; n += 1) {
+			const id = `${template}-${String(n)}`;
+			if (!graph.nodes.has(id) && !spawned.includes(id)) return id;
+		}
 	};
-	const read = templateValue(forEach.from, scope);
-	if (!read.ok) return read;
-	const { value } = read;
-	if (Array.isArray(value)) return {
-		ok: true,
-		list: value
+	const spawn = (tasks) => {
+		const jobs = tasks.map((task) => {
+			if (!templates.includes(task.template)) {
+				const names = templates.join(", ");
+				return rejected(task.template, `not one of your child workers (${names === "" ? "you have none" : names})`);
+			}
+			if (spawned.length >= maxWorkers) return rejected(task.template, `no workers left to spawn (maxWorkers: ${String(maxWorkers)})`);
+			const id = nextInstance(task.template);
+			spawned.push(id);
+			return {
+				id,
+				template: task.template,
+				brief: task.brief
+			};
+		});
+		return runJobs(jobs);
 	};
-	const name = String(templatePath(forEach.from)?.at(-1) ?? forEach.from);
 	return {
-		ok: false,
-		error: declaredProblem({ [name]: { list: {} } }, { [name]: value }) ?? `${name} is not a list`
+		children,
+		fanned: (owner?.children ?? []).filter((id) => isFanned(id)),
+		templates,
+		workersLeft: () => Math.max(0, maxWorkers - spawned.length),
+		delegate,
+		spawn
 	};
 };
-/** The output a `from` list comes from, whose freshness resume asks about. */
-const sourceOf = (forEach, scope) => {
-	if (!("from" in forEach)) return void 0;
-	const [root, id] = templatePath(forEach.from) ?? [];
-	return root === "nodes" ? scope.nodes[String(id)]?.output : void 0;
-};
-const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+// ../core/src/run/scope.ts
 /**
-* What `results` keeps of an item: its declared fields (a program's are under
-* `json`), its summary, Ork's own branch and worktree, and how a program
-* failed. The full output stays in the item's own `node.finished`.
+* @file A run's id and folder, and the scope templates and `when:` conditions
+*   read during it.
 */
-const entryOf = (declared, { ok, output, error }) => {
-	const json = isRecord$1(output["json"]) ? output["json"] : {};
-	const fields = Object.keys(declared ?? {}).map((field) => [field, Object.hasOwn(json, field) ? json[field] : output[field]]);
-	const own = [
-		"summary",
-		"branch",
-		"worktree",
-		"merge"
-	].map((field) => [field, output[field]]);
-	const failed = !ok && typeof output["exitCode"] === "number" ? [["exitCode", output["exitCode"]], ["error", error]] : [];
-	return Object.fromEntries([
-		...fields,
-		...own,
-		...failed
-	].filter(([, value]) => value !== void 0));
-};
-/** Whether an item passed but its work could not reach its owner. */
-const mergeFailed = ({ output }) => isRecord$1(output["merge"]) && output["merge"]["ok"] === false;
-const statusOf$2 = (result) => {
-	if (mergeFailed(result)) return "fail";
-	const { ok, output } = result;
-	const status = output["status"];
-	if (typeof status === "string") return status;
-	return ok ? "pass" : "fail";
-};
-/** Why a fan-out did not succeed, naming the first item that failed. */
-const whyNot = (count, failures, skipped) => {
-	const parts = [`${String(failures.length)} of ${String(count)} items failed`];
-	const [first] = failures;
-	if (first !== void 0) parts[0] = `${parts[0] ?? ""}; first, ${first}`;
-	if (skipped > 0) parts.push(`${String(skipped)} not started`);
-	return parts.join("; ");
+/** The run's id (given, or a new one) and its `.ork/runs/<run>` folder. */
+const runPlace = (options) => {
+	const runId = options.runId ?? randomUUID().slice(0, 8);
+	return {
+		runId,
+		runDir: options.runDir ?? path.join(options.cwd, ".ork", "runs", runId)
+	};
 };
 /**
-* Waits until the item may start: not while it is held, and without keeping a
-* session slot through a pause, which would stop other nodes.
+* The folders every node of a run reads from: the workflow's, the project's,
+* Ork's.
 */
-const awaitTurn = async (hold, slots, signal) => {
-	for (;;) {
-		await hold.wait("start", signal);
-		if (slots === null) return;
-		await slots.take();
-		if (!hold.held() || signal.aborted) return;
-		slots.release();
+const foldersOf = (options) => ({
+	workflowDir: options.workflowDir ?? options.cwd,
+	projectRoot: options.projectRoot ?? options.cwd,
+	...options.orkDir === void 0 ? {} : { orkDir: options.orkDir }
+});
+/** What templates and `when:` read during a run. */
+const runScope = (inputs, outputs, runId, item) => {
+	const scope = {
+		inputs,
+		nodes: Object.fromEntries(Object.entries(outputs).map(([id, output]) => [id, { output }]))
+	};
+	if (runId !== void 0) scope.run = { id: runId };
+	if (item !== void 0) {
+		scope.item = item.value;
+		scope.index = item.index;
 	}
+	return scope;
 };
-const createFanOut = (deps) => {
-	const { holds, slots, stops, nodeOf, perform, options } = deps;
-	return async (activation, forEach, round) => {
-		const { id, input } = activation;
-		const scope = deps.scope();
-		const recorded = options.replay?.listed?.(id, round, sourceOf(forEach, scope)) ?? null;
-		const listed = recorded === null ? listOf(forEach, scope) : {
-			ok: true,
-			list: unmasked(forEach, recorded)
-		};
-		if (!listed.ok) return failure(listed.error);
-		let { list } = listed;
-		const recordList = () => {
-			options.onEvent({
-				type: "each.listed",
-				node: id,
-				round,
-				count: list.length,
-				list,
-				...recorded === null && options.replay !== void 0 ? { anew: true } : {}
-			});
-		};
-		recordList();
-		const signal = stops.signalFor(id);
-		if ("maxItems" in forEach && list.length > forEach.maxItems) {
-			options.onEvent({
-				type: "each.exceeded",
-				node: id,
-				round,
-				count: list.length,
-				maxItems: forEach.maxItems
-			});
-			const chosen = await deps.loops.overList(id, list, forEach.maxItems, round, signal);
-			if (chosen === null) {
-				const reason = `the list of ${id} has ${String(list.length)} items, over maxItems ${String(forEach.maxItems)}`;
-				return stops.ended(id, {
-					...failure(reason),
-					limited: reason,
-					stopsAs: "failed"
-				});
-			}
-			const narrowed = chosen.length !== list.length;
-			list = chosen;
-			if (narrowed) recordList();
-		}
-		const node = nodeOf(activation);
-		const session = node !== void 0 && needsSlot(node);
-		const spends = node !== void 0 && spendsBudget(node);
-		const declared = node === void 0 ? void 0 : declaredOutputOf(node);
-		const results = list.map(() => ({}));
-		const statuses = list.map(() => "skipped");
-		const failures = [];
-		const mayStart = () => !signal.aborted && !deps.isStopped() && (forEach.onFailure !== "stop" || failures.length === 0);
-		const runItem = async (index) => {
-			const itemId = `${id}.${String(index)}`;
-			const hold = holds.forNode(itemId, id);
-			await awaitTurn(hold, session ? slots : null, signal);
-			try {
-				if (!mayStart() || spends && deps.budgetSpent()) return;
-				const result = await perform({
-					id: itemId,
-					input,
-					template: id,
-					item: {
-						of: id,
-						index,
-						value: list[index]
-					},
-					round
-				});
-				results[index] = entryOf(declared, result);
-				statuses[index] = statusOf$2(result);
-				if (!result.ok) failures.push(`${itemId}: ${result.error ?? "failed"}`);
-				else if (mergeFailed(result)) failures.push(`${itemId}: its work could not be merged`);
-			} finally {
-				if (session) slots.release();
-			}
-		};
-		let next = 0;
-		const worker = async () => {
-			while (next < list.length && mayStart()) {
-				const index = next;
-				next += 1;
-				await runItem(index);
+// ../core/src/run/context.ts
+/**
+* @file One activation's execute context: what the scheduler hands a node's
+*   executor. Its inputs and the outputs so far, where it works, the budget
+*   left, the human, its hold and its own stop signal (ADR-041), its ports on
+*   the bus, the session it resumes, its share of the machine, and, for a
+*   leader, its ownership of its children.
+*/
+const nodeContext = (deps, activation, cwd, round, clock) => {
+	const { options, runId } = deps;
+	const { graph } = options;
+	const { id, template } = activation;
+	const context = {
+		runId,
+		id,
+		workflow: graph.workflow,
+		inputs: options.inputs,
+		outputs: deps.outputs,
+		input: activation.input,
+		round,
+		cwd,
+		runDir: deps.runDir,
+		...foldersOf(options),
+		budgetLeftUsd: deps.spend.left(),
+		budgetLeftNow: deps.spend.budgetLeft,
+		reserveBudget: (usd) => {
+			deps.spend.reserve(id, usd, deps.nodeOf(activation)?.type !== "claude.leader");
+		},
+		budgetFreed: (signal) => deps.spend.freed(id, signal),
+		quota: deps.spend.quota,
+		ownSpend: (sessionId, total) => deps.spend.ownOf(id, sessionId, total),
+		human: deps.human,
+		hold: deps.holds.forNode(id, template),
+		...deps.ports.forNode(id, template, cwd),
+		...options.calls === void 0 ? {} : { calls: options.calls },
+		emit: (event) => {
+			deps.ports.owners.seen(id, event, cwd);
+			if (event.type === "session.finished" && event.fork !== true) {
+				const { sessionId, usage } = event.outcome;
+				deps.spend.report(id, sessionId, usage.costUsd);
 			}
-		};
-		const lanes = Math.min(forEach.maxParallel ?? slots.limit, list.length);
-		await Promise.all(Array.from({ length: lanes }, () => worker()));
-		const skipped = statuses.filter((status) => status === "skipped").length;
-		const ok = failures.length === 0 && skipped === 0;
-		const gathered = {
-			ok,
-			output: {
-				items: list,
-				results,
-				statuses,
-				count: list.length
-			},
-			...ok ? {} : { error: whyNot(list.length, failures, skipped) },
-			...!ok && deps.isStopped() ? { limited: deps.reasons[0] ?? "the run stopped" } : {}
-		};
-		return {
-			...stops.ended(id, gathered),
-			output: gathered.output
-		};
+			options.onEvent({
+				type: "node.event",
+				id,
+				event
+			});
+		},
+		signal: deps.stops.signalFor(id, template)
 	};
+	const owner = ownerPort(deps, id, template);
+	if (owner !== void 0) context.owner = owner;
+	if (template !== void 0) context.template = template;
+	const machine = clock === void 0 ? void 0 : machinePort(options, runId, id, clock);
+	if (machine !== void 0) context.machine = machine;
+	if (activation.brief !== void 0) context.brief = activation.brief;
+	if (activation.item !== void 0) context.item = activation.item;
+	const resume = options.replay?.cutOff?.(activation) ?? resumeOf(deps.nodeOf(activation), deps.sessionIds.get(id) ?? options.replay?.previousSession?.(activation));
+	if (resume !== void 0) context.resume = resume;
+	if (deps.nodeOf(activation)?.type === "claude.leader") context.ownership = createOwnership({
+		graph,
+		leader: id,
+		runChild: deps.runChild,
+		isRunning: (other) => deps.running.has(other),
+		checkpoint: () => options.workspace?.checkpoint(id) ?? Promise.resolve(null),
+		releaseClaims: () => {
+			const held = context.claims?.held() ?? [];
+			for (const resource of held) context.claims?.release(resource);
+			return held;
+		},
+		lend: deps.slots.release,
+		reclaim: deps.slots.take
+	});
+	return context;
 };
-// ../core/src/run/delegation.ts
-/** Node types a leader can hand work to. */
-const DELEGABLE = /* @__PURE__ */ new Set(["claude.leader", "claude.worker"]);
-/** A child a leader delegated to: waits for a slot, runs, reports back. */
-const createRunChild = (hooks) => async (child, brief) => {
-	await hooks.slots.take();
-	try {
-		await hooks.holds.forNode(child.id, child.template).wait("start", hooks.signal);
-		if (hooks.isStopped() || hooks.budgetSpent()) return failure(`not started: ${hooks.reasons[0] ?? "the run stopped"}`);
-		return await hooks.perform({
-			...child,
-			input: void 0,
-			brief
+/** Where `id`'s questions go first, if its leader takes them (ADR-063). */
+const ownerPort = (deps, id, template) => deps.ports.owners.portFor(id, template, {
+	budgetLeftUsd: deps.spend.left,
+	charge: (owner, sessionId, usage) => {
+		const own = deps.spend.count(owner, {
+			ok: true,
+			output: {},
+			sessionId,
+			usage
+		}, false);
+		deps.summary(owner).costUsd += own.usage?.costUsd ?? 0;
+	},
+	emit: (owner, event) => {
+		deps.options.onEvent({
+			type: "node.event",
+			id: owner,
+			event
 		});
-	} finally {
-		hooks.slots.release();
 	}
+});
+/**
+* The session a node that runs again continues, when it resumes (ADR-033): by
+* `session: resume`, the default for a leader; a worker starts fresh unless it
+* says `resume`.
+*/
+const resumeOf = (node, sessionId) => {
+	if (node === void 0 || !isClaudeNode(node)) return void 0;
+	if (node.type === "claude.subagent") return void 0;
+	return (node.session ?? (node.type === "claude.leader" ? "resume" : "fresh")) === "resume" ? sessionId : void 0;
 };
-const rejected = (child, error) => ({
-	child,
-	ok: false,
-	output: {
-		status: "fail",
-		summary: error
-	},
-	error
+// ../core/src/run/contacts.ts
+const SESSION_TYPES$5 = /* @__PURE__ */ new Set(["claude.leader", "claude.worker"]);
+const isSession$1 = (node) => SESSION_TYPES$5.has(node?.type ?? "");
+const isTool = (node) => node?.type.startsWith("tool.") ?? false;
+const channelPeersOf = (id, channels) => channels.flatMap(([a, b]) => {
+	if (a === id) return [b];
+	return b === id ? [a] : [];
 });
-const reportOf = (child, result) => {
-	const report = {
-		child,
-		ok: result.ok,
-		output: result.output
+/** Every declared node, with its owner, as a run records them. */
+const declaredNodes = (graph) => [...graph.nodes.values()].map(({ id, node }) => node.parent === void 0 ? {
+	id,
+	type: node.type
+} : {
+	id,
+	type: node.type,
+	parent: node.parent
+});
+/** Whom a session may write to, by how it knows them. */
+const contactsOf = (id, nodes, channels) => {
+	const byId = new Map(nodes.map((node) => [node.id, node]));
+	return {
+		owner: byId.get(id)?.parent,
+		children: nodes.filter((node) => node.parent === id && isSession$1(node)).map((node) => node.id),
+		channels: channelPeersOf(id, channels).filter((peer) => !isTool(byId.get(peer)))
 	};
-	if (result.error !== void 0) report.error = result.error;
-	return report;
 };
-const createOwnership = (hooks) => {
-	const { graph, leader } = hooks;
-	const owner = graph.nodes.get(leader);
-	const isFanned = (id) => forEachOf(graph.nodes.get(id)?.node) !== void 0;
-	const children = (owner?.children ?? []).flatMap((id) => {
-		const node = graph.nodes.get(id)?.node;
-		if (node === void 0 || !DELEGABLE.has(node.type) || isFanned(id)) return [];
-		const child = {
-			id,
-			type: node.type
-		};
-		if (node.description !== void 0) child.description = node.description;
-		return [child];
-	});
-	const templates = children.filter((c) => c.type === "claude.worker").map((c) => c.id);
-	const leaderNode = owner?.node;
-	const maxWorkers = leaderNode?.type === "claude.leader" ? leaderNode.maxWorkers ?? 0 : 0;
-	const spawned = [];
-	/** Runs the accepted jobs in parallel; the slot goes to them meanwhile. */
-	const runJobs = async (jobs) => {
-		const accepted = jobs.filter((j) => "brief" in j);
-		const notes = [];
-		if (accepted.length > 0) {
-			const problem = await hooks.checkpoint();
-			if (problem !== null) notes.push(`Your uncommitted work could not be committed (${problem}); the children started from your branch's last commit.`);
-			const released = hooks.releaseClaims().map((r) => `\`${r}\``);
-			if (released.length > 0) notes.push(`Your claims on ${released.join(", ")} were released while your children worked; claim again before you edit.`);
-		}
-		hooks.lend();
-		try {
-			return {
-				reports: await Promise.all(jobs.map(async (job) => {
-					if (!("brief" in job)) return job;
-					const child = { id: job.id };
-					if (job.template !== void 0) child.template = job.template;
-					const result = await hooks.runChild(child, {
-						from: leader,
-						text: job.brief
-					});
-					return reportOf(job.id, result);
-				})),
-				notes
-			};
-		} finally {
-			await hooks.reclaim();
-		}
-	};
-	const delegate = (tasks) => {
-		const seen = /* @__PURE__ */ new Set();
-		const jobs = tasks.map((task) => {
-			if (!children.some((c) => c.id === task.child)) {
-				const names = children.map((c) => c.id).join(", ");
-				return rejected(task.child, `not one of your children (${names === "" ? "you have none" : names})`);
-			}
-			if (seen.has(task.child) || hooks.isRunning(task.child)) return rejected(task.child, templates.includes(task.child) && maxWorkers > 0 ? "already running; use spawn_worker for another instance" : "already running");
-			seen.add(task.child);
-			return {
-				id: task.child,
-				brief: task.brief
-			};
+/** Whom a program in the tool node `id` may write to. */
+const scriptContactsOf = (id, nodes, channels) => {
+	const byId = new Map(nodes.map((node) => [node.id, node]));
+	const owner = byId.get(id)?.parent;
+	return [.../* @__PURE__ */ new Set([...owner !== void 0 && isSession$1(byId.get(owner)) ? [owner] : [], ...channelPeersOf(id, channels).filter((peer) => isSession$1(byId.get(peer)))])];
+};
+/** Whether a program in a tool node may write to the session `id`. */
+const hearsFromScripts = (id, nodes, channels) => nodes.some((node) => isTool(node) && scriptContactsOf(node.id, nodes, channels).includes(id));
+// ../core/src/usage/spend.ts
+/** What a report would add to the session's earlier ones, counting nothing. */
+const unreported = (reported, key, total) => {
+	if (total <= 0) return 0;
+	const before = reported.get(key) ?? 0;
+	return total < before ? total : total - before;
+};
+/**
+* What a report adds to the session's earlier ones, keeping the total in
+* `reported`. A zero says nothing, so it is ignored; a lower total is a session
+* that started counting again, so all of it is new.
+*/
+const ownSpend = (reported, key, total) => {
+	const own = unreported(reported, key, total);
+	if (total > 0) reported.set(key, total);
+	return own;
+};
+/**
+* What a run's events say it spent, for `ork resume`. The total is what its
+* nodes recorded. A session's report counts once its node finished, or when
+* `ork chat` made it outside any node: a session cut off before its node
+* finished has recorded nothing, so its next total counts the part that was cut
+* off. A leader's fork is never resumed, so its report counts when it comes,
+* whether or not its leader finished.
+*/
+const earlierSpend = (events) => {
+	const reported = /* @__PURE__ */ new Map();
+	const open = /* @__PURE__ */ new Map();
+	const forks = /* @__PURE__ */ new Map();
+	let total = 0;
+	for (const event of events) if (event.type === "node.started") open.set(event.id, null);
+	else if (event.type === "node.finished") {
+		total += event.usage?.costUsd ?? 0;
+		const last = open.get(event.id);
+		if (last !== null && last !== void 0) ownSpend(reported, last.key, last.cost);
+		open.delete(event.id);
+	} else if (event.type === "node.event" && event.event.type === "session.finished") {
+		const { sessionId, usage } = event.event.outcome;
+		const key = `${event.id}/${sessionId}`;
+		if (event.event.fork === true) {
+			const own = ownSpend(reported, key, usage.costUsd);
+			total += own;
+			forks.set(event.id, (forks.get(event.id) ?? 0) + own);
+		} else if (open.has(event.id)) open.set(event.id, {
+			key,
+			cost: usage.costUsd
 		});
-		return runJobs(jobs);
+		else ownSpend(reported, key, usage.costUsd);
+	}
+	return {
+		total,
+		reported,
+		forks
+	};
+};
+// ../core/src/run/reserves.ts
+const createReserves = () => {
+	const held = /* @__PURE__ */ new Map();
+	const waiters = /* @__PURE__ */ new Set();
+	const wake = () => {
+		const woken = [...waiters];
+		waiters.clear();
+		for (const resolve of woken) resolve();
 	};
-	const nextInstance = (template) => {
-		for (let n = 2;; n += 1) {
-			const id = `${template}-${String(n)}`;
-			if (!graph.nodes.has(id) && !spawned.includes(id)) return id;
+	return {
+		/** All that is set aside now. */
+		total: () => [...held.values()].reduce((sum, reserve) => sum + reserve.usd, 0),
+		/**
+		* `id` sets aside `usd` (nothing, or 0, lets it go). `waitable` is false
+		* for a leader, whose children must never wait on it.
+		*/
+		reserve: (id, usd, waitable) => {
+			const before = held.get(id)?.usd ?? 0;
+			if (usd === void 0 || usd <= 0) held.delete(id);
+			else held.set(id, {
+				usd,
+				waitable
+			});
+			if ((usd ?? 0) < before) wake();
+		},
+		/** The node ended: whatever it still held is let go. */
+		drop: (id) => {
+			if (held.delete(id)) wake();
+		},
+		/**
+		* Waits until a reserve shrinks. `false` at once when no other node holds
+		* one worth waiting on, or when `signal` aborts.
+		*/
+		freed: (id, signal) => {
+			if (![...held].some(([other, reserve]) => other !== id && reserve.waitable) || signal.aborted) return Promise.resolve(false);
+			return new Promise((resolve) => {
+				const done = (freed) => () => {
+					waiters.delete(onFree);
+					signal.removeEventListener("abort", onAbort);
+					resolve(freed);
+				};
+				const onFree = done(true);
+				const onAbort = done(false);
+				waiters.add(onFree);
+				signal.addEventListener("abort", onAbort, { once: true });
+			});
 		}
 	};
-	const spawn = (tasks) => {
-		const jobs = tasks.map((task) => {
-			if (!templates.includes(task.template)) {
-				const names = templates.join(", ");
-				return rejected(task.template, `not one of your child workers (${names === "" ? "you have none" : names})`);
-			}
-			if (spawned.length >= maxWorkers) return rejected(task.template, `no workers left to spawn (maxWorkers: ${String(maxWorkers)})`);
-			const id = nextInstance(task.template);
-			spawned.push(id);
-			return {
-				id,
-				template: task.template,
-				brief: task.brief
-			};
-		});
-		return runJobs(jobs);
+};
+// ../core/src/run/spending.ts
+/**
+* A result with only what this activation spent (ADR-046): a session's report
+* holds its total so far, while its tokens are this process's own. `reported`
+* holds each session's total.
+*/
+const withOwnSpend = (id, result, reported) => {
+	const { sessionId, usage } = result;
+	if (sessionId === void 0 || usage === void 0) return result;
+	const own = {
+		...usage,
+		costUsd: ownSpend(reported, `${id}/${sessionId}`, usage.costUsd)
 	};
 	return {
-		children,
-		fanned: (owner?.children ?? []).filter((id) => isFanned(id)),
-		templates,
-		workersLeft: () => Math.max(0, maxWorkers - spawned.length),
-		delegate,
-		spawn
+		...result,
+		usage: own,
+		output: "usage" in result.output ? {
+			...result.output,
+			usage: own
+		} : result.output
 	};
 };
-// ../core/src/run/scope.ts
+/** A run's spending so far; a resumed run starts from what it had spent. */
+const createSpend = (budgetUsd, earlier, limits) => {
+	const reported = new Map(earlier?.reported);
+	let spent = earlier?.total ?? 0;
+	/** What running sessions last reported, not yet in `spent`, by `node/session`. */
+	const inFlight = /* @__PURE__ */ new Map();
+	const committed = () => spent + [...inFlight.values()].reduce((sum, cost) => sum + cost, 0);
+	/** Caps running sessions were given (ADR-077): out of what is offered. */
+	const reserves = createReserves();
+	const budgetLeft = () => budgetUsd === void 0 ? void 0 : budgetUsd - committed() - reserves.total();
+	return {
+		total: () => spent,
+		/** A node sets aside its session's cap; nothing or 0 lets it go. */
+		reserve: reserves.reserve,
+		/** Waits until another node's reserve frees; `false` when none can. */
+		freed: reserves.freed,
+		/** What a session has spent in this activation, from its total so far. */
+		ownOf: (id, sessionId, total) => unreported(reported, `${id}/${sessionId}`, total),
+		/** A running session said what it has spent so far. */
+		report: (id, sessionId, total) => {
+			const key = `${id}/${sessionId}`;
+			inFlight.set(key, unreported(reported, key, total));
+		},
+		/** The node ended: `count` has what its sessions last reported. */
+		settled: (id) => {
+			for (const key of inFlight.keys()) if (key.startsWith(`${id}/`)) inFlight.delete(key);
+			reserves.drop(id);
+		},
+		/** What a session may spend: the least of the budget and any quota. */
+		left: () => {
+			const known = [budgetLeft(), limits?.().leftUsd].filter((left) => left !== void 0);
+			return known.length === 0 ? void 0 : Math.min(...known);
+		},
+		budgetLeft,
+		/** What the limits across runs allow now. */
+		quota: () => limits?.() ?? {},
+		/**
+		* What stops anything new from starting: a quota first, as a budget can be
+		* raised.
+		*/
+		spentOut: () => {
+			const blocked = limits?.().blocked;
+			if (blocked !== void 0) return {
+				status: "quota_exhausted",
+				reason: blocked
+			};
+			return budgetUsd !== void 0 && committed() >= budgetUsd ? {
+				status: "budget_exhausted",
+				reason: `the run's budget of $${String(budgetUsd)} is spent`
+			} : null;
+		},
+		/**
+		* Counts a result, and gives it back with only its own spend. A replayed
+		* result is as stored, and already in what the run started from.
+		*/
+		count: (id, result, replayed) => {
+			if (replayed) return result;
+			const own = withOwnSpend(id, result, reported);
+			spent += own.usage?.costUsd ?? 0;
+			return own;
+		}
+	};
+};
+/** A run's spending, from what the scheduler is given. */
+const spendOf = (budgetUsd, options) => createSpend(budgetUsd, options.replay?.earlier, options.limits);
+// ../core/src/run/gather.ts
+const asList = (value) => Array.isArray(value) ? value : [];
+/** `before` then `now`, leaving out an entry already there. */
+const joined = (before, now) => {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const entry of [...asList(before), ...asList(now)]) {
+		const key = JSON.stringify(entry);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(entry);
+	}
+	return out;
+};
 /**
-* @file A run's id and folder, and the scope templates and `when:` conditions
-*   read during it.
+* `result` with each gathered field holding every round's entries so far.
+* `previous` is the node's output from its last round, already gathered.
 */
-/** The run's id (given, or a new one) and its `.ork/runs/<run>` folder. */
-const runPlace = (options) => {
-	const runId = options.runId ?? randomUUID().slice(0, 8);
+const joinRounds = (fields, previous, result) => {
+	if (fields.length === 0 || previous === void 0) return result;
+	const output = { ...result.output };
+	for (const field of fields) output[field] = joined(previous[field], result.output[field]);
 	return {
-		runId,
-		runDir: options.runDir ?? path.join(options.cwd, ".ork", "runs", runId)
+		...result,
+		output
 	};
 };
+/** `result` with `node`'s `output.gather` fields joined to its earlier rounds. */
+const gatherRounds = (node, previous, result) => joinRounds(gatheredFieldsOf(node), previous, result);
 /**
-* The folders every node of a run reads from: the workflow's, the project's,
-* Ork's.
+* What `activation`'s rounds reported so far, to gather onto. A spawned
+* instance gathers nothing earlier: its id (`impl-2`) is reused by a different
+* worker in the leader's next round. A delegated child that hasn't run since a
+* resume starts from what it reported before it, since its leader's recorded
+* rounds are handed back whole and never run it again.
 */
-const foldersOf = (options) => ({
-	workflowDir: options.workflowDir ?? options.cwd,
-	projectRoot: options.projectRoot ?? options.cwd,
-	...options.orkDir === void 0 ? {} : { orkDir: options.orkDir }
+const previousOf = (activation, current, replay) => {
+	const { brief, template, id } = activation;
+	if (brief !== void 0 && template !== void 0) return void 0;
+	if (current !== void 0 || brief === void 0) return current;
+	return replay?.lastOutput?.(id);
+};
+/** Gathers each activation's result onto what its node reported before. */
+const createGatherer = (outputs, replay, nodeOf) => (activation, result) => gatherRounds(nodeOf(activation), previousOf(activation, outputs[activation.id], replay), result);
+// ../core/src/run/results.ts
+/** Control nodes pass their input through; a join's input is its output. */
+const passThrough = (input) => ({
+	output: input ?? {},
+	ok: true
 });
-/** What templates and `when:` read during a run. */
-const runScope = (inputs, outputs, runId, item) => {
-	const scope = {
-		inputs,
-		nodes: Object.fromEntries(Object.entries(outputs).map(([id, output]) => [id, { output }]))
+const recordRun = (entry, result) => {
+	entry.runs += 1;
+	entry.ok = result.ok;
+	entry.output = result.output;
+	entry.costUsd += result.usage?.costUsd ?? 0;
+	if (result.error === void 0) delete entry.error;
+	else entry.error = result.error;
+	if (result.ok) delete entry.end;
+	else entry.end = endOf(result);
+};
+const startedEvent = (activation, nodeType, round, agent) => {
+	const event = {
+		type: "node.started",
+		id: activation.id,
+		nodeType,
+		round
 	};
-	if (runId !== void 0) scope.run = { id: runId };
-	if (item !== void 0) {
-		scope.item = item.value;
-		scope.index = item.index;
-	}
-	return scope;
+	if (activation.brief !== void 0) event.owner = activation.brief.from;
+	if (agent !== void 0) event.agent = agent;
+	const { item } = activation;
+	if (item !== void 0) event.item = {
+		of: item.of,
+		index: item.index
+	};
+	return event;
 };
-// ../core/src/run/context.ts
-/**
-* @file One activation's execute context: what the scheduler hands a node's
-*   executor. Its inputs and the outputs so far, where it works, the budget
-*   left, the human, its hold and its own stop signal (ADR-041), its ports on
-*   the bus, the session it resumes, and, for a leader, its ownership of its
-*   children.
-*/
-const nodeContext = (deps, activation, cwd, round) => {
-	const { options, runId } = deps;
-	const { graph } = options;
-	const { id, template } = activation;
-	const context = {
-		runId,
-		id,
-		workflow: graph.workflow,
-		inputs: options.inputs,
-		outputs: deps.outputs,
-		input: activation.input,
+const finishedEvent = (id, round, result) => {
+	const event = {
+		type: "node.finished",
+		id,
 		round,
-		cwd,
-		runDir: deps.runDir,
-		...foldersOf(options),
-		budgetLeftUsd: deps.spend.left(),
-		budgetLeftNow: deps.spend.budgetLeft,
-		reserveBudget: (usd) => {
-			deps.spend.reserve(id, usd, deps.nodeOf(activation)?.type !== "claude.leader");
-		},
-		budgetFreed: (signal) => deps.spend.freed(id, signal),
-		quota: deps.spend.quota,
-		ownSpend: (sessionId, total) => deps.spend.ownOf(id, sessionId, total),
-		human: deps.human,
-		hold: deps.holds.forNode(id, template),
-		...deps.ports.forNode(id, template, cwd),
-		...options.calls === void 0 ? {} : { calls: options.calls },
-		emit: (event) => {
-			deps.ports.owners.seen(id, event, cwd);
-			if (event.type === "session.finished" && event.fork !== true) {
-				const { sessionId, usage } = event.outcome;
-				deps.spend.report(id, sessionId, usage.costUsd);
-			}
-			options.onEvent({
-				type: "node.event",
-				id,
-				event
-			});
-		},
-		signal: deps.stops.signalFor(id, template)
+		ok: result.ok,
+		output: result.output
 	};
-	const owner = ownerPort(deps, id, template);
-	if (owner !== void 0) context.owner = owner;
-	if (template !== void 0) context.template = template;
-	if (activation.brief !== void 0) context.brief = activation.brief;
-	if (activation.item !== void 0) context.item = activation.item;
-	const resume = options.replay?.cutOff?.(activation) ?? resumeOf(deps.nodeOf(activation), deps.sessionIds.get(id) ?? options.replay?.previousSession?.(activation));
-	if (resume !== void 0) context.resume = resume;
-	if (deps.nodeOf(activation)?.type === "claude.leader") context.ownership = createOwnership({
-		graph,
-		leader: id,
-		runChild: deps.runChild,
-		isRunning: (other) => deps.running.has(other),
-		checkpoint: () => options.workspace?.checkpoint(id) ?? Promise.resolve(null),
-		releaseClaims: () => {
-			const held = context.claims?.held() ?? [];
-			for (const resource of held) context.claims?.release(resource);
-			return held;
-		},
-		lend: deps.slots.release,
-		reclaim: deps.slots.take
-	});
-	return context;
+	if (result.usage !== void 0) event.usage = result.usage;
+	if (result.error !== void 0) event.error = result.error;
+	event.end = endOf(result);
+	return event;
 };
-/** Where `id`'s questions go first, if its leader takes them (ADR-063). */
-const ownerPort = (deps, id, template) => deps.ports.owners.portFor(id, template, {
-	budgetLeftUsd: deps.spend.left,
-	charge: (owner, sessionId, usage) => {
-		const own = deps.spend.count(owner, {
-			ok: true,
-			output: {},
-			sessionId,
-			usage
-		}, false);
-		deps.summary(owner).costUsd += own.usage?.costUsd ?? 0;
+const failure = (error) => ({
+	output: {
+		status: "fail",
+		summary: error
 	},
-	emit: (owner, event) => {
-		deps.options.onEvent({
-			type: "node.event",
-			id: owner,
-			event
-		});
-	}
+	ok: false,
+	error
+});
+/** The node's entry in the run summary, created on first use. */
+const summaryOf = (summaries, id) => {
+	const existing = summaries.get(id);
+	if (existing !== void 0) return existing;
+	const created = {
+		id,
+		runs: 0,
+		ok: null,
+		output: null,
+		costUsd: 0
+	};
+	summaries.set(id, created);
+	return created;
+};
+/** A run's summary; a resumed run's leaders keep their forks' spend (ADR-063). */
+const createSummaries = (earlier) => {
+	const summaries = /* @__PURE__ */ new Map();
+	const summary = (id) => summaryOf(summaries, id);
+	for (const [id, costUsd] of earlier?.forks ?? []) summary(id).costUsd += costUsd;
+	return {
+		summaries,
+		summary
+	};
+};
+/** The tighter of the workflow's budget and what a caller left it, if any. */
+const runBudget = (graph, settings) => {
+	const limits = [graph.workflow.limits?.budgetUsd, settings?.budgetCap].filter((limit) => limit !== void 0);
+	return limits.length === 0 ? {} : { budgetUsd: Math.min(...limits) };
+};
+/** The `run.started` event: the workflow, its entries, nodes and inputs. */
+const runStartedEvent = (graph, runId, options) => ({
+	type: "run.started",
+	runId,
+	workflow: graph.workflow.name,
+	entries: graph.entries,
+	nodes: declaredNodes(graph),
+	edges: graph.edges.map(({ from, to, when, maxRounds }) => ({
+		from,
+		to,
+		...when === void 0 ? {} : { when },
+		...maxRounds === void 0 ? {} : { maxRounds }
+	})),
+	channels: graph.channels,
+	inputs: options.inputs,
+	...options.settings === void 0 ? {} : { settings: options.settings },
+	...runBudget(graph, options.settings),
+	...options.orkVersion === void 0 ? {} : { ork: options.orkVersion }
 });
+/** The unread mail of nodes that never ran; a node that ran saw its notice. */
+const unreadOf = (nodes, unread) => {
+	const ran = new Set(nodes.filter((node) => node.runs > 0).map((node) => node.id));
+	const left = [...unread ?? []].filter(([node]) => !ran.has(node)).map(([node, messages]) => ({
+		node,
+		messages
+	}));
+	return left.length === 0 ? {} : { unread: left };
+};
 /**
-* The session a node that runs again continues, when it resumes (ADR-033): by
-* `session: resume`, the default for a leader; a worker starts fresh unless it
-* says `resume`.
+* The run's result: failed when any reason was given, unless it stopped. A
+* skipped node or a handled failure leaves it `succeeded`, and is counted.
 */
-const resumeOf = (node, sessionId) => {
-	if (node === void 0 || !isClaudeNode(node)) return void 0;
-	if (node.type === "claude.subagent") return void 0;
-	return (node.session ?? (node.type === "claude.leader" ? "resume" : "fresh")) === "resume" ? sessionId : void 0;
-};
+const runResult = (run) => ({
+	runId: run.runId,
+	status: run.stopped ?? (run.reasons.length > 0 ? "failed" : "succeeded"),
+	costUsd: run.costUsd,
+	nodes: run.nodes,
+	reasons: run.reasons,
+	worktrees: run.worktrees,
+	...run.outputs === void 0 ? {} : { outputs: run.outputs },
+	skipped: run.nodes.filter((node) => node.runs === 0).length,
+	failuresHandled: run.failuresHandled,
+	...unreadOf(run.nodes, run.unread)
+});
+/** A workflow's `outputs`, rendered as the run ends. */
+const renderOutputs = (outputs, scope) => outputs === void 0 ? void 0 : Object.fromEntries(Object.entries(outputs).map(([name, text]) => {
+	const template = parseTemplate(text);
+	return [name, template.ok ? renderTemplate(template.parts, scope) : text];
+}));
+/** Closes the run's worktrees; a failure is one more reason, not a crash. */
+const closeWorkspace = (workspace, reasons) => (workspace?.close() ?? Promise.resolve([])).catch((error) => {
+	reasons.push(`cleaning up worktrees: ${String(error)}`);
+	return [];
+});
 // ../core/src/store/nest-items.ts
 /** Whether a tree node is an item of a fanned node (`build.2`). */
 const isItem = (node) => node.template !== void 0 && /\.\d+$/u.test(node.id);
@@ -8307,6 +9048,13 @@ const runTree = (events) => {
 	}
 	return roots;
 };
+/** The nodes of a run waiting for a machine-wide slot now. */
+const slotWaitsOf = (events) => {
+	const waiting = /* @__PURE__ */ new Set();
+	for (const event of events) if (event.type === "slot.waiting") waiting.add(event.id);
+	else if (event.type === "slot.taken" || event.type === "node.finished") waiting.delete(event.id);
+	return [...waiting];
+};
 /** Folds a run's `ork pause` and `ork continue` commands (ADR-041). */
 const pausedOf = (events) => {
 	let run = false;
@@ -8499,7 +9247,10 @@ const createStops = (run) => {
 			own.delete(id);
 			return stopped.delete(id) ? {
 				...result,
-				...failure("stopped by the user")
+				...failedWith(endFor("interrupted"), {
+					status: "fail",
+					summary: "stopped by the user"
+				})
 			} : result;
 		}
 	};
@@ -8569,6 +9320,8 @@ const createClock = (options) => {
 			else resting.delete(id);
 			changed();
 		},
+		/** Stands the node's clock (and its owners' and the run's) still for `wait`. */
+		waitFor: asking,
 		/** The same channel, noting who waits on the user for how long. */
 		human: (channel) => ({
 			permit: (request) => asking(request.nodeId, () => channel.permit(request)),
@@ -8588,18 +9341,17 @@ const createClock = (options) => {
 	};
 };
 const timedOut = (timeout, partial) => {
-	const error = `timed out after ${timeout}`;
-	return {
+	const end = endFor("timed_out", { timeout });
+	return endedWith({
 		...partial,
 		ok: false,
-		error,
 		output: {
 			...partial?.output,
 			status: "fail",
-			summary: error,
+			summary: end.message,
 			timedOut: true
 		}
-	};
+	}, end);
 };
 /** Runs `start` under `timeout`, if it has one. */
 const withTimeout = async (bound) => {
@@ -8650,9 +9402,28 @@ const watchRunTimeout = (watched) => {
 		cancelled.abort();
 	};
 };
+// ../core/src/run/watch.ts
+/**
+* @file A `watch:` on a tool or MCP node (RFC-011): the node's look, repeated
+*   until its condition holds, with no model turn. The last look is its output.
+*   A failed look, such as a network error, is tried again up to `misses` in a
+*   row; an answer the node didn't declare fails it at once, as waiting can't
+*   mend that. The time between looks isn't work, so a pause keeps it and the
+*   run's clock stands still. It records what changed, not every look.
+*/
+/**
+* The ends of a failed look that the next look may mend besides a transient
+* kind: what a tool's non-zero exit or an MCP call's error ends as.
+*/
+const LOOKS_AGAIN = /* @__PURE__ */ new Set([
+	"command_failed",
+	"auth",
+	"tool_missing",
+	"interrupted"
+]);
 const SAID_LIMIT = 1024;
 /** What a look says, for telling whether it changed and showing it. */
-const saidBy = (result, declared) => {
+const saidBy$1 = (result, declared) => {
 	const { json, exitCode, stdout, text } = result.output;
 	const value = declared !== void 0 && typeof json === "object" && json !== null ? Object.fromEntries(Object.keys(declared).map((name) => [name, Reflect.get(json, name)])) : json ?? {
 		exitCode,
@@ -8685,7 +9456,7 @@ const leftBehind = (signal, graceMs) => {
 const runWatch = async (options) => {
 	const { id, watch, declared, look, hold, signal, graceMs, onEvent } = options;
 	const until = parseExpr(watch.until);
-	if (!until.ok) return failure(`watch.until: ${until.message}`);
+	if (!until.ok) return failedWith(endFor("invalid_node", { reason: `watch.until: ${until.message}` }));
 	const every = options.everyMs ?? timeoutMs(watch.every) ?? 0;
 	const misses = watch.misses ?? 3;
 	const limit = new AbortController();
@@ -8706,17 +9477,16 @@ const runWatch = async (options) => {
 	};
 	const expiredResult = () => {
 		const error = `watched for ${watch.timeout}, and ${markValue(watch.until)} never held`;
-		return {
+		return endedWith({
 			...last,
 			ok: false,
-			error,
 			output: {
 				...last?.output,
 				status: "fail",
 				summary: error,
 				timedOut: true
 			}
-		};
+		}, endFor("timed_out", { timeout: watch.timeout }, error));
 	};
 	/** Stands still while paused, and records the hold at once. */
 	const rest = async () => {
@@ -8761,11 +9531,14 @@ const runWatch = async (options) => {
 		for (;;) {
 			await hold?.wait("start", active);
 			const result = active.aborted ? null : await lookOnce();
-			if (signal.aborted) return ended("stopped", failure("stopped while watching"));
+			if (signal.aborted) return ended("stopped", failedWith(endFor("interrupted"), {
+				status: "fail",
+				summary: "stopped while watching"
+			}));
 			if (limit.signal.aborted || result === null) return ended("timed_out", expiredResult());
 			looks += 1;
 			last = result;
-			const said = saidBy(result, declared);
+			const said = saidBy$1(result, declared);
 			if (said !== lastSaid) {
 				lastSaid = said;
 				onEvent({
@@ -8781,7 +9554,7 @@ const runWatch = async (options) => {
 				missed = 0;
 				if (holds(result.output)) return ended("met", result);
 			} else {
-				if (!(result.transient === true || result.output["timedOut"] === true)) return ended("failed", result);
+				if (!(result.transient === true || LOOKS_AGAIN.has(result.end?.kind) || result.output["timedOut"] === true)) return ended("failed", result);
 				missed += 1;
 				if (missed >= misses) return ended("failed", {
 					...result,
@@ -8798,19 +9571,36 @@ const runWatch = async (options) => {
 const repeatsCall = (event) => event.type === "tool.called" || event.type === "tool.result";
 // ../core/src/run/execute.ts
 /** Runs an activation; control nodes pass their input through. */
-const createExecute = (deps) => async (activation, round) => {
+const saidBy = (error) => error instanceof Error ? error.message : String(error);
+/**
+* A thrown error's end: a failed git or missing program by its text, else
+* `fallback`.
+*/
+const thrown = (error, fallback) => {
+	const text = saidBy(error);
+	const read = endOf({
+		ok: false,
+		output: {},
+		error: text
+	});
+	return failedWith(read.kind === "unknown" ? endFor(fallback, { reason: text }, text) : read);
+};
+/** Runs an activation, its end's detail scrubbed of the run's paths. */
+const createExecute = (deps) => async (activation, round) => scrubbedEnd(await executeOne(deps, activation, round), [deps.options.cwd, deps.options.projectRoot ?? ""]);
+const executeOne = async (deps, activation, round) => {
 	const { options, contextDeps, clock, graceMs, nodeOf } = deps;
 	const node = nodeOf(activation);
-	if (node === void 0) return failure(`unknown node ${activation.id}`);
+	if (node === void 0) return failedWith(endFor("unknown", {}, `unknown node ${activation.id}`));
 	if (node.type.startsWith("control.")) return passThrough(activation.input);
 	const executor = options.executors[node.type];
-	if (executor === void 0) return failure(`no executor for ${node.type}`);
+	if (executor === void 0) return failedWith(endFor("unknown", {}, `no executor for ${node.type}`));
 	try {
 		const forEach = activation.item === void 0 ? forEachOf(node) : void 0;
 		if (forEach !== void 0) return await deps.fanOut(activation, forEach, round);
 		const { workspace } = options;
-		const place = await workspace?.prepare(activation.id, activation.template) ?? { cwd: options.cwd };
-		const context = nodeContext(contextDeps, activation, place.cwd, round);
+		const place = await (workspace?.prepare(activation.id, activation.template) ?? Promise.resolve({ cwd: options.cwd })).catch((error) => thrown(error, "invalid_node"));
+		if ("ok" in place) return place;
+		const context = nodeContext(contextDeps, activation, place.cwd, round, clock);
 		const once = (signal, emit) => withTimeout({
 			timeout: timeoutOf(node, options.graph.workflow),
 			clock: clock.forNode(activation.id),
@@ -8842,9 +9632,10 @@ const createExecute = (deps) => async (activation, round) => {
 			},
 			everyMs: options.watchEveryMs
 		});
-		return await workspace?.finish(activation.id, result) ?? result;
+		const ended = result.ok || !context.signal.aborted ? result : endedWith(result, stoppedEnd(context.signal));
+		return await workspace?.finish(activation.id, ended) ?? ended;
 	} catch (error) {
-		return failure(error instanceof Error ? error.message : String(error));
+		return thrown(error, "unknown");
 	}
 };
 // ../core/src/run/bus-calls.ts
@@ -9358,7 +10149,7 @@ const failed = (id, why) => {
 	return reason === "" ? `${id} failed` : `${id} failed: ${reason}`;
 };
 /** A program that ran says how it exited; anything else has its own reason. */
-const toolLine = (id, result) => {
+const toolLine$1 = (id, result) => {
 	const { output, ok, error } = result;
 	const code = output["exitCode"];
 	if (!(typeof code === "number" && code >= 0 && output["timedOut"] !== true && (ok || code !== 0))) return ok ? `${id} passed` : failed(id, error ?? "");
@@ -9368,7 +10159,7 @@ const toolLine = (id, result) => {
 /** Ork's own line about a result, when a rule gives no body. */
 const defaultRuleBody = (id, node, result) => {
 	const { output, ok } = result;
-	if (node !== void 0 && isToolNode(node)) return toolLine(id, result);
+	if (node !== void 0 && isToolNode(node)) return toolLine$1(id, result);
 	const summary = output["summary"];
 	const said = typeof summary === "string" ? summary : "";
 	if (!ok) return failed(id, result.error ?? said);
@@ -9636,7 +10427,7 @@ const startRun = (options) => {
 		expire: (reason) => {
 			stop("timed_out", reason);
 			options.calls?.stopAll();
-			abort.abort();
+			abort.abort(runTimedOut(limits.timeout));
 			settle();
 		},
 		leave: () => {
@@ -10816,12 +11607,13 @@ const parseReport = (value) => {
 // ../core/src/run/brief.ts
 /**
 * @file What a Claude node is asked: its brief, rendered against the run's
-*   inputs and outputs, and its `claude.subagent` children as Claude Code
-*   subagents of its session (the SDK's `agents`, the CLI's `--agents`). A
-*   subagent's role (its agent's instructions), `instructions` and `prompt` are
-*   its system prompt, and its `description` says when the session hands it
-*   work with the Agent tool; it runs inside that session, with no process,
-*   worktree or edges of its own.
+*   inputs and outputs, the model and effort it runs on (a fanned node's from
+*   its item), and its `claude.subagent` children as Claude Code subagents of
+*   its session (the SDK's `agents`, the CLI's `--agents`). A subagent's role
+*   (its agent's instructions), `instructions` and `prompt` are its system
+*   prompt, and its `description` says when the session hands it work with the
+*   Agent tool; it runs inside that session, with no process, worktree or edges
+*   of its own.
 */
 /** The tool a session hands a subagent work with. */
 const AGENT_TOOL = "Agent";
@@ -10850,6 +11642,23 @@ const renderBrief = (text, inputs, outputs, before, item) => {
 		warnings
 	};
 };
+/**
+* The model and effort a session asks for: the node's own, rendered with its
+* item on a fanned node (`{{item.model}}`), else the workflow's defaults. An
+* item's value that is no model name or effort level fails it.
+*/
+const modelOf = (node, defaults, run) => {
+	const scope = runScope(run.inputs, run.outputs ?? {}, void 0, run.item);
+	const model = itemSetting("model", node.model, scope);
+	if (!model.ok) return model;
+	const effort = itemEffort(node.effort, scope);
+	if (!effort.ok) return effort;
+	return {
+		ok: true,
+		model: model.value ?? defaults.model,
+		effort: effort.value ?? defaults.effort
+	};
+};
 const rendered = (text, inputs, outputs) => {
 	const brief = renderBrief(text, inputs, outputs);
 	return brief.ok ? brief.text : (text ?? "").trim();
@@ -10929,7 +11738,7 @@ const mailboxInstructions = (mailbox, owner) => {
 const verifyInstructions = (node) => {
 	if (!("verify" in node) || node.verify === void 0) return [];
 	const { command } = node.verify;
-	return [`- A report that is not \`fail\` or \`changes_requested\` is accepted only if ${command === void 0 || command.includes("{{") ? "a check the workflow defines" : `\`${command}\``} passes when you report. If it fails, you are told why and asked to fix it, so run it yourself first if you can.`];
+	return [`- A report that is not \`fail\` or \`changes_requested\` is accepted only if ${command === void 0 || command.includes("{{") ? "a check the workflow defines" : `\`${command}\``} passes when you report. If it fails, you are told why and asked to fix it, ${(command !== void 0 && node.tools?.deny?.includes(heavyRule(command))) === true ? "so run targeted checks (such as the tests you changed) first: Ork runs the full check, and this session may not." : "so run it yourself first if you can."}`];
 };
 /** Ork's own instructions for a node, kept short: they cost tokens every turn. */
 const harnessInstructions = (workflow, id, node, options = {}) => {
@@ -11026,6 +11835,11 @@ const planNodeSession = (workflow, id, options) => {
 		ok: false,
 		error: `\`${id}\` uses worktree isolation, which a run on its own does not set up; run the whole workflow, or pass \`--in-place\` to run it in this checkout`
 	};
+	const models = modelOf(node, defaults, options);
+	if (!models.ok) return {
+		ok: false,
+		error: models.error
+	};
 	const warnings = [];
 	const brief = renderBrief(node.prompt, options.inputs, options.outputs, options.before, options.item);
 	if (!brief.ok) return {
@@ -11073,10 +11887,8 @@ const planNodeSession = (workflow, id, options) => {
 		spec.agents = agents;
 		spec.tools.only?.push(AGENT_TOOL);
 	}
-	const model = node.model ?? defaults.model;
-	if (model !== void 0) spec.model = model;
-	const effort = node.effort ?? defaults.effort;
-	if (effort !== void 0) spec.effort = effort;
+	if (models.model !== void 0) spec.model = models.model;
+	if (models.effort !== void 0) spec.effort = models.effort;
 	const maxTurns = node.maxTurns ?? defaults.maxTurns;
 	if (maxTurns !== void 0) spec.maxTurns = maxTurns;
 	const budgets = [node.budgetUsd ?? defaults.budgetUsd, options.budgetLeftUsd].filter((b) => b !== void 0);
@@ -11279,6 +12091,112 @@ const explainWorkflowText = (text, file, nodeId, where) => {
 		sources: sourcesOf(result.explanation, place, where.home ?? homedir())
 	} : result;
 };
+// ../core/src/usage/quota.ts
+const WINDOWS = [
+	"day",
+	"week",
+	"month"
+];
+const FIELDS = {
+	day: "dayUsd",
+	week: "weekUsd",
+	month: "monthUsd"
+};
+/** Where a window began and when the next begins, in local time. */
+const windowOf = (window, now) => {
+	const [year, month, day] = [
+		now.getFullYear(),
+		now.getMonth(),
+		now.getDate()
+	];
+	if (window === "month") return {
+		since: new Date(year, month, 1),
+		until: new Date(year, month + 1)
+	};
+	if (window === "day") return {
+		since: new Date(year, month, day),
+		until: new Date(year, month, day + 1)
+	};
+	const monday = day - (now.getDay() + 6) % 7;
+	return {
+		since: new Date(year, month, monday),
+		until: new Date(year, month, monday + 7)
+	};
+};
+/** The caps that apply: the user's on everything, and the project's on itself. */
+const capsOf = (user, project, root) => WINDOWS.flatMap((window) => {
+	const field = FIELDS[window];
+	const everywhere = user?.[field];
+	const here = project?.[field];
+	const caps = [];
+	if (everywhere !== void 0) caps.push({
+		window,
+		capUsd: everywhere
+	});
+	if (here !== void 0 && root !== void 0) caps.push({
+		window,
+		capUsd: here,
+		project: root
+	});
+	return caps;
+});
+/** Each cap with what has been spent against it. */
+const standingOf = (store, caps, now) => caps.map((cap) => {
+	const { since, until } = windowOf(cap.window, now);
+	const spentUsd = store.spentSince(since.toISOString(), cap.project);
+	return {
+		...cap,
+		spentUsd,
+		leftUsd: cap.capUsd - spentUsd,
+		resetsAt: until.toISOString()
+	};
+});
+/** Dollars: cents, or more digits for an amount under a dollar. */
+const usd = (amount) => `$${amount.toFixed(amount > 0 && amount < 1 ? 4 : 2)}`;
+const at = (iso) => new Date(iso).toLocaleString(void 0, {
+	dateStyle: "medium",
+	timeStyle: "short"
+});
+const capReason = (spent) => `${spent.project === void 0 ? "your" : "this project's"} ${spent.window} quota of ${usd(spent.capUsd)} is spent (${usd(spent.spentUsd)}); it lifts on ${at(spent.resetsAt)}, or raise it in ${spent.project === void 0 ? "~/.ork/settings.yaml" : ".ork/project.yaml"}`;
+/** What a run or a call refused at its start says first, for its caller to read. */
+const NOT_STARTED = "Not started: ";
+/** Why a plan limit stops a run. */
+const planReason = (limit) => `your Claude plan's ${limit.window.replaceAll("_", " ")} limit was reached${limit.resetsAt === void 0 ? "" : `; it resets on ${at(limit.resetsAt)}, or use ork usage --clear-plan-limits if it has lifted`}`;
+/**
+* The windows that hold the whole account. One for a single model, such as
+* `seven_day_opus`, stops only the session it refused: other models may be
+* free.
+*/
+const ACCOUNT_WINDOWS = /* @__PURE__ */ new Set([
+	"five_hour",
+	"seven_day",
+	"overage",
+	"plan"
+]);
+/** The plan limits in force, the one that lifts last first. */
+const refusing = (limits, now) => limits.filter((limit) => limit.status === "rejected" && ACCOUNT_WINDOWS.has(limit.window) && limit.resetsAt !== void 0 && Date.parse(limit.resetsAt) > now.getTime()).toSorted((a, b) => String(b.resetsAt).localeCompare(String(a.resetsAt)));
+/** How long a report with no reset time stays worth showing. */
+const SHOWN_MS = 864e5;
+/** What the caps and the plan allow a run now. */
+const limitsNow = (store, caps, now) => {
+	const standing = standingOf(store, caps, now);
+	const [plan] = refusing(store.planLimits(), now);
+	const spent = standing.find((cap) => cap.leftUsd <= 0);
+	const blocked = plan === void 0 ? spent === void 0 ? void 0 : capReason(spent) : planReason(plan);
+	return {
+		...standing.length === 0 ? {} : { leftUsd: Math.min(...standing.map((cap) => cap.leftUsd)) },
+		...blocked === void 0 ? {} : { blocked }
+	};
+};
+/** What `ork usage` and the panel show. */
+const limitsReport = (store, { caps, problems }, now) => ({
+	problems,
+	caps: standingOf(store, caps, now),
+	plan: store.planLimits().filter((limit) => {
+		if (limit.status === "allowed") return false;
+		return (limit.resetsAt === void 0 ? Date.parse(limit.at) + SHOWN_MS : Date.parse(limit.resetsAt)) > now.getTime();
+	})
+});
 // ../core/src/remote/follow.ts
 /**
 * @file Following a run's events from another process (`ork logs -f`, the local
@@ -11292,18 +12210,16 @@ const followEvents = async (store, runId, onEvent, options) => {
 		seq: options.after ?? 0,
 		finished: false
 	};
-	const done = new AbortController();
 	const emit = (stored) => {
 		if (stored.seq <= seen.seq) return;
 		seen.seq = stored.seq;
 		onEvent(stored);
-		if (stored.event.type === "run.finished") {
-			seen.finished = true;
-			done.abort();
-		}
+		const { type } = stored.event;
+		if (type === "run.finished") seen.finished = true;
+		else if (type === "run.started" || type === "run.resumed") seen.finished = false;
 	};
 	const aborted = () => options.signal?.aborted === true;
-	/** Takes what the store has; true once `run.finished` is among it. */
+	/** Takes what the store has; true once the run's latest go has finished. */
 	const drain = () => {
 		for (const stored of store.events(runId, seen.seq)) emit(stored);
 		return seen.finished;
@@ -11312,7 +12228,11 @@ const followEvents = async (store, runId, onEvent, options) => {
 		if (drain()) return "finished";
 		if (!options.follow) return "stored";
 		if (aborted()) return "aborted";
-		const via = await followSocket(socketPath(runId, options.home), seen.seq, emit, options.signal === void 0 ? done.signal : AbortSignal.any([options.signal, done.signal]));
+		const done = new AbortController();
+		const via = await followSocket(socketPath(runId, options.home), seen.seq, (stored) => {
+			emit(stored);
+			if (seen.finished) done.abort();
+		}, options.signal === void 0 ? done.signal : AbortSignal.any([options.signal, done.signal]));
 		if (seen.finished) return "finished";
 		if (aborted()) return "aborted";
 		if (via === "ended") continue;
@@ -11362,31 +12282,58 @@ const noWait = (id) => ({
 		run: id
 	}
 });
-/** A node's report as a call's result; a failing one says why. */
-const reportResult = (id, node, output, ok, usage) => {
-	const summary = output["summary"];
-	return {
-		ok,
-		output: {
-			...output,
-			run: id
-		},
-		usage,
-		...ok ? {} : { error: typeof summary === "string" ? summary : `${node} reported failure.` }
-	};
+/**
+* A call that could not start its run: refused by a limit across runs
+* (RFC-007), or something the calling node asks for that isn't there.
+*/
+const startFailed = (error) => failedWith(error.includes("Not started: ") ? endFor("plan_limit", {}, error) : endFor("invalid_node", { reason: error }), {
+	status: "fail",
+	summary: error
+});
+/** How a run that ended `status` ended, when its nodes don't say. */
+const STATUS_KINDS = {
+	succeeded: "done",
+	failed: "unknown",
+	budget_exhausted: "budget_limit",
+	quota_exhausted: "plan_limit",
+	timed_out: "timed_out",
+	interrupted: "interrupted"
+};
+/**
+* How a called run ended, carried up to the node that called it: a limit the
+* run stopped at, or else how its first failed node ended.
+*/
+const runEnd = (result, detail) => {
+	const kind = STATUS_KINDS[result.status];
+	const node = result.nodes.find((entry) => entry.ok === false);
+	return kind === "unknown" && node !== void 0 ? endOf({
+		ok: false,
+		output: node.output ?? {},
+		...node.error === void 0 ? {} : { error: node.error },
+		...node.end === void 0 ? {} : { end: node.end }
+	}) : endFor(kind, {}, detail);
 };
+/** A node's report as a call's result; a failing one says why. */
+const reportResult = (id, output, ok, usage, end = endFor(ok ? "done" : "reported_failure")) => endedWith({
+	ok,
+	output: {
+		...output,
+		run: id
+	},
+	usage
+}, end);
 /**
 * What the node last reported, for a caller coming back to the run: a resumed
 * run hands its kept results back with no new events, so none would come.
 */
 const storedReport = (watch, id, node) => {
 	const found = watch.store.events(id).flatMap(({ event }) => event.type === "node.finished" && event.id === node && event.ok ? [event.output] : []).at(-1);
-	return found === void 0 ? void 0 : reportResult(id, node, found, true, usageOf(watch.newCost(id)));
+	return found === void 0 ? void 0 : reportResult(id, found, true, usageOf(watch.newCost(id)));
 };
 const resultOf = (id, result, cost) => {
 	const ok = result.status === "succeeded";
 	const summary = ok ? `Run ${id} succeeded.` : `Run ${id} ended ${result.status}: ${result.reasons.join("; ")}`;
-	return {
+	return endedWith({
 		ok,
 		output: {
 			status: ok ? "pass" : "fail",
@@ -11395,9 +12342,8 @@ const resultOf = (id, result, cost) => {
 			runStatus: result.status,
 			outputs: result.outputs ?? {}
 		},
-		usage: usageOf(cost),
-		...ok ? {} : { error: summary }
-	};
+		usage: usageOf(cost)
+	}, ok ? endFor("done") : runEnd(result, summary));
 };
 /** The first thing `pick` finds in the run's events after `after`, if any. */
 const followRun = async ({ store, home }, id, after, signal, pick) => {
@@ -11420,9 +12366,12 @@ const waitForRun = async (watch, id, after, signal) => {
 	const cost = watch.newCost(id);
 	if (result !== void 0) return resultOf(id, result, cost);
 	const [run] = watch.store.lookup(id);
-	const status = run === void 0 ? "gone" : liveStatus(run);
+	const said = `Run ${id} ended without a result (${run === void 0 ? "gone" : liveStatus(run)}).`;
 	return {
-		...failure(`Run ${id} ended without a result (${status}).`),
+		...failedWith(endFor("unknown", {}, said), {
+			status: "fail",
+			summary: said
+		}),
 		usage: usageOf(cost)
 	};
 };
@@ -11431,20 +12380,34 @@ const waitForNode = async (watch, id, node, after, signal) => {
 	const seen = await followRun(watch, id, after, signal, (event) => {
 		if (event.type === "node.finished" && event.id === node) return {
 			ok: event.ok,
-			output: event.output
+			output: event.output,
+			end: endOf(event)
 		};
 		return event.type === "run.finished" ? { ended: event.result } : void 0;
 	});
 	const usage = usageOf(watch.newCost(id));
-	if (seen === void 0) return {
-		...failure(`Run ${id} ended before ${node} reported.`),
-		usage
-	};
-	if ("ended" in seen) return {
-		...failure(`${node} of run ${id} did not report: the run ended ${seen.ended.status}.`),
-		usage
-	};
-	return reportResult(id, node, seen.output, seen.ok, usage);
+	if (seen === void 0) {
+		const said = `Run ${id} ended before ${node} reported.`;
+		return {
+			...failedWith(endFor("unknown", {}, said), {
+				status: "fail",
+				summary: said
+			}),
+			usage
+		};
+	}
+	if ("ended" in seen) {
+		const said = `${node} of run ${id} did not report: the run ended ${seen.ended.status}.`;
+		const end = seen.ended.status === "succeeded" ? endFor("no_report", {}, said) : runEnd(seen.ended, said);
+		return {
+			...failedWith(end, {
+				status: "fail",
+				summary: said
+			}),
+			usage
+		};
+	}
+	return reportResult(id, seen.output, seen.ok, usage, seen.end);
 };
 // ../core/src/remote/detach.ts
 /**
@@ -11976,18 +12939,18 @@ const usageRowsOf = (run, events) => {
 	}
 	return rows;
 };
-const SOURCE$1 = `SELECT seq, at, data FROM events
+const SOURCE$2 = `SELECT seq, at, data FROM events
   WHERE run_id = ? AND (
     type IN ('run.started', 'node.started', 'node.finished')
     OR (type = 'node.event'
         AND json_extract(data, '$.event.type') IN ('session.started', 'session.finished'))
   ) ORDER BY seq`;
-const INSERT = `INSERT OR IGNORE INTO usage (
+const INSERT$1 = `INSERT OR IGNORE INTO usage (
     run_id, seq, at, project, workflow, node, template, model, driver, kind,
     round, failed, cost_usd, input_tokens, output_tokens, cache_read_tokens,
     cache_write_tokens, turns, duration_ms
   ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
-const rowsFromEvents = (db, run) => usageRowsOf(run, db.prepare(SOURCE$1).all(run.id).map((r) => ({
+const rowsFromEvents = (db, run) => usageRowsOf(run, db.prepare(SOURCE$2).all(run.id).map((r) => ({
 	seq: Number(r["seq"]),
 	at: text(r, "at"),
 	event: eventOf(text(r, "data"))
@@ -11997,7 +12960,7 @@ const writeRow = (insert, row) => {
 };
 /** Fills the ledger from the runs recorded before it existed. */
 const backfillUsage = (db) => {
-	const insert = db.prepare(INSERT);
+	const insert = db.prepare(INSERT$1);
 	for (const run of db.prepare("SELECT id, project, workflow FROM runs").all()) {
 		const rows = rowsFromEvents(db, {
 			id: text(run, "id"),
@@ -12059,7 +13022,7 @@ const alive = (row) => {
 };
 /** The ledger's queries; `recordUsage` is the store's own, called on append. */
 const usageQueries = (db) => {
-	const insert = db.prepare(INSERT);
+	const insert = db.prepare(INSERT$1);
 	const spentAll = db.prepare("SELECT COALESCE(SUM(cost_usd), 0) AS spent FROM usage WHERE at >= ?");
 	const spentHere = db.prepare("SELECT COALESCE(SUM(cost_usd), 0) AS spent FROM usage WHERE at >= ? AND project = ?");
 	const runById = db.prepare("SELECT id, project, workflow FROM runs WHERE id = ?");
@@ -12384,21 +13347,26 @@ const resumeNode = async (talk, run, request, node, signal) => {
 	const refused = await talk.resumeSession(run, node, body, signal);
 	if (refused !== null) return failure(refused);
 	const finished = store.events(run.id, from).flatMap(({ event }) => event.type === "node.event" && event.event.type === "session.finished" && event.id === node ? [event.event.outcome] : []).at(-1);
-	if (finished?.report === null || finished === void 0) return failure(`${node} ended without a report when resumed.`);
+	if (finished?.report === null || finished === void 0) {
+		const said = `${node} ended without a report when resumed.`;
+		return failedWith(endFor("no_report", {}, said), {
+			status: "fail",
+			summary: said
+		});
+	}
 	const ok = finished.report.status !== "fail";
 	const own = usageRowsOf(run, store.events(run.id)).filter((row) => row.seq > from && row.node === node).reduce((sum, row) => sum + row.costUsd, 0);
-	return {
+	return endedWith({
 		ok,
 		output: {
 			...finished.report,
 			run: run.id
 		},
-		...ok ? {} : { error: finished.report.summary },
 		usage: {
 			...finished.usage,
 			costUsd: own + talk.newCost(run.id)
 		}
-	};
+	}, endFor(ok ? "done" : "reported_failure"));
 };
 /** A later activation: as a message, or by resuming a session that has ended. */
 const continueConversation = async (talk, id, request, signal) => {
@@ -12417,7 +13385,13 @@ const continueConversation = async (talk, id, request, signal) => {
 	if (isLive()) await followRun(talk, id, lastSeq(store, id), signal, finishedRun);
 	const [run] = store.lookup(id);
 	if (run === void 0) return failure(`Run ${id} is gone.`);
-	if (signal.aborted) return failure(`Stopped while run ${id} was finishing.`);
+	if (signal.aborted) {
+		const said = `Stopped while run ${id} was finishing.`;
+		return failedWith(endFor("interrupted", {}, said), {
+			status: "fail",
+			summary: said
+		});
+	}
 	return resumeNode(talk, run, request, node, signal);
 };
 // ../core/src/remote/calls.ts
@@ -12513,7 +13487,7 @@ const createCalls = (options) => {
 	};
 	const converse = async (request, signal) => {
 		const unadopted = await adoptConversation(request, signal);
-		if (unadopted !== null) return failure(unadopted);
+		if (unadopted !== null) return startFailed(unadopted);
 		const known = conversations.get(request.callId);
 		if (known !== void 0) {
 			const done = stopOnAbort(known, signal);
@@ -12525,7 +13499,7 @@ const createCalls = (options) => {
 		}
 		const begun = await begin(request);
 		adopt.delete(request.callId);
-		if (!begun.ok) return failure(begun.error);
+		if (!begun.ok) return startFailed(begun.error);
 		const { id, after, fresh } = begun;
 		conversations.set(request.callId, id);
 		const done = stopOnAbort(id, signal);
@@ -12534,7 +13508,7 @@ const createCalls = (options) => {
 				const refused = await linkChannels(talk, id, request, signal);
 				if (refused !== null) {
 					stop(id);
-					return failure(refused);
+					return startFailed(refused);
 				}
 			}
 			if (fresh) tellInput(talk, id, request);
@@ -12550,7 +13524,7 @@ const createCalls = (options) => {
 	};
 	const callOnce = async (request, signal) => {
 		const begun = await begin(request);
-		if (!begun.ok) return failure(begun.error);
+		if (!begun.ok) return startFailed(begun.error);
 		const { id, after } = begun;
 		const done = stopOnAbort(id, signal);
 		try {
@@ -13510,6 +14484,82 @@ const projectQueries = (db) => {
 		}
 	};
 };
+// ../core/src/store/tool-cpu.ts
+const SOURCE$1 = `SELECT seq, at, data FROM events
+  WHERE run_id = ? AND (
+    type = 'run.started'
+    OR (type = 'node.event' AND json_extract(data, '$.event.type') = 'tool.result'
+        AND json_extract(data, '$.event.cpu') IS NOT NULL)
+  ) ORDER BY seq`;
+const INSERT = `INSERT OR IGNORE INTO tool_cpu (
+    run_id, seq, at, project, workflow, node, template, user_ms, system_ms
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+/** A run's tool commands' rows, from its events. */
+const rowsOf = (db, run) => {
+	const declared = /* @__PURE__ */ new Set();
+	const rows = [];
+	for (const r of db.prepare(SOURCE$1).all(run.id)) {
+		const event = eventOf(text(r, "data"));
+		if (event.type === "run.started") {
+			for (const node of event.nodes) declared.add(node.id);
+			continue;
+		}
+		if (event.type !== "node.event" || event.event.type !== "tool.result") continue;
+		const { cpu } = event.event;
+		if (cpu === void 0) continue;
+		const template = declared.has(event.id) ? void 0 : templateOf(event.id, declared);
+		rows.push({
+			runId: run.id,
+			seq: Number(r["seq"]),
+			at: text(r, "at"),
+			project: run.project,
+			workflow: run.workflow,
+			node: event.id,
+			...template === void 0 ? {} : { template },
+			userMs: cpu.userMs,
+			systemMs: cpu.systemMs
+		});
+	}
+	return rows;
+};
+const write = (db, rows) => {
+	const insert = db.prepare(INSERT);
+	for (const row of rows) insert.run(row.runId, row.seq, row.at, row.project, row.workflow, row.node, row.template ?? null, row.userMs, row.systemMs);
+};
+const runsOf = (db, sql, ...values) => db.prepare(sql).all(...values).map((run) => ({
+	id: text(run, "id"),
+	project: text(run, "project"),
+	workflow: text(run, "workflow")
+}));
+/** Fills the table from the runs recorded before it existed. */
+const backfillToolCpu = (db) => {
+	for (const run of runsOf(db, "SELECT id, project, workflow FROM runs")) write(db, rowsOf(db, run));
+};
+const toolCpuQueries = (db) => ({
+	/** Writes a run's rows; the store's own, on each timed `tool.result`. */
+	recordToolCpu: (runId) => {
+		const [run] = runsOf(db, "SELECT id, project, workflow FROM runs WHERE id = ?", runId);
+		if (run !== void 0) write(db, rowsOf(db, run));
+	},
+	toolCpu: (filter = {}) => {
+		const { sql, values } = whereOf(filter);
+		return db.prepare(`SELECT * FROM tool_cpu ${sql} ORDER BY at, run_id, seq`).all(...values).map((r) => {
+			const row = {
+				runId: text(r, "run_id"),
+				seq: Number(r["seq"]),
+				at: text(r, "at"),
+				project: text(r, "project"),
+				workflow: text(r, "workflow"),
+				node: text(r, "node"),
+				userMs: Number(r["user_ms"]),
+				systemMs: Number(r["system_ms"])
+			};
+			const template = text(r, "template");
+			if (template !== "") row.template = template;
+			return row;
+		});
+	}
+});
 // ../core/src/store/triggers.ts
 const recordOf$1 = (row) => {
 	const acceptedHash = text(row, "accepted_hash");
@@ -13587,8 +14637,8 @@ const triggerQueries = (db) => {
 };
 // ../core/src/store/queries.ts
 /**
-* Every query set on `db`; `insertFeedback` and `recordUsage` are the store's
-* own.
+* Every query set on `db`; `insertFeedback`, `recordUsage` and `recordToolCpu`
+* are the store's own.
 */
 const storeQueries = (db) => ({
 	...decisionQueries(db),
@@ -13596,6 +14646,7 @@ const storeQueries = (db) => ({
 	...feedbackQueries(db),
 	...projectQueries(db),
 	...usageQueries(db),
+	...toolCpuQueries(db),
 	...planLimitQueries(db),
 	...triggerQueries(db),
 	...draftQueries(db)
@@ -13799,7 +14850,23 @@ const MIGRATIONS = [
    ALTER TABLE runs ADD COLUMN failures_handled INTEGER;`,
 	`ALTER TABLE decisions ADD COLUMN note TEXT;`,
 	`ALTER TABLE decisions ADD COLUMN owner TEXT;`,
-	`ALTER TABLE decisions ADD COLUMN document TEXT;`
+	`ALTER TABLE decisions ADD COLUMN document TEXT;`,
+	(db) => {
+		db.exec(`CREATE TABLE tool_cpu (
+       run_id TEXT NOT NULL,
+       seq INTEGER NOT NULL,
+       at TEXT NOT NULL,
+       project TEXT NOT NULL,
+       workflow TEXT NOT NULL,
+       node TEXT NOT NULL,
+       template TEXT,
+       user_ms INTEGER NOT NULL,
+       system_ms INTEGER NOT NULL,
+       PRIMARY KEY (run_id, seq)
+     ) WITHOUT ROWID;
+     CREATE INDEX tool_cpu_by_time ON tool_cpu (at);`);
+		backfillToolCpu(db);
+	}
 ];
 const versionOf = (db) => Number(db.prepare("PRAGMA user_version").get()?.["user_version"] ?? 0);
 /**
@@ -13925,8 +14992,9 @@ const openStore = (file = storePath(), options = {}) => {
 	const allRuns = db.prepare("SELECT * FROM runs ORDER BY started_at DESC, rowid DESC LIMIT ?");
 	const projectRuns = db.prepare("SELECT * FROM runs WHERE project = ? ORDER BY started_at DESC, rowid DESC LIMIT ?");
 	const eventsAfter = db.prepare("SELECT seq, at, data FROM events WHERE run_id = ? AND seq > ? ORDER BY seq");
+	const controlEvents = db.prepare("SELECT seq, at, data FROM events WHERE run_id = ? AND type IN ('run.command', 'run.started', 'run.finished') ORDER BY seq");
 	const runNodes = db.prepare("SELECT node FROM events WHERE run_id = ? AND node IS NOT NULL GROUP BY node ORDER BY MIN(seq)");
-	const { insertFeedback, recordUsage, recordPlanLimit, ...queries } = storeQueries(db);
+	const { insertFeedback, recordUsage, recordToolCpu, recordPlanLimit, ...queries } = storeQueries(db);
 	return {
 		...queries,
 		begin: (run) => {
@@ -13953,6 +15021,7 @@ const openStore = (file = storePath(), options = {}) => {
 			insertEvent.run(runId, seq, at, event.type, nodeOf(event), JSON.stringify(event, maskReplacer));
 			if (event.type === "node.finished" && event.usage !== void 0) addCost.run(event.usage.costUsd, runId);
 			if (event.type === "node.event" && event.event.type === "session.finished") recordUsage(runId);
+			if (event.type === "node.event" && event.event.type === "tool.result" && event.event.cpu !== void 0) recordToolCpu(runId);
 			if (event.type === "node.event" && event.event.type === "plan.limit") recordPlanLimit(event.event, at);
 			if (event.type === "feedback.recorded") insertFeedback(runId, seq, at, event.node, event.feedback);
 			if (event.type === "run.finished") {
@@ -13981,12 +15050,95 @@ const openStore = (file = storePath(), options = {}) => {
 			at: text(r, "at"),
 			event: eventOf(text(r, "data"))
 		})),
+		controlEvents: (runId) => controlEvents.all(runId).map((r) => ({
+			runId,
+			seq: Number(r["seq"]),
+			at: text(r, "at"),
+			event: eventOf(text(r, "data"))
+		})),
 		nodes: (runId) => runNodes.all(runId).map((r) => text(r, "node")),
 		close: () => {
 			db.close();
 		}
 	};
 };
+// ../core/src/store/activity.ts
+/**
+* @file What each node of a run is doing, and when it started and finished,
+*   folded from the stored events so nothing new has to be recorded. The tree
+*   (view.ts) folds the events alone; this needs when they were written, and
+*   keeps a screen's one-line answer to "what is it doing" in one place.
+*/
+const LONGEST_LINE = 120;
+/**
+* The fields of a tool's input that say what it's working on, best first. Only
+* these are shown, so what else a tool was given stays in the logs.
+*/
+const TARGETS = [
+	"file_path",
+	"notebook_path",
+	"path",
+	"url",
+	"pattern",
+	"query",
+	"command"
+];
+const oneLine = (text) => {
+	const line = text.replaceAll(/\s+/gu, " ").trim();
+	return line.length > LONGEST_LINE ? `${line.slice(0, 119)}…` : line;
+};
+const toolLine = ({ name, input }) => {
+	const target = TARGETS.map((field) => input[field]).find((value) => typeof value === "string" && value.trim() !== "");
+	if (typeof target !== "string") return name;
+	return oneLine(target.startsWith(`${name} `) ? target : `${name} ${target}`);
+};
+/** What a finished node said, or why it failed. */
+const finishedNow = (ok, error, summary) => {
+	if (!ok) return error === void 0 ? void 0 : oneLine(error);
+	return typeof summary === "string" && summary.trim() !== "" ? oneLine(summary) : void 0;
+};
+/** Each node's activity, by id; a node that never started has none. */
+const runActivity = (stored) => {
+	const nodes = /* @__PURE__ */ new Map();
+	const of = (id) => {
+		const found = nodes.get(id);
+		if (found !== void 0) return found;
+		const fresh = {};
+		nodes.set(id, fresh);
+		return fresh;
+	};
+	for (const { at, event } of stored) if (event.type === "node.started") {
+		const node = of(event.id);
+		node.startedAt ??= at;
+		delete node.finishedAt;
+		delete node.now;
+	} else if (event.type === "node.event") {
+		if (event.event.type === "tool.called") of(event.id).now = toolLine(event.event);
+	} else if (event.type === "slot.waiting") of(event.id).now = oneLine(slotWaitLine(event.holders));
+	else if (event.type === "slot.taken") delete of(event.id).now;
+	else if (event.type === "decision.opened") of(event.node).now = oneLine(`Asked: ${event.question}`);
+	else if (event.type === "decision.answered") of(event.node).now = oneLine(`Answered: ${event.answer}`);
+	else if (event.type === "decision.withdrawn") delete of(event.node).now;
+	else if (event.type === "node.finished") {
+		const node = of(event.id);
+		node.finishedAt = at;
+		const now = finishedNow(event.ok, event.error, event.output["summary"]);
+		if (now === void 0) delete node.now;
+		else node.now = now;
+	}
+	return nodes;
+};
+/** The ownership tree, with what each node is doing and when it ran. */
+const activeTree = (stored) => {
+	const activity = runActivity(stored);
+	const dress = (node) => {
+		Object.assign(node, activity.get(node.id));
+		for (const child of node.children) dress(child);
+	};
+	const roots = runTree(stored.map(({ event }) => event));
+	for (const root of roots) dress(root);
+	return roots;
+};
 // ../core/src/triggers/check.ts
 /**
 * @file Checking `triggers.yaml` against the project's workflows (RFC-011):
@@ -14653,112 +15805,6 @@ const planUpgrade = (options) => {
 const RUNS_LOOKED_AT = 500;
 /** The ids of runs still running anywhere on this machine, newest first. */
 const runningRunIds = (store) => store.runs({ limit: RUNS_LOOKED_AT }).filter((run) => liveStatus(run) === "running").map((run) => run.id);
-// ../core/src/usage/quota.ts
-const WINDOWS = [
-	"day",
-	"week",
-	"month"
-];
-const FIELDS = {
-	day: "dayUsd",
-	week: "weekUsd",
-	month: "monthUsd"
-};
-/** Where a window began and when the next begins, in local time. */
-const windowOf = (window, now) => {
-	const [year, month, day] = [
-		now.getFullYear(),
-		now.getMonth(),
-		now.getDate()
-	];
-	if (window === "month") return {
-		since: new Date(year, month, 1),
-		until: new Date(year, month + 1)
-	};
-	if (window === "day") return {
-		since: new Date(year, month, day),
-		until: new Date(year, month, day + 1)
-	};
-	const monday = day - (now.getDay() + 6) % 7;
-	return {
-		since: new Date(year, month, monday),
-		until: new Date(year, month, monday + 7)
-	};
-};
-/** The caps that apply: the user's on everything, and the project's on itself. */
-const capsOf = (user, project, root) => WINDOWS.flatMap((window) => {
-	const field = FIELDS[window];
-	const everywhere = user?.[field];
-	const here = project?.[field];
-	const caps = [];
-	if (everywhere !== void 0) caps.push({
-		window,
-		capUsd: everywhere
-	});
-	if (here !== void 0 && root !== void 0) caps.push({
-		window,
-		capUsd: here,
-		project: root
-	});
-	return caps;
-});
-/** Each cap with what has been spent against it. */
-const standingOf = (store, caps, now) => caps.map((cap) => {
-	const { since, until } = windowOf(cap.window, now);
-	const spentUsd = store.spentSince(since.toISOString(), cap.project);
-	return {
-		...cap,
-		spentUsd,
-		leftUsd: cap.capUsd - spentUsd,
-		resetsAt: until.toISOString()
-	};
-});
-/** Dollars: cents, or more digits for an amount under a dollar. */
-const usd = (amount) => `$${amount.toFixed(amount > 0 && amount < 1 ? 4 : 2)}`;
-const at = (iso) => new Date(iso).toLocaleString(void 0, {
-	dateStyle: "medium",
-	timeStyle: "short"
-});
-const capReason = (spent) => `${spent.project === void 0 ? "your" : "this project's"} ${spent.window} quota of ${usd(spent.capUsd)} is spent (${usd(spent.spentUsd)}); it lifts on ${at(spent.resetsAt)}, or raise it in ${spent.project === void 0 ? "~/.ork/settings.yaml" : ".ork/project.yaml"}`;
-/** What a run or a call refused at its start says first, for its caller to read. */
-const NOT_STARTED = "Not started: ";
-/** Why a plan limit stops a run. */
-const planReason = (limit) => `your Claude plan's ${limit.window.replaceAll("_", " ")} limit was reached${limit.resetsAt === void 0 ? "" : `; it resets on ${at(limit.resetsAt)}, or use ork usage --clear-plan-limits if it has lifted`}`;
-/**
-* The windows that hold the whole account. One for a single model, such as
-* `seven_day_opus`, stops only the session it refused: other models may be
-* free.
-*/
-const ACCOUNT_WINDOWS = /* @__PURE__ */ new Set([
-	"five_hour",
-	"seven_day",
-	"overage",
-	"plan"
-]);
-/** The plan limits in force, the one that lifts last first. */
-const refusing = (limits, now) => limits.filter((limit) => limit.status === "rejected" && ACCOUNT_WINDOWS.has(limit.window) && limit.resetsAt !== void 0 && Date.parse(limit.resetsAt) > now.getTime()).toSorted((a, b) => String(b.resetsAt).localeCompare(String(a.resetsAt)));
-/** How long a report with no reset time stays worth showing. */
-const SHOWN_MS = 864e5;
-/** What the caps and the plan allow a run now. */
-const limitsNow = (store, caps, now) => {
-	const standing = standingOf(store, caps, now);
-	const [plan] = refusing(store.planLimits(), now);
-	const spent = standing.find((cap) => cap.leftUsd <= 0);
-	const blocked = plan === void 0 ? spent === void 0 ? void 0 : capReason(spent) : planReason(plan);
-	return {
-		...standing.length === 0 ? {} : { leftUsd: Math.min(...standing.map((cap) => cap.leftUsd)) },
-		...blocked === void 0 ? {} : { blocked }
-	};
-};
-/** What `ork usage` and the panel show. */
-const limitsReport = (store, { caps, problems }, now) => ({
-	problems,
-	caps: standingOf(store, caps, now),
-	plan: store.planLimits().filter((limit) => {
-		if (limit.status === "allowed") return false;
-		return (limit.resetsAt === void 0 ? Date.parse(limit.at) + SHOWN_MS : Date.parse(limit.resetsAt)) > now.getTime();
-	})
-});
 // ../core/src/usage/caps.ts
 /**
 * @file Which limits across runs apply where (RFC-007): the user's settings and
@@ -15113,6 +16159,11 @@ const commitWork = async (worktree, never, message) => {
 		};
 	}
 };
+/** A node's result once its work could not be committed: a failed `git commit`. */
+const uncommitted = (result, error) => endedWith({
+	...result,
+	ok: false
+}, endFor("command_failed", { program: "git commit" }, error));
 // ../core/src/worktree/close.ts
 const reasonOf = (options, id) => {
 	const why = options.unmerged.get(id);
@@ -15294,12 +16345,7 @@ const createWorkspace = (options) => {
 		if (work.committed) event(id, "committed", worktree);
 		if (work.error === void 0) return next;
 		unmerged.set(holder, `uncommitted: ${work.error}`);
-		const error = `could not commit its work: ${work.error}`;
-		return {
-			...next,
-			ok: false,
-			error
-		};
+		return uncommitted(next, work.error);
 	};
 	const finish = async (id, result) => {
 		const from = continued.get(id);
@@ -15355,4 +16401,4 @@ const createWorkspace = (options) => {
 		close
 	};
 };
-export { adoptedCalls as $, NodeSchema as $n, targetOf as $t, inspectProject as A, inside as An, scriptContactsOf as At, createCalls as B, newWorkflowText as Bn, mcpNotText as Bt, workflowTextHash as C, newProjectId as Cn, runTree as Ct, openStore as D, runDirOf as Dn, isItem as Dt, isNodeEvent as E, projectsHome as En, stillTheSameProcess as Et, clearGitLocalEnv as F, plainPathInside as Fn, declaredOutputOf as Ft, peerOf as G, parseWorkflow as Gn, DISCUSSIONS as Gt, endLink as H, beforeOf as Hn, FEEDBACK_KINDS as Ht, parseInputPairs as I, writePlainFile as In, PROJECT_FILE as It, flattenTree as J, EdgeInputSchema as Jn, sendPost as Jt, tellNode as K, serializeWorkflow as Kn, planPost as Kt, resolveInputs as L, skillsIn as Ln, gitRulesOf as Lt, git as M, LESSON_CAP_TOKENS as Mn, calledWorkflows as Mt, gitOk as N, estimateTokens as Nn, envReadsOf as Nt, storePath as O, shownPath as On, nestItems as Ot, lines as P, guardedBase as Pn, nodeSays as Pt, tellLiveRun as Q, settingsOf as Qn, normalizeTitle as Qt, driverRefusals as R, WorkflowEditSchema as Rn, loadProject as Rt, readProjectTriggers as S, inRepoPlace as Sn, runStatus as St, watchingPid as T, placeFor as Tn, processAlive as Tt, endLinksOf as U, programsRunBy as Un, FEEDBACK_SEVERITIES as Ut, addressOf as V, readDocument as Vn, serversIn as Vt, linkNodes as W, renderJsonSchema as Wn, FEEDBACK_TARGETS as Wt, requestPause as X, CheckReportSchema as Xn, createFeedback as Xt, requestContinue as Y, WorkflowSchema as Yn, publishPost as Yt, requestStop as Z, expandEdge as Zn, fingerprint as Zt, lateTriggers as _, createAgent as _n, EXPERIMENTS as _r, MESSAGE_LIMIT as _t, limitsNow as a, socketPath as an, timeoutMs as ar, followEvents as at, triggerStanding as b, loadAgents as bn, liveStatus as bt, usd as c, MASK as cn, integrationFor as cr, planNodeSession as ct, runningRunIds as d, planAgentMigration as dn, readyDriver as dr, parseReport as dt, evaluate as en, isClaudeNode as er, detachResume as et, runningScript as f, applySteps as fn, AGENT_TOOL_LAYOUTS as fr, reportSchemaFor as ft, parseVersion as g, toolsInUse as gn, firstLine as gr, startRun as gt, isNewer as h, toolLinks as hn, DRIVER_IDS as hr, walkSummary as ht, NOT_STARTED as i, serveRun as in, retiredDriverHint as ir, detachRun as it, removeWorktree as j, projectRootOf as jn, declaredProblem as jt, BRANCH_PREFIX as k, workflowDirOf as kn, runScope as kt, planUpgrade as l, maskReplacer as ln, PREFERRED_DRIVER as lr, namingNoDriver as lt, compareVersions as m, linkTools as mn, AGENT_DRIVERS as mr, walkChecks as mt, resolveBase as n, renderTemplate as nn, DriverSchema as nr, listKey as nt, limitsReport as o, socketRoom as on, INTEGRATIONS as or, explainWorkflowText as ot, detectInstaller as p, planMoveInto as pn, ORK_LAYOUT as pr, checkWorkflowText as pt, unlinkNodes as q, markValue as qn, runGh as qt, capsHere as r, readCondition as rn, NodeIdSchema as rr, DETACHED_ENV as rt, planReason as s, wakeRun as sn, TOOL_PREFIX as sr, explainSession as st, createWorkspace as t, parseTemplate as tn, isToolNode as tr, resumable as tt, releaseNotes as u, maskSecrets as un, driverChecks as ur, sessionDriver as ut, triggersReport as v, deleteAgent as vn, experimentsOn as vr, userMessageText as vt, takeWatchLock as w, placeFiles as wn, templateOf as wt, declaredTriggers as x, hasInRepoFiles as xn, pausedOf as xt, createWatcher as y, catalogAgent as yn, knownExperiments as yr, heldTimeout as yt, driverQueues as z, applyEdits as zn, MCP_FILE as zt };
+export { DETACHED_ENV as $, skillsIn as $n, endOf as $t, lines as A, linkTools as An, AGENT_DRIVERS as Ar, nestItems as At, linkNodes as B, placeFiles as Bn, lowerChild as Bt, openStore as C, wakeRun as Cn, TOOL_PREFIX as Cr, runStatus as Ct, removeWorktree as D, planAgentMigration as Dn, readyDriver as Dr, processAlive as Dt, inspectProject as E, maskSecrets as En, driverChecks as Er, templateOf as Et, driverQueues as F, catalogAgent as Fn, knownExperiments as Fr, failedWith as Ft, requestContinue as G, workflowDirOf as Gn, PROJECT_FILE as Gt, tellNode as H, projectsHome as Hn, envReadsOf as Ht, createCalls as I, loadAgents as In, stoppedEnd as It, tellLiveRun as J, LESSON_CAP_TOKENS as Jn, machineRulesOf as Jt, requestPause as K, inside as Kn, gitRulesOf as Kt, addressOf as L, hasInRepoFiles as Ln, calledWorkflows as Lt, parseInputPairs as M, toolsInUse as Mn, firstLine as Mr, runScope as Mt, resolveInputs as N, createAgent as Nn, EXPERIMENTS as Nr, declaredProblem as Nt, git as O, applySteps as On, AGENT_TOOL_LAYOUTS as Or, stillTheSameProcess as Ot, driverRefusals as P, deleteAgent as Pn, experimentsOn as Pr, endedWith as Pt, listKey as Q, writePlainFile as Qn, createSignals as Qt, endLink as R, inRepoPlace as Rn, slotClock as Rt, isNodeEvent as S, socketRoom as Sn, INTEGRATIONS as Sr, pausedOf as St, BRANCH_PREFIX as T, maskReplacer as Tn, PREFERRED_DRIVER as Tr, slotWaitsOf as Tt, unlinkNodes as U, runDirOf as Un, nodeSays as Ut, peerOf as V, placeFor as Vn, startAt as Vt, flattenTree as W, shownPath as Wn, declaredOutputOf as Wt, detachResume as X, guardedBase as Xn, mcpNotText as Xt, adoptedCalls as Y, estimateTokens as Yn, MCP_FILE as Yt, resumable as Z, plainPathInside as Zn, serversIn as Zt, readProjectTriggers as _, parseTemplate as _n, isToolNode as _r, startRun as _t, releaseNotes as a, FEEDBACK_SEVERITIES as an, programsRunBy as ar, planReason as at, watchingPid as b, serveRun as bn, retiredDriverHint as br, heldTimeout as bt, detectInstaller as c, planPost as cn, serializeWorkflow as cr, explainSession as ct, parseVersion as d, publishPost as dn, WorkflowSchema as dr, sessionDriver as dt, outcomeEnd as en, WorkflowEditSchema as er, detachRun as et, lateTriggers as f, createFeedback as fn, CheckReportSchema as fr, parseReport as ft, declaredTriggers as g, evaluate as gn, isClaudeNode as gr, walkSummary as gt, triggerStanding as h, targetOf as hn, NodeSchema as hr, walkChecks as ht, planUpgrade as i, FEEDBACK_KINDS as in, beforeOf as ir, limitsReport as it, clearGitLocalEnv as j, toolLinks as jn, DRIVER_IDS as jr, scriptContactsOf as jt, gitOk as k, planMoveInto as kn, ORK_LAYOUT as kr, isItem as kt, compareVersions as l, runGh as ln, markValue as lr, planNodeSession as lt, createWatcher as m, normalizeTitle as mn, settingsOf as mr, checkWorkflowText as mt, resolveBase as n, END_KINDS as nn, newWorkflowText as nr, NOT_STARTED as nt, runningRunIds as o, FEEDBACK_TARGETS as on, renderJsonSchema as or, usd as ot, triggersReport as p, fingerprint as pn, expandEdge as pr, reportSchemaFor as pt, requestStop as q, projectRootOf as qn, loadProject as qt, capsHere as r, endFor as rn, readDocument as rr, limitsNow as rt, runningScript as s, DISCUSSIONS as sn, parseWorkflow as sr, explainWorkflowText as st, createWorkspace as t, END_DETAIL_LIMIT as tn, applyEdits as tr, followEvents as tt, isNewer as u, sendPost as un, EdgeInputSchema as ur, namingNoDriver as ut, workflowTextHash as v, renderTemplate as vn, DriverSchema as vr, MESSAGE_LIMIT as vt, storePath as w, MASK as wn, integrationFor as wr, runTree as wt, activeTree as x, socketPath as xn, timeoutMs as xr, liveStatus as xt, takeWatchLock as y, readCondition as yn, NodeIdSchema as yr, userMessageText as yt, endLinksOf as z, newProjectId as zn, slotWaitLine as zt };