@tangle-network/agent-runtime 0.300.0 → 0.301.0

package/dist/{supervise-C5mktzrh.js → supervise-BJrEC2Mh.js}

@@ -1,9 +1,9 @@
-import { $ as bindScopeRetainedOwnerProvider, $n as parseWorkerToolTraceArtifact, A as driverExecutorFactory, Aa as addResourceSpend, Ai as prepareJsonlAppend, An as resolveAgentEnvironmentProvider, Ar as contentAddress, At as createExecutor, B as recordScopeOwnerDriverAttempt, C as createContinuationKeeper, Ca as sleep, Cr as runAbortable, Da as unmeteredSpend, Dr as readHarnessTranscript, Dt as captureReusableExecutorConfig, Ei as unsupportedProfileDimensions, Er as persistHarnessTranscript, Et as bindReusableExecutorExecutionId, F as beginScopeOwnerAttempt, Gi as runtimeOwnedExecutorMaterialization, H as recordScopeOwnerPause, Hi as recordRuntimeOwnedDriveHarnessProviderEvidence, Hr as createOtelExporter, Ia as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, In as registerRetainedExecutorPreparation, It as createRouterTranscript, Ji as runtimeOwnedScopeOwnerRuntime, Jr as toOtelAttributes, Ki as runtimeOwnedExecutorProviderEvidence, L as deriveNodeExecutionIdentity, Li as inheritRuntimeOwnedExecutorAttestation, Ln as retainedExecutorSeamKey, Ma as withBudgetResources, Mt as snapshotExecutorConfig, Oa as withTimeout, Oi as worktreeCliProfileMaterialization, P as assertRecursiveReservationPolicy, Pi as attestRuntimeOwnedScopeOwner, Q as bindScopeRetainedOwnerEnvironmentId, R as meterRuntimeOwnedAccounting, Ra as teardownExecutor, Rt as WORKER_TRACE_PROPAGATION, Sr as linkAbort, U as restoreScopeOwnerAcceptedExecution, Ui as runtimeOwnedDriveHarnessProviderEvidence, V as recordScopeOwnerMaterialization, Vi as providerAttemptEvidence, W as scopeOwnerExecutorNodeContext, Wi as runtimeOwnedExecutorExecutionBinding, Wr as generateSpanId, _ as CheckUnavailableError, _i as fullProfileMaterialization, an as bridgeModelRouteRefusal, at as scopeRetainedOwnerPriorSpend, b as bestComposite, bi as promptModelProfileMaterialization, br as RunCancellationReason, c as runTree, ct as scopeRetainedOwnerResult, dn as bridgeStopSignalKey, ea as detachedSnapshot, et as consumeScopeRetainedOwnerResult, f as runDriverWithRetry, gi as defineProfileMaterializationContract, h as CONTINUATIONS_DIR, ha as addSpend, hi as controlProfileMaterialization, i as bestDelivered, in as bridgeAdmissionRefusal, ir as assertValidBudget, it as scopeRetainedOwnerContext, j as isDriverSpec, ja as resourceTelemetry, ji as readCommittedJsonLines, k as driverChild, ka as zeroSpend, ki as isNoEntError, lr as spendFromUsageTotals, mi as assertProfileMaterialization, n as createRootHandle, nt as prepareScopeRetainedOwnerTask, or as meterUsageEvent, ot as scopeRetainedOwnerResourceReader, p as summarizeDriverAttempts, qi as runtimeOwnedPendingExecutorMaterialization, qt as createInbox, r as createSupervisor, rt as reconcileScopeRetainedOwnerEnvironment, s as runFinalizer, sr as newUsageTotals, st as scopeRetainedOwnerRestorePoint, tr as executorFailure, tt as noteScopeRetainedOwnerCoordination, u as HarnessTurnFailedError, un as bridgeRuntimeAttachmentsKey, ur as errMessage, v as admitContinuationPolicy, vi as profileMaterializationAxes$1, wi as renderUnsupported, wn as routerBrain, x as checkVerdictOf, yi as promptControlProfileMaterialization, z as meterRuntimeOwnedProviderAttempt, za as teardownSurfaces } from "./supervisor-CQSu5XGl.js";
+import { $ as bindScopeRetainedOwnerEnvironmentId, $n as parseWorkerToolTraceArtifact, A as driverExecutorFactory, Aa as withTimeout, Ai as worktreeCliProfileMaterialization, An as resolveAgentEnvironmentProvider, B as recordScopeOwnerDriverAttempt, Ba as teardownExecutor, Bt as WORKER_TRACE_PROPAGATION, C as createContinuationKeeper, Ei as renderUnsupported, F as beginScopeOwnerAttempt, Gi as runtimeOwnedDriveHarnessProviderEvidence, H as recordScopeOwnerPause, Ii as attestRuntimeOwnedScopeOwner, In as registerRetainedExecutorPreparation, Ji as runtimeOwnedExecutorProviderEvidence, Ki as runtimeOwnedExecutorExecutionBinding, Kr as generateSpanId, L as deriveNodeExecutionIdentity, Ln as retainedExecutorSeamKey, Ma as addResourceSpend, Mi as prepareJsonlAppend, Mr as contentAddress, Mt as createExecutor, Na as resourceTelemetry, Ni as readCommittedJsonLines, Oi as unsupportedProfileDimensions, Or as persistHarnessTranscript, Ot as bindReusableExecutorExecutionId, P as assertRecursiveReservationPolicy, Pa as withBudgetResources, Pt as snapshotExecutorConfig, Q as beginScopeRetainedOwnerDrive, R as meterRuntimeOwnedAccounting, Ra as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, Rt as createRouterTranscript, Si as promptModelProfileMaterialization, Sr as RunCancellationReason, Ta as sleep, Tr as runAbortable, U as restoreScopeOwnerAcceptedExecution, Ui as providerAttemptEvidence, V as recordScopeOwnerMaterialization, Va as teardownSurfaces, W as scopeOwnerExecutorNodeContext, Wi as recordRuntimeOwnedDriveHarnessProviderEvidence, Wr as createOtelExporter, Xi as runtimeOwnedScopeOwnerRuntime, Xr as toOtelAttributes, Yi as runtimeOwnedPendingExecutorMaterialization, Yt as createInbox, _ as CheckUnavailableError, _a as addSpend, _i as controlProfileMaterialization, at as scopeRetainedOwnerContext, b as bestComposite, bi as profileMaterializationAxes$1, c as runTree, ct as scopeRetainedOwnerRestorePoint, dr as bridgeStopSignalKey, et as bindScopeRetainedOwnerProvider, f as runDriverWithRetry, fr as errMessage, gi as assertProfileMaterialization, h as CONTINUATIONS_DIR, i as bestDelivered, in as isLiveNodeStatus, ir as assertValidBudget, it as reconcileScopeRetainedOwnerEnvironment, j as isDriverSpec, ja as zeroSpend, ji as isNoEntError, k as driverChild, ka as unmeteredSpend, kr as readHarnessTranscript, kt as captureReusableExecutorConfig, lr as spendFromUsageTotals, lt as scopeRetainedOwnerResult, n as createRootHandle, na as detachedSnapshot, nt as noteScopeRetainedOwnerCoordination, on as bridgeAdmissionRefusal, or as meterUsageEvent, ot as scopeRetainedOwnerPriorSpend, p as summarizeDriverAttempts, qi as runtimeOwnedExecutorMaterialization, qt as createActivityLog, r as createSupervisor, rt as prepareScopeRetainedOwnerTask, s as runFinalizer, sn as bridgeModelRouteRefusal, sr as newUsageTotals, st as scopeRetainedOwnerResourceReader, tr as executorFailure, tt as consumeScopeRetainedOwnerResult, u as HarnessTurnFailedError, ur as bridgeRuntimeAttachmentsKey, ut as scopeRetainedOwnerTurnEnded, v as admitContinuationPolicy, vi as defineProfileMaterializationContract, wn as routerBrain, wr as linkAbort, x as checkVerdictOf, xi as promptControlProfileMaterialization, yi as fullProfileMaterialization, z as meterRuntimeOwnedProviderAttempt, zi as inheritRuntimeOwnedExecutorAttestation } from "./supervisor-DA_nvF-h.js";
 import { f as RuntimeRunStateError, i as ConfigError, m as ValidationError } from "./errors-DodWX-cb.js";
 import { _ as agentHarness, a as concreteProfileModel, c as profileModelExecutionSettings, n as assertModelAllowed, o as enforceTokenLimits, r as assertProfileModelsAllowed, s as profileBridgeWireModel, t as assertExecutableAgentProfile, v as harnessRunsAgent } from "./model-policy-DydyWTQg.js";
 import { n as assertNoSymlinkDescendant } from "./durable-file-DWQA4ooo.js";
 import { t as composeRuntimeHooks } from "./runtime-hooks-tXpAarhW.js";
-import { B as withCoordinationAwaitFence, C as applyRunCancellation, E as DEFAULT_AWAIT_EVENT_TIMEOUT_MS, I as COORDINATION_CLIENT_TOOL_TIMEOUT_MS, L as MCP_TOOL_TIMEOUT_HEADER, R as declaredAwaitFenceMs, b as withRunContext, c as createProgressTracker, d as progressStop, j as createCoordinationToolsForManager, k as coordinationVerbNames, n as createSteerAcknowledger, r as driverAgent, t as createCancelAcknowledger, u as plateau, v as createFileRunContext, w as watchRunCancellation, y as createInMemoryRunContext, z as declaredToolTimeoutMs } from "./coordination-driver-DzTvehd6.js";
+import { A as watchRunCancellation, E as withRunContext, I as createCoordinationToolsForManager, P as coordinationVerbNames, T as createInMemoryRunContext, _ as progressStop, c as composeWakeInput, g as plateau, k as applyRunCancellation, l as deadlineWarningAt, m as createProgressTracker, n as createSteerAcknowledger, r as driverAgent, t as createCancelAcknowledger, u as resolveWakePolicy, w as createFileRunContext } from "./coordination-driver-vNrdQBSH.js";
 import { r as createStdioToolServer, t as PROTOCOL_VERSION } from "./tool-server-Dqer2M4_.js";
 import { k as writeRunCancellation, o as readRunCancelRequest, s as readRunCancellation } from "./run-layout-DSCWdbX2.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, canonicalCandidateJson, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
@@ -16,6 +16,13 @@ import { isMaterializerHarness } from "@tangle-network/agent-profile-materialize
 import { ATTR } from "@tangle-network/agent-trace-contract";
 import { createServer } from "node:http";
 import { withProfileKb } from "@tangle-network/agent-interface/profile-kb";
+//#region src/mcp/tools/coordination-request-context.ts
+/** The tool-call timeout Runtime asks harnesses to give its coordination server. The Tangle
+*  profile materializer writes it as `MCP_TOOL_TIMEOUT` (Claude Code) and `tool_timeout_sec`
+*  (Codex) when an attachment declares `metadata.toolTimeoutMs`, so a fenced coordination call
+*  that holds its response for its whole fence is never cut off at the 60 s harness default. */
+const COORDINATION_CLIENT_TOOL_TIMEOUT_MS = 3e5;
+//#endregion
 //#region src/runtime/supervise/completion-gate.ts
 /**
 *
@@ -287,12 +294,10 @@ function coordinationHttpHandler(input) {
 			active++;
 		}
 		admitted = true;
-		const declaredTimeoutMs = declaredToolTimeoutMs(req.headers[MCP_TOOL_TIMEOUT_HEADER]);
-		const declaredFenceMs = declaredTimeoutMs === void 0 ? void 0 : declaredAwaitFenceMs(declaredTimeoutMs);
 		timer = setTimeout(() => {
 			timedOut = true;
 			reject(executing ? 504 : 408);
-		}, Math.max(limits.requestTimeoutMs, declaredTimeoutMs ?? 0));
+		}, limits.requestTimeoutMs);
 		timer.unref();
 		let size = 0;
 		const chunks = [];
@@ -342,7 +347,7 @@ function coordinationHttpHandler(input) {
 						reject(authorization);
 						return;
 					}
-					const response = await withCoordinationAwaitFence(declaredFenceMs, () => input.handle(message));
+					const response = await input.handle(message);
 					if (!finished) respond(response === null ? 202 : 200, response ?? void 0);
 					await audit(timedOut ? "completed-after-deadline" : "completed", timedOut ? 504 : response === null ? 202 : 200, action);
 				} catch {
@@ -459,25 +464,23 @@ async function preflightPublicCoordination(input) {
 *
 * Two rules close that failure:
 * - Identity. A call joins an existing invocation when its tool name and its RFC 8785 canonical
-*   arguments match, and that invocation has not yet returned its outcome to a caller. The handler
-*   is not invoked again. Key order does not matter: the observed retry reordered every key.
-* - Fence. A call waits at most `fenceMs` for the outcome. If the handler is still running, the call
-*   returns a non-error pending result. A later identical call keeps waiting, then returns the value
-*   or throws the handler's error once the handler settles.
+*   arguments match, and that invocation has not yet settled. The handler is not invoked again.
+*   Key order does not matter: the observed retry reordered every key.
+* - Fence. A call waits at most `fenceMs` for the outcome. If the handler is still running, the
+*   call returns a receipt. The handler keeps running, and its outcome is published to the
+*   manager's inbox, where its next wake delivers it. Nothing has to call again to collect it.
 *
-* An invocation's identity ends when a call returns its outcome. The next identical call is a fresh
-* run, because equal arguments do not make a call a replay. Code mode's `execute` and Knowledge's
+* An invocation's identity ends when its handler settles. The next identical call is a fresh run,
+* because equal arguments do not make a call a replay: code mode's `execute` and Knowledge's
 * `knowledge_search` read live state, so their callers repeat identical arguments to get a current
 * answer. A handler that finishes within the fence therefore behaves exactly as it did unwrapped.
-* No escape hatch is needed: the only calls this absorbs are ones whose caller could not have seen
-* the outcome.
 */
 function singleFlightTools(tools, options) {
-	const { fenceMs } = options;
+	const { fenceMs, receipts } = options;
 	if (!Number.isSafeInteger(fenceMs) || fenceMs <= 0) throw new ValidationError("singleFlightTools: fenceMs must be a positive safe integer");
 	const now = options.now ?? Date.now;
 	const invocations = /* @__PURE__ */ new Map();
-	const start = (tool, raw) => {
+	const start = (tool, raw, key) => {
 		const invocation = {
 			startedAt: now(),
 			settled: (async () => tool.handler(raw))().then((value) => {
@@ -494,8 +497,19 @@ function singleFlightTools(tools, options) {
 				return invocation.outcome;
 			}),
 			outcome: void 0,
-			waiting: 0
+			waiting: 0,
+			receipt: void 0
 		};
+		invocation.settled.then(async (outcome) => {
+			if (invocations.get(key) === invocation) invocations.delete(key);
+			if (invocation.receipt !== void 0) await receipts.settleToolReceipt(invocation.receipt, outcome).catch((error) => {
+				console.error("Runtime could not publish a receipted tool outcome", {
+					tool: tool.name,
+					receipt: invocation.receipt,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			});
+		});
 		return invocation;
 	};
 	const wrap = (tool) => Object.freeze({
@@ -504,7 +518,7 @@ function singleFlightTools(tools, options) {
 			const key = invocationKey(tool.name, raw);
 			let invocation = invocations.get(key);
 			if (invocation === void 0) {
-				invocation = start(tool, raw);
+				invocation = start(tool, raw, key);
 				invocations.set(key, invocation);
 			}
 			if (invocation.outcome === void 0) {
@@ -516,8 +530,10 @@ function singleFlightTools(tools, options) {
 				}
 			}
 			const outcome = invocation.outcome;
-			if (outcome === void 0) return pendingToolCall(tool.name, now() - invocation.startedAt);
-			if (invocations.get(key) === invocation) invocations.delete(key);
+			if (outcome === void 0) {
+				invocation.receipt ??= receipts.openToolReceipt(tool.name);
+				return toolCallReceipt(tool.name, invocation.receipt, now() - invocation.startedAt);
+			}
 			if (outcome.ok) return outcome.value;
 			throw outcome.error;
 		}
@@ -538,19 +554,20 @@ function invocationKey(name, raw) {
 		throw new ValidationError(`${name}: arguments must be finite JSON so a repeated call can join its earlier run`, { cause: error });
 	}
 }
-function pendingToolCall(tool, elapsedMs) {
+function toolCallReceipt(tool, receipt, elapsedMs) {
 	return {
-		pending: true,
+		running: true,
+		receipt,
 		tool,
 		elapsedMs,
-		instruction: `${tool} is still running; nothing failed. Call ${tool} again with the same arguments to keep waiting. That call joins this run and returns its result, or its error, once it finishes. Different arguments start a separate run.`
+		instruction: `${tool} is still running; nothing failed. Do not call it again: its result arrives with receipt ${receipt} when you are next woken. Continue other work, or end your turn to wait.`
 	};
 }
 //#endregion
 //#region src/runtime/supervise/coordination-mcp.ts
 /**
 *
-* Serve the coordination verbs (spawn_worker / await_event / observe_agent / steer_agent / stop)
+* Serve the coordination verbs (spawn_worker / observe_agent / steer_agent / submit_result / stop)
 * as a real HTTP MCP server over a LIVE `Scope`. This is the keystone that lets a coding-harness
 * agent (opencode via the cli-bridge, claude-code, codex) BE the supervisor: it mounts this MCP
 * (`mcp.mcpServers.coordination`) and calls `spawn_worker` as a native tool, which lands on
@@ -597,20 +614,20 @@ function assertCoordinationTransport(options) {
 * exactly when a deliverable is injected.
 */
 const DELIVERABLE_VERB = "submit_result";
+/** The longest any coordination call holds its response, whatever the request timeout: under the
+*  60 s MCP tool-call timeout Claude Code and Codex apply by default. */
+const RESPONSE_FENCE_CAP_MS = 45e3;
 /**
-* The longest one coordination call holds its HTTP response before it answers with a re-pollable
-* pending result instead: `await_event` by default, and `submit_result` and every method-supplied
-* node tool always.
+* The longest a fenced coordination call (`submit_result` and every method-supplied node tool)
+* holds its HTTP response before it answers with a receipt instead. The call keeps running, and
+* its outcome reaches the manager in its next wake.
 *
 * It is half of `requestTimeoutMs`, so the answer leaves before the transport's own 504 at
-* `requestTimeoutMs`, with the other half left for body transfer, admission, and serialization.
-* Deriving it here means a configured request timeout moves both fences with it. It is capped at
-* {@link DEFAULT_AWAIT_EVENT_TIMEOUT_MS} so a long request timeout does not lengthen each wait; at
-* the default 90 s request timeout both values are 45 s, under the 60 s MCP tool-call timeout that
-* Claude Code and Codex apply by default.
+* `requestTimeoutMs`, with the other half left for body transfer, admission, and serialization,
+* and at most {@link RESPONSE_FENCE_CAP_MS}.
 */
 function coordinationResponseFenceMs(requestTimeoutMs) {
-	return Math.max(1, Math.min(DEFAULT_AWAIT_EVENT_TIMEOUT_MS, Math.floor(requestTimeoutMs / 2)));
+	return Math.max(1, Math.min(RESPONSE_FENCE_CAP_MS, Math.floor(requestTimeoutMs / 2)));
 }
 /** Stand up the existing coordination tools with bounded HTTP access over one live scope. */
 async function serveCoordinationMcp(opts) {
@@ -698,7 +715,6 @@ async function serveCoordinationMcpForManager(opts, lifetime) {
 		...opts.deliverable ? { deliverable: opts.deliverable } : {},
 		...opts.readContinuation ? { readContinuation: opts.readContinuation } : {},
 		...opts.onStop ? { onStop: opts.onStop } : {},
-		awaitTimeoutMs: opts.awaitTimeoutMs ?? responseFenceMs,
 		...opts.analysts ? { analysts: opts.analysts } : {},
 		...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {},
 		...opts.sourceEvidenceRefs ? { sourceEvidenceRefs: opts.sourceEvidenceRefs } : {},
@@ -727,8 +743,14 @@ async function serveCoordinationMcpForManager(opts, lifetime) {
 		if (reservedNames.has(tool.name)) throw new ValidationError(`serveCoordinationMcp: node tool ${JSON.stringify(tool.name)} shadows a coordination verb or another node tool`);
 		reservedNames.add(tool.name);
 	}
-	const nodeTools = singleFlightTools(opts.nodeTools ?? [], { fenceMs: responseFenceMs });
-	const fencedVerbs = singleFlightTools(coord.tools.filter((tool) => tool.name === DELIVERABLE_VERB), { fenceMs: responseFenceMs });
+	const nodeTools = singleFlightTools(opts.nodeTools ?? [], {
+		fenceMs: responseFenceMs,
+		receipts: coord
+	});
+	const fencedVerbs = singleFlightTools(coord.tools.filter((tool) => tool.name === DELIVERABLE_VERB), {
+		fenceMs: responseFenceMs,
+		receipts: coord
+	});
 	if (opts.deliverable && fencedVerbs.tools.length !== 1) throw new ValidationError(`serveCoordinationMcp: a deliverable is injected but the coordination verbs lack ${DELIVERABLE_VERB}, so its check would run unfenced`);
 	const fencedByName = new Map(fencedVerbs.tools.map((tool) => [tool.name, tool]));
 	const availableTools = [...coord.tools.map((tool) => fencedByName.get(tool.name) ?? tool), ...nodeTools.tools];
@@ -747,7 +769,7 @@ async function serveCoordinationMcpForManager(opts, lifetime) {
 		serverVersion: "1",
 		tools: servedTools
 	});
-	opts.onCoordinationTools?.([...mcp.tools.values()]);
+	opts.onCoordinationTools?.([...mcp.tools.values()], coord);
 	const server = createServer(coordinationHttpHandler({
 		options: opts,
 		identity,
@@ -1296,6 +1318,7 @@ function composeReentryTask(input) {
 		const changes = stateLines(state, false, input.tools);
 		return [reentry.steer, ...changes.length > 0 ? ["", ...changes] : []].join("\n");
 	}
+	if (reentry.reason === "wake" && continuity.session === "continued") return reentry.input;
 	return [
 		`You are re-entering a run that is already in progress (driver attempt ${input.attempt}). This is the same run and the same objective, not a new one.`,
 		whyLine(reentry),
@@ -1317,6 +1340,12 @@ function composeReentryTask(input) {
 			"",
 			reentry.steer
 		] : [],
+		...reentry.reason === "wake" ? [
+			"",
+			"## What woke you",
+			"",
+			reentry.input
+		] : [],
 		"",
 		"## Run state, from the coordinator",
 		"",
@@ -1326,7 +1355,6 @@ function composeReentryTask(input) {
 		"",
 		"Continue the run from this state.",
 		...continuity.workspace === "kept" || continuity.workspace === "restored" ? ["Read the files you already wrote before you repeat any step of the task. A step whose file is there is done, and its content stands."] : [],
-		...input.tools?.includes("await_event") === true ? ["Receive the waiting events with await_event before starting new work."] : [],
 		...input.tools?.includes("observe_agent") === true ? ["Read the output of every settled worker with observe_agent before you spawn anything new."] : [],
 		"Do not spawn a replacement for a worker that is running or has settled.",
 		"Your coordination tools are served by the same coordinator as before, and the state above comes from it."
@@ -1340,6 +1368,7 @@ function composeReentryTask(input) {
 */
 function whyLine(reentry) {
 	if (reentry.reason === "unmet-contract") return `Your previous turn ended with the completion check unmet (continuation ${reentry.continuation}).`;
+	if (reentry.reason === "wake") return "Your previous turn ended while your workers ran, and Runtime woke you with what happened.";
 	return reentry.reason === "upstream-unavailable" ? "Your previous turn was interrupted before it finished; the run itself is intact." : `Your previous turn ended before it finished (retry ${reentry.retry}); the run itself is intact.`;
 }
 function environmentLine(continuity) {
@@ -1357,7 +1386,7 @@ function stateLines(state, full, tools) {
 	else if (full) lines.push("Workers settled: none.");
 	if (state.waiting.length > 0) lines.push(`Events waiting for you: ${state.waiting.length} (${state.waiting.map((event) => event.worker === void 0 ? event.type : `${event.type} from ${event.worker}`).join("; ")}).`);
 	else if (full) lines.push("Events waiting for you: none.");
-	if (state.unacknowledged.length > 0) lines.push(`Events delivered to a turn that did not finish, so treat them as unread: ${state.unacknowledged.map((event) => `#${event.seq} ${event.type}${event.worker === void 0 ? "" : ` from ${event.worker}`}`).join("; ")}.` + (tools?.includes("await_event") === true ? " Pass their numbers in await_event's acknowledge once you have processed them." : ""));
+	if (state.unacknowledged.length > 0) lines.push(`Events delivered to a turn that has not finished, so treat them as unread: ${state.unacknowledged.map((event) => `#${event.seq} ${event.type}${event.worker === void 0 ? "" : ` from ${event.worker}`}`).join("; ")}.`);
 	if (state.lastRejection !== void 0) lines.push(`Your last submit_result was refused: ${state.lastRejection.reason}`);
 	return lines;
 }
@@ -1769,6 +1798,7 @@ function declaredRuntimeToolNames(profile) {
 /** Describe Runtime declarations that cannot resolve without a product tool provider. */
 function runtimeToolDeclarationError(profile, hasProductToolResolver, mountedStaticToolNames = []) {
 	const mountedStaticToolNameSet = new Set(mountedStaticToolNames);
+	if (declaredRuntimeToolNames(profile).includes("await_event")) return `the profile declares ${JSON.stringify(`${coordinationProfileToolPrefix}await_event`)}, which no longer exists: a manager ends its turn to wait, and Runtime wakes it with what happened. Remove the grant`;
 	const unresolved = declaredRuntimeToolNames(profile).filter((name) => !coordinationVerbNameSet$1.has(name) && !hasProductToolResolver && !mountedStaticToolNameSet.has(name));
 	if (unresolved.length === 0) return void 0;
 	return `the profile declares ${unresolved.map((name) => JSON.stringify(`${coordinationProfileToolPrefix}${name}`)).join(", ")}, but this run has no resolveSupervisorTools provider or router-mounted static tool for those tools`;
@@ -1860,6 +1890,7 @@ function assertCoordinationBinding(binding) {
 }
 function createVerbSlot() {
 	let bound;
+	let waits;
 	const verb = (name) => async (args) => {
 		if (bound === void 0) throw new ValidationError(`supervisorAgent: coordination verb "${name}" was called before this manager's coordination tools were bound`);
 		const tool = bound.find((descriptor) => descriptor.name === name);
@@ -1869,7 +1900,12 @@ function createVerbSlot() {
 	return {
 		verbs: Object.freeze({
 			spawnAgent: verb("spawn_worker"),
-			awaitEvent: verb("await_event"),
+			awaitSettlement: async (args) => {
+				if (waits === void 0) throw new ValidationError("supervisorAgent: coordination verb \"awaitSettlement\" was called before this manager's coordination tools were bound");
+				const ids = args?.workerIds;
+				if (!Array.isArray(ids) || !ids.every((id) => typeof id === "string" && id.length > 0)) throw new ValidationError("awaitSettlement: workerIds must be an array of worker ids");
+				return { settled: await waits.awaitSettlement(ids) };
+			},
 			steerAgent: verb("steer_agent"),
 			observeAgent: verb("observe_agent"),
 			listQuestions: verb("list_questions"),
@@ -1886,8 +1922,9 @@ function createVerbSlot() {
 				inputSchema
 			})));
 		},
-		bind(tools) {
+		bind(tools, coordination) {
 			bound = tools;
+			waits = coordination;
 		}
 	};
 }
@@ -1978,7 +2015,7 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 			...deps.escalateQuestion ? { escalateQuestion: deps.escalateQuestion } : {},
 			...deps.watchWorkers ? { watchWorkers: deps.watchWorkers } : {},
 			...deps.stallAfterMs !== void 0 ? { stallAfterMs: deps.stallAfterMs } : {},
-			...deps.awaitTimeoutMs !== void 0 ? { awaitTimeoutMs: deps.awaitTimeoutMs } : {},
+			...deps.wake !== void 0 ? { wake: deps.wake } : {},
 			...deps.continuityByProfile ? { continuityByProfile: deps.continuityByProfile } : {},
 			...deps.preflightSpawn ? { preflightSpawn: deps.preflightSpawn } : {},
 			...deps.resolveSpawnProfile ? { resolveSpawnProfile: deps.resolveSpawnProfile } : {},
@@ -1994,7 +2031,7 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 			...deps.replaySettlements ? { replaySettlements: true } : {},
 			...priorCoordination ? { priorCoordination } : {},
 			...deps.finalizer ? { finalizer: deps.finalizer } : {},
-			...slot ? { onCoordinationTools: (tools) => slot.bind(tools) } : {},
+			...slot ? { onCoordinationTools: (tools, coordination) => slot.bind(tools, coordination) } : {},
 			...deps.controlDir === void 0 ? {} : { controlDir: deps.controlDir },
 			...deps.steerDir === void 0 ? {} : { steerDir: deps.steerDir },
 			...deps.controlScope === void 0 ? {} : { controlScope: deps.controlScope },
@@ -2024,13 +2061,25 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 	const rawDeliverReady = driveHarness.deliverReady;
 	if (rawDeliverReady !== void 0 && typeof rawDeliverReady !== "function") throw new ValidationError("supervisorAgent: driveHarness.deliverReady must be a function when provided");
 	const deliverReady = rawDeliverReady?.bind(driveHarness);
+	const wakePolicy = resolveWakePolicy(deps.wake);
+	let managerInbox;
+	let waitingOn;
+	let liveCoordinator;
 	const externalAgent = {
 		name,
-		...deliver ? { deliver(message) {
-			return deliver(message);
-		} } : {},
+		deliver(message) {
+			return managerInbox?.(message) ?? false;
+		},
+		resultAccepted: () => Boolean(liveCoordinator?.submittedResult()),
 		traceSource: () => driveHarness.traceSource?.(),
-		progress: () => driveHarness.progress?.(),
+		progress: () => {
+			const harnessProgress = driveHarness.progress?.();
+			if (waitingOn === void 0) return harnessProgress;
+			return {
+				...harnessProgress,
+				note: `waiting for ${waitingOn} worker${waitingOn === 1 ? "" : "s"}; Runtime wakes it when one reports`
+			};
+		},
 		...driveHarness.harnessTranscript ? { harnessTranscript: () => driveHarness.harnessTranscript?.() } : {},
 		...driveHarness.harnessTranscriptSettled ? { harnessTranscriptSettled: () => driveHarness.harnessTranscriptSettled?.() ?? Promise.resolve() } : {},
 		async act(task, scope) {
@@ -2102,12 +2151,17 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 				...priorCoordination?.analystDefinitions?.length ? { priorAnalystDefinitions: priorCoordination.analystDefinitions } : {},
 				...nodeTools?.length ? { nodeTools } : {},
 				toolNames: runtimeToolNames,
-				onCoordinationTools: (tools) => slot.bind(tools)
+				onCoordinationTools: (tools, coordination) => slot.bind(tools, coordination)
 			}, coordinationLifetime.signal).catch((error) => {
 				coordinationLifetime.abort(error);
 				throw error;
 			});
 			ledger = mcp;
+			liveCoordinator = mcp;
+			managerInbox = (message) => {
+				if (deliver !== void 0 && harnessInvocationActive && (deliverReady === void 0 || deliverReady()) && deliver(message)) return true;
+				return controls.receiveLeadMessage(message);
+			};
 			const coordinationTools = slot.descriptors();
 			const providerProfile = detachedSnapshot(providerVisibleProfile(stableProfile), "supervisorAgent provider-visible profile");
 			let controlObserver;
@@ -2120,8 +2174,8 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 					signal: coordinationLifetime.signal,
 					controlScope: deps.controlScope ?? "run",
 					...deps.controlScope === "subtree" ? {} : {
-						deliverRoot: (message) => deliver?.(message) ?? false,
-						deliverRootReady: () => deliver === void 0 || harnessInvocationActive && (deliverReady === void 0 || deliverReady())
+						deliverRoot: (message) => managerInbox?.(message) ?? false,
+						deliverRootReady: () => true
 					},
 					onError: (error) => {
 						coordinationLifetime.abort(error);
@@ -2234,6 +2288,8 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 					if (last?.unavailable !== void 0) throw new CheckUnavailableError(`the completion check could not run: ${last.unavailable}`);
 				};
 				const loopRecords = [];
+				let deadlineWarned = false;
+				const managerStartedAt = Date.now();
 				let environmentReplacements = 0;
 				let workspaceRestores = 0;
 				const describe = deps.deliverable?.describe;
@@ -2296,7 +2352,7 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 								if (completed) await controls.endDriverAttempt("completed");
 								else await controls.endDriverAttempt("failed").catch(() => void 0);
 							}
-							if (contractDeclared && !mcp.submittedResult()) {
+							if (contractDeclared && !mcp.submittedResult() && !controls.hasOpenWork()) {
 								await mcp.drainResolved();
 								candidate = await finalize();
 								if (candidate === void 0 && !mcp.isStopped()) await readCheckAtTurnEnd(attempt);
@@ -2305,6 +2361,35 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 						progress: readProgress,
 						budget: () => scope.budget,
 						signal: scope.signal,
+						wait: {
+							open: () => !mcp.submittedResult() && !mcp.isStopped() && progressStopReason === void 0 && controls.hasOpenWork(),
+							wake: async (nextAttempt) => {
+								const deadlineMs = scope.budget.deadlineMs;
+								const warnAt = deadlineWarningAt(deadlineMs, wakePolicy, deadlineWarned, managerStartedAt);
+								waitingOn = scope.view.nodes.filter((node) => node.id !== scope.view.root && isLiveNodeStatus(node.status)).length;
+								try {
+									const wake = await controls.awaitWake({
+										attempt: nextAttempt,
+										signal: AbortSignal.any([scope.signal, stopController.signal]),
+										heartbeatMs: wakePolicy.heartbeatMs,
+										debounceMs: wakePolicy.debounceMs,
+										...warnAt === void 0 ? {} : { deadlineAt: warnAt }
+									});
+									if (wake === void 0 || stopController.signal.aborted) return void 0;
+									if (wake.reason === "deadline") deadlineWarned = true;
+									return {
+										input: composeWakeInput(wake, {
+											tools: runtimeToolNames,
+											deadlineMs,
+											now: Date.now()
+										}),
+										idleMs: wake.idleMs
+									};
+								} finally {
+									waitingOn = void 0;
+								}
+							}
+						},
 						...deps.driverRetry ? { policy: deps.driverRetry } : {},
 						...continuation !== void 0 && keeper !== void 0 && continuationDeadlineMs ? { continuation: {
 							maxBarren: continuation.maxBarren,
@@ -2372,6 +2457,7 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 				});
 				throw error;
 			} finally {
+				managerInbox = void 0;
 				coordinationLifetime.abort(/* @__PURE__ */ new Error("supervisor manager stopped"));
 				try {
 					await controlObserver?.close();
@@ -3116,6 +3202,15 @@ async function providerAcceptsCoordinationAttachments(backend) {
 	const attachments = create.runtimeAttachments;
 	return Boolean(attachments && typeof attachments === "object" && "mcp" in attachments && attachments.mcp === true);
 }
+/**
+* A manager waits between turns, and a wake can come much later than five minutes after its last
+* turn. Claude Code 2.1.289 writes its prompt cache with a five-minute lifetime unless this variable
+* is set; a wake after the cache expired re-writes the manager's whole context, about 140K tokens
+* per turn on a Discovery root measured 2026-10-05. That root ran on a subscription and already
+* wrote one-hour entries; the variable makes the hour hold for every claude-code manager, whatever
+* its credential. A value the caller set wins.
+*/
+const CLAUDE_CODE_ONE_HOUR_CACHE = "ENABLE_PROMPT_CACHING_1H";
 /** Run a harness-brained manager through the same executor factory as its children. The manager's
 * full profile is preserved, the live coordination server is added under one reserved alias, and
 * every streamed turn is charged to the manager's scope before it may continue. */
@@ -3126,6 +3221,30 @@ function driveHarnessFromBackend(backend, executionId, now = Date.now, maxTurns,
 	const baseFactory = createExecutor(boundBackend);
 	const ownerRuntime = boundBackend.backend === "provider" ? boundBackend.runtime ?? resolveAgentEnvironmentProvider(boundBackend.provider, boundBackend.registry).name : "cli";
 	let activeExecutor;
+	const driveActivity = createActivityLog();
+	let driveTurns = 0;
+	const noteDriveProgress = (event) => {
+		const at = Date.now();
+		if (event.kind === "tool_call") driveActivity.push({
+			at,
+			kind: "tool",
+			label: event.toolName
+		});
+		else if (event.kind === "tool_result") driveActivity.push({
+			at,
+			kind: "tool",
+			label: event.toolName,
+			status: "ok"
+		});
+		else if (event.kind === "text_delta" || event.kind === "reasoning_delta") {
+			const last = driveActivity.last();
+			if (last === void 0 || last.kind !== "turn" || at - last.at > 3e4) driveActivity.push({
+				at,
+				kind: "turn",
+				label: "model output"
+			});
+		}
+	};
 	let managerTranscript;
 	let managerArtifact;
 	const drive = async ({ profile, authoredProfile, task, scope, coordinationMcpUrl, coordinationMcpHeaders, stopSignal, coordinationTools, reentry }) => {
@@ -3138,6 +3257,7 @@ function driveHarnessFromBackend(backend, executionId, now = Date.now, maxTurns,
 				const execution = runtimeOwnedExecutorMaterialization(activeExecutor)?.execution;
 				return execution?.kind === "environment" ? execution.id : void 0;
 			});
+			await scopeRetainedOwnerTurnEnded(scope);
 		}
 		let driveTask = task;
 		if (reentry !== void 0) {
@@ -3188,6 +3308,7 @@ function driveHarnessFromBackend(backend, executionId, now = Date.now, maxTurns,
 				defaults: {
 					...boundBackend.defaults ?? {},
 					env: {
+						...providerDriverProfile.harness === "claude-code" ? { [CLAUDE_CODE_ONE_HOUR_CACHE]: "1" } : {},
 						...boundBackend.defaults?.env ?? {},
 						[credentialName]: authorization.slice(7)
 					},
@@ -3304,6 +3425,7 @@ function driveHarnessFromBackend(backend, executionId, now = Date.now, maxTurns,
 				runtime: executor.runtime
 			});
 			if (retainedOwner) committedOwnerSpend = addSpend(committedOwnerSpend, charge);
+			if (effectiveStopSignal?.aborted === true) return;
 			const budget = scope.budget;
 			if (budget.tokensLeft <= 0 || budget.usdCapped && budget.usdLeft <= 0 || Object.values(budget.resources ?? {}).some((resource) => !resource.known || resource.remaining <= 0) || budget.deadlineMs > 0 && now() >= budget.deadlineMs) throw new ValidationError("driveHarnessFromBackend: supervisor budget exhausted");
 		};
@@ -3362,6 +3484,7 @@ function driveHarnessFromBackend(backend, executionId, now = Date.now, maxTurns,
 			await retainedOwner.onResult(result);
 			terminalAccountingCaptured = true;
 		};
+		const endDrive = retainedOwner ? beginScopeRetainedOwnerDrive(scope) : () => {};
 		try {
 			const declaration = runtimeOwnedExecutorMaterialization(executor);
 			const executionBinding = runtimeOwnedExecutorExecutionBinding(executor);
@@ -3383,9 +3506,12 @@ function driveHarnessFromBackend(backend, executionId, now = Date.now, maxTurns,
 				for await (const event of run) if (event.kind === "iteration") {
 					await meterPending();
 					turns += 1;
+					driveTurns += 1;
 					if (turnStop !== void 0 && turns >= turnCap && !turnStop.signal.aborted) turnStop.abort(`supervise: maxTurns ${turnCap} reached`);
-				} else if (event.kind === "progress") rootStream?.append(event.progress);
-				else pendingUsage.push(event);
+				} else if (event.kind === "progress") {
+					rootStream?.append(event.progress);
+					noteDriveProgress(event.progress);
+				} else pendingUsage.push(event);
 				await meterPending();
 				const artifact = executor.resultArtifact();
 				terminalArtifact = artifact;
@@ -3501,6 +3627,7 @@ function driveHarnessFromBackend(backend, executionId, now = Date.now, maxTurns,
 			const capture = executor.harnessTranscript?.();
 			if (capture !== void 0 && (capture.status !== "unavailable" || managerTranscript?.status === "unavailable" || managerTranscript === void 0)) managerTranscript = capture;
 			if (activeExecutor === executor) activeExecutor = void 0;
+			endDrive();
 		}
 		if (failed) throw failure;
 		if (turnFailure !== void 0) throw turnFailure;
@@ -3514,7 +3641,16 @@ function driveHarnessFromBackend(backend, executionId, now = Date.now, maxTurns,
 	};
 	drive.deliverReady = () => activeExecutor !== void 0;
 	drive.traceSource = () => activeExecutor?.traceSource?.();
-	drive.progress = () => activeExecutor?.progress?.();
+	drive.progress = () => {
+		const fromExecutor = activeExecutor?.progress?.();
+		const own = driveActivity.read();
+		const recentActivity = [...fromExecutor?.recentActivity ?? [], ...own].sort((a, b) => a.at - b.at).slice(-12);
+		return {
+			...fromExecutor,
+			turns: Math.max(fromExecutor?.turns ?? 0, driveTurns),
+			...recentActivity.length > 0 ? { recentActivity } : {}
+		};
+	};
 	if (boundBackend.backend === "provider") {
 		drive.harnessTranscript = () => managerTranscript ?? activeExecutor?.harnessTranscript?.();
 		drive.harnessTranscriptSettled = () => activeExecutor?.harnessTranscriptSettled?.() ?? Promise.resolve();
@@ -3679,7 +3815,7 @@ const superviseOptionKeySet = /* @__PURE__ */ new Set([
 	"runId",
 	"signal",
 	"stallAfterMs",
-	"awaitTimeoutMs",
+	"wake",
 	"steerDir",
 	"stopRule",
 	"watchWorkers",
@@ -4324,7 +4460,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 					...!analystLineage && spawnContext.analyst === void 0 && !spawnContext.assignmentId.startsWith("analyst:") && options.analyzeOnSettle ? { analyzeOnSettle: options.analyzeOnSettle } : {},
 					...options.watchWorkers ? { watchWorkers: options.watchWorkers } : {},
 					...options.stallAfterMs !== void 0 ? { stallAfterMs: options.stallAfterMs } : {},
-					...options.awaitTimeoutMs !== void 0 ? { awaitTimeoutMs: options.awaitTimeoutMs } : {},
+					...options.wake !== void 0 ? { wake: options.wake } : {},
 					...options.continuityByProfile ? { continuityByProfile: options.continuityByProfile } : {},
 					...spawnPreflight ? { preflightSpawn: spawnPreflight } : {},
 					...options.resolveSpawnProfile ? { resolveSpawnProfile: options.resolveSpawnProfile } : {},
@@ -4447,7 +4583,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 			...options.analyzeOnSettle ? { analyzeOnSettle: options.analyzeOnSettle } : {},
 			...options.watchWorkers ? { watchWorkers: options.watchWorkers } : {},
 			...options.stallAfterMs !== void 0 ? { stallAfterMs: options.stallAfterMs } : {},
-			...options.awaitTimeoutMs !== void 0 ? { awaitTimeoutMs: options.awaitTimeoutMs } : {},
+			...options.wake !== void 0 ? { wake: options.wake } : {},
 			...options.continuityByProfile ? { continuityByProfile: options.continuityByProfile } : {},
 			...options.stopRule ? { stopRule: stopRuleOf(options.stopRule) } : {},
 			...options.onProgressStop ? { onProgressStop: options.onProgressStop } : {},
@@ -4588,4 +4724,4 @@ function rootProviderModelEvidenceFromExecution(evidence) {
 //#endregion
 export { gateOnDeliverable as C, serveCoordinationMcp as S, readRootStream as _, superviseWithTestBrain as a, composeReentryTask as b, resolveWorkerSpawnRetry as c, assertCoordinationBinding as d, coordinationProfileToolPrefix as f, ROOT_STREAM_FILE as g, supervisorAgentWithTestBrain as h, superviseRootProfile as i, retryPreSpawnRefusals as l, supervisorAgent as m, profileGuidanceComposer as n, workerFromBackend as o, resolveSupervisorProfile as p, supervise as r, isPreSpawnExecutorFailure as s, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, withWorkerSpawnRetry as u, readRootStreamReceipt as v, mapExecutorResult as w, createSupervisorSpanRecorder as x, UNPROVEN_CONTINUITY as y };
 
-//# sourceMappingURL=supervise-C5mktzrh.js.map
+//# sourceMappingURL=supervise-BJrEC2Mh.js.map