@tangle-network/agent-runtime 0.300.0 → 0.306.1

package/dist/{coordination-driver-DzTvehd6.js → coordination-driver-yj9HPXef.js}

@@ -1,5 +1,6 @@
-import { $i as detachedFrozen, $n as parseWorkerToolTraceArtifact, Aa as addResourceSpend, Ai as prepareJsonlAppend, Ar as contentAddress, Bn as InMemoryResultBlobStore, Da as unmeteredSpend, E as failedItems, It as createRouterTranscript, Lr as resolveRedactor, M as withDriverExecutor, Ma as withBudgetResources, Mi as writeAllBytes, Qt as createPeerMailbox, Rn as FileResultBlobStore, Tn as runBrainLoop, Vi as providerAttemptEvidence, Vn as InMemorySpawnJournal, _ as CheckUnavailableError, c as runTree, er as workerTraceAnalysisStore, ft as resolveSpawnResourcePaths, ga as chargedTokens, i as bestDelivered, ir as assertValidBudget, ji as readCommittedJsonLines, jt as createExecutorRegistry, nn as isLiveNodeStatus, o as pickBestDelivered, ot as scopeRetainedOwnerResourceReader, qt as createInbox, rn as isTerminalNodeStatus, s as runFinalizer, ur as errMessage, x as checkVerdictOf, xa as promptCacheTokenClasses, z as meterRuntimeOwnedProviderAttempt, zn as FileSpawnJournal } from "./supervisor-CQSu5XGl.js";
+import { Di as providerAttemptEvidence, Dn as FileSpawnJournal, Dr as resolveRedactor, Dt as createRouterTranscript, En as FileResultBlobStore, Fn as prepareJsonlAppend, Hn as workerTraceAnalysisStore, In as readCommittedJsonLines, Jt as isTerminalNodeStatus, Kn as assertValidBudget, Ln as writeAllBytes, On as InMemoryResultBlobStore, R as meterRuntimeOwnedProviderAttempt, Rt as createInbox, St as createExecutorRegistry, T as failedItems, Ut as createPeerMailbox, Vn as parseWorkerToolTraceArtifact, _ as CheckUnavailableError, br as contentAddress, c as runTree, er as errMessage, et as scopeRetainedOwnerResourceReader, i as bestDelivered, j as withDriverExecutor, kn as InMemorySpawnJournal, o as pickBestDelivered, pn as runBrainLoop, qt as isLiveNodeStatus, s as runFinalizer, st as resolveSpawnResourcePaths, x as checkVerdictOf, zi as detachedFrozen } from "./supervisor-gCfG6K1-.js";
 import { f as RuntimeRunStateError, m as ValidationError } from "./errors-DodWX-cb.js";
+import { V as chargedTokens, Z as promptCacheTokenClasses, at as unmeteredSpend, ft as withBudgetResources, lt as addResourceSpend } from "./workspace-streams-ILw0eWZ0.js";
 import { A as writeWorkerCancellation, M as writeWorkerSteerAcknowledgement, b as workerCancellationsDir, c as readWorkerCancelRequests, d as readWorkerSteerRequests, k as writeRunCancellation, l as readWorkerCancellation, o as readRunCancelRequest, r as claimWorkerSteerDelivery, s as readRunCancellation, u as readWorkerSteerAcknowledgement } from "./run-layout-DSCWdbX2.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest } from "@tangle-network/agent-interface";
 import { argHash, errorStreakDetector, observeAll, repeatedActionDetector } from "@tangle-network/agent-eval";
@@ -7,7 +8,6 @@ import { randomUUID } from "node:crypto";
 import { mkdirSync, readFileSync, watch } from "node:fs";
 import { join } from "node:path";
 import { registry } from "zod";
-import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/runtime/supervise/detector-monitor.ts
 /**
 *
@@ -57,6 +57,7 @@ function createEventBus(now = Date.now) {
 	const queue = [];
 	const log = [];
 	const subscribers = [];
+	const queuedHandlers = [];
 	const byKind = {};
 	const staged = /* @__PURE__ */ new WeakMap();
 	let seq = 0;
@@ -97,6 +98,7 @@ function createEventBus(now = Date.now) {
 			log.push(record);
 			published += 1;
 			byKind[event.type] = (byKind[event.type] ?? 0) + 1;
+			if (opts?.queue !== false) for (const handler of [...queuedHandlers]) handler(record);
 			return record;
 		},
 		pull(kinds) {
@@ -113,6 +115,13 @@ function createEventBus(now = Date.now) {
 				if (i >= 0) subscribers.splice(i, 1);
 			};
 		},
+		onQueued(handler) {
+			queuedHandlers.push(handler);
+			return () => {
+				const i = queuedHandlers.indexOf(handler);
+				if (i >= 0) queuedHandlers.splice(i, 1);
+			};
+		},
 		pending(kinds) {
 			return kinds ? queue.filter((r) => matches(r, kinds)).length : queue.length;
 		},
@@ -129,53 +138,6 @@ function createEventBus(now = Date.now) {
 	};
 }
 //#endregion
-//#region src/mcp/tools/coordination-request-context.ts
-/**
-* The header a harness sends to a remote MCP server whose tool-call timeout it
-* raised, carrying the applied timeout in milliseconds. The Tangle profile
-* materializer writes it beside `MCP_TOOL_TIMEOUT` (Claude Code) and
-* `tool_timeout_sec` (Codex) when an attachment declares
-* `metadata.toolTimeoutMs`. Without it the server must assume the harness
-* default, 60 s for Claude Code 2.1.287 and Codex (measured 2026-10-03).
-*/
-const MCP_TOOL_TIMEOUT_HEADER = "x-mcp-tool-timeout-ms";
-/** The tool-call timeout Runtime asks harnesses to give its coordination server. */
-const COORDINATION_CLIENT_TOOL_TIMEOUT_MS = 3e5;
-/**
-* The longest `await_event` holds for a caller that declared a raised timeout.
-* A held response through the Sandbox edge was measured to 200 s on 2026-10-03.
-*/
-const MAX_DECLARED_AWAIT_FENCE_MS = 18e4;
-const MIN_DECLARED_TOOL_TIMEOUT_MS = 1e3;
-const MAX_DECLARED_TOOL_TIMEOUT_MS = 36e5;
-const requestContext = new AsyncLocalStorage();
-/**
-* The tool-call timeout a request declared through {@link MCP_TOOL_TIMEOUT_HEADER},
-* or `undefined` when it is absent or malformed. A malformed value is treated as
-* absent: the caller then gets the default fence, which every harness tolerates.
-*/
-function declaredToolTimeoutMs(header) {
-	if (typeof header !== "string" || !/^[0-9]{1,8}$/.test(header)) return void 0;
-	const value = Number(header);
-	return value >= MIN_DECLARED_TOOL_TIMEOUT_MS && value <= MAX_DECLARED_TOOL_TIMEOUT_MS ? value : void 0;
-}
-/**
-* How long `await_event` may hold for a caller that declared `declaredMs`: 60% of
-* it, so the answer leaves well before the client gives up, and at most
-* {@link MAX_DECLARED_AWAIT_FENCE_MS}.
-*/
-function declaredAwaitFenceMs(declaredMs) {
-	return Math.min(MAX_DECLARED_AWAIT_FENCE_MS, Math.floor(declaredMs * .6));
-}
-/** Run one coordination request with the fence its caller declared, if any. */
-function withCoordinationAwaitFence(awaitFenceMs, run) {
-	return awaitFenceMs === void 0 ? run() : requestContext.run({ awaitFenceMs }, run);
-}
-/** The fence the current coordination request declared, or `undefined`. */
-function coordinationRequestAwaitFenceMs() {
-	return requestContext.getStore()?.awaitFenceMs;
-}
-//#endregion
 //#region src/mcp/tools/worker-output.ts
 const WORKER_OUTPUT_PAGE_CHARS = 16384;
 function workerOutputReadOptions(raw) {
@@ -532,13 +494,6 @@ function emptyPreflightCounts() {
 		"unmountable-tool": 0
 	};
 }
-/** Default ceiling for a single `await_event` block (ms). Every `pending` return costs the driver an
-*  inference turn, so the ceiling is as long as the harness clients allow: Claude Code 2.1.287 and
-*  Codex both time out an MCP tool call at 60 s by default (measured 2026-10-03: a 150 s HTTP MCP
-*  call failed at about 60 s and passed with `MCP_TOOL_TIMEOUT=300000`), and the Sandbox edge held
-*  a 200 s response. 45 s leaves 15 s of that minute for transfer and the driver's own latency. At
-*  15 s a Discovery root director spent 303 of its 401 native tool calls (76%) re-polling. */
-const DEFAULT_AWAIT_EVENT_TIMEOUT_MS = 45e3;
 /** Default and maximum bounds for one {@link CoordinationTools} journal read. The defaults are
 *  sized for a driver turn (a page a model can read and still have room to act on); the maxima
 *  bound what a single tool result may cost even when the caller asks for everything. */
@@ -563,7 +518,9 @@ const journalEventKinds = [
 	"escalation",
 	"analyst-defined",
 	"analyst-assignment",
-	"acknowledgement"
+	"acknowledgement",
+	"tool-outcome",
+	"lead-message"
 ];
 /** The reserved coordination verb names — the complete set `createCoordinationTools` can emit
 *  (the analyst pair is conditional but still reserved). A driver's extra WORK tools must not
@@ -582,7 +539,6 @@ const coordinationVerbNames = [
 	"cancel_worker",
 	"observe_agent",
 	"steer_agent",
-	"await_event",
 	"list_questions",
 	"answer_question",
 	"ask_parent",
@@ -596,22 +552,18 @@ const coordinationVerbNames = [
 	"define_analyst"
 ];
 /**
-* The `CoordinationEvent` kinds a driver may name in `await_event`. The pull queue carries the
-* UP-leg only: `steer` / `answer` / `instruction` / `delivery-attempt` are recorded `queue: false`
-* (history and subscribers, never pulled back), and `mail` is delivered to its addressee's inbox.
-*
-* Declared once because the tool advertises this list in its JSON Schema AND filters on it at
-* dispatch. Written twice, the two drift and the schema promises a kind the filter drops — a
-* driver then blocks on a queue that already holds its event.
+* The `CoordinationEvent` kinds that wake a waiting manager. The queue carries the UP-leg only:
+* `steer` / `answer` / `instruction` / `delivery-attempt` are recorded `queue: false` (history and
+* subscribers, never delivered back), and `mail` is delivered to its addressee's inbox. A
+* `question` on this bus is the manager's own `ask_parent`, already escalated: it never wakes the
+* asker, whose answer arrives as a `lead-message`.
 */
-const awaitableEventKinds = [
+const wakeEventKinds = [
 	"settled",
-	"question",
-	"finding"
+	"finding",
+	"tool-outcome",
+	"lead-message"
 ];
-function isAwaitableEventKind(value) {
-	return awaitableEventKinds.includes(value);
-}
 const idArg = {
 	type: "string",
 	description: "The workerId returned by spawn_worker."
@@ -1007,6 +959,10 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		return readyInFlight;
 	};
 	const deliveries = [];
+	const openReceipts = /* @__PURE__ */ new Map();
+	let receiptSeq = 0;
+	let leadPublishing = 0;
+	let deadlineNoticeDelivered = false;
 	let driverAttempt;
 	let journalReadTo = 0;
 	let lastRejection;
@@ -1338,7 +1294,16 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			}, { analyst: route.kind });
 		} catch {}
 	};
+	let flushing = 0;
 	const flushPendingSettlement = async () => {
+		flushing += 1;
+		try {
+			return await flushPendingSettlementOnce();
+		} finally {
+			flushing -= 1;
+		}
+	};
+	const flushPendingSettlementOnce = async () => {
 		const pending = pendingSettlement;
 		if (!pending) return false;
 		await bus.publish(pending.event);
@@ -1604,6 +1569,14 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			type: "acknowledgement",
 			...ev.acknowledgement
 		};
+		if (ev.type === "tool-outcome") return {
+			type: "tool-outcome",
+			...ev.outcome
+		};
+		if (ev.type === "lead-message") return {
+			type: "lead-message",
+			...ev.message
+		};
 		return {
 			type: ev.type,
 			...ev.down
@@ -1906,21 +1879,26 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		const received = new Set(ledger.map((worker) => worker.id));
 		const nodes = opts.scope.view?.nodes ?? [];
 		return {
-			running: nodes.filter((node) => isLiveNodeStatus(node.status) && node.status !== "waiting"),
+			running: nodes.filter((node) => isLiveNodeStatus(node.status)),
 			unqueued: nodes.filter((node) => !isLiveNodeStatus(node.status) && !received.has(node.id) && !flushedAnalystRuns.has(node.id)),
-			queued: bus.queued(["settled", "finding"])
+			queued: bus.queued([
+				"settled",
+				"finding",
+				"lead-message"
+			])
 		};
 	};
 	const openWorkRefusal = (verb) => {
+		if (deadlineNoticeDelivered) return void 0;
 		const { running, unqueued, queued } = openWork();
 		if (running.length === 0 && unqueued.length === 0 && queued.length === 0) return void 0;
 		const parts = [];
 		if (running.length > 0) parts.push(`${running.length} worker${running.length === 1 ? " is" : "s are"} still running (${running.map((node) => node.id).join(", ")})`);
 		const waiting = unqueued.length + queued.length;
-		if (waiting > 0) parts.push(`${waiting} event${waiting === 1 ? " is" : "s are"} waiting for you in await_event`);
+		if (waiting > 0) parts.push(`${waiting} event${waiting === 1 ? " is" : "s are"} waiting for you`);
 		return {
 			error: "open-work",
-			reason: `${parts.join(" and ")}. Call await_event until it returns idle, read each settled worker's output, and then call ${verb} again. Nothing was ${verb === "stop" ? "stopped" : "checked"}.`,
+			reason: `${parts.join(" and ")}. End your turn to wait: you will be woken with each result. Read each settled worker's output, and then call ${verb} again. Nothing was ${verb === "stop" ? "stopped" : "checked"}.`,
 			running: running.map((node) => ({
 				id: node.id,
 				label: node.label,
@@ -1994,7 +1972,6 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			unsub();
 		} catch {}
 	};
-	const awaitTimeoutMs = opts.awaitTimeoutMs ?? 45e3;
 	let inFlightDrain = null;
 	const ensureDrain = () => {
 		if (!inFlightDrain) inFlightDrain = drainSettlement().finally(() => {
@@ -2045,28 +2022,104 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		});
 		return managerAnalysis;
 	};
-	const awaitFenceMs = () => {
-		const declared = coordinationRequestAwaitFenceMs();
-		return declared !== void 0 && awaitTimeoutMs > 0 ? declared : awaitTimeoutMs;
+	const settledWithoutDrain = async () => {
+		if (inFlightDrain) return;
+		inFlightDrain = (async () => {
+			let drained = false;
+			while (await drainSettlement("nextResolved")) drained = true;
+			return drained;
+		})().finally(() => {
+			inFlightDrain = null;
+		});
+		await inFlightDrain;
+	};
+	const hasOpenWork = () => {
+		const { running, unqueued, queued } = openWork();
+		return running.length > 0 || unqueued.length > 0 || queued.length > 0 || bus.pending(wakeEventKinds) > 0 || openReceipts.size > 0 || leadPublishing > 0 || pendingSettlement !== void 0 || flushing > 0;
 	};
-	const raceDrainWithTimeout = async (drain) => {
-		const fenceMs = awaitFenceMs();
-		if (fenceMs <= 0) return { drained: await drain };
+	const awaitWake = async (input) => {
+		const startedAt = Date.now();
+		await ready();
+		await settledWithoutDrain();
+		if (!hasOpenWork() || input.signal.aborted) return void 0;
+		const heartbeatAt = startedAt + Math.max(0, input.heartbeatMs);
+		const deadlineAt = input.deadlineAt ?? Number.POSITIVE_INFINITY;
+		const wakeAt = Math.min(heartbeatAt, deadlineAt);
+		let unsubscribe;
 		let timer;
-		const timeout = new Promise((resolve) => {
-			timer = setTimeout(() => resolve(void 0), fenceMs);
-			if (typeof timer?.unref === "function") timer.unref();
-		});
+		let onAbort;
+		let outsideWake = false;
 		try {
-			return await Promise.race([drain.then((drained) => ({ drained })), timeout]);
+			const queuedEvent = new Promise((resolve) => {
+				unsubscribe = bus.onQueued((record) => {
+					if (wakeEventKinds.includes(record.event.type)) resolve();
+				});
+			});
+			const elapsed = new Promise((resolve) => {
+				timer = setTimeout(resolve, Math.max(0, wakeAt - Date.now()));
+			});
+			const aborted = new Promise((resolve) => {
+				onAbort = () => resolve();
+				input.signal.addEventListener("abort", onAbort, { once: true });
+			});
+			const outside = (input.alsoWakeOn ?? new Promise(() => void 0)).then(() => {
+				outsideWake = true;
+			});
+			let cursorIdle = false;
+			while (bus.pending(wakeEventKinds) === 0 && !outsideWake && !input.signal.aborted && Date.now() < wakeAt) {
+				const drained = !cursorIdle && openWork().running.length > 0 ? ensureDrain() : new Promise(() => void 0);
+				if (await Promise.race([
+					drained.then((value) => value ? "drained" : "idle"),
+					queuedEvent.then(() => "queued"),
+					elapsed.then(() => "elapsed"),
+					aborted.then(() => "aborted"),
+					outside.then(() => "outside")
+				]) === "idle") {
+					cursorIdle = true;
+					if (!hasOpenWork()) break;
+				}
+			}
+			if (input.signal.aborted) return void 0;
+			if (flushing > 0 && inFlightDrain !== null) await inFlightDrain.catch(() => false);
+			if (bus.pending(wakeEventKinds) > 0 && input.debounceMs > 0 && openWork().running.length > 0) {
+				await Promise.race([new Promise((resolve) => {
+					setTimeout(resolve, input.debounceMs);
+				}), aborted]);
+				if (input.signal.aborted) return void 0;
+				await settledWithoutDrain();
+			}
 		} finally {
+			unsubscribe?.();
 			if (timer) clearTimeout(timer);
+			if (onAbort) input.signal.removeEventListener("abort", onAbort);
 		}
+		const events = [];
+		for (let next = bus.pullRecord(wakeEventKinds); next; next = bus.pullRecord(wakeEventKinds)) {
+			deliveries.push({
+				record: next,
+				attempt: input.attempt ?? driverAttempt,
+				acknowledged: false
+			});
+			events.push({
+				...projectEvent(next.event),
+				eventSeq: next.seq
+			});
+		}
+		if (events.length === 0 && !outsideWake && !hasOpenWork()) return void 0;
+		const reason = events.length > 0 || outsideWake ? "events" : Date.now() >= deadlineAt ? "deadline" : "heartbeat";
+		if (reason === "deadline") deadlineNoticeDelivered = true;
+		return detachedFrozen({
+			reason,
+			events,
+			live: liveSnapshot(),
+			freeSlots: freeWorkerSlots(),
+			idleMs: Date.now() - startedAt
+		});
 	};
 	const tools = [
 		{
 			name: "spawn_worker",
-			description: "Start a worker the driver will drive. `profile` is the worker or another driver; `task` is what it should do. Reserves budget from the conserved pool and fails closed. Pass an optional `budget` (per-field) to give a sub-task more or less than the default — it merges over the per-worker default; the conserved pool is still the hard fence. Each worker reserves its whole budget when it starts, so the pool divided by the per-worker budget is how many run at once: to run a wide team at once, give each worker less. When every worker slot is busy, or the pool cannot cover the budget until your running workers return what they hold, the worker is admitted with `status: \"queued\"` and starts on its own when a slot and its budget free — it is never refused for concurrency, so spawn all the work you want done and await_event for the results. A queued worker whose budget never frees settles down as budget-exhausted. Pass a `key` naming the assignment to make it run-once ACROSS restarts: a key that already completed returns the finished result (`resumed: \"completed\"` — no work re-runs, nothing is spent), a key whose prior attempt failed (`down`) spawns fresh and says so (`resumed: \"retried\"`), and a key the process died with IN FLIGHT retries under the same key when the executor provably died with the process (an inline worker — the same `resumed: \"retried\"`, naming the interruption). A key with no terminal receipt whose execution may still exist elsewhere (sandbox, CLI bridge, router) is refused (`error: \"in-doubt\"`) until its exact prior execution is recovered. A key still running is refused (`error: \"duplicate-key\"`). Returns `freeSlots`: how many MORE workers start at once (`null` = no slot bound), and `queued`: how many of your workers wait for a slot. Parallel workers finish the run sooner than one at a time." + (profileTable === void 0 ? "" : " This run has a profiles table: pass `profile` as one of the table's names to run that exact profile, or write a new profile under a name the table does not hold."),
+			description: "Start a worker the driver will drive. `profile` is the worker or another driver; `task` is what it should do. Reserves budget from the conserved pool and fails closed. Pass an optional `budget` (per-field) to give a sub-task more or less than the default — it merges over the per-worker default; the conserved pool is still the hard fence. Each worker reserves its whole budget when it starts, so the pool divided by the per-worker budget is how many run at once: to run a wide team at once, give each worker less. When every worker slot is busy, or the pool cannot cover the budget until your running workers return what they hold, the worker is admitted with `status: \"queued\"` and starts on its own when a slot and its budget free — it is never refused for concurrency, so spawn all the work you want done, then end your turn: you are woken with each result. A queued worker whose budget never frees settles down as budget-exhausted. Pass a `key` naming the assignment to make it run-once ACROSS restarts: a key that already completed returns the finished result (`resumed: \"completed\"` — no work re-runs, nothing is spent), a key whose prior attempt failed (`down`) spawns fresh and says so (`resumed: \"retried\"`), and a key the process died with IN FLIGHT retries under the same key when the executor provably died with the process (an inline worker — the same `resumed: \"retried\"`, naming the interruption). A key with no terminal receipt whose execution may still exist elsewhere (sandbox, CLI bridge, router) is refused (`error: \"in-doubt\"`) until its exact prior execution is recovered. A key still running is refused (`error: \"duplicate-key\"`). Returns `freeSlots`: how many MORE workers start at once (`null` = no slot bound), and `queued`: how many of your workers wait for a slot. Parallel workers finish the run sooner than one at a time." + (profileTable === void 0 ? "" : " This run has a profiles table: pass `profile` as one of the table's names to run that exact profile, or write a new profile under a name the table does not hold."),
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -2087,7 +2140,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 					},
 					successorOf: {
 						type: "string",
-						description: "The workerId of a SETTLED worker you spawned that this new worker replaces — for example one that failed, stalled, or finished with a weak result, restarted with a changed profile or task. The run record then names the predecessor on the new worker. Refused for an id you did not spawn (`error: \"successor-unknown\"`) and for a worker still live (`error: \"successor-live\"` — await_event until it settles). Put what the successor needs from its predecessor in `task`."
+						description: "The workerId of a SETTLED worker you spawned that this new worker replaces — for example one that failed, stalled, or finished with a weak result, restarted with a changed profile or task. The run record then names the predecessor on the new worker. Refused for an id you did not spawn (`error: \"successor-unknown\"`) and for a worker still live (`error: \"successor-live\"` — end your turn until it settles). Put what the successor needs from its predecessor in `task`."
 					},
 					budget: {
 						type: "object",
@@ -2187,7 +2240,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 					};
 					if (isLiveNodeStatus(predecessor.status)) return {
 						error: "successor-live",
-						reason: `worker '${successorOf}' has not settled — await_event until it does, then spawn its successor (steer_agent redirects a live worker instead)`,
+						reason: `worker '${successorOf}' has not settled — end your turn until it does, then spawn its successor (steer_agent redirects a live worker instead)`,
 						live: liveWorkerCount(),
 						freeSlots: freeWorkerSlots()
 					};
@@ -2293,7 +2346,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		},
 		{
 			name: "observe_agent",
-			description: "Inspect a worker WHILE IT RUNS, not only after it finishes: status, spend so far, and `progress` — how long since it last did anything (`idleMs`), whether that counts as stalled, how many turns it has taken, the last tools/files it touched (`recentActivity`), what its executor CHANGED about the profile you gave it (`derived` — an MCP config it materialized, an extension it had to add), whether a steer can even reach it (`steerable`), and how many steers it has not yet read (`pendingMessages`). For a worker that leads its own team, `progress.team` counts the agents below it (working, queued, done, down) and its idle clock reads the newest activity anywhere in that team, so a lead whose workers are busy is not stalled. A queued worker waits for a worker slot and is never stalled. A worker whose executor has FINISHED but whose settlement you have not yet drained reports `settlementPending` with its terminal kind; its `status` still reads running until await_event delivers it, so call await_event, not observe_agent again. The settled output artifact is returned once drained. Select a field with `outputPath`, for example [\"content\"] to read a provider result without its event history. Omit it to read the complete artifact. Large outputs return a bounded JSON `outputPage`; repeat with `outputOffset: outputPage.nextOffset` until it is null, concatenate page text, then parse the JSON. Offsets and limits count UTF-16 characters. The full artifact stays retained; an outRef is a content address, not a workspace path. Use this BEFORE steer_agent: a steer is only worth sending when the progress says the worker is on the wrong path or has stopped making any.",
+			description: "Inspect a worker WHILE IT RUNS, not only after it finishes: status, spend so far, and `progress` — how long since it last did anything (`idleMs`), whether that counts as stalled, how many turns it has taken, the last tools/files it touched (`recentActivity`), what its executor CHANGED about the profile you gave it (`derived` — an MCP config it materialized, an extension it had to add), whether a steer can even reach it (`steerable`), and how many steers it has not yet read (`pendingMessages`). For a worker that leads its own team, `progress.team` counts the agents below it (working, queued, done, down) and its idle clock reads the newest activity anywhere in that team, so a lead whose workers are busy is not stalled. A queued worker waits for a worker slot and is never stalled. A worker whose executor has FINISHED but whose settlement you have not yet drained reports `settlementPending` with its terminal kind; its `status` still reads running until your next wake delivers it, so end your turn rather than observing again. The settled output artifact is returned once drained. Select a field with `outputPath`, for example [\"content\"] to read a provider result without its event history. Omit it to read the complete artifact. Large outputs return a bounded JSON `outputPage`; repeat with `outputOffset: outputPage.nextOffset` until it is null, concatenate page text, then parse the JSON. Offsets and limits count UTF-16 characters. The full artifact stays retained; an outRef is a content address, not a workspace path. Use this BEFORE steer_agent: a steer is only worth sending when the progress says the worker is on the wrong path or has stopped making any.",
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -2358,7 +2411,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 					progress: progress ?? null,
 					...pending ? {
 						settlementPending: pending,
-						hint: `this worker has finished (${pending.kind}); its settlement is queued — call await_event to receive it, observing again will not change this`
+						hint: `this worker has finished (${pending.kind}); its settlement is queued for your next wake — end your turn to receive it, observing again will not change this`
 					} : {}
 				};
 			}
@@ -2400,7 +2453,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		},
 		{
 			name: "cancel_worker",
-			description: "Cancel one of YOUR live workers — running, or queued for a worker slot — and every worker it leads. Its unspent budget returns to your pool when it settles, so this is how you take back what a stalled or no-longer-needed worker holds (for example when spawn_worker is refused budget-exhausted while workers you no longer need hold the budget). The cancelled worker still settles `down` through await_event with what it spent. Refused (`error: \"not-live\"`) for a worker that already settled or is not yours.",
+			description: "Cancel one of YOUR live workers — running, or queued for a worker slot — and every worker it leads. Its unspent budget returns to your pool when it settles, so this is how you take back what a stalled or no-longer-needed worker holds (for example when spawn_worker is refused budget-exhausted while workers you no longer need hold the budget). The cancelled worker still settles `down`, delivered in your next wake with what it spent. Refused (`error: \"not-live\"`) for a worker that already settled or is not yours.",
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -2432,117 +2485,6 @@ function createCoordinationToolsForManager(opts, lifetime) {
 				};
 			}
 		},
-		{
-			name: "await_event",
-			description: "Wait for and pull the next message a worker, sub-driver, or analyst sent up — the unified inbox. Read a settled artifact with the returned `outputRead` call; the receipt carries its reference, not its bytes. An event is one of: a settled worker output ('settled'), a question needing your answer ('question', from ask_parent / the worker's ask-user), or a trace-analyst finding ('finding', from analyze-on-settle). Pass kinds:['settled'] for just the next finished worker; omit `kinds` to also receive questions and findings. Returns { idle: true } when nothing is queued and no workers are live. If a worker is still running when the wait elapses, returns { pending: true, live: [...] } (the workers still in flight) instead of blocking indefinitely — call await_event again to keep waiting; the settlement is not lost. Every reply carries `freeSlots`: how many more workers you can start right now (`null` = uncapped). A settled worker frees its slot, so `freeSlots > 0` means capacity is sitting idle — spawn into it before waiting again. Each event carries `eventSeq`; pass the ones you have processed in `acknowledge` on a later call. An event delivered to a turn that ends in failure is named again when you are re-entered, until it is acknowledged. Pass `max` above 1 to read a whole team at once: the reply is `{ events: [...] }` with the first event it waited for plus every other event already waiting, up to `max`, so a lead of hundreds of workers reads their receipts in a few turns instead of one each.",
-			inputSchema: {
-				type: "object",
-				properties: {
-					kinds: {
-						type: "array",
-						items: {
-							type: "string",
-							enum: [...awaitableEventKinds]
-						},
-						description: "Restrict to these event kinds (any if omitted)."
-					},
-					acknowledge: {
-						type: "array",
-						items: {
-							type: "integer",
-							minimum: 0
-						},
-						description: "The eventSeq of each earlier event you have now processed."
-					},
-					max: {
-						type: "integer",
-						minimum: 1,
-						description: "Most events to return in one reply. Omit or 1 for one event; above 1 returns `{ events }`."
-					}
-				}
-			},
-			handler: async (raw) => {
-				const args = raw === void 0 ? {} : obj(raw);
-				const max = args.max === void 0 ? 1 : args.max;
-				if (typeof max !== "number" || !Number.isSafeInteger(max) || max < 1) throw new Error("coordination tools: \"max\" must be a positive integer");
-				const k = args.kinds;
-				const kinds = Array.isArray(k) ? k.filter(isAwaitableEventKind) : void 0;
-				if (Array.isArray(args.acknowledge)) {
-					const named = new Set(args.acknowledge.filter((value) => typeof value === "number" && Number.isInteger(value)));
-					await acknowledge(deliveries.filter((delivery) => named.has(delivery.record.seq)), "manager");
-				}
-				const deliver = (record) => {
-					deliveries.push({
-						record,
-						attempt: driverAttempt,
-						acknowledged: false
-					});
-					return {
-						...projectEvent(record.event),
-						eventSeq: record.seq
-					};
-				};
-				if (max > 1) {
-					const fenceMs = awaitFenceMs();
-					const fenceAt = fenceMs > 0 ? Date.now() + fenceMs / 2 : Infinity;
-					if (!inFlightDrain) {
-						inFlightDrain = (async () => {
-							let drained = false;
-							while (bus.pending(kinds) < max && Date.now() < fenceAt) {
-								if (!await drainSettlement("nextResolved")) break;
-								drained = true;
-							}
-							return drained;
-						})().finally(() => {
-							inFlightDrain = null;
-						});
-						await inFlightDrain;
-					}
-					const events = [];
-					const takeQueued = () => {
-						for (let next = bus.pullRecord(kinds); next; next = bus.pullRecord(kinds)) {
-							events.push(deliver(next));
-							if (events.length >= max) return;
-						}
-					};
-					takeQueued();
-					if (events.length === 0) {
-						const first = await pullOne();
-						if (!("eventSeq" in first)) return first;
-						const { freeSlots: _slots, ...head } = first;
-						events.push(head);
-						takeQueued();
-					}
-					return {
-						events,
-						freeSlots: freeWorkerSlots()
-					};
-				}
-				return pullOne();
-				async function pullOne() {
-					let ev = bus.pullRecord(kinds);
-					if (ev) return {
-						...deliver(ev),
-						freeSlots: freeWorkerSlots()
-					};
-					const raced = await raceDrainWithTimeout(ensureDrain());
-					if (raced === void 0) return {
-						pending: true,
-						live: liveSnapshot(),
-						freeSlots: freeWorkerSlots()
-					};
-					ev = bus.pullRecord(kinds);
-					if (!ev) return {
-						idle: !raced.drained,
-						freeSlots: freeWorkerSlots()
-					};
-					return {
-						...deliver(ev),
-						freeSlots: freeWorkerSlots()
-					};
-				}
-			}
-		},
 		{
 			name: "list_questions",
 			description: "List questions raised by workers, drivers, or analysts. Blocking stop behavior follows questionPolicy.",
@@ -3010,7 +2952,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 				};
 				if (isLiveNodeStatus(node.status)) return {
 					error: "worker-not-settled",
-					reason: `worker ${JSON.stringify(id)} has not settled, so it has no trace to analyze yet — await_event until it settles, then run the lens`
+					reason: `worker ${JSON.stringify(id)} has not settled, so it has no trace to analyze yet — end your turn until it settles, then run the lens`
 				};
 				const trace = ledger.find((worker) => worker.id === id)?.trace ?? node.trace ?? {
 					status: "unavailable",
@@ -3163,6 +3105,69 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			const attempt = driverAttempt;
 			if (outcome === "completed") await acknowledge(deliveries.filter((delivery) => delivery.attempt === attempt), "turn-completed");
 		},
+		hasOpenWork,
+		awaitWake,
+		awaitSettlement: async (workerIds, signal) => {
+			const wanted = new Set(workerIds);
+			const settledIds = () => ledger.filter((worker) => wanted.has(worker.id)).map((w) => w.id);
+			await ready();
+			for (;;) {
+				await settledWithoutDrain();
+				const hit = settledIds();
+				if (hit.length > 0) return hit;
+				signal?.throwIfAborted();
+				if (!(opts.scope.view?.nodes ?? []).some((node) => wanted.has(node.id) && isLiveNodeStatus(node.status))) return [];
+				if (!await (signal === void 0 ? ensureDrain() : Promise.race([ensureDrain(), new Promise((_resolve, reject) => {
+					signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+				})])) && settledIds().length === 0) return [];
+			}
+		},
+		receiveLeadMessage: (message) => {
+			const parsed = leadMessageOf(message);
+			if (parsed === void 0) return false;
+			leadPublishing += 1;
+			bus.publish({
+				type: "lead-message",
+				message: parsed
+			}).catch((error) => {
+				console.error("Runtime could not queue a lead message for its manager", {
+					manager: opts.scope.view.root,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}).finally(() => {
+				leadPublishing -= 1;
+			});
+			return true;
+		},
+		openToolReceipt: (tool) => {
+			receiptSeq += 1;
+			const receipt = `${tool}#${receiptSeq}`;
+			openReceipts.set(receipt, {
+				tool,
+				startedAt: Date.now()
+			});
+			return receipt;
+		},
+		settleToolReceipt: async (receipt, outcome) => {
+			const open = openReceipts.get(receipt);
+			if (open === void 0) return;
+			openReceipts.delete(receipt);
+			await bus.publish({
+				type: "tool-outcome",
+				outcome: detachedFrozen({
+					receipt,
+					tool: open.tool,
+					...outcome.ok ? {
+						ok: true,
+						value: outcome.value
+					} : {
+						ok: false,
+						error: outcome.error instanceof Error ? outcome.error.message : String(outcome.error)
+					},
+					elapsedMs: Date.now() - open.startedAt
+				})
+			});
+		},
 		reentryState: () => {
 			const { unqueued, queued } = openWork();
 			const deliveredSettled = new Set(deliveries.flatMap((delivery) => delivery.record.event.type === "settled" ? [delivery.record.event.worker.id] : []));
@@ -3272,6 +3277,22 @@ function safeJsonText(value) {
 		return String(value);
 	}
 }
+function leadMessageOf(message) {
+	if (message === null || typeof message !== "object") return void 0;
+	const m = message;
+	const interrupt = m.interrupt === true;
+	if (typeof m.steer === "string") return {
+		kind: "steer",
+		text: m.steer,
+		interrupt
+	};
+	if (typeof m.answer === "string") return {
+		kind: "answer",
+		text: m.answer,
+		...typeof m.questionId === "string" ? { questionId: m.questionId } : {},
+		interrupt
+	};
+}
 //#endregion
 //#region src/runtime/supervise/run-cancellation.ts
 /** Apply a durable request through the run's existing abort controller. */
@@ -3700,7 +3721,7 @@ function renderAnytimeTable(report) {
 * A stop rule reads the run's own PROGRESS and decides. Three signals feed it:
 *   - the objective curve over settled work (best-so-far, from `anytime.ts` — see below),
 *   - the LIVE worker feed (`WorkerProgress`: `idleMs`, `stalled`, `turns`, `tokens`),
-*   - tree-level shape (how many are in flight, how many are waiting, when the last settle landed).
+*   - tree-level shape (how many are in flight, when the last settle landed).
 *
 * ── Two boundaries this module holds deliberately ───────────────────────────────────────────────
 *
@@ -3758,7 +3779,6 @@ function createProgressTracker(opts = {}) {
 			const workers = [];
 			if (scope && treeView) for (const node of treeView.nodes) {
 				if (isTerminalNodeStatus(node.status)) continue;
-				if (node.status === "waiting") continue;
 				const p = scope.progress(node.id, viewOpts?.stallAfterMs !== void 0 ? {
 					now: now(),
 					stallAfterMs: viewOpts.stallAfterMs
@@ -3776,8 +3796,7 @@ function createProgressTracker(opts = {}) {
 				lastImprovementAt,
 				settlesSinceImprovement: lastImprovementIdx < 0 ? recorded.length : recorded.length - 1 - lastImprovementIdx,
 				workers,
-				inFlight: treeView?.inFlight ?? 0,
-				waiting: treeView?.waiting ?? 0
+				inFlight: treeView?.inFlight ?? 0
 			};
 		},
 		evaluate(rule, scope, viewOpts) {
@@ -3819,7 +3838,7 @@ function noProgressFor(opts) {
 			stop: true,
 			reason: `no-progress: ${v.settlesSinceImprovement} settles with no improvement (limit ${opts.settles}), best=${v.best}`
 		};
-		if (opts.ms !== void 0 && v.waiting === 0 && v.lastSettleAt > 0) {
+		if (opts.ms !== void 0 && v.lastSettleAt > 0) {
 			const idle = v.now - v.lastSettleAt;
 			if (idle >= opts.ms) return {
 				stop: true,
@@ -3861,7 +3880,6 @@ function plateau(opts) {
 function allWorkersStalled(opts = {}) {
 	const minWorkers = opts.minWorkers ?? 1;
 	return (v) => {
-		if (v.waiting > 0) return CONTINUE;
 		if (v.workers.length < minWorkers) return CONTINUE;
 		if (!v.workers.every((w) => w.stalled)) return CONTINUE;
 		const worst = Math.max(...v.workers.map((w) => w.idleMs));
@@ -3919,6 +3937,56 @@ function progressStop(tracker, rule, ledger, scope, now, stallAfterMs) {
 	return tracker.evaluate(rule, scope, stallAfterMs !== void 0 ? { stallAfterMs } : void 0);
 }
 //#endregion
+//#region src/runtime/supervise/wake.ts
+/** How long a waiting manager hears nothing before Runtime wakes it to reconsider: 15 min. */
+const DEFAULT_WAKE_HEARTBEAT_MS = 15 * 6e4;
+/** How long a wake waits for more events after its first, while other workers still run: 2 s. */
+const DEFAULT_WAKE_DEBOUNCE_MS = 2e3;
+/** How long before its deadline a manager is woken once to submit its best result: 15 min. */
+const DEFAULT_DEADLINE_WARNING_MS = 15 * 6e4;
+/** The instruction every manager receives about waiting. */
+const WAIT_BY_ENDING_TURN = "When you are waiting for workers, end your turn. You will be woken with what happened: a worker settled, a finding, a message or answer from your lead, or the deadline approaching.";
+function resolveWakePolicy(policy) {
+	const pick = (value, fallback, name) => {
+		const resolved = value ?? fallback;
+		if (!Number.isSafeInteger(resolved) || resolved < 0) throw new TypeError(`wake.${name} must be a nonnegative safe integer of milliseconds`);
+		return resolved;
+	};
+	return {
+		heartbeatMs: pick(policy?.heartbeatMs, DEFAULT_WAKE_HEARTBEAT_MS, "heartbeatMs"),
+		debounceMs: pick(policy?.debounceMs, DEFAULT_WAKE_DEBOUNCE_MS, "debounceMs"),
+		deadlineWarningMs: pick(policy?.deadlineWarningMs, DEFAULT_DEADLINE_WARNING_MS, "deadlineWarningMs")
+	};
+}
+/**
+* The deadline warning, at most once per manager: the epoch ms to wake at, or undefined. The lead
+* is at most a quarter of the manager's whole time to its deadline, so a short run is not warned
+* the moment it starts.
+*/
+function deadlineWarningAt(deadlineMs, policy, warned, startedAtMs) {
+	if (warned || deadlineMs <= 0 || policy.deadlineWarningMs <= 0) return void 0;
+	return deadlineMs - Math.min(policy.deadlineWarningMs, Math.max(0, deadlineMs - startedAtMs) / 4);
+}
+/** The input a woken manager's next turn receives. */
+function composeWakeInput(wake, context) {
+	const span = (ms) => ms < 12e4 ? `${Math.max(0, Math.round(ms / 1e3))} s` : `${Math.round(ms / 6e4)} min`;
+	const lines = [];
+	const waited = `You waited ${span(wake.idleMs)} without spending a turn.`;
+	if (wake.reason === "deadline") {
+		const left = context.deadlineMs === void 0 ? void 0 : context.deadlineMs - context.now;
+		lines.push(`The run's deadline is ${left === void 0 ? "near" : `in ${span(left)}`}. ${waited}`, context.tools?.includes("submit_result") === true ? "Submit your best result now with submit_result. A run that reaches its deadline without an accepted result delivers nothing." : "Finish now with your best result.");
+	} else if (wake.reason === "heartbeat") lines.push(`Nothing reached your inbox. ${waited} Reconsider whether the running workers still serve the objective.`);
+	else lines.push(`${wake.events.length} event${wake.events.length === 1 ? "" : "s"} arrived. ${waited}`);
+	if (wake.events.length > 0) {
+		lines.push("", "## Events", "");
+		for (const event of wake.events) lines.push(`- ${JSON.stringify(event)}`);
+	}
+	lines.push("", wake.live.length === 0 ? "Workers running: none." : `Workers running: ${wake.live.map((worker) => String(worker.id)).join(", ")}.`);
+	if (wake.freeSlots !== null) lines.push(`Free worker slots: ${wake.freeSlots}.`);
+	lines.push("", WAIT_BY_ENDING_TURN);
+	return lines.join("\n");
+}
+//#endregion
 //#region src/runtime/supervise/coordination-driver.ts
 /**
 *
@@ -3977,7 +4045,7 @@ function formatOverspend(violation) {
 *  overspend usd up to the turn tripwire). */
 function poolStarved(scope, perWorker, preserveOwnerTurns = false) {
 	const b = scope.budget;
-	if (scope.view.inFlight > 0 || scope.view.waiting > 0) return false;
+	if (scope.view.inFlight > 0) return false;
 	const tokenStarved = preserveOwnerTurns ? b.tokensLeft <= 0 : b.tokensLeft < perWorker.maxTokens;
 	const iterationStarved = b.iterationsLeft <= 0;
 	const usdStarved = b.usdCapped && (b.usdLeft <= 0 || !preserveOwnerTurns && perWorker.maxUsd !== void 0 && b.usdLeft < perWorker.maxUsd);
@@ -3987,12 +4055,14 @@ function poolStarved(scope, perWorker, preserveOwnerTurns = false) {
 /** The number of driver turns a manager whose spend Runtime cannot measure may take when no
 *  deadline or dollar cap bounds it. */
 const UNMETERED_DRIVER_TURNS = 16;
+/** How often a waiting driver applies operator cancels and steers between its turns. */
+const WAITING_CONTROL_POLL_MS = 5e3;
 /**
 * Safety guards for a manager's own turns when no deadline bounds them.
 *
 * `poolStarved` lets a manager keep taking turns while its workers run, because those workers hold
 * the pool its turns would otherwise be refused from. With no turn cap and no deadline, a manager
-* waiting on a worker that never settles would take a metered turn per `await_event` fence forever.
+* waiting on a worker that never settles would take a metered turn per heartbeat wake forever.
 * Money bounds that: a manager that has overdrawn its pool by as much again as the whole pool stops.
 * A brain that reports no usage cannot be bounded by money, so without a deadline or dollar cap it
 * keeps the historical 16-turn bound. A caller's explicit `maxTurns` or a deadline replaces both.
@@ -4416,7 +4486,6 @@ function driverAgent(opts) {
 				...opts.sourceEvidenceRefs ? { sourceEvidenceRefs: opts.sourceEvidenceRefs } : {},
 				...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
 				...opts.stallAfterMs !== void 0 ? { stallAfterMs: opts.stallAfterMs } : {},
-				...opts.awaitTimeoutMs !== void 0 ? { awaitTimeoutMs: opts.awaitTimeoutMs } : {},
 				...opts.continuityByProfile ? { continuityByProfile: opts.continuityByProfile } : {},
 				...opts.preflightSpawn ? { preflightSpawn: opts.preflightSpawn } : {},
 				...opts.resolveSpawnProfile ? { resolveSpawnProfile: opts.resolveSpawnProfile } : {},
@@ -4453,7 +4522,7 @@ function driverAgent(opts) {
 			const modelTools = selectedTools.flatMap((selected) => selected.kind === "descriptor" ? [selected.descriptor] : []);
 			probeableByName = new Map(modelTools.map((tool) => [tool.name, tool]));
 			const selectedExtraNames = new Set(selectedTools.flatMap((selected) => selected.kind === "extra" ? [selected.extra.name] : []));
-			opts.onCoordinationTools?.(modelTools);
+			opts.onCoordinationTools?.(modelTools, coord);
 			const acknowledger = opts.controlDir === void 0 ? void 0 : createCancelAcknowledger({
 				dir: opts.controlDir,
 				coord,
@@ -4471,10 +4540,6 @@ function driverAgent(opts) {
 				signal: scope.signal,
 				...opts.controlScope === "subtree" ? {} : { deliverRoot: inbox.deliver }
 			});
-			for (const w of scope.resume?.waits ?? []) {
-				const rearmed = scope.wait(w.spec, { label: w.label });
-				if (!rearmed.ok) throw new RuntimeRunStateError(`driverAgent: cannot re-arm resumed wait '${w.label}' (${rearmed.reason})`);
-			}
 			const byName = new Map(modelTools.map((tool) => [tool.name, tool]));
 			const toolSpecs = selectedTools.map((selected) => selected.kind === "descriptor" ? {
 				type: "function",
@@ -4496,6 +4561,9 @@ function driverAgent(opts) {
 			const poolTokens = scope.budget.tokensLeft + scope.budget.reservedTokens;
 			let driverTurns = 0;
 			let progressStopReason;
+			const wakePolicy = resolveWakePolicy(opts.wake);
+			let deadlineWarned = false;
+			const startedAt = now();
 			let driverTurn = 0;
 			let driverCall = 0;
 			const meteredBrain = async (messages, tools, detail, conversationTurn) => {
@@ -4645,6 +4713,38 @@ function driverAgent(opts) {
 						});
 						transcript.observe(messages);
 					},
+					afterFinal: async () => {
+						if (coord.isStopped() || coord.submittedResult() !== void 0 || scope.signal.aborted) return;
+						if (inbox.pending() === 0 && !coord.hasOpenWork()) return void 0;
+						const deadlineMs = scope.budget.deadlineMs;
+						const warnAt = deadlineWarningAt(deadlineMs, wakePolicy, deadlineWarned, startedAt);
+						const controlClock = acknowledger === void 0 && steerAcknowledger === void 0 ? void 0 : setInterval(() => {
+							(async () => {
+								await steerAcknowledger?.pass("turn");
+								acknowledger?.pass("turn");
+							})().catch(() => void 0);
+						}, WAITING_CONTROL_POLL_MS);
+						controlClock?.unref?.();
+						let wake;
+						try {
+							wake = await coord.awaitWake({
+								signal: scope.signal,
+								heartbeatMs: wakePolicy.heartbeatMs,
+								debounceMs: wakePolicy.debounceMs,
+								...warnAt === void 0 ? {} : { deadlineAt: warnAt },
+								alsoWakeOn: inbox.pending() > 0 ? Promise.resolve() : inbox.nextDelivery()
+							});
+						} finally {
+							if (controlClock !== void 0) clearInterval(controlClock);
+						}
+						if (wake === void 0) return void 0;
+						if (wake.reason === "deadline") deadlineWarned = true;
+						return composeWakeInput(wake, {
+							tools: selectedTools.map((selected) => selected.kind === "descriptor" ? selected.descriptor.name : selected.extra.name),
+							deadlineMs,
+							now: now()
+						});
+					},
 					stopBefore: () => {
 						if (coord.isStopped() || scope.signal.aborted || poolStarved(scope, opts.perWorker, opts.preserveOwnerTurns) || deadlinePassed(scope, now) || ownTurnsUnbounded(scope, poolTokens, driverTurns, opts.maxTurns)) return true;
 						if (!opts.stopRule || !tracker) return false;
@@ -4710,10 +4810,9 @@ function resumeBrief(resume, current, prior) {
 	const inDoubt = byState("in-doubt").filter(([, value]) => !currentIds.has(value.id));
 	const failed = byState("down");
 	if (completed.length > 0) lines.push("", "COMPLETED keys — spawn_worker with the same key returns the finished result, spending nothing:", ...completed.map(([k, v]) => `- ${k} → ${v.id} (${v.label})`));
-	if (recovered.length > 0) lines.push("", "Recovered keys are attached to this scope. Use await_event to receive their results and coordinate with their original workers:", ...recovered.map(([key, value]) => `- ${key} → ${value.id} (${value.label})`));
+	if (recovered.length > 0) lines.push("", "Recovered keys are attached to this scope. Their results arrive when you are woken; coordinate with their original workers:", ...recovered.map(([key, value]) => `- ${key} → ${value.id} (${value.label})`));
 	if (inDoubt.length > 0) lines.push("", "Keys IN DOUBT — a prior process recorded them as started but never recorded a terminal receipt. Do NOT spawn a replacement under these keys; inspect or recover each exact prior execution first:", ...inDoubt.map(([k, v]) => `- ${k} (prior attempt ${v.id}, ${v.label})`));
 	if (failed.length > 0) lines.push("", "Keys whose prior attempt FAILED (settled down) — spawn_worker with the same key retries:", ...failed.map(([k, v]) => `- ${k} (prior attempt ${v.id}, ${v.label})`));
-	if (resume.waits.length > 0) lines.push("", "Pending waits RE-ARMED on their original deadlines (they settle through await_event):", ...resume.waits.map((w) => `- ${w.label} (${w.spec.kind})`));
 	appendPriorCoordination(lines, prior);
 	const spent = resume.priorSpend;
 	lines.push("", "Budget the run ALREADY spent before this process (it counts toward the run total):", `- child work: tokens charged=${chargedTokens(spent.childWork.tokens)} (in=${spent.childWork.tokens.input} out=${spent.childWork.tokens.output}), usd=${spent.childWork.usd}, iterations=${spent.childWork.iterations}`, `- driver inference: tokens charged=${chargedTokens(spent.driverInference.tokens)} (in=${spent.driverInference.tokens.input} out=${spent.driverInference.tokens.output}), usd=${spent.driverInference.usd}`);
@@ -4784,6 +4883,6 @@ function safeJson(v) {
 	}
 }
 //#endregion
-export { createCoordinationTools as A, withCoordinationAwaitFence as B, applyRunCancellation as C, analystToolGroupNames as D, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as E, questionEscalationTargets as F, defaultToolDetectors as H, COORDINATION_CLIENT_TOOL_TIMEOUT_MS as I, MCP_TOOL_TIMEOUT_HEADER as L, downMessageRefusalReasons as M, normalizeAnalyzeOnSettle as N, canonicalFindingEvent as O, parseAuthoredAnalystDefinition as P, declaredAwaitFenceMs as R, foldCoordinationRecords as S, ANALYST_DEFINITION_BOUNDS as T, watchTrace as U, createEventBus as V, renderAnytimeTable as _, allOf as a, withRunContext as b, createProgressTracker as c, progressStop as d, sampleFromSettled as f, plateauLength as g, bestSoFar as h, finalizeBestDelivered as i, createCoordinationToolsForManager as j, coordinationVerbNames as k, noProgressFor as l, areaUnderCurve as m, createSteerAcknowledger as n, allWorkersStalled as o, anytimeReport as p, driverAgent as r, anyOf as s, createCancelAcknowledger as t, plateau as u, createFileRunContext as v, watchRunCancellation as w, FileCoordinationLog as x, createInMemoryRunContext as y, declaredToolTimeoutMs as z };
+export { analystToolGroupNames as A, defaultToolDetectors as B, createInMemoryRunContext as C, applyRunCancellation as D, foldCoordinationRecords as E, downMessageRefusalReasons as F, normalizeAnalyzeOnSettle as I, parseAuthoredAnalystDefinition as L, coordinationVerbNames as M, createCoordinationTools as N, watchRunCancellation as O, createCoordinationToolsForManager as P, questionEscalationTargets as R, createFileRunContext as S, FileCoordinationLog as T, watchTrace as V, anytimeReport as _, DEFAULT_DEADLINE_WARNING_MS as a, plateauLength as b, resolveWakePolicy as c, anyOf as d, createProgressTracker as f, sampleFromSettled as g, progressStop as h, finalizeBestDelivered as i, canonicalFindingEvent as j, ANALYST_DEFINITION_BOUNDS as k, allOf as l, plateau as m, createSteerAcknowledger as n, composeWakeInput as o, noProgressFor as p, driverAgent as r, deadlineWarningAt as s, createCancelAcknowledger as t, allWorkersStalled as u, areaUnderCurve as v, withRunContext as w, renderAnytimeTable as x, bestSoFar as y, createEventBus as z };
 
-//# sourceMappingURL=coordination-driver-DzTvehd6.js.map
+//# sourceMappingURL=coordination-driver-yj9HPXef.js.map