@krapht/ork 1.0.0-alpha.8 → 1.0.0-alpha.9

package/dist/{src-DosUvy4B.mjs → src-BwFxTank.mjs}

@@ -608,7 +608,10 @@ const agentSettings = {
 	practices: PracticesSchema.optional(),
 	tools: ToolRulesSchema.optional(),
 	session: z.enum(["fresh", "resume"]).optional().describe("When the node runs again (a loop, another delegation): resume its session, or start a fresh one with the new input. Default: resume for a leader, fresh for a worker."),
-	output: z.strictObject({ schema: z.record(z.string(), z.unknown()).optional().describe("Extra structured fields the node must report, e.g. { verdict: [approve, escalate] }.") }).optional()
+	output: z.strictObject({
+		schema: z.record(z.string(), z.unknown()).optional().describe("Extra structured fields the node must report, e.g. { verdict: [approve, escalate] }."),
+		gather: z.array(z.string().min(1)).min(1).optional().describe("List fields kept across rounds: each round's entries are added to the earlier rounds' instead of replacing them, e.g. [decisions].")
+	}).optional()
 };
 /** The settings keys an agent can bring, in canonical order. */
 const AGENT_SETTING_KEYS = [
@@ -858,7 +861,7 @@ const serializeAgent = (name, agent) => {
 // ../schema/src/edges.ts
 const ARROW = "->";
 const splitList = (side) => side.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-const asList$1 = (value) => Array.isArray(value) ? value : [value];
+const asList$2 = (value) => Array.isArray(value) ? value : [value];
 /**
 * Expands `"a, b -> c, d"` (or the object form) into the cartesian product of
 * edges.
@@ -866,7 +869,7 @@ const asList$1 = (value) => Array.isArray(value) ? value : [value];
 const expandEdge = (input, source) => {
 	if (typeof input !== "string") return {
 		ok: true,
-		edges: asList$1(input.from).flatMap((from) => asList$1(input.to).map((to) => {
+		edges: asList$2(input.from).flatMap((from) => asList$2(input.to).map((to) => {
 			const edge = {
 				from,
 				to,
@@ -907,7 +910,7 @@ const formatEdge = (input) => {
 		const [left = "", right = ""] = input.split(ARROW);
 		return `${splitList(left).join(", ")} ${ARROW} ${splitList(right).join(", ")}`;
 	}
-	if (input.when === void 0 && input.maxRounds === void 0) return `${asList$1(input.from).join(", ")} ${ARROW} ${asList$1(input.to).join(", ")}`;
+	if (input.when === void 0 && input.maxRounds === void 0) return `${asList$2(input.from).join(", ")} ${ARROW} ${asList$2(input.to).join(", ")}`;
 	return input;
 };
 /** Settings every Claude node takes unless it (or its agent) sets its own. */
@@ -1055,6 +1058,31 @@ const markValue = (value) => {
 	const pad = line.startsWith("`") || line.endsWith("`") ? " " : "";
 	return `${fence}${pad}${line}${pad}${fence}`;
 };
+// ../schema/src/issue-messages.ts
+const NODE_TYPES = NodeSchema.options.map((o) => o.shape.type.value);
+const isMap$1 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/** The text for an issue at or under a `forEach`, else `null`. */
+const forEachMessage = (issue, path, value) => {
+	const key = path.at(-1);
+	if (issue.code === "too_small" && path.at(-2) === "forEach") {
+		if (key === "items") return "`forEach.items` is empty: list at least one item, or use `from`";
+		if (key === "maxItems") return "`forEach.maxItems` must be at least 1: the most items to run before Ork asks";
+	}
+	if (issue.code !== "invalid_union" || key !== "forEach") return null;
+	if (!isMap$1(value)) return "`forEach` takes a map: `items: [...]` for a list written here, or `from:` with `maxItems:` for an earlier node's";
+	if ("items" in value && "from" in value) return "`forEach` takes `items` or `from`, not both";
+	if ("from" in value) return "`forEach` with `from` needs `maxItems`: the most items to run before Ork asks";
+	if (!("items" in value)) return "`forEach` needs `items` or `from`: a list written here, or an earlier node's";
+	return null;
+};
+/** The text for a `list` rule that is not a map of fields, else `null`. */
+const listRuleMessage = (issue, value) => issue.code === "invalid_union" && isMap$1(value) && "list" in value ? "`list` takes a map of each item's fields, e.g. `list: { title: string }` (`list: {}` for items of any shape)" : null;
+/** The text for a node whose `type` is missing or unknown, else `null`. */
+const nodeTypeMessage = (issue, value) => {
+	if (issue.code !== "invalid_union" || issue.discriminator !== "type") return null;
+	const types = NODE_TYPES.map((type) => markValue(type)).join(", ");
+	return value === void 0 ? `node needs a \`type\`: one of ${types}` : `unknown node type ${markValue(typeof value === "string" ? value : JSON.stringify(value) ?? "")}: expected one of ${types}`;
+};
 // ../schema/src/newer-version.ts
 /**
 * A file with a higher `schemaVersion` than this Ork reads was made by a newer
@@ -1075,7 +1103,6 @@ const newerVersion = (issues, raw) => {
 *   diagnostics, and the workflow's byte-stable canonical serializer.
 */
 const SCHEMA_URL = "https://raw.githubusercontent.com/mimshins/ork/main/packages/schema/workflow.schema.json";
-const NODE_TYPES = NodeSchema.options.map((o) => o.shape.type.value);
 const createLocate = (doc, counter) => (path) => {
 	for (let depth = path.length; depth >= 0; depth -= 1) {
 		const node = doc.getIn(path.slice(0, depth), true);
@@ -1090,6 +1117,12 @@ const createLocate = (doc, counter) => (path) => {
 	return null;
 };
 const toPath = (path) => path.map((p) => typeof p === "number" ? p : String(p));
+/** The value at a path of the raw document, or undefined. */
+const valueAt = (raw, path) => {
+	let value = raw;
+	for (const segment of path) value = value !== null && typeof value === "object" ? Reflect.get(value, segment) : void 0;
+	return value;
+};
 const describeIssue = (issue, raw, path) => {
 	if (issue.code === "unrecognized_keys") {
 		const [first] = issue.keys;
@@ -1098,14 +1131,12 @@ const describeIssue = (issue, raw, path) => {
 			path: first === void 0 ? path : [...path, first]
 		};
 	}
-	if (issue.code === "invalid_union" && issue.discriminator === "type") {
-		let value = raw;
-		for (const segment of path) value = value !== null && typeof value === "object" ? Reflect.get(value, segment) : void 0;
-		return {
-			message: value === void 0 ? `node needs a \`type\`: one of ${NODE_TYPES.map((type) => markValue(type)).join(", ")}` : `unknown node type ${markValue(typeof value === "string" ? value : JSON.stringify(value) ?? "")}: expected one of ${NODE_TYPES.map((type) => markValue(type)).join(", ")}`,
-			path
-		};
-	}
+	const value = valueAt(raw, path);
+	const said = forEachMessage(issue, path, value) ?? listRuleMessage(issue, value) ?? nodeTypeMessage(issue, value);
+	if (said !== null) return {
+		message: said,
+		path
+	};
 	return {
 		message: issue.message.replaceAll(/"([^"`\n]+)"/gu, "`$1`"),
 		path
@@ -4194,7 +4225,7 @@ const resolvePath = (segments, scope) => {
 };
 /** Truthiness as expressions see it: an empty list is false. */
 const truthy = (value) => Array.isArray(value) ? value.length > 0 : Boolean(value);
-const asList = (value) => Array.isArray(value) ? value : [];
+const asList$1 = (value) => Array.isArray(value) ? value : [];
 const order = (op, l, r) => {
 	if (op === "<") return l < r;
 	if (op === "<=") return l <= r;
@@ -4222,7 +4253,7 @@ const evaluate = (expr, scope) => {
 		case "call": {
 			const args = expr.args.map((arg) => evaluate(arg, scope));
 			const [subject, value] = args;
-			const list = asList(subject);
+			const list = asList$1(subject);
 			const matches = (item) => args.length > 1 ? item === value : truthy(item);
 			switch (expr.name) {
 				case "any": return list.some((item) => matches(item));
@@ -4328,11 +4359,21 @@ const readableText = (value, before) => {
 * Fills a parsed template. `readable` is for text a person reads (a gate's
 * `question` and `document`); scripts and prompts keep JSON (ADR-047).
 */
-const renderTemplate = (parts, scope, { readable = false } = {}) => parts.reduce((text, part) => {
-	if (typeof part === "string") return text + part;
-	const value = evaluate(part.expr, scope);
-	return text + (readable ? readableText(value, text) : stringify$1(value));
-}, "");
+const renderTemplate = (parts, scope, { readable = false } = {}) => {
+	let text = "";
+	let afterList = false;
+	for (const part of parts) {
+		const value = typeof part === "string" ? part : evaluate(part.expr, scope);
+		const piece = readable ? readableText(value, text) : stringify$1(value);
+		if (piece.trim() === "") {
+			text += piece;
+			continue;
+		}
+		text = afterList && !isContainer(value) ? `${text.trimEnd()}\n\n${piece.trimStart()}` : text + piece;
+		afterList = readable && isContainer(value) && depthOf(value) <= 2;
+	}
+	return text;
+};
 // ../core/src/feedback/fingerprint.ts
 /**
 * @file Feedback fingerprints: records about the same thing (same target, kind,
@@ -5055,6 +5096,8 @@ const REPORT_STATUSES = [
 ];
 /** What a node declares of its output (RFC-010), if it does. */
 const declaredOutputOf = (node) => "output" in node ? node.output?.schema : void 0;
+/** The report fields a node keeps across its rounds (ADR-073), if any. */
+const gatheredFieldsOf = (node) => node !== void 0 && isClaudeNode(node) ? node.output?.gather ?? [] : [];
 /** What a node with `forEach` reports instead of its type's fields (RFC-013). */
 const GATHERED_FIELDS = [
 	"items",
@@ -5686,6 +5729,11 @@ const ownersOf = (workflow, id) => {
 	return owners;
 };
 // ../core/src/graph/for-each.ts
+/**
+* @file The checks on `forEach` (RFC-013): where its list comes from, and where
+*   `{{item}}` and `{{index}}` may be read and what `{{item.<field>}}` may
+*   name.
+*/
 const isItemRoot = (root) => ITEM_ROOTS.includes(root);
 /**
 * Nodes whose output exists before `id` runs: its flow ancestors and its
@@ -5701,7 +5749,7 @@ const upstreamOf = (workflow, edges, id) => {
 };
 /** The field a path under `nodes.<id>.output` reads, as `says.ts` names it. */
 const fieldOfPath = (segments) => segments.slice(3).join(".");
-const isList = (said) => said.items !== void 0 || said.kind === "statuses";
+const isList$1 = (said) => said.items !== void 0 || said.kind === "statuses";
 /** What a node's `from` list's items have, or `undefined` if nothing says. */
 const sourceFields = (segments, says) => {
 	const [root, id] = segments;
@@ -5745,6 +5793,11 @@ const checkFiles = (id, key, files) => files.flatMap((file, index) => {
 		index
 	]))) : [];
 });
+/**
+* Whether one activation's parsed JSON is at `output.json` (a program, an MCP
+* call).
+*/
+const readsJson = (node) => (isToolNode(node) || node.type === "mcp.call") && forEachOf$1(node) === void 0;
 /** The source of one `from`: it exists, runs first, and is a declared list. */
 const checkSource = (workflow, edges, says, id, segments, path) => {
 	const named = describePath(segments);
@@ -5759,8 +5812,15 @@ const checkSource = (workflow, edges, says, id, segments, path) => {
 	if (source === id || !ancestorsOf(id, first).has(String(source))) return [error("forEach.order", `\`${named}\`: \`${String(source)}\` does not run before \`${id}\`, so its list can't exist when \`${id}\` starts`, path)];
 	const field = fieldOfPath(segments);
 	const said = says[String(source)]?.fields.find(({ field: name }) => name === field);
-	if (field === "" || said !== void 0 && !isList(said)) return [error("forEach.not-list", `\`${named}\` is not a list: \`${String(source)}\` declares ${field === "" ? "its whole output" : `\`${field}\``} as something else; declare it as \`{ list: { … } }\``, path)];
-	return said === void 0 ? [warning("forEach.undeclared", `\`${named}\`: nothing declares this list, so a run can't check it or its items; add \`{ list: { … } }\` to \`${String(source)}\`'s \`output.schema\``, path)] : [];
+	if (field === "" || said !== void 0 && !isList$1(said)) return [error("forEach.not-list", `\`${named}\` is not a list: \`${String(source)}\` declares ${field === "" ? "its whole output" : `\`${field}\``} as something else; declare it as \`{ list: { … } }\``, path)];
+	if (said !== void 0) return [];
+	const add = `add \`{ list: { … } }\` to \`${String(source)}\`'s \`output.schema\``;
+	const node = workflow.nodes[String(source)];
+	if (node !== void 0 && readsJson(node) && !field.startsWith("json.")) {
+		const declared = says[String(source)]?.fields.some(({ field: name }) => name === `json.${field}`);
+		return [warning("forEach.undeclared", `\`${named}\`: a tool's JSON is read as \`nodes.${String(source)}.output.json.${field}\`${declared === true ? "" : `; ${add}`}`, path)];
+	}
+	return [warning("forEach.undeclared", `\`${named}\`: nothing declares this list, so a run can't check it or its items; ${add}`, path)];
 };
 /** Every `forEach`'s source, and `{{item}}` in the lists no template reads. */
 const checkForEach = (workflow, edges) => {
@@ -5839,6 +5899,26 @@ const checkGroup = (workflow, edges, component) => {
 };
 /** What's wrong with the shape of each group of nodes that loop together. */
 const checkLoops = (workflow, edges) => stronglyConnected(Object.keys(workflow.nodes), edges).flatMap((component) => checkGroup(workflow, edges, component));
+// ../core/src/graph/gather.ts
+/** Whether a declared field is a list: `{ type: array }` or `{ list: … }`. */
+const isList = (rule) => listShape(rule) !== void 0 || typeof rule === "object" && rule !== null && "type" in rule && rule.type === "array";
+const gatherProblems = (id, node) => {
+	const fields = gatheredFieldsOf(node);
+	if (fields.length === 0) return [];
+	const path = [
+		"nodes",
+		id,
+		"output",
+		"gather"
+	];
+	if (forEachOf$1(node) !== void 0) return [error("output.gather", `\`${id}\` runs once per item and reports its items' results, so it has no fields of its own to keep across rounds`, path)];
+	const declared = declaredOutputOf(node) ?? {};
+	return fields.flatMap((field, index) => {
+		const rule = declared[field];
+		if (rule === void 0) return [error("output.gather", `\`${field}\` isn't in \`${id}\`'s \`output.schema\`; declare it as a list to keep it across rounds`, [...path, index])];
+		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/script.ts
 /**
 * @file Checks on the programs a workflow declares (RFC-006): a tool node's and
@@ -5910,7 +5990,7 @@ const checkNodes = (workflow, edges) => {
 		const incoming = edges.filter((e) => e.to === id);
 		const outgoing = edges.filter((e) => e.from === id);
 		if (node.type === "claude.subagent" && node.timeout !== void 0) diagnostics.push(warning("timeout.subagent", `sub-agent \`${id}\` runs inside its parent's session, so its timeout has no effect; set one on the parent`, [...path, "timeout"]));
-		diagnostics.push(...statusProblems(id, node));
+		diagnostics.push(...statusProblems(id, node), ...gatherProblems(id, node));
 		if (node.type === "control.join") {
 			const sources = new Set(incoming.map((e) => e.from)).size;
 			if (sources < 2) diagnostics.push(warning("join.inputs", `join \`${id}\` has ${sources} incoming node(s); a join waits for two or more`, path));
@@ -6823,14 +6903,23 @@ const createLoops = (options) => {
 	};
 	/**
 	* What a list over its cap runs: asked of a live owner, then the human. All
-	* of it, the first `maxItems`, or `null` to stop.
+	* of it, the first `maxItems`, or `null` to stop. A stop (`signal`) ends the
+	* wait and withdraws the question; the list comes back whole, and nothing of
+	* it starts because the stop also bars its items.
 	*/
-	const overList = async (node, list, maxItems, round) => {
+	const overList = async (node, list, maxItems, round, signal) => {
 		const question = eachQuestion(node, list.length, maxItems, round);
-		const choice = await options.bus?.askOwner(node, question) ?? await options.human.ask({
+		const asking = async () => await options.bus?.askOwner(node, question) ?? (signal.aborted ? null : options.human.ask({
 			nodeId: node,
-			...question
-		});
+			...question,
+			signal
+		}));
+		const stopped = Promise.withResolvers();
+		signal.addEventListener("abort", () => {
+			stopped.resolve(null);
+		}, { once: true });
+		const choice = await Promise.race([asking(), stopped.promise]);
+		if (signal.aborted) return list;
 		if (choice === EACH_CHOICES.first) return list.slice(0, maxItems);
 		return choice === EACH_CHOICES.all ? list : null;
 	};
@@ -6911,6 +7000,40 @@ 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$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];
+	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]));
+	return {
+		owner: byId.get(id)?.parent,
+		children: nodes.filter((node) => node.parent === id && isSession(node)).map((node) => node.id),
+		channels: channelPeersOf(id, channels).filter((peer) => !isTool(byId.get(peer)))
+	};
+};
+/** 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(byId.get(owner)) ? [owner] : [], ...channelPeersOf(id, channels).filter((peer) => isSession(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) => {
@@ -6966,46 +7089,7 @@ const earlierSpend = (events) => {
 		forks
 	};
 };
-// ../core/src/run/contacts.ts
-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];
-	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]));
-	return {
-		owner: byId.get(id)?.parent,
-		children: nodes.filter((node) => node.parent === id && isSession(node)).map((node) => node.id),
-		channels: channelPeersOf(id, channels).filter((peer) => !isTool(byId.get(peer)))
-	};
-};
-/** 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(byId.get(owner)) ? [owner] : [], ...channelPeersOf(id, channels).filter((peer) => isSession(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/run/results.ts
-/** Control nodes pass their input through; a join's input is its output. */
-const passThrough = (input) => ({
-	output: input ?? {},
-	ok: true
-});
+// ../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`
@@ -7031,11 +7115,23 @@ const withOwnSpend = (id, result, reported) => {
 const createSpend = (budgetUsd, earlier, limits) => {
 	const reported = new Map(earlier?.reported);
 	let spent = earlier?.total ?? 0;
-	const budgetLeft = () => budgetUsd === void 0 ? void 0 : budgetUsd - spent;
+	/** 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);
+	const budgetLeft = () => budgetUsd === void 0 ? void 0 : budgetUsd - committed();
 	return {
 		total: () => spent,
 		/** 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);
+		},
 		/** What a session may spend: the least of the budget and any quota. */
 		left: () => {
 			const known = [budgetLeft(), limits?.().leftUsd].filter((left) => left !== void 0);
@@ -7054,7 +7150,7 @@ const createSpend = (budgetUsd, earlier, limits) => {
 				status: "quota_exhausted",
 				reason: blocked
 			};
-			return budgetUsd !== void 0 && spent >= budgetUsd ? {
+			return budgetUsd !== void 0 && committed() >= budgetUsd ? {
 				status: "budget_exhausted",
 				reason: `the run's budget of $${String(budgetUsd)} is spent`
 			} : null;
@@ -7073,6 +7169,56 @@ const createSpend = (budgetUsd, earlier, limits) => {
 };
 /** 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;
+};
+/**
+* `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;
@@ -7270,10 +7416,10 @@ const sourceOf = (forEach, scope) => {
 const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /**
 * What `results` keeps of an item: its declared fields (a program's are under
-* `json`), its summary, and Ork's own branch and worktree. The full output
-* stays in the item's own `node.finished`.
+* `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 entryOf = (declared, output) => {
+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 = [
@@ -7282,7 +7428,12 @@ const entryOf = (declared, output) => {
 		"worktree",
 		"merge"
 	].map((field) => [field, output[field]]);
-	return Object.fromEntries([...fields, ...own].filter(([, value]) => value !== void 0));
+	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;
@@ -7332,10 +7483,12 @@ const createFanOut = (deps) => {
 				node: id,
 				round,
 				count: list.length,
-				list
+				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",
@@ -7344,14 +7497,14 @@ const createFanOut = (deps) => {
 				count: list.length,
 				maxItems: forEach.maxItems
 			});
-			const chosen = await deps.loops.overList(id, list, forEach.maxItems, round);
+			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 {
+				return stops.ended(id, {
 					...failure(reason),
 					limited: reason,
 					stopsAs: "failed"
-				};
+				});
 			}
 			const narrowed = chosen.length !== list.length;
 			list = chosen;
@@ -7361,7 +7514,6 @@ const createFanOut = (deps) => {
 		const session = node !== void 0 && needsSlot(node);
 		const spends = node !== void 0 && spendsBudget(node);
 		const declared = node === void 0 ? void 0 : declaredOutputOf(node);
-		const signal = stops.signalFor(id);
 		const results = list.map(() => ({}));
 		const statuses = list.map(() => "skipped");
 		const failures = [];
@@ -7383,7 +7535,7 @@ const createFanOut = (deps) => {
 					},
 					round
 				});
-				results[index] = entryOf(declared, result.output);
+				results[index] = entryOf(declared, result);
 				statuses[index] = statusOf(result);
 				if (!result.ok) failures.push(`${itemId}: ${result.error ?? "failed"}`);
 				else if (mergeFailed(result)) failures.push(`${itemId}: its work could not be merged`);
@@ -7619,6 +7771,10 @@ const nodeContext = (deps, activation, cwd, round) => {
 		...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,
@@ -9375,6 +9531,7 @@ const startRun = (options) => {
 			loops
 		})
 	});
+	const gather = createGatherer(outputs, options.replay, nodeOf);
 	/** Runs one activation and records it; routing is the caller's. */
 	const perform = async (activation) => {
 		const { id } = activation;
@@ -9387,8 +9544,9 @@ const startRun = (options) => {
 			const agent = graph.agents.get(activation.template ?? id);
 			onEvent(startedEvent(activation, type, round, agent));
 		}
-		const result = spend.count(id, stops.ended(id, recorded ?? await execute(activation, round)), recorded !== null);
+		const result = gather(activation, spend.count(id, stops.ended(id, recorded ?? await execute(activation, round)), recorded !== null));
 		if (result.limited !== void 0) stop(result.stopsAs ?? "quota_exhausted", result.limited);
+		spend.settled(id);
 		holds.finished(id);
 		ports.finished(id);
 		clock.leave(id);
@@ -11208,10 +11366,11 @@ const mailOf = (events) => {
 *   (ADR-026). Each node's recorded results, in order, up to its first that
 *   failed or never finished, are handed back by the replay, so the scheduler
 *   rebuilds outputs, rounds, joins and loop counts without running them; the
-*   rest run again, and so does everything a new result feeds. Also: the run's
-*   inputs and settings, its worktrees, the answers to its loops, and a fanned
-*   node's lists and its items' results by round (RFC-013). `replay.ts` hands
-*   them back.
+*   rest run again, and so does everything a new result feeds. A run resumed
+*   more than once reads as one history: a later result replaces the earlier
+*   one at its place. Also: the run's inputs and settings, its worktrees, the
+*   answers to its loops, and a fanned node's lists and its items' results by
+*   round (RFC-013). `replay.ts` hands them back.
 */
 const listKey = (node, round) => `${node}/${String(round)}`;
 /** How a run ended that cut its working nodes off, rather than failing them. */
@@ -11221,6 +11380,8 @@ const CUTTING = /* @__PURE__ */ new Set([
 	"quota_exhausted",
 	"timed_out"
 ]);
+/** Whether `id` is an item (`<node>.<index>`) of `node`. */
+const isItemOf = (id, node) => id.startsWith(`${node}.`) && /^\d+$/u.test(id.slice(node.length + 1));
 /** Reads a run's events back into what `ork resume` needs. */
 const resumeState = (events) => {
 	const history = /* @__PURE__ */ new Map();
@@ -11243,18 +11404,36 @@ const resumeState = (events) => {
 	let ended;
 	/** Nodes whose last activation did not finish well, and its session. */
 	const unfinished = /* @__PURE__ */ new Map();
+	/** A new run of `id`'s `round` replaces what is recorded there and after. */
+	const supersede = (id, round) => {
+		fanOuts.items.get(id)?.delete(round);
+		const kept = history.get(id)?.slice(0, round - 1);
+		if (kept === void 0) return;
+		if (kept.length === 0) history.delete(id);
+		else history.set(id, kept);
+	};
+	/** A list resolved anew: what its items did came from another list. */
+	const forgetItems = (node, round) => {
+		for (const [id, rounds] of fanOuts.items) if (isItemOf(id, node)) rounds.delete(round);
+		for (const id of unfinished.keys()) if (isItemOf(id, node)) unfinished.delete(id);
+	};
 	for (const event of events) {
 		if (event.type === "run.started") {
 			inputs = event.inputs ?? inputs;
 			settings = event.settings ?? settings;
+			closed.clear();
 			continue;
 		}
 		if (event.type === "node.started") {
-			if (event.owner === void 0) open.set(event.id, event.item === void 0 ? {} : { item: true });
+			if (event.owner === void 0) {
+				open.set(event.id, event.item === void 0 ? {} : { item: true });
+				supersede(event.id, event.round);
+			}
 			continue;
 		}
 		if (event.type === "each.listed") {
 			fanOuts.lists.set(listKey(event.node, event.round), event.list);
+			if (event.anew === true) forgetItems(event.node, event.round);
 			continue;
 		}
 		if (event.type === "node.event") {
@@ -11274,6 +11453,7 @@ const resumeState = (events) => {
 				if (current.sessionId !== void 0) unfinished.set(event.id, current.sessionId);
 				continue;
 			}
+			unfinished.delete(event.id);
 			const result = {
 				ok: true,
 				output: event.output
@@ -13479,6 +13659,13 @@ const syncFrom = async (worktree, from) => {
 	return snapshot(worktree);
 };
 // ../core/src/worktree/upstream.ts
+/** Where `id` worked: its own place, or for a fanned node each item's. */
+const placesOf = (id, placeOf) => {
+	const own = placeOf.get(id);
+	if (own !== void 0) return [own];
+	const item = `${id}.`;
+	return [...placeOf].filter(([other]) => other.startsWith(item)).map(([, place]) => place);
+};
 /**
 * The one place `id`'s upstream nodes worked in other than `root`, or
 * `undefined` when there is none or they disagree. `placeOf` is where each node
@@ -13497,8 +13684,7 @@ const upstreamPlace = (graph, id, placeOf, root) => {
 			queue.push(...(node?.incoming ?? []).map((e) => e.from));
 			continue;
 		}
-		const place = placeOf.get(from);
-		if (place !== void 0 && place !== root) places.add(place);
+		for (const place of placesOf(from, placeOf)) if (place !== root) places.add(place);
 	}
 	const [only, other] = places;
 	return other === void 0 ? only : void 0;
@@ -13704,6 +13890,18 @@ const closeWorktrees = async (options) => {
 	}
 	return kept;
 };
+// ../core/src/worktree/conflict.ts
+const withConflict = (result, conflicts, into) => ({
+	...result,
+	output: {
+		...result.output,
+		merge: {
+			ok: false,
+			conflicts,
+			into
+		}
+	}
+});
 // ../core/src/worktree/workspace.ts
 /**
 * @file Where each node of a run works (ADR-020), under the project's git rules
@@ -13716,6 +13914,7 @@ const closeWorktrees = async (options) => {
 *   its owner: a merge, a patch, or not at all. A spawned worker works like the
 *   declared child it is an instance of.
 */
+const ITEM_FAILED = "item failed; kept for inspection";
 const createWorkspace = (options) => {
 	const { graph, runId, root, head, onEvent } = options;
 	const rules = gitRulesOf(graph.workflow);
@@ -13863,6 +14062,8 @@ const createWorkspace = (options) => {
 		}
 		const next = await settle(id, id, worktree, result);
 		outputs.set(id, next.output);
+		if (!next.ok && templateOf.has(id) && !unmerged.has(id)) unmerged.set(id, ITEM_FAILED);
+		if (next.ok && unmerged.get(id) === ITEM_FAILED) unmerged.delete(id);
 		const owner = ownerOf(id);
 		const ownerTree = owner === void 0 ? void 0 : worktrees.get(owner);
 		if (!next.ok || owner === void 0 || ownerTree === void 0) return next;
@@ -13880,17 +14081,7 @@ const createWorkspace = (options) => {
 		const files = outcome.conflicts.join(", ");
 		unmerged.set(id, `merge conflict${files === "" ? "" : ` in ${files}`}`);
 		event(id, "conflict", worktree, files === "" ? outcome.error : files);
-		return {
-			...next,
-			output: {
-				...next.output,
-				merge: {
-					ok: false,
-					conflicts: outcome.conflicts,
-					into: nameOf(ownerTree)
-				}
-			}
-		};
+		return withConflict(next, outcome.conflicts, nameOf(ownerTree));
 	};
 	const close = () => closeWorktrees({
 		root,