@krapht/ork 0.4.0 → 1.0.0-alpha.1

package/dist/{src-CGqMati3.mjs → src-hrj2h0IZ.mjs}

@@ -85,7 +85,7 @@ const sdk = {
 			name,
 			status: "warn",
 			detail: "no API key or cloud provider",
-			hint: "Set ANTHROPIC_API_KEY (or CLAUDE_CODE_USE_BEDROCK=1 / CLAUDE_CODE_USE_VERTEX=1) to use the SDK driver."
+			hint: "Set ANTHROPIC_API_KEY (or CLAUDE_CODE_USE_BEDROCK=1 / CLAUDE_CODE_USE_VERTEX=1 / CLAUDE_CODE_USE_FOUNDRY=1) to use the SDK driver."
 		});
 	}
 };
@@ -107,7 +107,10 @@ const olderThan = (text, min) => {
 	}
 	return false;
 };
-/** The registry of Claude drivers; the first is the default. */
+/**
+* The registry of Claude drivers, in the order `ork doctor` lists them. None is
+* a default: a run takes the one ready here (`ready.ts`).
+*/
 const CLAUDE_DRIVERS = [sdk, {
 	id: "cli",
 	label: "your own `claude` CLI, logged in by you",
@@ -552,7 +555,8 @@ const ClaudeLeaderNodeSchema = z.strictObject({
 	...claudeFields,
 	...notifyFields,
 	...stepFields,
-	maxWorkers: z.number().int().nonnegative().optional().describe("Cap on dynamically spawned workers.")
+	maxWorkers: z.number().int().nonnegative().optional().describe("Cap on dynamically spawned workers."),
+	questions: z.enum(["owner", "user"]).optional().describe("Who a child's ask_user goes to first: `owner` asks a fork of this leader's session, which answers when what it was given settles it or passes it on; `user` (the default) asks the person.")
 });
 const ClaudeWorkerNodeSchema = z.strictObject({
 	type: z.literal("claude.worker"),
@@ -897,6 +901,28 @@ const UserSettingsSchema = z.strictObject({
 	schemaVersion: z.literal(1),
 	quotas: QuotasSchema.optional().describe("Most to spend across every project on this machine.")
 });
+const CheckSchema = z.discriminatedUnion("type", [McpCallNodeSchema, ...TOOL_NODE_SCHEMAS]);
+const TriggerSchema = z.strictObject({
+	every: everySchema("1m").describe("How long to wait between looks, e.g. 5m. At least 1m."),
+	check: CheckSchema.optional().describe("What to look at; it reports { \"events\": [{ \"key\": \"...\", \"inputs\": { ... } }] }. Without one, the trigger starts a run every time."),
+	run: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u, "the name of a workflow in this project, not a path or a flag").describe("The workflow to start, by its name in this project."),
+	inputs: z.record(z.string(), z.string()).optional().describe("Inputs every run gets. They win over what a check reports, and aren't marked untrusted."),
+	maxRunsPerDay: z.number().int().positive().optional().describe("Most runs to start in a calendar day. Default: 10."),
+	concurrency: z.number().int().positive().optional().describe("How many of its runs may be going at once. A new key waits for the next look. Default: 1.")
+});
+const TriggersFileSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	triggers: z.record(NodeIdSchema, TriggerSchema)
+});
+/** What a check reports: each thing it found, and the run's inputs for it. */
+const CheckReportSchema = z.object({ events: z.array(z.object({
+	key: z.string().min(1),
+	inputs: z.record(z.string(), z.union([
+		z.string(),
+		z.number(),
+		z.boolean()
+	])).optional()
+})) });
 const NodeListSchema = z.union([NodeIdSchema, z.array(NodeIdSchema).min(1)]);
 /**
 * Either the shorthand `"a -> b"`, `"a -> b, c"`, `"a, b -> c"`, or the object
@@ -970,28 +996,20 @@ const markValue = (value) => {
 	const pad = line.startsWith("`") || line.endsWith("`") ? " " : "";
 	return `${fence}${pad}${line}${pad}${fence}`;
 };
-const CheckSchema = z.discriminatedUnion("type", [McpCallNodeSchema, ...TOOL_NODE_SCHEMAS]);
-const TriggerSchema = z.strictObject({
-	every: everySchema("1m").describe("How long to wait between looks, e.g. 5m. At least 1m."),
-	check: CheckSchema.optional().describe("What to look at; it reports { \"events\": [{ \"key\": \"...\", \"inputs\": { ... } }] }. Without one, the trigger starts a run every time."),
-	run: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u, "the name of a workflow in this project, not a path or a flag").describe("The workflow to start, by its name in this project."),
-	inputs: z.record(z.string(), z.string()).optional().describe("Inputs every run gets. They win over what a check reports, and aren't marked untrusted."),
-	maxRunsPerDay: z.number().int().positive().optional().describe("Most runs to start in a calendar day. Default: 10."),
-	concurrency: z.number().int().positive().optional().describe("How many of its runs may be going at once. A new key waits for the next look. Default: 1.")
-});
-const TriggersFileSchema = z.strictObject({
-	schemaVersion: z.literal(1),
-	triggers: z.record(NodeIdSchema, TriggerSchema)
-});
-/** What a check reports: each thing it found, and the run's inputs for it. */
-const CheckReportSchema = z.object({ events: z.array(z.object({
-	key: z.string().min(1),
-	inputs: z.record(z.string(), z.union([
-		z.string(),
-		z.number(),
-		z.boolean()
-	])).optional()
-})) });
+// ../schema/src/newer-version.ts
+/**
+* A file with a higher `schemaVersion` than this Ork reads was made by a newer
+* Ork: the message saying so, instead of `expected 1` and whatever else the
+* newer format holds. `null` when that is not why the file failed.
+*/
+const newerVersion = (issues, raw) => {
+	const written = raw !== null && typeof raw === "object" ? Reflect.get(raw, "schemaVersion") : void 0;
+	const issue = issues.find((found) => found.code === "invalid_value" && found.path.length === 1 && found.path[0] === "schemaVersion");
+	const [read] = issue?.code === "invalid_value" ? issue.values : [];
+	if (typeof written !== "number" || typeof read !== "number") return null;
+	if (written <= read) return null;
+	return `this file was made by a newer Ork (\`schemaVersion: ${String(written)}\`; this one reads ${String(read)}). Upgrade with \`ork upgrade\`.`;
+};
 // ../schema/src/yaml.ts
 /**
 * @file Workflow and project YAML: parsing with source positions for
@@ -1080,19 +1098,32 @@ const parseWith = (text, schema) => {
 		};
 	}
 	const result = schema.safeParse(raw);
-	if (!result.success) return {
-		ok: false,
-		locate,
-		diagnostics: result.error.issues.map((issue) => {
-			const described = describeIssue(issue, raw, toPath(issue.path));
-			return withPosition({
+	if (!result.success) {
+		const newer = newerVersion(result.error.issues, raw);
+		if (newer !== null) return {
+			ok: false,
+			locate,
+			diagnostics: [withPosition({
 				severity: "error",
-				code: `schema.${issue.code}`,
-				message: described.message,
-				path: described.path
-			}, locate);
-		})
-	};
+				code: "schema.newer_version",
+				message: newer,
+				path: ["schemaVersion"]
+			}, locate)]
+		};
+		return {
+			ok: false,
+			locate,
+			diagnostics: result.error.issues.map((issue) => {
+				const described = describeIssue(issue, raw, toPath(issue.path));
+				return withPosition({
+					severity: "error",
+					code: `schema.${issue.code}`,
+					message: described.message,
+					path: described.path
+				}, locate);
+			})
+		};
+	}
 	return {
 		ok: true,
 		data: result.data,
@@ -1171,8 +1202,8 @@ const serializeWorkflow = (workflow) => {
 };
 // ../schema/src/json-schema.ts
 /**
-* @file Renders the published JSON Schemas for workflow files, agent sidecars
-*   and project rules from the Zod models.
+* @file Renders the published JSON Schemas for workflow files, agent sidecars,
+*   project rules, user settings and triggers from the Zod models.
 */
 /** The published JSON Schema for workflow files, as formatted JSON text. */
 const renderJsonSchema = () => {
@@ -3529,6 +3560,27 @@ const writePlugin = (stack, dir, description) => {
 */
 /** Where a run's socket lives; `home` is `~` (tests pass a folder). */
 const socketPath = (runId, home = homedir()) => path.join(home, ".ork", "sockets", `${runId}.sock`);
+/** The longest run id Ork makes: a run of one node's, `node-` and 8 more. */
+const LONGEST_RUN_ID = "node-00000000";
+/**
+* The bytes a Unix socket's path may take, its ending zero left out: 104 on
+* macOS and the BSDs, 108 on Linux. `undefined` where Ork's sockets are not
+* Unix sockets.
+*/
+const SOCKET_PATH_MAX = {
+	darwin: 103,
+	freebsd: 103,
+	openbsd: 103,
+	linux: 107
+};
+/**
+* Whether every run's socket fits under this `~`. One that doesn't can't
+* listen, and the run looks at the store every second instead (L38).
+*/
+const socketRoom = (home = homedir(), platform = process.platform) => ({
+	bytes: Buffer.byteLength(socketPath(LONGEST_RUN_ID, home)),
+	max: SOCKET_PATH_MAX[platform]
+});
 /** For errors another handler already settles. */
 const ignore$1 = () => {};
 const messageOf$1 = (line) => {
@@ -4287,9 +4339,10 @@ const publishPost = (item, records, options) => {
 /**
 * @file Posting feedback about Ork to its GitHub Discussions (ADR-059) with the
 *   person's own `gh`, never a token of Ork's: the "Agent feedback" category of
-*   `mimshins/ork`, found by its slug. The category's 100 most recently updated
-*   threads are read first; one whose body carries the item's fingerprint
-*   marker gets a "+1" comment, and otherwise a new thread starts.
+*   `mimshins/ork`, found by its slug. The category's threads are read first,
+*   most recently updated first, a page at a time up to `THREADS_SEARCHED`; one
+*   whose body carries the item's fingerprint marker gets a "+1" comment, and
+*   otherwise a new thread starts.
 */
 /** Where feedback about Ork goes. */
 const DISCUSSIONS = {
@@ -4297,6 +4350,14 @@ const DISCUSSIONS = {
 	name: "ork",
 	category: "agent-feedback"
 };
+/** How many threads one read asks for: GitHub's most. */
+const THREADS_PAGE = 100;
+/**
+* How many of the category's threads are searched for the marker at most, a
+* page at a time until it is found: a duplicate thread is public, and ten reads
+* cover the category for a long while.
+*/
+const THREADS_SEARCHED = 1e3;
 /** The real `gh`, on `PATH`. */
 const runGh = (args) => new Promise((resolve) => {
 	execFile("gh", [...args], { maxBuffer: 16777216 }, (error, stdout, stderr) => {
@@ -4333,9 +4394,36 @@ const graphql = async (gh, query, vars) => {
 };
 const text$1 = (value) => typeof value === "string" ? value : "";
 const PLACE = `query($owner:String!,$name:String!,$slug:String!){repository(owner:$owner,name:$name){id discussionCategory(slug:$slug){id}}}`;
-const THREADS = `query($owner:String!,$name:String!,$cat:ID!){repository(owner:$owner,name:$name){discussions(categoryId:$cat,first:${String(100)},orderBy:{field:UPDATED_AT,direction:DESC}){nodes{id url body}}}}`;
+const THREADS = `query($owner:String!,$name:String!,$cat:ID!,$after:String){repository(owner:$owner,name:$name){discussions(categoryId:$cat,first:${String(THREADS_PAGE)},after:$after,orderBy:{field:UPDATED_AT,direction:DESC}){nodes{id url body} pageInfo{hasNextPage endCursor}}}}`;
 const CREATE = `mutation($repo:ID!,$cat:ID!,$title:String!,$body:String!){createDiscussion(input:{repositoryId:$repo,categoryId:$cat,title:$title,body:$body}){discussion{url}}}`;
 const COMMENT = `mutation($id:ID!,$body:String!){addDiscussionComment(input:{discussionId:$id,body:$body}){comment{url}}}`;
+/**
+* The category's thread whose body carries `marker`, read a page at a time,
+* most recently updated first, until it is found, the threads end, or
+* `THREADS_SEARCHED` have been read.
+*/
+const findThread = async (gh, vars, marker) => {
+	let after;
+	for (let read = 0; read < THREADS_SEARCHED; read += THREADS_PAGE) {
+		const page = await graphql(gh, THREADS, {
+			...vars,
+			...after === void 0 ? {} : { after }
+		});
+		if (!page.ok) return page;
+		const discussions = field(field(page.data, "repository"), "discussions");
+		const nodes = field(discussions, "nodes");
+		const thread = (Array.isArray(nodes) ? nodes : []).find((node) => text$1(field(node, "body")).includes(marker));
+		if (thread !== void 0) return {
+			ok: true,
+			thread
+		};
+		const info = field(discussions, "pageInfo");
+		const cursor = text$1(field(info, "endCursor"));
+		if (field(info, "hasNextPage") !== true || cursor === "") break;
+		after = cursor;
+	}
+	return { ok: true };
+};
 /** Finds where `post` goes, reading only: its thread, or the category. */
 const planPost = async (post, gh = runGh) => {
 	const where = {
@@ -4354,14 +4442,12 @@ const planPost = async (post, gh = runGh) => {
 		ok: false,
 		error: `No \`${DISCUSSIONS.category}\` category in the Discussions of \`${DISCUSSIONS.owner}/${DISCUSSIONS.name}\`.`
 	};
-	const threads = await graphql(gh, THREADS, {
+	const found = await findThread(gh, {
 		...where,
 		cat
-	});
-	if (!threads.ok) return threads;
-	const nodes = field(field(field(threads.data, "repository"), "discussions"), "nodes");
-	const marker = fingerprintMarker(post.fingerprint);
-	const thread = (Array.isArray(nodes) ? nodes : []).find((node) => text$1(field(node, "body")).includes(marker));
+	}, fingerprintMarker(post.fingerprint));
+	if (!found.ok) return found;
+	const { thread } = found;
 	return thread === void 0 ? {
 		ok: true,
 		plan: {
@@ -4648,7 +4734,11 @@ const OUTPUT_FIELDS = {
 		"count"
 	],
 	"control.router": null,
-	"human.gate": ["choice", "answeredBy"],
+	"human.gate": [
+		"choice",
+		"answeredBy",
+		"note"
+	],
 	"workflow.call": null,
 	"mcp.call": ["text", "json"]
 };
@@ -4754,6 +4844,9 @@ const ownSays = (node) => {
 			field: "choice",
 			kind: "values",
 			values: optionIds(node)
+		}, {
+			field: "note",
+			kind: "text"
 		}],
 		canFail: false,
 		canDeclare: false
@@ -5403,6 +5496,8 @@ const envOutsideEnv = (segments, path) => error("template.env", `\`${describePat
 * - The tree has no cycles;
 * - A node that sets `isolation: continue` neither owns nor is owned: it works in
 *   the worktree its input came from, outside the tree's merges.
+* - A leader's `questions:` is about its children's questions, so a leader with
+*   no `claude.leader` or `claude.worker` child can't set it.
 */
 const checkOwnership = (workflow) => {
 	const diagnostics = [];
@@ -5430,6 +5525,14 @@ const checkOwnership = (workflow) => {
 			"isolation"
 		]));
 	}
+	for (const [id, node] of Object.entries(nodes)) {
+		if (node.type !== "claude.leader" || node.questions === void 0) continue;
+		if (!Object.values(nodes).some((other) => other.parent === id && (other.type === "claude.leader" || other.type === "claude.worker"))) diagnostics.push(error("questions.no-children", `\`${id}\` sets \`questions\`, but owns no \`claude.leader\` or \`claude.worker\` whose questions it could take`, [
+			"nodes",
+			id,
+			"questions"
+		]));
+	}
 	const reported = /* @__PURE__ */ new Set();
 	for (const start of Object.keys(nodes)) {
 		const seen = [];
@@ -5904,7 +6007,15 @@ const checkCallTargets = (workflow, own, registered) => Object.entries(workflow.
 */
 /** A `maxRounds` edge. Removing them leaves a DAG (the compiler checks it). */
 const isLoopEdge = (edge) => edge.maxRounds !== void 0;
-const edgeKey = (edge) => `${String(edge.source)}:${edge.from}->${edge.to}`;
+const keys = /* @__PURE__ */ new WeakMap();
+const edgeKey = (edge) => {
+	let key = keys.get(edge);
+	if (key === void 0) {
+		key = `${String(edge.source)}:${edge.from}->${edge.to}`;
+		keys.set(edge, key);
+	}
+	return key;
+};
 /**
 * Decides every outgoing edge of a finished node. An edge with `when:` is taken
 * when its condition holds for the node's output; one without is taken when the
@@ -5942,21 +6053,58 @@ const joinOutput = (edges, resolved) => {
 		count: ran.length
 	};
 };
+/** How a reason for a run that was left waiting starts: a bug in Ork. */
+const STUCK_REASON = "ork engine error:";
+/**
+* Why a run that was left waiting fails: a node neither ran nor was skipped
+* while an edge could still reach it. The scheduler resolves every edge whose
+* source can't run any more, so only a bug in Ork leaves one.
+*/
+const stuckReason = (waiting) => `${STUCK_REASON} ${waiting.map(({ id, waitingOn }) => `${id} was still waiting on ${waitingOn.join(", ")}`).join("; ")} with nothing left to run; this is a bug in Ork, not in the workflow`;
+/** Each node's place along the non-loop edges, sources first. */
+const orderOf = (graph) => {
+	const order = /* @__PURE__ */ new Map();
+	const left = /* @__PURE__ */ new Map();
+	for (const [id, compiled] of graph.nodes) left.set(id, compiled.incoming.filter((e) => !isLoopEdge(e)).length);
+	const ready = [...left].filter(([, count]) => count === 0).map(([id]) => id);
+	for (let id = ready.shift(); id !== void 0; id = ready.shift()) {
+		order.set(id, order.size);
+		for (const edge of graph.nodes.get(id)?.outgoing ?? []) {
+			if (isLoopEdge(edge)) continue;
+			const count = (left.get(edge.to) ?? 0) - 1;
+			left.set(edge.to, count);
+			if (count === 0) ready.push(edge.to);
+		}
+	}
+	return order;
+};
 /**
-* Tracks, per target, which incoming non-loop edges have resolved since the
-* target last ran or was skipped.
+* Tracks, per target, which incoming non-loop edges have resolved in its
+* current round: since every one last resolved.
 *
-* - A node runs when any incoming edge is taken, and is skipped once every
+* - A node runs each time an incoming edge is taken, and is skipped once every
 *   incoming non-loop edge has resolved as not taken (dead-path elimination),
 *   so nothing downstream waits on a branch that will never run.
 * - A `control.join` waits: `all` until every input resolved, `any` for the first
 *   that ran, `n` for `n` that ran. A join none of whose required inputs ran is
 *   skipped.
+* - An edge whose source can't run any more counts as not taken (`stranded`): in
+*   a later round, a branch the loop doesn't go back to never runs again.
 */
 const createInbox = (graph) => {
 	const resolved = /* @__PURE__ */ new Map();
+	/** Targets that ran, or joins that fired, in their current round. */
 	const fired = /* @__PURE__ */ new Set();
-	const forwardIn = (id) => (graph.nodes.get(id)?.incoming ?? []).filter((e) => !isLoopEdge(e));
+	let order;
+	const forwards = /* @__PURE__ */ new Map();
+	const forwardIn = (id) => {
+		let edges = forwards.get(id);
+		if (edges === void 0) {
+			edges = (graph.nodes.get(id)?.incoming ?? []).filter((e) => !isLoopEdge(e));
+			forwards.set(id, edges);
+		}
+		return edges;
+	};
 	const reset = (id) => {
 		resolved.delete(id);
 		fired.delete(id);
@@ -5994,30 +6142,69 @@ const createInbox = (graph) => {
 	/** Records that `edge` resolved, and says what happens at its target. */
 	const arrive = (edge, taken, output) => {
 		const id = edge.to;
-		const isJoin = graph.nodes.get(id)?.node.type === "control.join";
-		if (!isJoin && taken) {
-			reset(id);
-			return {
-				kind: "activate",
-				input: output
-			};
-		}
 		const seen = resolved.get(id) ?? /* @__PURE__ */ new Map();
 		resolved.set(id, seen);
 		seen.set(edgeKey(edge), {
 			taken,
 			output
 		});
-		if (isJoin) return arriveAtJoin(id, seen);
-		const inputs = forwardIn(id);
-		const allDead = inputs.every((e) => seen.get(edgeKey(e))?.taken === false);
-		if (inputs.length > 0 && allDead) {
-			reset(id);
-			return { kind: "skip" };
-		}
-		return { kind: "wait" };
+		if (graph.nodes.get(id)?.node.type === "control.join") return arriveAtJoin(id, seen);
+		const complete = forwardIn(id).every((e) => seen.has(edgeKey(e)));
+		const ran = taken || fired.has(id);
+		if (complete) reset(id);
+		else if (taken) fired.add(id);
+		if (taken) return {
+			kind: "activate",
+			input: output
+		};
+		return complete && !ran ? { kind: "skip" } : { kind: "wait" };
+	};
+	/** The edges a target still waits on. */
+	const missingOf = (id, seen) => forwardIn(id).filter((e) => !seen.has(edgeKey(e)));
+	/**
+	* The first target, in graph order, whose every edge still to resolve comes
+	* from a node that can't run any more: neither `active` (queued or running)
+	* nor after one along the non-loop edges. A loop's edge starts a new round,
+	* so it doesn't count. Its edges count as not taken; the caller delivers
+	* them, and asks again, as that can start something.
+	*/
+	const stranded = (active) => {
+		const candidates = [...resolved].map(([id, seen]) => ({
+			id,
+			missing: missingOf(id, seen)
+		})).filter(({ missing }) => !missing.some((e) => active(e.from)));
+		if (candidates.length === 0) return [];
+		/** Nodes known to be unable to run, in this call. */
+		const dead = /* @__PURE__ */ new Set();
+		const canRun = (from) => {
+			const visited = /* @__PURE__ */ new Set([from]);
+			const stack = [from];
+			for (let id = stack.pop(); id !== void 0; id = stack.pop()) {
+				if (active(id)) return true;
+				for (const edge of forwardIn(id)) {
+					if (visited.has(edge.from) || dead.has(edge.from)) continue;
+					visited.add(edge.from);
+					stack.push(edge.from);
+				}
+			}
+			for (const id of visited) dead.add(id);
+			return false;
+		};
+		order ??= orderOf(graph);
+		const known = order;
+		const place = (id) => known.get(id) ?? Infinity;
+		return candidates.filter(({ missing }) => !missing.some((e) => canRun(e.from))).toSorted((a, b) => place(a.id) - place(b.id))[0]?.missing ?? [];
+	};
+	/** Targets an edge reached that still wait on others. */
+	const waiting = () => [...resolved].map(([id, seen]) => ({
+		id,
+		waitingOn: [...new Set(missingOf(id, seen).map((e) => e.from))]
+	}));
+	return {
+		arrive,
+		stranded,
+		waiting
 	};
-	return { arrive };
 };
 // ../core/src/run/escalation.ts
 const LOOP_CHOICES = {
@@ -6202,6 +6389,125 @@ const createOwnership = (hooks) => {
 		spawn
 	};
 };
+// ../core/src/run/scope.ts
+/**
+* @file A run's id and folder, and the scope templates and `when:` conditions
+*   read during it.
+*/
+/** 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)
+	};
+};
+/**
+* The folders every node of a run reads from: the workflow's, the project's,
+* Ork's.
+*/
+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) => {
+	const scope = {
+		inputs,
+		nodes: Object.fromEntries(Object.entries(outputs).map(([id, output]) => [id, { output }]))
+	};
+	if (runId !== void 0) scope.run = { id: runId };
+	return scope;
+};
+// ../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,
+		round,
+		cwd,
+		runDir: deps.runDir,
+		...foldersOf(options),
+		budgetLeftUsd: deps.spend.left(),
+		budgetLeftNow: deps.spend.budgetLeft,
+		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);
+			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;
+	if (activation.brief !== void 0) context.brief = activation.brief;
+	const resume = options.replay?.cutOff?.(activation) ?? resumeOf(deps.nodeOf(activation), deps.sessionIds.get(id));
+	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),
+		lend: deps.slots.release,
+		reclaim: deps.slots.take
+	});
+	return context;
+};
+/** 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
+		});
+	}
+});
+/**
+* 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;
+};
 // ../core/src/usage/spend.ts
 /** What a report would add to the session's earlier ones, counting nothing. */
 const unreported = (reported, key, total) => {
@@ -6224,11 +6530,13 @@ const ownSpend = (reported, key, total) => {
 * 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.
+* 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") {
@@ -6239,7 +6547,11 @@ const earlierSpend = (events) => {
 	} else if (event.type === "node.event" && event.event.type === "session.finished") {
 		const { sessionId, usage } = event.event.outcome;
 		const key = `${event.id}/${sessionId}`;
-		if (open.has(event.id)) open.set(event.id, {
+		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
 		});
@@ -6247,12 +6559,13 @@ const earlierSpend = (events) => {
 	}
 	return {
 		total,
-		reported
+		reported,
+		forks
 	};
 };
 // ../core/src/run/contacts.ts
-const SESSION_TYPES$3 = /* @__PURE__ */ new Set(["claude.leader", "claude.worker"]);
-const isSession = (node) => SESSION_TYPES$3.has(node?.type ?? "");
+const SESSION_TYPES$4 = /* @__PURE__ */ new Set(["claude.leader", "claude.worker"]);
+const isSession = (node) => SESSION_TYPES$4.has(node?.type ?? "");
 const isTool = (node) => node?.type.startsWith("tool.") ?? false;
 const channelPeersOf = (id, channels) => channels.flatMap(([a, b]) => {
 	if (a === id) return [b];
@@ -6285,12 +6598,6 @@ const scriptContactsOf = (id, nodes, channels) => {
 /** 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/run/results.ts
-/**
-* @file Small helpers for the scheduler's results: pass-through and failure
-*   results, run-summary entries, what a run has spent, `node.finished` events,
-*   the declared nodes `run.started` lists, which session a re-run node
-*   resumes, and closing the workspace at the end.
-*/
 /** Control nodes pass their input through; a join's input is its output. */
 const passThrough = (input) => ({
 	output: input ?? {},
@@ -6416,6 +6723,16 @@ const summaryOf = (summaries, id) => {
 	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);
@@ -6439,7 +6756,19 @@ const runStartedEvent = (graph, runId, options) => ({
 	...options.settings === void 0 ? {} : { settings: options.settings },
 	...runBudget(graph, options.settings)
 });
-/** The run's result: failed when any reason was given, unless it stopped. */
+/** 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"),
@@ -6447,7 +6776,10 @@ const runResult = (run) => ({
 	nodes: run.nodes,
 	reasons: run.reasons,
 	worktrees: run.worktrees,
-	...run.outputs === void 0 ? {} : { outputs: run.outputs }
+	...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]) => {
@@ -6459,95 +6791,6 @@ const closeWorkspace = (workspace, reasons) => (workspace?.close() ?? Promise.re
 	reasons.push(`cleaning up worktrees: ${String(error)}`);
 	return [];
 });
-/**
-* 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;
-};
-// ../core/src/run/scope.ts
-/**
-* @file A run's id and folder, and the scope templates and `when:` conditions
-*   read during it.
-*/
-/** 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)
-	};
-};
-/**
-* The folders every node of a run reads from: the workflow's, the project's,
-* Ork's.
-*/
-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) => {
-	const scope = {
-		inputs,
-		nodes: Object.fromEntries(Object.entries(outputs).map(([id, output]) => [id, { output }]))
-	};
-	if (runId !== void 0) scope.run = { id: runId };
-	return scope;
-};
-// ../core/src/run/context.ts
-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,
-		round,
-		cwd,
-		runDir: deps.runDir,
-		...foldersOf(options),
-		budgetLeftUsd: deps.spend.left(),
-		budgetLeftNow: deps.spend.budgetLeft,
-		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) => {
-			options.onEvent({
-				type: "node.event",
-				id,
-				event
-			});
-		},
-		signal: deps.stops.signalFor(id, template)
-	};
-	if (template !== void 0) context.template = template;
-	if (activation.brief !== void 0) context.brief = activation.brief;
-	const resume = options.replay?.cutOff?.(activation) ?? resumeOf(deps.nodeOf(activation), deps.sessionIds.get(id));
-	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),
-		lend: deps.slots.release,
-		reclaim: deps.slots.take
-	});
-	return context;
-};
 // ../core/src/run/holds.ts
 const createHolds = (options) => {
 	let paused = false;
@@ -6778,7 +7021,8 @@ const createClock = (options) => {
 		/** The same channel, noting who waits on the user for how long. */
 		human: (channel) => ({
 			permit: (request) => asking(request.nodeId, () => channel.permit(request)),
-			ask: (question) => asking(question.nodeId, () => channel.ask(question))
+			ask: (question) => asking(question.nodeId, () => channel.ask(question)),
+			...channel.settled === void 0 ? {} : { settled: channel.settled }
 		}),
 		/** Stands still while the node, or a node it owns, waits on the user. */
 		forNode: (id) => ({
@@ -7128,7 +7372,7 @@ const createOwnerQuestions = ({ ownerOf, deliverTo, onEvent }) => {
 			deliver(ownerQuestionText(id, node, question));
 			return promise;
 		},
-		answer: (id, question, choice) => {
+		answer: (id, question, choice, note) => {
 			const asked = open.get(question);
 			if (asked?.owner !== id) return {
 				ok: false,
@@ -7139,11 +7383,13 @@ const createOwnerQuestions = ({ ownerOf, deliverTo, onEvent }) => {
 				error: `\`${choice}\` is not an option: ${asked.options.map((o) => o.id).join(", ")}`
 			};
 			open.delete(question);
+			const said = note?.trim() ?? "";
 			onEvent({
 				type: "owner.answered",
 				node: id,
 				question,
-				answer: choice
+				answer: choice,
+				...said === "" ? {} : { note: said }
 			});
 			asked.resolve(choice);
 			return { ok: true };
@@ -7164,7 +7410,7 @@ const createOwnerQuestions = ({ ownerOf, deliverTo, onEvent }) => {
 	};
 };
 // ../core/src/run/bus.ts
-const SESSION_TYPES$2 = /* @__PURE__ */ new Set(["claude.leader", "claude.worker"]);
+const SESSION_TYPES$3 = /* @__PURE__ */ new Set(["claude.leader", "claude.worker"]);
 const createBus = ({ graph, onEvent, mail, relay, slots }) => {
 	/** Spawned instance -> the declared node it is an instance of. */
 	const templates = /* @__PURE__ */ new Map();
@@ -7183,7 +7429,7 @@ const createBus = ({ graph, onEvent, mail, relay, slots }) => {
 	/** Sessions in `wait`: called when a message arrives or the session ends. */
 	const waiters = /* @__PURE__ */ new Map();
 	const declared = (id) => graph.nodes.get(templates.get(id) ?? id);
-	const hasSession = (id) => SESSION_TYPES$2.has(graph.nodes.get(id)?.node.type ?? "");
+	const hasSession = (id) => SESSION_TYPES$3.has(graph.nodes.get(id)?.node.type ?? "");
 	const inbox = (id) => {
 		const existing = inboxes.get(id);
 		if (existing !== void 0) return existing;
@@ -7288,7 +7534,7 @@ const createBus = ({ graph, onEvent, mail, relay, slots }) => {
 				});
 				return unread;
 			},
-			answer: (question, choice) => questions.answer(id, question, choice),
+			answer: (question, choice, note) => questions.answer(id, question, choice, note),
 			connect: (deliver) => {
 				live.set(id, deliver);
 				for (const body of waiting.get(id) ?? []) deliver(userMessageText(body));
@@ -7353,6 +7599,11 @@ const createBus = ({ graph, onEvent, mail, relay, slots }) => {
 				via: "rule"
 			});
 			land(to);
+		},
+		unread: () => {
+			const counts = /* @__PURE__ */ new Map();
+			for (const [id, unread] of [...inboxes, ...waiting]) counts.set(id, (counts.get(id) ?? 0) + unread.length);
+			return new Map([...counts].filter(([, count]) => count > 0));
 		}
 	};
 };
@@ -7365,7 +7616,7 @@ const createBus = ({ graph, onEvent, mail, relay, slots }) => {
 *   notice when it is released; a node's claims are released when it finishes.
 *   Claims are advisory: they steer agents, they do not lock files.
 */
-const SESSION_TYPES$1 = /* @__PURE__ */ new Set(["claude.leader", "claude.worker"]);
+const SESSION_TYPES$2 = /* @__PURE__ */ new Set(["claude.leader", "claude.worker"]);
 const WHOLE = ".";
 /**
 * A resource as the run compares it: a path from the project root (an absolute
@@ -7390,7 +7641,7 @@ const writersOf = (graph) => {
 	const isolation = graph.workflow.defaults?.isolation ?? "worktree";
 	const writers = /* @__PURE__ */ new Set();
 	for (const [id, { node }] of graph.nodes) {
-		if (!SESSION_TYPES$1.has(node.type)) continue;
+		if (!SESSION_TYPES$2.has(node.type)) continue;
 		if ("isolation" in node && (node.isolation ?? isolation) === "readonly") continue;
 		writers.add(id);
 	}
@@ -7485,6 +7736,55 @@ const createClaims = ({ graph, onEvent, notify }) => {
 		releaseAll
 	};
 };
+// ../core/src/run/owners.ts
+/** The node types whose sessions can ask (`ask_user`). */
+const ASKING = /* @__PURE__ */ new Set(["claude.leader", "claude.worker"]);
+const createOwners = (graph) => {
+	const sessions = /* @__PURE__ */ new Map();
+	/** The leader that takes `id`'s questions first, if one does. */
+	const ownerOf = (id, template) => {
+		const node = graph.nodes.get(template ?? id)?.node;
+		if (node?.parent === void 0 || !ASKING.has(node.type)) return void 0;
+		const owner = graph.nodes.get(node.parent)?.node;
+		return owner?.type === "claude.leader" && owner.questions === "owner" ? node.parent : void 0;
+	};
+	return {
+		/** Notes `id`'s own sessions as they start and end; forks aren't its own. */
+		seen: (id, event, cwd) => {
+			if (event.type === "session.started" && event.fork !== true) sessions.set(id, {
+				sessionId: event.sessionId,
+				cwd: event.cwd ?? cwd,
+				model: event.model,
+				...event.driver === void 0 ? {} : { driver: event.driver }
+			});
+			const last = sessions.get(id);
+			if (event.type === "session.finished" && event.fork !== true && last !== void 0 && event.outcome.sessionId !== "") sessions.set(id, {
+				...last,
+				sessionId: event.outcome.sessionId
+			});
+		},
+		/**
+		* The port for `id`'s questions, or `undefined` when they go straight to
+		* the person. `charge` counts a fork's spend; `emit` records an event as a
+		* node's.
+		*/
+		portFor: (id, template, hooks) => {
+			const owner = ownerOf(id, template);
+			if (owner === void 0) return void 0;
+			return {
+				id: owner,
+				session: () => sessions.get(owner),
+				budgetLeftUsd: hooks.budgetLeftUsd,
+				charge: (sessionId, usage) => {
+					hooks.charge(owner, sessionId, usage);
+				},
+				emit: (event) => {
+					hooks.emit(owner, event);
+				}
+			};
+		}
+	};
+};
 // ../core/src/run/rules.ts
 /**
 * @file Firing a finished node's `notify:` rules (RFC-005). A rule sends
@@ -7570,8 +7870,17 @@ const createRunPorts = ({ options, slots, scope, stopping }) => {
 		onEvent
 	});
 	const send = bus.rule;
+	const rules = createRules({
+		graph,
+		send,
+		scope,
+		stopping,
+		scrub
+	});
 	return {
 		bus,
+		/** Each node's latest session, and whose questions go to a leader first. */
+		owners: createOwners(graph),
 		/** One activation's ports; `template` is a spawned worker's node. */
 		forNode: (id, template, cwd) => ({
 			mailbox: bus.mailbox(id, template),
@@ -7579,13 +7888,7 @@ const createRunPorts = ({ options, slots, scope, stopping }) => {
 			feedback: feedback.port(id, template)
 		}),
 		/** Sends what a node's fresh result declares (`notify:`). */
-		fireRules: createRules({
-			graph,
-			send,
-			scope,
-			stopping,
-			scrub
-		}).fire,
+		fireRules: rules.fire,
 		/** The activation of `id` ended: its claims are released. */
 		finished: (id) => {
 			claims.releaseAll(id);
@@ -7596,6 +7899,11 @@ const createRunPorts = ({ options, slots, scope, stopping }) => {
 const createRouter = (options) => {
 	const { graph, onEvent } = options;
 	const inbox = createInbox(graph);
+	/** Failed results with an edge taken: the run went on (G8, L42). */
+	let handled = 0;
+	/** How many activations of each node are queued, running or routing. */
+	const active = /* @__PURE__ */ new Map();
+	const isActive = (id) => active.has(id);
 	const skip = (id) => {
 		options.skipped(id);
 		onEvent({
@@ -7625,9 +7933,51 @@ const createRouter = (options) => {
 				if (taken) anyTaken = true;
 			}
 		}
-		if (!result.ok && !anyTaken) options.failed(`${id}: ${result.error ?? "failed"}`);
+		if (result.ok) return;
+		if (anyTaken) handled += 1;
+		else options.failed(`${id}: ${result.error ?? "failed"}`);
+	};
+	/** An activation of `id` is queued; it is active until `done`. */
+	const queued = (id) => {
+		active.set(id, (active.get(id) ?? 0) + 1);
+	};
+	/** An activation of `id` has run and routed, or never will. */
+	const done = (id) => {
+		const count = (active.get(id) ?? 0) - 1;
+		if (count > 0) active.set(id, count);
+		else active.delete(id);
+	};
+	/**
+	* Resolves as not taken each edge whose source can't run any more, given what
+	* is active (queued, running or routing), so a node fed only by branches that
+	* didn't run in this round is skipped, and a join waiting on one fires. One
+	* target at a time, in graph order, as each can start something.
+	*/
+	const resolveStranded = () => {
+		for (let edges = inbox.stranded(isActive); edges.length > 0 && !options.stopped(); edges = inbox.stranded(isActive)) for (const edge of edges) deliver(edge, false, {});
+	};
+	/**
+	* Routes a finished activation unless the run has stopped, then resolves as
+	* not taken what can't run any more in this round.
+	*/
+	const finished = async (id, result) => {
+		if (!options.stopped()) await route(id, result);
+		done(id);
+		if (!options.stopped()) resolveStranded();
+	};
+	/** Why the run fails if a node still waits with nothing left to run. */
+	const stuck = () => {
+		const waiting = inbox.waiting();
+		return waiting.length === 0 ? [] : [stuckReason(waiting)];
+	};
+	return {
+		route,
+		finished,
+		queued,
+		done,
+		stuck,
+		handled: () => handled
 	};
-	return { route };
 };
 // ../core/src/run/slots.ts
 /**
@@ -7676,7 +8026,7 @@ const startRun = (options) => {
 	const sessionIds = /* @__PURE__ */ new Map();
 	const spend = spendOf(limits.budgetUsd, options);
 	const running = /* @__PURE__ */ new Set();
-	const summaries = /* @__PURE__ */ new Map();
+	const { summaries, summary } = createSummaries(options.replay?.earlier);
 	const queue = [];
 	const reasons = [];
 	const stops = createStops(abort.signal);
@@ -7688,7 +8038,6 @@ const startRun = (options) => {
 		pump();
 	});
 	const scope = () => runScope(options.inputs, outputs, runId);
-	const summary = (id) => summaryOf(summaries, id);
 	const nodeOf = (activation) => graph.nodes.get(activation.template ?? activation.id)?.node;
 	const stop = (status, reason) => {
 		if (stopped !== null) return;
@@ -7697,7 +8046,9 @@ const startRun = (options) => {
 		queue.length = 0;
 	};
 	const enqueue = (id, input) => {
-		if (stopped === null) queue.push({
+		if (stopped !== null) return;
+		router.queued(id);
+		queue.push({
 			id,
 			input
 		});
@@ -7738,12 +8089,8 @@ const startRun = (options) => {
 		activate: enqueue,
 		takeLoop: loops.take,
 		stopped: () => stopped !== null,
-		skipped: (id) => {
-			summary(id);
-		},
-		failed: (reason) => {
-			reasons.push(reason);
-		}
+		skipped: (id) => void summary(id),
+		failed: (reason) => void reasons.push(reason)
 	});
 	const cancelTimeout = watchRunTimeout({
 		timeout: limits.timeout,
@@ -7764,15 +8111,16 @@ const startRun = (options) => {
 		cancelTimeout();
 		const worktrees = await closeWorkspace(options.workspace, reasons);
 		await options.beforeFinish?.();
-		const nodes = [...summaries.values()];
 		const result = runResult({
 			runId,
 			stopped,
 			costUsd: spend.total(),
-			nodes,
+			nodes: [...summaries.values()],
 			reasons,
 			worktrees,
-			outputs: renderOutputs(graph.workflow.outputs, scope())
+			outputs: renderOutputs(graph.workflow.outputs, scope()),
+			failuresHandled: router.handled(),
+			unread: ports.bus.unread()
 		});
 		onEvent({
 			type: "run.finished",
@@ -7782,6 +8130,7 @@ const startRun = (options) => {
 	};
 	const settle = () => {
 		if (settled || busy > 0 || queue.length > 0) return;
+		if (stopped === null) reasons.push(...router.stuck());
 		settled = true;
 		close();
 	};
@@ -7823,7 +8172,8 @@ const startRun = (options) => {
 			slots,
 			nodeOf,
 			runChild,
-			spend
+			spend,
+			summary
 		},
 		clock,
 		graceMs,
@@ -7859,7 +8209,7 @@ const startRun = (options) => {
 	const run = async (activation, isSession) => {
 		const result = await perform(activation);
 		if (isSession) slots.release();
-		if (stopped === null) await router.route(activation.id, result);
+		await router.finished(activation.id, result);
 		busy -= 1;
 		pump();
 	};
@@ -7889,10 +8239,7 @@ const startRun = (options) => {
 		settle();
 	};
 	onEvent(runStartedEvent(graph, runId, options));
-	for (const id of graph.entries) queue.push({
-		id,
-		input: void 0
-	});
+	for (const id of graph.entries) enqueue(id);
 	queueMicrotask(pump);
 	return {
 		runId,
@@ -8051,6 +8398,8 @@ const walkFindings = (graph, tally) => {
 	const onlyRounds = graph.edges.filter((edge) => edge.maxRounds !== void 0 && behind(graph, [edge.to]).has(edge.from) && tally.entered.has(linkOf(edge)) && !tally.left.has(linkOf(edge)) && !anyBehind(graph, edge.from, hidden) && !said.has(edge.source)).map((edge) => warning("walk.only-rounds", `every way the walk tried through the loop \`${linkOf(edge)}\` ran out of rounds`, ["edges", edge.source]));
 	return [...neverRuns, ...onlyRounds];
 };
+/** Whether a run ended with a node still waiting, which only a bug causes. */
+const leftWaiting = (result) => result.reasons.some((reason) => reason.startsWith(STUCK_REASON));
 /** A path that never settled, which only a bug in the scheduler can cause. */
 const unfinished = (choices) => warning("walk.unfinished", `the walk got stuck on one way through this workflow${choices.length === 0 ? "" : ` (${choices.map((choice) => `\`${choice}\``).join(", ")})`}. This is a bug in Ork, not in the workflow`, []);
 // ../core/src/run/walk-reads.ts
@@ -8620,7 +8969,8 @@ const walkWorkflow = async (graph, options = {}) => {
 		if (result === null) {
 			handle.interrupt();
 			stuck = path.said;
-		} else if (path.overran()) overran = true;
+		} else if (leftWaiting(result)) stuck = path.said;
+		else if (path.overran()) overran = true;
 		else {
 			counts.paths += 1;
 			const succeeded = result.status === "succeeded";
@@ -9153,6 +9503,20 @@ const subagentsOf = (workflow, owner, inputs, outputs = {}) => {
 	});
 	return entries.length === 0 ? void 0 : Object.fromEntries(entries);
 };
+// ../core/src/run/driver.ts
+/** The node types that start a session of their own, and so need a driver. */
+const SESSION_TYPES$1 = /* @__PURE__ */ new Set(["claude.leader", "claude.worker"]);
+/** The driver a workflow names for a node, if it names one. */
+const namedDriver = (node, workflow) => ("driver" in node ? node.driver : void 0) ?? workflow.defaults?.driver;
+/** The session nodes that name no driver, which take the one ready here. */
+const namingNoDriver = (workflow) => Object.entries(workflow.nodes).filter(([, node]) => SESSION_TYPES$1.has(node.type) && namedDriver(node, workflow) === void 0).map(([id]) => id);
+/**
+* The driver a session runs on: `override` (`--driver`), else what the workflow
+* names, else `ready`, the driver the run found ready when it started (and
+* recorded, for a resume). `undefined` only when none applies, which a run
+* refuses before it starts.
+*/
+const sessionDriver = (choice) => choice.override ?? choice.named ?? choice.ready;
 // ../core/src/run/harness.ts
 const CLAIMS_LINE = "- Other nodes may change this project at the same time. Before you edit a file or folder, `claim` it (a path from the project root); if someone holds it, work on something else or ask them. `release` what you are done with; Ork releases the rest when you finish.";
 const HANDOFF = {
@@ -9328,6 +9692,7 @@ const planNodeSession = (workflow, id, options) => {
 		permissionMode: "default",
 		reportSchema: reportSchemaFor(node)
 	};
+	if (node.type === "claude.leader") spec.promptCache = "1h";
 	const agents = subagentsOf(workflow, declared, options.inputs, options.outputs);
 	if (agents !== void 0) {
 		spec.agents = agents;
@@ -9348,7 +9713,7 @@ const planNodeSession = (workflow, id, options) => {
 	return {
 		ok: true,
 		spec,
-		driver: node.driver ?? defaults.driver ?? "sdk",
+		driver: namedDriver(node, workflow),
 		warnings,
 		context
 	};
@@ -9846,7 +10211,7 @@ const resumeState = (events) => {
 		if (event.type === "node.event") {
 			const inner = event.event;
 			const current = open.get(event.id);
-			if (current === void 0) continue;
+			if (current === void 0 || inner.fork === true) continue;
 			if (inner.type === "session.started") current.sessionId = inner.sessionId;
 			if (inner.type === "session.finished" && inner.outcome.sessionId) current.sessionId = inner.outcome.sessionId;
 			continue;
@@ -9990,6 +10355,7 @@ const replayLoopAnswers = (human, answers) => {
 	const left = [...answers];
 	return {
 		permit: (request) => human.permit(request),
+		...human.settled === void 0 ? {} : { settled: human.settled },
 		ask: (question) => {
 			const index = left.findIndex((a) => a.question === question.question);
 			const [given] = index === -1 ? [] : left.splice(index, 1);
@@ -10079,7 +10445,7 @@ const adoptedCalls = (store, runId) => {
 	return adopted;
 };
 /** What the called run's own `limits.budgetUsd` is capped to, and so on. */
-const argsOf = (file, id, caller, request) => [
+const argsOf = (file, id, caller, request, machineClaude) => [
 	"run",
 	file,
 	"--run-id",
@@ -10088,7 +10454,8 @@ const argsOf = (file, id, caller, request) => [
 	caller,
 	...Object.entries(request.inputs).flatMap(([name, value]) => ["--input", `${name}=${value}`]),
 	...request.budgetLeftUsd === void 0 ? [] : ["--budget-cap", String(request.budgetLeftUsd)],
-	...request.ref === void 0 ? [] : ["--base-ref", request.ref]
+	...request.ref === void 0 ? [] : ["--base-ref", request.ref],
+	...machineClaude ? ["--machine-claude"] : []
 ];
 /** Why the target's `calls.accept` shuts this project out, or `null`. */
 const notAccepted = (options, request, target) => {
@@ -10132,7 +10499,7 @@ const startCall = async (options, request) => {
 	const detached = await (options.detach ?? detachRun)({
 		store,
 		runId: id,
-		args: argsOf(file, id, `${runId}/${request.callId}`, request),
+		args: argsOf(file, id, `${runId}/${request.callId}`, request, options.machineClaude === true),
 		cwd: target.root,
 		runDir: runDirOf(target, id),
 		env: options.env
@@ -10396,6 +10763,11 @@ const notRunning = (run) => {
 	const status = liveStatus(run);
 	return status === "running" ? null : `Run ${run.id} is not running (${status}).`;
 };
+/**
+* A run of one node (`ork run <wf> --node n`) has no scheduler to hold or to
+* fail one node through, so it takes only a stop of the whole run.
+*/
+const oneNode = (run, cannot) => run.id.startsWith("node-") ? `Run ${run.id} runs one node, which it cannot ${cannot}; stop the whole run instead: ork stop ${run.id}` : null;
 /** Every node of a run's tree, spawned instances included. */
 const flattenTree = (nodes) => nodes.flatMap((node) => [node, ...flattenTree(node.children)]);
 /** What a run's stored events say about it now. */
@@ -10421,12 +10793,14 @@ const request = async (store, run, command, refusal, home) => {
 const stopRefusal = (store, run, node) => {
 	const refused = notRunning(run);
 	if (refused !== null || node === void 0) return refused;
+	const single = oneNode(run, "stop by name");
+	if (single !== null) return single;
 	const named = stateOf(store, run).nodes.filter((n) => n.id === node || n.template === node);
 	if (named.length === 0) return `${node} is not a node of run ${run.id}.`;
 	return named.some((n) => n.state === "running") ? null : `${node} is not running in run ${run.id}.`;
 };
 const pauseRefusal = (store, run, node) => {
-	const refused = notRunning(run);
+	const refused = notRunning(run) ?? oneNode(run, "pause or continue");
 	if (refused !== null) return refused;
 	const { paused, nodes } = stateOf(store, run);
 	if (paused.run) return `Run ${run.id} is already paused.`;
@@ -10435,7 +10809,7 @@ const pauseRefusal = (store, run, node) => {
 	return paused.nodes.includes(node) ? `${node} is already paused in run ${run.id}.` : null;
 };
 const continueRefusal = (store, run, node) => {
-	const refused = notRunning(run);
+	const refused = notRunning(run) ?? oneNode(run, "pause or continue");
 	if (refused !== null) return refused;
 	const { paused } = stateOf(store, run);
 	if (node === void 0) return paused.run || paused.nodes.length > 0 ? null : `Run ${run.id} is not paused.`;
@@ -10937,15 +11311,59 @@ const parseInputPairs = (pairs) => {
 		raw
 	};
 };
+// ../core/src/worktree/git-env.ts
+/**
+* @file Git's local environment variables, the ones a git hook sets (`GIT_DIR`,
+*   `GIT_INDEX_FILE`, …), and an environment without them. Ork finds a project
+*   by its path, never through these, so an `ork` started from a hook clears
+*   them at its entry, and core's git runner leaves them out for callers that
+*   don't start there (specs/worktrees.md).
+*/
+/**
+* What `git rev-parse --local-env-vars` prints (git 2.39.5). A fixed list, so
+* no git is spawned at every start; a test fails when the installed git names
+* one that is missing here.
+*/
+const GIT_LOCAL_ENV = [
+	"GIT_ALTERNATE_OBJECT_DIRECTORIES",
+	"GIT_CONFIG",
+	"GIT_CONFIG_PARAMETERS",
+	"GIT_CONFIG_COUNT",
+	"GIT_OBJECT_DIRECTORY",
+	"GIT_DIR",
+	"GIT_WORK_TREE",
+	"GIT_IMPLICIT_WORK_TREE",
+	"GIT_GRAFT_FILE",
+	"GIT_INDEX_FILE",
+	"GIT_NO_REPLACE_OBJECTS",
+	"GIT_REPLACE_REF_BASE",
+	"GIT_PREFIX",
+	"GIT_INTERNAL_SUPER_PREFIX",
+	"GIT_SHALLOW_FILE",
+	"GIT_COMMON_DIR"
+];
+/** A copy of `env` without git's local variables. */
+const withoutGitLocalEnv = (env) => {
+	const clean = { ...env };
+	for (const name of GIT_LOCAL_ENV) delete clean[name];
+	return clean;
+};
+/** Removes git's local variables from `env` in place (the CLI's entry). */
+const clearGitLocalEnv = (env = process.env) => {
+	for (const name of GIT_LOCAL_ENV) delete env[name];
+};
 // ../core/src/worktree/git.ts
 /**
 * @file A minimal `git` runner for the worktree manager: arguments without a
-*   shell, results that never throw.
+*   shell, results that never throw, and none of git's local variables (a
+*   hook's `GIT_DIR` or `GIT_INDEX_FILE`), so it acts on the repository at
+*   `cwd` (specs/worktrees.md).
 */
 /** Runs `git` with arguments (no shell) in `cwd`. Never throws. */
 const git = (cwd, args) => new Promise((resolve) => {
 	execFile("git", args, {
 		cwd,
+		env: withoutGitLocalEnv(process.env),
 		maxBuffer: 33554432,
 		encoding: "utf8"
 	}, (error, stdout, stderr) => {
@@ -11706,6 +12124,8 @@ const isNewer = (candidate, current) => {
 };
 // ../core/src/update/installers.ts
 const SOURCE = "/packages/cli/";
+/** Pnpm's global virtual store, where pnpm 11 keeps global packages. */
+const PNPM_STORE_LINKS = /\/store\/v\d+\/links\//u;
 const has = (...parts) => (script) => parts.some((part) => script.includes(part));
 const INSTALLERS = [
 	{
@@ -11738,7 +12158,7 @@ const INSTALLERS = [
 	{
 		id: "pnpm",
 		label: "pnpm (global)",
-		owns: has("/pnpm/global/", "/.pnpm-global/"),
+		owns: (script) => has("/pnpm/global/", "/.pnpm-global/")(script) || PNPM_STORE_LINKS.test(script),
 		command: (spec) => [
 			"pnpm",
 			"add",
@@ -12502,4 +12922,4 @@ const createWorkspace = (options) => {
 		close
 	};
 };
-export { resumable as $, planMoveInto as $t, parseInputPairs as A, parseWorkflow as An, FEEDBACK_KINDS as At, unlinkNodes as B, isClaudeNode as Bn, normalizeTitle as Bt, watchingPid as C, writePlainFile as Cn, runScope as Ct, git as D, newWorkflowText as Dn, nodeSays as Dt, removeWorktree as E, applyEdits as En, envReadsOf as Et, endLink as F, WorkflowSchema as Fn, runGh as Ft, tellLiveRun as G, TOOL_PREFIX as Gn, parseTemplate as Gt, requestContinue as H, programsRunBy as Hn, maskReplacer as Ht, endLinksOf as I, expandEdge as In, sendPost as It, eventOf as J, ORK_LAYOUT as Jn, serveRun as Jt, backfillUsage as K, integrationFor as Kn, renderTemplate as Kt, linkNodes as L, settingsOf as Ln, publishPost as Lt, declaredProblem as M, CheckReportSchema as Mn, FEEDBACK_TARGETS as Mt, createCalls as N, markValue as Nn, DISCUSSIONS as Nt, gitOk as O, readDocument as On, declaredOutputOf as Ot, addressOf as P, EdgeInputSchema as Pn, planPost as Pt, detachResume as Q, applySteps as Qt, peerOf as R, NodeSchema as Rn, createFeedback as Rt, takeWatchLock as S, plainPathInside as Sn, heldTimeout as St, inspectProject as T, WorkflowEditSchema as Tn, calledWorkflows as Tt, requestPause as U, timeoutMs as Un, maskSecrets as Ut, flattenTree as V, isToolNode as Vn, targetOf as Vt, requestStop as W, INTEGRATIONS as Wn, evaluate as Wt, text as X, firstLine as Xn, wakeRun as Xt, inTransaction as Y, CLAUDE_DRIVERS as Yn, socketPath as Yt, adoptedCalls as Z, planAgentMigration as Zt, createWatcher as _, inside as _n, walkChecks as _t, limitsNow as a, catalogAgent as an, explainWorkflowText as at, readProjectTriggers as b, estimateTokens as bn, MESSAGE_LIMIT as bt, usd as c, hasInRepoFiles as cn, parseReport as ct, runningRunIds as d, placeFiles as dn, runStatus as dt, linkTools as en, createReplay as et, runningScript as f, placeFor as fn, runTree as ft, triggersReport as g, workflowDirOf as gn, checkWorkflowText as gt, lateTriggers as h, shownPath as hn, stillTheSameProcess as ht, NOT_STARTED as i, deleteAgent as in, followEvents as it, resolveInputs as j, serializeWorkflow as jn, FEEDBACK_SEVERITIES as jt, lines as k, renderJsonSchema as kn, gitRulesOf as kt, planUpgrade as l, inRepoPlace as ln, liveStatus as lt, isNewer as m, runDirOf as mn, processAlive as mt, resolveBase as n, toolsInUse as nn, DETACHED_ENV as nt, limitsReport as o, loadAgents as on, explainSession as ot, detectInstaller as p, projectsHome as pn, ownProcessStart as pt, usageQueries as q, AGENT_TOOL_LAYOUTS as qn, readCondition as qt, capsHere as r, createAgent as rn, detachRun as rt, planReason as s, PROJECT_MODES as sn, planNodeSession as st, createWorkspace as t, toolLinks as tn, replayLoopAnswers as tt, releaseNotes as u, newProjectId as un, pausedOf as ut, triggerStanding as v, projectRootOf as vn, walkSummary as vt, BRANCH_PREFIX as w, skillsIn as wn, scriptContactsOf as wt, workflowTextHash as x, guardedBase as xn, userMessageText as xt, declaredTriggers as y, LESSON_CAP_TOKENS as yn, startRun as yt, tellNode as z, beforeOf as zn, fingerprint as zt };
+export { text as $, timeoutMs as $n, parseTemplate as $t, gitOk as A, guardedBase as An, runScope as At, linkNodes as B, serializeWorkflow as Bn, FEEDBACK_TARGETS as Bt, workflowTextHash as C, runDirOf as Cn, walkChecks as Ct, inspectProject as D, projectRootOf as Dn, userMessageText as Dt, BRANCH_PREFIX as E, inside as En, MESSAGE_LIMIT as Et, declaredProblem as F, applyEdits as Fn, PROJECT_FILE as Ft, requestContinue as G, expandEdge as Gn, publishPost as Gt, tellNode as H, EdgeInputSchema as Hn, planPost as Ht, createCalls as I, newWorkflowText as In, gitRulesOf as It, tellLiveRun as J, beforeOf as Jn, normalizeTitle as Jt, requestPause as K, settingsOf as Kn, createFeedback as Kt, addressOf as L, readDocument as Ln, loadProject as Lt, clearGitLocalEnv as M, writePlainFile as Mn, envReadsOf as Mt, parseInputPairs as N, skillsIn as Nn, nodeSays as Nt, removeWorktree as O, LESSON_CAP_TOKENS as On, heldTimeout as Ot, resolveInputs as P, WorkflowEditSchema as Pn, declaredOutputOf as Pt, inTransaction as Q, NodeIdSchema as Qn, evaluate as Qt, endLink as R, renderJsonSchema as Rn, FEEDBACK_KINDS as Rt, readProjectTriggers as S, projectsHome as Sn, checkWorkflowText as St, watchingPid as T, workflowDirOf as Tn, startRun as Tt, unlinkNodes as U, WorkflowSchema as Un, runGh as Ut, peerOf as V, markValue as Vn, DISCUSSIONS as Vt, flattenTree as W, CheckReportSchema as Wn, sendPost as Wt, usageQueries as X, isToolNode as Xn, maskReplacer as Xt, backfillUsage as Y, isClaudeNode as Yn, targetOf as Yt, eventOf as Z, programsRunBy as Zn, maskSecrets as Zt, lateTriggers as _, hasInRepoFiles as _n, runStatus as _t, limitsNow as a, wakeRun as an, CLAUDE_DRIVERS as ar, DETACHED_ENV as at, triggerStanding as b, placeFiles as bn, processAlive as bt, usd as c, planMoveInto as cn, explainWorkflowText as ct, runningRunIds as d, toolsInUse as dn, namingNoDriver as dt, renderTemplate as en, INTEGRATIONS as er, adoptedCalls as et, runningScript as f, createAgent as fn, sessionDriver as ft, parseVersion as g, PROJECT_MODES as gn, pausedOf as gt, isNewer as h, loadAgents as hn, liveStatus as ht, NOT_STARTED as i, socketRoom as in, ORK_LAYOUT as ir, replayLoopAnswers as it, lines as j, plainPathInside as jn, calledWorkflows as jt, git as k, estimateTokens as kn, scriptContactsOf as kt, planUpgrade as l, linkTools as ln, explainSession as lt, compareVersions as m, catalogAgent as mn, reportSchemaFor as mt, resolveBase as n, serveRun as nn, integrationFor as nr, resumable as nt, limitsReport as o, planAgentMigration as on, firstLine as or, detachRun as ot, detectInstaller as p, deleteAgent as pn, parseReport as pt, requestStop as q, NodeSchema as qn, fingerprint as qt, capsHere as r, socketPath as rn, AGENT_TOOL_LAYOUTS as rr, createReplay as rt, planReason as s, applySteps as sn, followEvents as st, createWorkspace as t, readCondition as tn, TOOL_PREFIX as tr, detachResume as tt, releaseNotes as u, toolLinks as un, planNodeSession as ut, triggersReport as v, inRepoPlace as vn, runTree as vt, takeWatchLock as w, shownPath as wn, walkSummary as wt, declaredTriggers as x, placeFor as xn, stillTheSameProcess as xt, createWatcher as y, newProjectId as yn, ownProcessStart as yt, endLinksOf as z, parseWorkflow as zn, FEEDBACK_SEVERITIES as zt };