zidane 7.2.4 → 8.0.4

package/dist/restate.js

@@ -1,7 +1,8 @@
-import { L as buildAliasMaps } from "./openai-compat-Dy56weK8.js";
-import { i as coerceToolResultContent, l as toolOutputByteLength, u as toolResultToText } from "./types-CWgENVLY.js";
-import { At as reserveChildLabel, a as stagedToolState, ar as hydrateReadStateFromSessionAsync, i as isToolStateOps } from "./agent-D0zZnGbt.js";
+import { d as toolResultToText, i as coerceToolResultContent, u as toolOutputByteLength } from "./types-Cu0ZGDu9.js";
+import { n as buildAliasMaps } from "./aliasing-lVFbm81n.js";
+import { C as hydrateReadStateFromSessionAsync, i as stagedToolState, m as reserveChildLabel, r as isToolStateOps } from "./tool-state-Dku6YqAB.js";
 import { r as formatTokenUsage } from "./stats-DAKBEKjc.js";
+import { n as DEFAULT_MEDIA_BUDGET, t as DEFAULT_MAX_IMAGE_EDGE } from "./defaults-Cx3zvDOV.js";
 import { createHash } from "node:crypto";
 //#region src/restate/awakeable.ts
 /**
@@ -72,7 +73,7 @@ function restateAwakeableTool(options) {
 				awakeableId: awakeable.id
 			};
 		}, runOpts);
-		if (marker.awakeableId !== awakeable.id) throw new Error(`restateAwakeableTool(${name}): journal drift — broadcast marker carries awakeable "${marker.awakeableId}" but this replay minted "${awakeable.id}". The journal and the code path no longer line up; refusing to park on an unreachable awakeable.`);
+		if (marker.awakeableId !== awakeable.id) throw new Error(`restateAwakeableTool(${name}): journal drift: broadcast marker carries awakeable "${marker.awakeableId}" but this replay minted "${awakeable.id}". The journal and the code path no longer line up; refusing to park on an unreachable awakeable.`);
 		const value = await awakeable.promise;
 		if (toResult) return toResult(value, input);
 		return typeof value === "string" ? value : JSON.stringify(value);
@@ -152,11 +153,12 @@ function restateBehavior(overrides = {}) {
 		cache: true,
 		shouldRethrowToolError: shouldRethrowRestateControlError,
 		compactStrategy: "tail",
-		compactThreshold: 128 * 1024,
+		compactThreshold: 131072,
 		compactKeepTurns: 8,
 		elideStaleReads: "stub",
-		mediaKeepTurns: 8,
-		toolOutputBudget: 64 * 1024,
+		mediaBudget: DEFAULT_MEDIA_BUDGET,
+		maxImageEdge: DEFAULT_MAX_IMAGE_EDGE,
+		toolOutputBudget: 65536,
 		autoCompact: { threshold: .85 },
 		...overrides
 	};
@@ -280,8 +282,7 @@ function rethrowSoftToolError(value) {
 	return value;
 }
 //#endregion
-//#region src/restate/tool.ts
-const SHELL_BACKGROUND_DISABLED_MESSAGE = "shell error: background mode is disabled for Restate-backed agents. Fall back to foreground (drop `run_in_background`).";
+//#region src/restate/tool-hydrate.ts
 /**
 * Once-per-session (per process) guard for the restate tool wrapper's read-state
 * hydration. Rebuilds the map from `session.turns` the first time any wrapped
@@ -294,182 +295,30 @@ const SHELL_BACKGROUND_DISABLED_MESSAGE = "shell error: background mode is disab
 * `restateTool`-wrapped consumers; it is NOT what the gate depends on.
 */
 const HYDRATED_READ_STATE_SESSIONS = /* @__PURE__ */ new WeakSet();
-/**
-* Wrap a single `ToolDef` so its `execute` runs inside `ctx.run`. The
-* tool's `spec` and `isConcurrencySafe` pass through unchanged.
-*/
-function restateTool(inner, ctx, options = {}) {
-	const runOpts = options.runOptions ?? { maxRetryAttempts: 1 };
-	const nameFor = options.entryName ?? ((seq, name) => `tool-${name}-${seq}`);
-	const canonicalName = inner.spec.name;
-	const shellBackgroundDisabled = (options.disableShellBackground ?? options.detachedTasks !== "durable") && canonicalName === "shell";
-	const durableStart = options.durableStart;
-	if (durableStart && !durableStart.attach && !durableStart.wait) throw new Error(`restateTool(${canonicalName}): durableStart needs an \`attach\` (in-journal wait) or a \`wait\` (awakeable park) phase`);
-	let seq = 0;
-	const hydrateOnce = async (toolCtx) => {
-		if (!toolCtx.session || HYDRATED_READ_STATE_SESSIONS.has(toolCtx.session)) return;
-		HYDRATED_READ_STATE_SESSIONS.add(toolCtx.session);
-		let aliasMaps;
-		if (toolCtx.toolAliases) try {
-			aliasMaps = buildAliasMaps(toolCtx.toolAliases, Object.keys(toolCtx.tools));
-		} catch {
-			aliasMaps = void 0;
-		}
-		await hydrateReadStateFromSessionAsync(toolCtx.session, toolCtx.handle.cwd, {
-			defaultLineNumbers: toolCtx.behavior?.readLineNumbers ?? true,
-			...aliasMaps ? { aliasMaps } : {},
-			readFileForHash: async (path) => {
-				try {
-					return await toolCtx.execution.readFile(toolCtx.handle, path);
-				} catch {
-					return null;
-				}
-			}
-		});
-	};
-	const softErrors = options.softErrors ?? true;
-	const coerceBlocks = options.coerceResultBlocks ?? true;
-	const runJournaled = (input, toolCtx) => {
-		seq += 1;
-		return ctx.run(nameFor(seq, canonicalName, input, toolCtx.callId), async () => {
-			options.replayTracker?.markLive();
-			await hydrateOnce(toolCtx);
-			const staged = stagedToolState(toolCtx.state);
-			staged?.clear();
-			if (shellBackgroundDisabled && input.run_in_background === true) return SHELL_BACKGROUND_DISABLED_MESSAGE;
-			if (!softErrors) {
-				const out = await inner.execute(input, toolCtx);
-				return attachToolState(coerceBlocks ? coerceToolResultContent(out) : out, staged);
-			}
-			try {
-				const out = await inner.execute(input, toolCtx);
-				return attachToolState(coerceBlocks ? coerceToolResultContent(out) : out, staged);
-			} catch (err) {
-				if (isRestateControlOrAbort(err, toolCtx.signal)) throw err;
-				return attachToolState(makeSoftToolError(err), staged);
-			}
-		}, runOpts);
-	};
-	const finishJournaled = async (journaled, staged) => {
-		let value;
-		try {
-			value = await journaled;
-		} catch (err) {
-			staged?.clear();
-			throw err;
-		}
-		const output = applyToolState(value, staged);
-		return softErrors ? rethrowSoftToolError(output) : output;
-	};
-	const executeDurably = (input, toolCtx) => {
-		const staged = stagedToolState(toolCtx.state);
-		if (!softErrors && !staged) return runJournaled(input, toolCtx);
-		return finishJournaled(runJournaled(input, toolCtx), staged);
-	};
-	const durableExecuteImpl = (input, toolCtx) => {
-		const staged = stagedToolState(toolCtx.state);
-		if (!softErrors && !staged) return runJournaled(input, toolCtx);
-		return unwrapDurableToolValue(runJournaled(input, toolCtx), staged, softErrors);
-	};
-	const executeTwoPhaseInner = async (input, toolCtx) => {
-		const start = durableStart;
-		const staged = stagedToolState(toolCtx.state);
-		seq += 1;
-		const entry = nameFor(seq, canonicalName, input, toolCtx.callId);
-		const runFinal = async (body) => applyToolState(await ctx.run(entry, async () => {
-			options.replayTracker?.markLive();
-			return attachToolState(await body(), staged);
-		}, runOpts), staged);
-		const token = await ctx.run(`${entry}-start`, async () => {
-			options.replayTracker?.markLive();
-			await hydrateOnce(toolCtx);
-			return start.start(input, toolCtx);
-		}, runOpts);
-		const onAbort = start.onAbort;
-		const signal = toolCtx.signal;
-		let fired = false;
-		const fireAbortCleanup = () => {
-			if (fired || !onAbort) return;
-			fired = true;
-			Promise.resolve(onAbort(token, input, toolCtx)).catch((err) => {
-				if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/restate] durableStart onAbort threw: ${err instanceof Error ? err.message : String(err)}\n`);
-			});
-		};
-		const wait = start.wait;
-		if (wait) {
-			if (wait.inline?.(token, input, toolCtx)) {
-				if (!onAbort || !signal) return await runFinal(() => wait.result(token, null, input, toolCtx));
-				if (signal.aborted) fireAbortCleanup();
-				else signal.addEventListener("abort", fireAbortCleanup, { once: true });
-				try {
-					return await runFinal(() => wait.result(token, null, input, toolCtx));
-				} finally {
-					signal.removeEventListener("abort", fireAbortCleanup);
-				}
-			}
-			if (signal?.aborted) {
-				fireAbortCleanup();
-				throw new Error(`${canonicalName}: aborted before durable wait registration`);
-			}
-			signal?.addEventListener("abort", fireAbortCleanup, { once: true });
+/** Hydrate the session's read-state map once per session (per process) — see {@link HYDRATED_READ_STATE_SESSIONS}. */
+async function hydrateOnce(toolCtx) {
+	if (!toolCtx.session || HYDRATED_READ_STATE_SESSIONS.has(toolCtx.session)) return;
+	HYDRATED_READ_STATE_SESSIONS.add(toolCtx.session);
+	let aliasMaps;
+	if (toolCtx.toolAliases) try {
+		aliasMaps = buildAliasMaps(toolCtx.toolAliases, Object.keys(toolCtx.tools));
+	} catch {
+		aliasMaps = void 0;
+	}
+	await hydrateReadStateFromSessionAsync(toolCtx.session, toolCtx.handle.cwd, {
+		defaultLineNumbers: toolCtx.behavior?.readLineNumbers ?? true,
+		...aliasMaps ? { aliasMaps } : {},
+		readFileForHash: async (path) => {
 			try {
-				const timeoutMs = typeof wait.timeoutMs === "function" ? wait.timeoutMs(input, toolCtx) : wait.timeoutMs;
-				const awakeable = awakeableWithTimeout(ctx, {
-					...timeoutMs !== void 0 ? { timeoutMs } : {},
-					...wait.promises ? { promises: wait.promises } : {}
-				});
-				const marker = await ctx.run(`${entry}-register`, async () => {
-					options.replayTracker?.markLive();
-					await wait.register(token, awakeable.id, input, toolCtx);
-					return {
-						registered: true,
-						awakeableId: awakeable.id
-					};
-				}, runOpts);
-				if (marker.awakeableId !== awakeable.id) throw new Error(`restateTool(${canonicalName}): journal drift — registration marker carries awakeable "${marker.awakeableId}" but this replay minted "${awakeable.id}". Refusing to park on an unreachable awakeable.`);
-				const resumed = await parkWithSignal(awakeable.promise, signal, canonicalName);
-				return await runFinal(() => wait.result(token, resumed, input, toolCtx));
-			} finally {
-				signal?.removeEventListener("abort", fireAbortCleanup);
+				return await toolCtx.execution.readFile(toolCtx.handle, path);
+			} catch {
+				return null;
 			}
 		}
-		const attach = () => runFinal(() => start.attach(token, input, toolCtx));
-		if (!onAbort || !signal) return attach();
-		if (signal.aborted) {
-			fireAbortCleanup();
-			return attach();
-		}
-		signal.addEventListener("abort", fireAbortCleanup, { once: true });
-		try {
-			return await attach();
-		} finally {
-			signal.removeEventListener("abort", fireAbortCleanup);
-		}
-	};
-	const executeTwoPhase = async (input, toolCtx) => {
-		const staged = stagedToolState(toolCtx.state);
-		try {
-			return await executeTwoPhaseInner(input, toolCtx);
-		} catch (err) {
-			staged?.clear();
-			throw err;
-		}
-	};
-	if (durableStart) {
-		const { durableExecute: _dropped, ...rest } = inner;
-		return {
-			...rest,
-			spec: shellBackgroundDisabled ? withoutShellBackgroundInput(inner.spec) : inner.spec,
-			execute: executeTwoPhase
-		};
-	}
-	return {
-		...inner,
-		spec: shellBackgroundDisabled ? withoutShellBackgroundInput(inner.spec) : inner.spec,
-		execute: executeDurably,
-		durableExecute: durableExecuteImpl
-	};
+	});
 }
+//#endregion
+//#region src/restate/tool-journal.ts
 function isToolStateEnvelope(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
 	const candidate = value;
@@ -525,6 +374,85 @@ function unwrapDurableToolValue(promise, staged, softErrors) {
 		return softErrors ? rethrowSoftToolError(output) : output;
 	});
 }
+//#endregion
+//#region src/restate/tool-two-phase.ts
+/** The two-phase (start + attach / awakeable wait) execution — see `restateTool`. */
+async function executeTwoPhaseInner(env, input, toolCtx) {
+	const { ctx, options, runOpts, nameFor, canonicalName, durableStart, counter } = env;
+	const start = durableStart;
+	const staged = stagedToolState(toolCtx.state);
+	counter.seq += 1;
+	const entry = nameFor(counter.seq, canonicalName, input, toolCtx.callId);
+	const runFinal = async (body) => applyToolState(await ctx.run(entry, async () => {
+		options.replayTracker?.markLive();
+		return attachToolState(await body(), staged);
+	}, runOpts), staged);
+	const token = await ctx.run(`${entry}-start`, async () => {
+		options.replayTracker?.markLive();
+		await hydrateOnce(toolCtx);
+		return start.start(input, toolCtx);
+	}, runOpts);
+	const onAbort = start.onAbort;
+	const signal = toolCtx.signal;
+	let fired = false;
+	const fireAbortCleanup = () => {
+		if (fired || !onAbort) return;
+		fired = true;
+		Promise.resolve(onAbort(token, input, toolCtx)).catch((err) => {
+			if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/restate] durableStart onAbort threw: ${err instanceof Error ? err.message : String(err)}\n`);
+		});
+	};
+	const wait = start.wait;
+	if (wait) {
+		if (wait.inline?.(token, input, toolCtx)) {
+			if (!onAbort || !signal) return await runFinal(() => wait.result(token, null, input, toolCtx));
+			if (signal.aborted) fireAbortCleanup();
+			else signal.addEventListener("abort", fireAbortCleanup, { once: true });
+			try {
+				return await runFinal(() => wait.result(token, null, input, toolCtx));
+			} finally {
+				signal.removeEventListener("abort", fireAbortCleanup);
+			}
+		}
+		if (signal?.aborted) {
+			fireAbortCleanup();
+			throw new Error(`${canonicalName}: aborted before durable wait registration`);
+		}
+		signal?.addEventListener("abort", fireAbortCleanup, { once: true });
+		try {
+			const timeoutMs = typeof wait.timeoutMs === "function" ? wait.timeoutMs(input, toolCtx) : wait.timeoutMs;
+			const awakeable = awakeableWithTimeout(ctx, {
+				...timeoutMs !== void 0 ? { timeoutMs } : {},
+				...wait.promises ? { promises: wait.promises } : {}
+			});
+			const marker = await ctx.run(`${entry}-register`, async () => {
+				options.replayTracker?.markLive();
+				await wait.register(token, awakeable.id, input, toolCtx);
+				return {
+					registered: true,
+					awakeableId: awakeable.id
+				};
+			}, runOpts);
+			if (marker.awakeableId !== awakeable.id) throw new Error(`restateTool(${canonicalName}): journal drift: registration marker carries awakeable "${marker.awakeableId}" but this replay minted "${awakeable.id}". Refusing to park on an unreachable awakeable.`);
+			const resumed = await parkWithSignal(awakeable.promise, signal, canonicalName);
+			return await runFinal(() => wait.result(token, resumed, input, toolCtx));
+		} finally {
+			signal?.removeEventListener("abort", fireAbortCleanup);
+		}
+	}
+	const attach = () => runFinal(() => start.attach(token, input, toolCtx));
+	if (!onAbort || !signal) return attach();
+	if (signal.aborted) {
+		fireAbortCleanup();
+		return attach();
+	}
+	signal.addEventListener("abort", fireAbortCleanup, { once: true });
+	try {
+		return await attach();
+	} finally {
+		signal.removeEventListener("abort", fireAbortCleanup);
+	}
+}
 /**
 * Park on `promise`, but stop waiting when the per-call abort signal
 * fires (run abort, `cancelTool`, sibling-cascade cancel) — a deliberate
@@ -549,6 +477,98 @@ function parkWithSignal(promise, signal, name) {
 		});
 	});
 }
+//#endregion
+//#region src/restate/tool.ts
+const SHELL_BACKGROUND_DISABLED_MESSAGE = "shell error: background mode is disabled for Restate-backed agents. Fall back to foreground (drop `run_in_background`).";
+/**
+* Wrap a single `ToolDef` so its `execute` runs inside `ctx.run`. The
+* tool's `spec` and `isConcurrencySafe` pass through unchanged.
+*/
+function restateTool(inner, ctx, options = {}) {
+	const runOpts = options.runOptions ?? { maxRetryAttempts: 1 };
+	const nameFor = options.entryName ?? ((seq, name) => `tool-${name}-${seq}`);
+	const canonicalName = inner.spec.name;
+	const shellBackgroundDisabled = (options.disableShellBackground ?? options.detachedTasks !== "durable") && canonicalName === "shell";
+	const durableStart = options.durableStart;
+	if (durableStart && !durableStart.attach && !durableStart.wait) throw new Error(`restateTool(${canonicalName}): durableStart needs an \`attach\` (in-journal wait) or a \`wait\` (awakeable park) phase`);
+	const counter = { seq: 0 };
+	const softErrors = options.softErrors ?? true;
+	const coerceBlocks = options.coerceResultBlocks ?? true;
+	const runJournaled = (input, toolCtx) => {
+		counter.seq += 1;
+		return ctx.run(nameFor(counter.seq, canonicalName, input, toolCtx.callId), async () => {
+			options.replayTracker?.markLive();
+			await hydrateOnce(toolCtx);
+			const staged = stagedToolState(toolCtx.state);
+			staged?.clear();
+			if (shellBackgroundDisabled && input.run_in_background === true) return SHELL_BACKGROUND_DISABLED_MESSAGE;
+			if (!softErrors) {
+				const out = await inner.execute(input, toolCtx);
+				return attachToolState(coerceBlocks ? coerceToolResultContent(out) : out, staged);
+			}
+			try {
+				const out = await inner.execute(input, toolCtx);
+				return attachToolState(coerceBlocks ? coerceToolResultContent(out) : out, staged);
+			} catch (err) {
+				if (isRestateControlOrAbort(err, toolCtx.signal)) throw err;
+				return attachToolState(makeSoftToolError(err), staged);
+			}
+		}, runOpts);
+	};
+	const finishJournaled = async (journaled, staged) => {
+		let value;
+		try {
+			value = await journaled;
+		} catch (err) {
+			staged?.clear();
+			throw err;
+		}
+		const output = applyToolState(value, staged);
+		return softErrors ? rethrowSoftToolError(output) : output;
+	};
+	const executeDurably = (input, toolCtx) => {
+		const staged = stagedToolState(toolCtx.state);
+		if (!softErrors && !staged) return runJournaled(input, toolCtx);
+		return finishJournaled(runJournaled(input, toolCtx), staged);
+	};
+	const durableExecuteImpl = (input, toolCtx) => {
+		const staged = stagedToolState(toolCtx.state);
+		if (!softErrors && !staged) return runJournaled(input, toolCtx);
+		return unwrapDurableToolValue(runJournaled(input, toolCtx), staged, softErrors);
+	};
+	const twoPhaseEnv = {
+		ctx,
+		options,
+		runOpts,
+		nameFor,
+		canonicalName,
+		durableStart,
+		counter
+	};
+	const executeTwoPhase = async (input, toolCtx) => {
+		const staged = stagedToolState(toolCtx.state);
+		try {
+			return await executeTwoPhaseInner(twoPhaseEnv, input, toolCtx);
+		} catch (err) {
+			staged?.clear();
+			throw err;
+		}
+	};
+	if (durableStart) {
+		const { durableExecute: _dropped, ...rest } = inner;
+		return {
+			...rest,
+			spec: shellBackgroundDisabled ? withoutShellBackgroundInput(inner.spec) : inner.spec,
+			execute: executeTwoPhase
+		};
+	}
+	return {
+		...inner,
+		spec: shellBackgroundDisabled ? withoutShellBackgroundInput(inner.spec) : inner.spec,
+		execute: executeDurably,
+		durableExecute: durableExecuteImpl
+	};
+}
 function withoutShellBackgroundInput(spec) {
 	const inputSchema = spec.inputSchema;
 	const properties = isRecord(inputSchema.properties) ? inputSchema.properties : void 0;
@@ -583,7 +603,7 @@ function wrapAgentTools(tools, ctx, opts = {}) {
 	const excludeSet = new Set(opts.exclude ?? []);
 	const skipWaitTask = opts.detachedTasks === "durable";
 	const wrapped = {};
-	for (const [name, def] of Object.entries(tools)) wrapped[name] = excludeSet.has(name) || def.runsNestedAgent === true || skipWaitTask && def.spec.name === "wait_task" ? def : restateTool(def, ctx, opts);
+	for (const [name, def] of Object.entries(tools)) wrapped[name] = excludeSet.has(name) || def.runsNestedAgent === true || def.callsNestedTools === true || skipWaitTask && def.spec.name === "wait_task" ? def : restateTool(def, ctx, opts);
 	return wrapped;
 }
 //#endregion
@@ -825,7 +845,7 @@ function restateSessionStore(ctx, options = {}) {
 	function guardSessionId(sessionId) {
 		if (warnedMismatch || sessionId === ctx.key) return;
 		warnedMismatch = true;
-		process.stderr.write(`[zidane/restate] restateSessionStore: sessionId "${sessionId}" != bound object key "${ctx.key}". This store ignores the sessionId and operates on the bound object — pass createSession({ id: ctx.key }) to silence this.\n`);
+		process.stderr.write(`[zidane/restate] restateSessionStore: sessionId "${sessionId}" != bound object key "${ctx.key}". This store ignores the sessionId and uses the bound object. Pass createSession({ id: ctx.key }) to silence this.\n`);
 	}
 	async function generateTurnId() {
 		if (nextTurnSeq === void 0) nextTurnSeq = (await loadTurns()).length;
@@ -981,7 +1001,107 @@ function maxDefined(values) {
 	return max;
 }
 //#endregion
-//#region src/restate/spawn.ts
+//#region src/restate/spawn-events.ts
+/**
+* Replay a finished child's transcript onto the PARENT's hook bus as `child:*`
+* events, so hosts that already render subagent activity (`src/output/
+* terminal.ts`, the GUI engine, any `child:tool:*` listener) light up for
+* parallel children without a single change.
+*
+* Not live \u2014 hook bubbling cannot cross an invocation boundary, so these fire
+* when the child finishes, in submission order. Everything here is derived
+* from the journaled call result, so a parent replay produces the identical
+* sequence; like the in-process tool's `child:tool:*`, they DO re-fire on that
+* replay, so hosts dedupe by `callId` / `turnId` or gate on
+* `createReplayTracker`.
+*
+* Only events that describe things the child actually did are synthesized.
+* `tool:gate` / `tool:transform` / `tool:dispatched` / `tool:cancelled` /
+* `background:*` describe decisions taken inside another process; inventing
+* them would be fiction, so they stay absent.
+*/
+async function replayChildEvents(child, turns, ctx) {
+	if (turns.length === 0) return;
+	const outputs = /* @__PURE__ */ new Map();
+	for (const turn of turns) for (const block of turn.content) if (block.type === "tool_result") outputs.set(block.callId, {
+		output: block.output,
+		...block.isError !== void 0 ? { isError: block.isError } : {}
+	});
+	const childIdentity = {
+		childId: child.label,
+		depth: child.depth
+	};
+	const identity = {
+		...childIdentity,
+		runId: child.runId,
+		...child.parentRunId !== void 0 ? { parentRunId: child.parentRunId } : {},
+		parentCallId: child.callId
+	};
+	const runToolCounts = {};
+	let assistantTurns = 0;
+	for (const turn of turns) {
+		if (turn.role !== "assistant") continue;
+		assistantTurns += 1;
+		const text = turn.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+		if (text.length > 0) await ctx.hooks.callHook("child:stream:text", {
+			...childIdentity,
+			turnId: turn.id,
+			delta: text,
+			text
+		});
+		const turnToolCounts = {};
+		for (const block of turn.content) {
+			if (block.type !== "tool_call") continue;
+			runToolCounts[block.name] = (runToolCounts[block.name] ?? 0) + 1;
+			turnToolCounts[block.name] = (turnToolCounts[block.name] ?? 0) + 1;
+			const base = {
+				...identity,
+				turnId: turn.id,
+				callId: block.id,
+				name: block.name,
+				displayName: block.name,
+				input: block.input,
+				runToolCounts: { ...runToolCounts }
+			};
+			await ctx.hooks.callHook("child:tool:before", base);
+			const settled = outputs.get(block.id);
+			if (settled === void 0) continue;
+			const isError = settled.isError === true;
+			if (isError) await ctx.hooks.callHook("child:tool:error", {
+				...base,
+				error: new Error(toolResultToText(settled.output))
+			});
+			await ctx.hooks.callHook("child:tool:after", {
+				...base,
+				result: settled.output,
+				isError,
+				outputBytes: toolOutputByteLength(settled.output)
+			});
+		}
+		const usage = turn.usage ?? {
+			input: 0,
+			output: 0
+		};
+		await ctx.hooks.callHook("child:turn:after", {
+			...childIdentity,
+			turn: assistantTurns,
+			turnId: turn.id,
+			usage,
+			message: turn,
+			toolCounts: {
+				turn: { ...turnToolCounts },
+				run: { ...runToolCounts }
+			}
+		});
+		await ctx.hooks.callHook("child:stream:end", {
+			...childIdentity,
+			turnId: turn.id,
+			text
+		});
+	}
+}
+//#endregion
+//#region src/restate/spawn-state.ts
 const ZERO_STATS = {
 	totalIn: 0,
 	totalOut: 0,
@@ -990,405 +1110,344 @@ const ZERO_STATS = {
 	turns: 0,
 	elapsed: 0
 };
-const DEFAULT_DESCRIPTION = "Delegate a self-contained task to a sub-agent that runs independently and returns only its final report. Several spawn calls in one turn run in parallel.";
-function restateSpawnTool(options) {
-	const persist = options.persist ?? true;
-	const emitEvents = options.emitChildEvents ?? true;
-	let dispatchSeq = 0;
-	let sessionlessLabels = 0;
-	let cancelSignalled = false;
-	let nestedLabels = 0;
-	const pending = [];
-	const drainRegistered = /* @__PURE__ */ new WeakSet();
-	/**
-	* Build the request and the bookkeeping entry. Deliberately side-effect free
-	* apart from reserving the label: the fleet path has to be able to reject a
-	* misconfigured `dispatch` (below) without leaving a phantom child queued for
-	* the merge. `commit` is what actually enrols the child.
-	*/
-	function prepare(input, ctx) {
-		const task = String(input.task ?? "");
-		const depth = (ctx.depth ?? 0) + 1;
-		const label = ctx.session ? reserveChildLabel(ctx.session) : `child-${++sessionlessLabels}`;
-		return {
-			entry: {
-				order: ++dispatchSeq,
-				label,
-				task,
-				depth,
-				callId: ctx.callId,
-				runId: `${ctx.runId ?? "run"}-${label}`,
-				...ctx.runId !== void 0 ? { parentRunId: ctx.runId } : {},
-				...ctx.session !== void 0 ? { session: ctx.session } : {}
-			},
-			req: {
-				task,
-				label,
-				depth,
-				...ctx.runId !== void 0 ? { parentRunId: ctx.runId } : {},
-				parentCallId: ctx.callId,
-				...ctx.session !== void 0 ? { sessionId: ctx.session.id } : {},
-				...typeof input.model === "string" ? { model: input.model } : {},
-				...typeof input.subagent_type === "string" ? { subagentType: input.subagent_type } : {}
-			}
-		};
-	}
-	/** Enrol a dispatched child for merging, and announce it. */
-	function commit(entry, input, ctx) {
-		pending.push(entry);
-		registerDrain(ctx);
-		watchAbort(entry, ctx);
-		Promise.resolve(ctx.hooks.callHook("spawn:before", {
+function errorText(entry) {
+	if (entry.failure !== void 0) return entry.failure instanceof Error ? entry.failure.message : String(entry.failure);
+	return entry.result?.error ?? "sub-agent failed";
+}
+//#endregion
+//#region src/restate/spawn-merge.ts
+/**
+* Persist finished children and announce them. Runs where awaiting is legal,
+* in submission order rather than settlement order, so two children that
+* complete out of order still land deterministically.
+*/
+async function drain(rt, ctx) {
+	if (rt.pending.length === 0) return;
+	const batch = rt.pending.splice(0, rt.pending.length).sort((a, b) => a.order - b.order);
+	let touchedSession;
+	for (const entry of batch) {
+		const result = entry.result;
+		const stats = result?.stats ?? ZERO_STATS;
+		const status = result?.status ?? (entry.cancelRequested ? "aborted" : "error");
+		const session = entry.session;
+		if (rt.persist && session) {
+			touchedSession = session;
+			session.startRun(entry.runId, entry.task, {
+				...entry.parentRunId !== void 0 ? { parentRunId: entry.parentRunId } : {},
+				depth: entry.depth,
+				label: entry.label,
+				...entry.callId ? { parentCallId: entry.callId } : {}
+			});
+			if (result && result.turns.length > 0) await session.appendTurns(result.turns.map((turn) => ({
+				...turn,
+				runId: entry.runId
+			})));
+			const rollup = {
+				turns: stats.turns,
+				tokensIn: stats.totalIn,
+				tokensOut: stats.totalOut,
+				...stats.cost !== void 0 ? { cost: stats.cost } : {}
+			};
+			if (status === "completed") session.completeRun(entry.runId, rollup);
+			else if (status === "error") session.errorRun(entry.runId, errorText(entry), rollup);
+			else session.abortRun(entry.runId, rollup);
+			stampJournaledRunTimes(session, entry, result);
+		}
+		if (rt.emitEvents && result) await replayChildEvents(entry, result.turns, ctx);
+		if (result?.children && result.children.length > 0) {
+			const merged = await mergeDescendants(rt, {
+				...entry,
+				parentChildId: entry.label
+			}, result.children, ctx);
+			if (merged) touchedSession = merged;
+		}
+		rt.options.onChildMerged?.({
+			label: entry.label,
+			task: entry.task,
+			depth: entry.depth,
+			status,
+			stats,
+			turns: result?.turns ?? [],
+			...result?.startedAt !== void 0 ? { startedAt: result.startedAt } : {},
+			...result?.endedAt !== void 0 ? { endedAt: result.endedAt } : {},
+			...result?.children !== void 0 ? { children: result.children } : {}
+		}, ctx);
+		if (status === "error") await ctx.hooks.callHook("spawn:error", {
+			id: entry.label,
+			task: entry.task,
+			error: new Error(errorText(entry)),
+			depth: entry.depth
+		});
+		await ctx.hooks.callHook("spawn:complete", {
 			id: entry.label,
 			task: entry.task,
 			callId: entry.callId,
 			depth: entry.depth,
-			...typeof input.model === "string" ? { model: input.model } : {}
-		})).catch(() => {});
-	}
-	function registerDrain(ctx) {
-		if (drainRegistered.has(ctx.hooks)) return;
-		drainRegistered.add(ctx.hooks);
-		ctx.hooks.hook("tool-results:after", async () => {
-			await drain(ctx);
-		});
-		ctx.hooks.hook("turn:after", async () => {
-			await drain(ctx);
+			status,
+			stats,
+			...result?.text ? { text: result.text } : {}
 		});
 	}
-	/**
-	* Persist finished children and announce them. Runs where awaiting is legal,
-	* in submission order rather than settlement order, so two children that
-	* complete out of order still land deterministically.
-	*/
-	async function drain(ctx) {
-		if (pending.length === 0) return;
-		const batch = pending.splice(0, pending.length).sort((a, b) => a.order - b.order);
-		let touchedSession;
-		for (const entry of batch) {
-			const result = entry.result;
-			const stats = result?.stats ?? ZERO_STATS;
-			const status = result?.status ?? (entry.cancelRequested ? "aborted" : "error");
-			const session = entry.session;
-			if (persist && session) {
-				touchedSession = session;
-				session.startRun(entry.runId, entry.task, {
-					...entry.parentRunId !== void 0 ? { parentRunId: entry.parentRunId } : {},
-					depth: entry.depth,
-					label: entry.label
-				});
-				if (result && result.turns.length > 0) await session.appendTurns(result.turns.map((turn) => ({
-					...turn,
-					runId: entry.runId
-				})));
-				const rollup = {
-					turns: stats.turns,
-					tokensIn: stats.totalIn,
-					tokensOut: stats.totalOut,
-					...stats.cost !== void 0 ? { cost: stats.cost } : {}
-				};
-				if (status === "completed") session.completeRun(entry.runId, rollup);
-				else if (status === "error") session.errorRun(entry.runId, errorText(entry), rollup);
-				else session.abortRun(entry.runId, rollup);
-				stampJournaledRunTimes(session, entry, result);
-			}
-			if (emitEvents && result) await replayChildEvents(entry, result.turns, ctx);
-			if (result?.children && result.children.length > 0) {
-				const merged = await mergeDescendants(entry, result.children, ctx);
-				if (merged) touchedSession = merged;
-			}
-			options.onChildMerged?.({
-				label: entry.label,
-				task: entry.task,
-				depth: entry.depth,
-				status,
-				stats,
-				turns: result?.turns ?? [],
-				...result?.startedAt !== void 0 ? { startedAt: result.startedAt } : {},
-				...result?.endedAt !== void 0 ? { endedAt: result.endedAt } : {},
-				...result?.children !== void 0 ? { children: result.children } : {}
-			}, ctx);
-			if (status === "error") await ctx.hooks.callHook("spawn:error", {
-				id: entry.label,
-				task: entry.task,
-				error: new Error(errorText(entry)),
-				depth: entry.depth
-			});
-			await ctx.hooks.callHook("spawn:complete", {
-				id: entry.label,
-				task: entry.task,
-				callId: entry.callId,
-				depth: entry.depth,
-				status,
-				stats,
-				...result?.text ? { text: result.text } : {}
+	await touchedSession?.save();
+}
+/**
+* Merge a child's own descendants under it, depth-first and in the order the
+* child reported them.
+*
+* Each nested child is RE-LABELED from the merging session's counter: the
+* label it arrived with was minted by its own parent's counter and would
+* collide (every level starts at `child-1`). Re-labeling keeps the session's
+* labels unique and makes the synthesized events agree with the persisted
+* tree.
+*
+* Each nested child is announced as `child:spawn:before` → its work →
+* (`child:spawn:error`) → `child:spawn:complete`, owned by the merged label
+* of the child that spawned it (`parentChildId`) — the same lifecycle an
+* in-process nested spawn bubbles, so hosts nest and close it identically.
+* Unconditional, like the top-level `spawn:complete`: lifecycle is not
+* `emitChildEvents` traffic. No `callId`: the spawn call inside the child is
+* not part of the merged result.
+*/
+async function mergeDescendants(rt, parent, nested, ctx) {
+	let touched;
+	const session = parent.session;
+	for (const child of nested) {
+		const depth = parent.depth + 1;
+		const label = session ? reserveChildLabel(session) : `${parent.runId}-nested-${++rt.nestedLabels}`;
+		const runId = `${parent.runId}-${label}`;
+		const record = {
+			id: label,
+			task: child.task,
+			depth,
+			parentChildId: parent.parentChildId
+		};
+		await ctx.hooks.callHook("child:spawn:before", record);
+		if (rt.persist && session) {
+			touched = session;
+			session.startRun(runId, child.task, {
+				parentRunId: parent.runId,
+				depth,
+				label
 			});
-		}
-		await touchedSession?.save();
-	}
-	/**
-	* Merge a child's own descendants under it, depth-first and in the order the
-	* child reported them.
-	*
-	* Each nested child is RE-LABELED from the merging session's counter: the
-	* label it arrived with was minted by its own parent's counter and would
-	* collide (every level starts at `child-1`). Re-labeling keeps the session's
-	* labels unique and makes the synthesized events agree with the persisted
-	* tree.
-	*/
-	async function mergeDescendants(parent, nested, ctx) {
-		let touched;
-		const session = parent.session;
-		for (const child of nested) {
-			const depth = parent.depth + 1;
-			const label = session ? reserveChildLabel(session) : `${parent.runId}-nested-${++nestedLabels}`;
-			const runId = `${parent.runId}-${label}`;
-			if (persist && session) {
-				touched = session;
-				session.startRun(runId, child.task, {
-					parentRunId: parent.runId,
-					depth,
-					label
-				});
-				if (child.turns.length > 0) await session.appendTurns(child.turns.map((turn) => ({
-					...turn,
-					runId
-				})));
-				const rollup = {
-					turns: child.stats.turns,
-					tokensIn: child.stats.totalIn,
-					tokensOut: child.stats.totalOut,
-					...child.stats.cost !== void 0 ? { cost: child.stats.cost } : {}
-				};
-				if (child.status === "completed") session.completeRun(runId, rollup);
-				else if (child.status === "error") session.errorRun(runId, "sub-agent failed", rollup);
-				else session.abortRun(runId, rollup);
-				const record = session.runs.find((run) => run.id === runId);
-				if (record) {
-					const startedAt = child.startedAt ?? child.turns[0]?.createdAt;
-					const endedAt = child.endedAt ?? child.turns[child.turns.length - 1]?.createdAt ?? startedAt;
-					if (startedAt !== void 0) record.startedAt = startedAt;
-					if (endedAt !== void 0) record.endedAt = endedAt;
-				}
+			if (child.turns.length > 0) await session.appendTurns(child.turns.map((turn) => ({
+				...turn,
+				runId
+			})));
+			const rollup = {
+				turns: child.stats.turns,
+				tokensIn: child.stats.totalIn,
+				tokensOut: child.stats.totalOut,
+				...child.stats.cost !== void 0 ? { cost: child.stats.cost } : {}
+			};
+			if (child.status === "completed") session.completeRun(runId, rollup);
+			else if (child.status === "error") session.errorRun(runId, "sub-agent failed", rollup);
+			else session.abortRun(runId, rollup);
+			const run = session.runs.find((r) => r.id === runId);
+			if (run) {
+				const startedAt = child.startedAt ?? child.turns[0]?.createdAt;
+				const endedAt = child.endedAt ?? child.turns[child.turns.length - 1]?.createdAt ?? startedAt;
+				if (startedAt !== void 0) run.startedAt = startedAt;
+				if (endedAt !== void 0) run.endedAt = endedAt;
 			}
-			if (emitEvents) await replayChildEvents({
-				label,
-				depth,
+		}
+		if (rt.emitEvents) await replayChildEvents({
+			label,
+			depth,
+			runId,
+			callId: parent.callId,
+			...parent.runId ? { parentRunId: parent.runId } : {}
+		}, child.turns, ctx);
+		if (child.children && child.children.length > 0) {
+			const deeper = await mergeDescendants(rt, {
 				runId,
+				depth,
 				callId: parent.callId,
-				...parent.runId ? { parentRunId: parent.runId } : {}
-			}, child.turns, ctx);
-			if (child.children && child.children.length > 0) {
-				const deeper = await mergeDescendants({
-					runId,
-					depth,
-					callId: parent.callId,
-					...session ? { session } : {}
-				}, child.children, ctx);
-				touched = touched ?? deeper;
-			}
+				parentChildId: label,
+				...session ? { session } : {}
+			}, child.children, ctx);
+			touched = touched ?? deeper;
 		}
-		return touched;
-	}
-	/**
-	* Repair the run record's timestamps with journaled values.
-	*
-	* `startRun` / `completeRun` / `errorRun` / `abortRun` stamp `Date.now()`
-	* internally, and these records reach `ctx.set` through `save()` below — so a
-	* live value here changes the state payload on a replay and kills the
-	* invocation with `RestateError 570`. The loop repairs its own runs exactly
-	* this way (`agent.ts`: `sessionRun.startedAt = runStartedAt`, `run.endedAt =
-	* await clock.now()`); the merge path has to do the same.
-	*
-	* Sampling the parent's clock here is not an option: the drain runs inside a
-	* hook the loop may abandon (`settledHook`), and an awaited journal op left in
-	* flight is its own failure mode. Everything below is already journaled by the
-	* time it reaches us — either measured by the child on ITS clock and carried
-	* inside the journaled call result, or read from state the parent's own run
-	* already wrote.
-	*/
-	function stampJournaledRunTimes(session, entry, result) {
-		const merged = session.runs.find((run) => run.id === entry.runId);
-		if (!merged) return;
-		const turns = result?.turns ?? [];
-		const parentStartedAt = entry.parentRunId !== void 0 ? session.runs.find((run) => run.id === entry.parentRunId)?.startedAt : void 0;
-		const startedAt = result?.startedAt ?? turns[0]?.createdAt ?? parentStartedAt;
-		const endedAt = result?.endedAt ?? turns[turns.length - 1]?.createdAt ?? startedAt;
-		if (startedAt !== void 0) merged.startedAt = startedAt;
-		if (endedAt !== void 0) merged.endedAt = endedAt;
-	}
-	/**
-	* Replay a finished child's transcript onto the PARENT's hook bus as `child:*`
-	* events, so hosts that already render subagent activity (`src/output/
-	* terminal.ts`, the GUI engine, any `child:tool:*` listener) light up for
-	* parallel children without a single change.
-	*
-	* Not live \u2014 hook bubbling cannot cross an invocation boundary, so these fire
-	* when the child finishes, in submission order. Everything here is derived
-	* from the journaled call result, so a parent replay produces the identical
-	* sequence; like the in-process tool's `child:tool:*`, they DO re-fire on that
-	* replay, so hosts dedupe by `callId` / `turnId` or gate on
-	* `createReplayTracker`.
-	*
-	* Only events that describe things the child actually did are synthesized.
-	* `tool:gate` / `tool:transform` / `tool:dispatched` / `tool:cancelled` /
-	* `background:*` describe decisions taken inside another process; inventing
-	* them would be fiction, so they stay absent.
-	*/
-	async function replayChildEvents(child, turns, ctx) {
-		if (turns.length === 0) return;
-		const outputs = /* @__PURE__ */ new Map();
-		for (const turn of turns) for (const block of turn.content) if (block.type === "tool_result") outputs.set(block.callId, {
-			output: block.output,
-			...block.isError !== void 0 ? { isError: block.isError } : {}
+		if (child.status === "error") await ctx.hooks.callHook("child:spawn:error", {
+			...record,
+			error: /* @__PURE__ */ new Error("sub-agent failed")
+		});
+		await ctx.hooks.callHook("child:spawn:complete", {
+			...record,
+			status: child.status,
+			stats: child.stats
 		});
-		const childIdentity = {
-			childId: child.label,
-			depth: child.depth
-		};
-		const identity = {
-			...childIdentity,
-			runId: child.runId,
-			...child.parentRunId !== void 0 ? { parentRunId: child.parentRunId } : {},
-			parentCallId: child.callId
-		};
-		const runToolCounts = {};
-		let assistantTurns = 0;
-		for (const turn of turns) {
-			if (turn.role !== "assistant") continue;
-			assistantTurns += 1;
-			const text = turn.content.filter((block) => block.type === "text").map((block) => block.text).join("");
-			if (text.length > 0) await ctx.hooks.callHook("child:stream:text", {
-				...childIdentity,
-				turnId: turn.id,
-				delta: text,
-				text
-			});
-			const turnToolCounts = {};
-			for (const block of turn.content) {
-				if (block.type !== "tool_call") continue;
-				runToolCounts[block.name] = (runToolCounts[block.name] ?? 0) + 1;
-				turnToolCounts[block.name] = (turnToolCounts[block.name] ?? 0) + 1;
-				const base = {
-					...identity,
-					turnId: turn.id,
-					callId: block.id,
-					name: block.name,
-					displayName: block.name,
-					input: block.input,
-					runToolCounts: { ...runToolCounts }
-				};
-				await ctx.hooks.callHook("child:tool:before", base);
-				const settled = outputs.get(block.id);
-				if (settled === void 0) continue;
-				if (settled.isError === true) {
-					await ctx.hooks.callHook("child:tool:error", {
-						...base,
-						error: new Error(toolResultToText(settled.output))
-					});
-					continue;
-				}
-				await ctx.hooks.callHook("child:tool:after", {
-					...base,
-					result: settled.output,
-					outputBytes: toolOutputByteLength(settled.output)
-				});
-			}
-			const usage = turn.usage ?? {
-				input: 0,
-				output: 0
-			};
-			await ctx.hooks.callHook("child:turn:after", {
-				...childIdentity,
-				turn: assistantTurns,
-				turnId: turn.id,
-				usage,
-				message: turn,
-				toolCounts: {
-					turn: { ...turnToolCounts },
-					run: { ...runToolCounts }
-				}
-			});
-			await ctx.hooks.callHook("child:stream:end", {
-				...childIdentity,
-				turnId: turn.id,
-				text
-			});
-		}
-	}
-	function errorText(entry) {
-		if (entry.failure !== void 0) return entry.failure instanceof Error ? entry.failure.message : String(entry.failure);
-		return entry.result?.error ?? "sub-agent failed";
 	}
-	/**
-	* Shape the model-facing result. Mirrors the in-process tool's wording so a
-	* host or model tuned on one reads the other.
-	*
-	* `stats.elapsed` is safe to print here even though it is a live measurement:
-	* the child measured it inside ITS invocation and it arrives in the journaled
-	* call result, so the parent replays the same bytes. (Sampling it on the
-	* parent side is what corrupts a transcript — see `docs/RESTATE.md`.)
-	*/
-	/**
-	* Arm the abort path for one child. Nothing is read off the dispatch promise:
-	* touching its `invocationId` mid-flight would register a second consumer on
-	* the runtime's progress channel (see `onAbort`'s note), so the hook gets
-	* labels and the host cancels the tree.
-	*/
-	function watchAbort(entry, ctx) {
-		if (!options.onAbort) return;
-		if (ctx.signal.aborted) {
-			requestCancel(ctx);
-			return;
+	return touched;
+}
+/**
+* Repair the run record's timestamps with journaled values.
+*
+* `startRun` / `completeRun` / `errorRun` / `abortRun` stamp `Date.now()`
+* internally, and these records reach `ctx.set` through `save()` below — so a
+* live value here changes the state payload on a replay and kills the
+* invocation with `RestateError 570`. The loop repairs its own runs exactly
+* this way (`agent.ts`: `sessionRun.startedAt = runStartedAt`, `run.endedAt =
+* await clock.now()`); the merge path has to do the same.
+*
+* Sampling the parent's clock here is not an option: the drain runs inside a
+* hook the loop may abandon (`settledHook`), and an awaited journal op left in
+* flight is its own failure mode. Everything below is already journaled by the
+* time it reaches us — either measured by the child on ITS clock and carried
+* inside the journaled call result, or read from state the parent's own run
+* already wrote.
+*/
+function stampJournaledRunTimes(session, entry, result) {
+	const merged = session.runs.find((run) => run.id === entry.runId);
+	if (!merged) return;
+	const turns = result?.turns ?? [];
+	const parentStartedAt = entry.parentRunId !== void 0 ? session.runs.find((run) => run.id === entry.parentRunId)?.startedAt : void 0;
+	const startedAt = result?.startedAt ?? turns[0]?.createdAt ?? parentStartedAt;
+	const endedAt = result?.endedAt ?? turns[turns.length - 1]?.createdAt ?? startedAt;
+	if (startedAt !== void 0) merged.startedAt = startedAt;
+	if (endedAt !== void 0) merged.endedAt = endedAt;
+}
+//#endregion
+//#region src/restate/spawn-dispatch.ts
+/**
+* Build the request and the bookkeeping entry. Deliberately side-effect free
+* apart from reserving the label: the fleet path has to be able to reject a
+* misconfigured `dispatch` (below) without leaving a phantom child queued for
+* the merge. `commit` is what actually enrols the child.
+*/
+function prepare(rt, input, ctx) {
+	const task = String(input.task ?? "");
+	const depth = (ctx.depth ?? 0) + 1;
+	const label = ctx.session ? reserveChildLabel(ctx.session) : `child-${++rt.sessionlessLabels}`;
+	return {
+		entry: {
+			order: ++rt.dispatchSeq,
+			label,
+			task,
+			depth,
+			callId: ctx.callId,
+			runId: `${ctx.runId ?? "run"}-${label}`,
+			...ctx.runId !== void 0 ? { parentRunId: ctx.runId } : {},
+			...ctx.session !== void 0 ? { session: ctx.session } : {}
+		},
+		req: {
+			task,
+			label,
+			depth,
+			...ctx.runId !== void 0 ? { parentRunId: ctx.runId } : {},
+			parentCallId: ctx.callId,
+			...ctx.session !== void 0 ? { sessionId: ctx.session.id } : {},
+			...typeof input.model === "string" ? { model: input.model } : {},
+			...typeof input.subagent_type === "string" ? { subagentType: input.subagent_type } : {}
 		}
-		const onAbort = () => requestCancel(ctx);
-		ctx.signal.addEventListener("abort", onAbort, { once: true });
-		entry.release = () => ctx.signal.removeEventListener("abort", onAbort);
-	}
-	/**
-	* Fire the host's abort hook once for the whole in-flight set. Called once per
-	* abort, not once per child: cancelling the tree is a single operation, and a
-	* second call would append a redundant journal command.
-	*/
-	function requestCancel(ctx) {
-		const onAbort = options.onAbort;
-		if (!onAbort || cancelSignalled) return;
-		const inFlight = pending.filter((entry) => !entry.settled);
-		if (inFlight.length === 0) return;
-		cancelSignalled = true;
-		for (const entry of inFlight) entry.cancelRequested = true;
-		onAbort(inFlight.map((entry) => ({
-			label: entry.label,
-			task: entry.task,
-			depth: entry.depth
-		})), ctx);
+	};
+}
+/** Enrol a dispatched child for merging, and announce it. */
+function commit(rt, entry, input, ctx) {
+	rt.pending.push(entry);
+	registerDrain(rt, ctx);
+	watchAbort(rt, entry, ctx);
+	Promise.resolve(ctx.hooks.callHook("spawn:before", {
+		id: entry.label,
+		task: entry.task,
+		callId: entry.callId,
+		depth: entry.depth,
+		...typeof input.model === "string" ? { model: input.model } : {}
+	})).catch(() => {});
+}
+function registerDrain(rt, ctx) {
+	if (rt.drainRegistered.has(ctx.hooks)) return;
+	rt.drainRegistered.add(ctx.hooks);
+	ctx.hooks.hook("tool-results:after", async () => {
+		await drain(rt, ctx);
+	});
+	ctx.hooks.hook("turn:after", async () => {
+		await drain(rt, ctx);
+	});
+}
+/**
+* Shape the model-facing result. Mirrors the in-process tool's wording so a
+* host or model tuned on one reads the other.
+*
+* `stats.elapsed` is safe to print here even though it is a live measurement:
+* the child measured it inside ITS invocation and it arrives in the journaled
+* call result, so the parent replays the same bytes. (Sampling it on the
+* parent side is what corrupts a transcript — see `docs/RESTATE.md`.)
+*/
+/**
+* Arm the abort path for one child. Nothing is read off the dispatch promise:
+* touching its `invocationId` mid-flight would register a second consumer on
+* the runtime's progress channel (see `onAbort`'s note), so the hook gets
+* labels and the host cancels the tree.
+*/
+function watchAbort(rt, entry, ctx) {
+	if (!rt.options.onAbort) return;
+	if (ctx.signal.aborted) {
+		requestCancel(rt, ctx);
+		return;
 	}
-	function settle(entry, value, failure) {
-		entry.settled = true;
-		entry.release?.();
-		if (failure !== void 0) {
-			entry.failure = failure;
-			if (entry.cancelRequested) return `[sub-agent ${entry.label}] Aborted (cancelled)`;
-			return `[sub-agent ${entry.label}] Error: ${errorText(entry)}`;
-		}
-		const result = value ?? {
-			status: "error",
-			text: "",
-			turns: [],
-			stats: ZERO_STATS
-		};
-		entry.result = result;
-		const head = `[sub-agent ${entry.label}]`;
-		const usage = `Tokens: ${formatTokenUsage(result.stats)}`;
-		if (result.status === "completed") return [
-			`${head} Completed in ${result.stats.turns} turns (${result.stats.elapsed}ms)`,
-			usage,
-			"",
-			result.text || "(no text response)"
-		].join("\n");
-		if (result.status === "error") return `${head} Error: ${errorText(entry)}`;
-		return [`${head} ${result.status === "timeout" ? "Timed out" : "Aborted"} after ${result.stats.turns} turns (${result.stats.elapsed}ms)`, usage].join("\n");
+	const onAbort = () => requestCancel(rt, ctx);
+	ctx.signal.addEventListener("abort", onAbort, { once: true });
+	entry.release = () => ctx.signal.removeEventListener("abort", onAbort);
+}
+/**
+* Fire the host's abort hook once for the whole in-flight set. Called once per
+* abort, not once per child: cancelling the tree is a single operation, and a
+* second call would append a redundant journal command.
+*/
+function requestCancel(rt, ctx) {
+	const onAbort = rt.options.onAbort;
+	if (!onAbort || rt.cancelSignalled) return;
+	const inFlight = rt.pending.filter((entry) => !entry.settled);
+	if (inFlight.length === 0) return;
+	rt.cancelSignalled = true;
+	for (const entry of inFlight) entry.cancelRequested = true;
+	onAbort(inFlight.map((entry) => ({
+		label: entry.label,
+		task: entry.task,
+		depth: entry.depth
+	})), ctx);
+}
+function settle(entry, value, failure) {
+	entry.settled = true;
+	entry.release?.();
+	if (failure !== void 0) {
+		entry.failure = failure;
+		if (entry.cancelRequested) return `[sub-agent ${entry.label}] Aborted (cancelled)`;
+		return `[sub-agent ${entry.label}] Error: ${errorText(entry)}`;
 	}
+	const result = value ?? {
+		status: "error",
+		text: "",
+		turns: [],
+		stats: ZERO_STATS
+	};
+	entry.result = result;
+	const head = `[sub-agent ${entry.label}]`;
+	const usage = `Tokens: ${formatTokenUsage(result.stats)}`;
+	if (result.status === "completed") return [
+		`${head} Completed in ${result.stats.turns} turns (${result.stats.elapsed}ms)`,
+		usage,
+		"",
+		result.text || "(no text response)"
+	].join("\n");
+	if (result.status === "error") return `${head} Error: ${errorText(entry)}`;
+	return [`${head} ${result.status === "timeout" ? "Timed out" : "Aborted"} after ${result.stats.turns} turns (${result.stats.elapsed}ms)`, usage].join("\n");
+}
+//#endregion
+//#region src/restate/spawn.ts
+const DEFAULT_DESCRIPTION = "Delegate a self-contained task to a sub-agent that runs independently and returns only its final report. Several spawn calls in one turn run in parallel.";
+function restateSpawnTool(options) {
+	const rt = {
+		options,
+		persist: options.persist ?? true,
+		emitEvents: options.emitChildEvents ?? true,
+		dispatchSeq: 0,
+		sessionlessLabels: 0,
+		cancelSignalled: false,
+		nestedLabels: 0,
+		pending: [],
+		drainRegistered: /* @__PURE__ */ new WeakSet()
+	};
 	return {
 		spec: {
 			name: "spawn",
@@ -1415,16 +1474,16 @@ function restateSpawnTool(options) {
 		isConcurrencySafe: true,
 		runsNestedAgent: true,
 		durableExecute: (input, ctx) => {
-			const { req, entry } = prepare(input, ctx);
+			const { req, entry } = prepare(rt, input, ctx);
 			const promise = options.dispatch(req, ctx);
 			if (typeof promise.map !== "function") throw new TypeError("restateSpawnTool: `dispatch` must return the runtime's durable promise (e.g. `ctx.serviceClient(svc).runChild(req)`), which exposes `map`.");
-			commit(entry, input, ctx);
+			commit(rt, entry, input, ctx);
 			return promise.map((value, failure) => settle(entry, value, failure));
 		},
 		execute: async (input, ctx) => {
-			const { req, entry } = prepare(input, ctx);
+			const { req, entry } = prepare(rt, input, ctx);
 			const promise = options.dispatch(req, ctx);
-			commit(entry, input, ctx);
+			commit(rt, entry, input, ctx);
 			try {
 				return settle(entry, await promise);
 			} catch (err) {
@@ -1554,7 +1613,7 @@ function restateWaitBackground(options) {
 				awakeableId: awakeable.id
 			};
 		}, runOpts);
-		if (marker.awakeableId !== awakeable.id) throw new Error(`restateWaitBackground(${taskId}): journal drift — registration marker carries awakeable "${marker.awakeableId}" but this replay minted "${awakeable.id}". Refusing to park on an unreachable awakeable.`);
+		if (marker.awakeableId !== awakeable.id) throw new Error(`restateWaitBackground(${taskId}): journal drift: registration marker carries awakeable "${marker.awakeableId}" but this replay minted "${awakeable.id}". Refusing to park on an unreachable awakeable.`);
 		const found = (await ctx.run(`${entry}-probe`, async () => {
 			options.replayTracker?.markLive();
 			return [...await probe(handle, taskId)];