agents 0.23.0 → 0.25.0

package/dist/{src-DlSHshb2.js → src-BZeu-SCD.js}

@@ -1,26 +1,28 @@
 import { camelCaseToKebabCase, isInternalJsStubProp } from "./utils.js";
 import { getAgentByName } from "./agent-routing.js";
-import { AGENT_TOOL_MILESTONE_PART } from "./agent-tool-types.js";
+import { AGENT_TOOL_MILESTONE_PART, isAgentToolLifecycleChunk } from "./agent-tool-types.js";
 import { n as getCurrentAgent$1, t as __DO_NOT_USE_WILL_BREAK__agentContext } from "./current-agent-DhoDkSnH.js";
 import "./internal_context.js";
 import { copyCallableMetadata, decoratedMethods, getCallableMetadata, isCallableMethod } from "./callable-decorator.js";
 import "./types.js";
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
+import { t as _classPrivateMethodInitSpec } from "./classPrivateMethodInitSpec-qMjJ6sHQ.js";
 import { signAgentHeaders } from "./email.js";
 import { sendAgentEmail } from "./email-send.js";
-import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
 import { n as withInvocationScope, r as writeSpanAttributes, t as tracer } from "./cloudflare-Dzvc7V2N.js";
 import { parseSubAgentPath } from "./sub-routing.js";
-import { t as LifecycleCapability } from "./capability-BjSKYpzg.js";
-import { t as _classPrivateMethodInitSpec } from "./classPrivateMethodInitSpec-qMjJ6sHQ.js";
-import { a as abortWithoutAlarmRetry, i as setLifecycleRouteTransport, n as setLifecycleEventSink, r as setLifecycleHostInvoker, t as Lifecycle } from "./lifecycle-CMRGjZdw.js";
+import { a as getConnectionFlag, c as isConnectionReadonly, d as setConnectionProtocolEnabled, f as setConnectionReadonly, i as ensureConnectionWrapped, l as registerInternalConnectionKeys, o as getConnectionRawState, s as isConnectionProtocolEnabled, t as WebSockets, u as setConnectionFlag } from "./websockets-Ci-LZFHH.js";
+import { t as LifecycleCapability } from "./capability-B4WbF81e.js";
+import { a as abortWithoutAlarmRetry, i as setLifecycleRouteTransport, n as setLifecycleEventSink, r as setLifecycleHostInvoker, t as Lifecycle } from "./lifecycle-CFu6OV03.js";
 import { isErrorRetryable, tryN, validateRetryOptions } from "./retries.js";
 import { SqlError } from "./sql-error.js";
-import { o as callablesFromDecorated, t as WebSockets } from "./websockets-DUfRHPRq.js";
-import { a as ensureMcpServerTable, d as DisposableStore, i as normalizeServerId, l as RPC_DO_PREFIX, o as MCPConnectionState, t as MCPClientManager } from "./client-jagG8a9_.js";
+import { a as ensureMcpServerTable, d as DisposableStore, i as normalizeServerId, l as RPC_DO_PREFIX, o as MCPConnectionState, t as MCPClientManager } from "./client-fyQrLGkD.js";
 import { DurableObjectOAuthClientProvider } from "./mcp/client/do-oauth-client-provider.js";
 import { genericObservability } from "./observability/index.js";
-import { n as setSchedulerCallbackResolver, t as Scheduler } from "./scheduler-DD9NdYbF.js";
-import { n as setTaskDefinitionResolver, r as setTaskRoutedMemoryLimitHandler, t as Tasks } from "./tasks-ylZgBjhj.js";
+import { n as setSchedulerCallbackResolver, t as Scheduler } from "./scheduler-DZ3xQfeK.js";
+import { n as setQueueCallbackResolver, t as Queue } from "./queue-BB-zfIYF.js";
+import { n as setTaskDefinitionResolver, r as setTaskRoutedMemoryLimitHandler, t as Tasks } from "./tasks-68DESxf0.js";
+import { State } from "./state/index.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { DurableObject, RpcTarget, exports } from "cloudflare:workers";
 import { nanoid } from "nanoid";
@@ -294,12 +296,47 @@ function _addColumnIfNotExists(sql) {
 */
 const CF_SUB_AGENT_OUTER_URL_KEY = "_cf_subAgentOuterUrl";
 const CF_SUB_AGENT_TAGS_KEY = "_cf_subAgentTags";
+/**
+* Set on a socket closed because its sub-agent was deleted. Its late
+* message/close events are dropped, so they can't reach a same-name
+* replacement created after the delete. Storage-frozen — never rename.
+*/
+const CF_SUB_AGENT_DELETED_KEY = "_cf_subAgentDeleted";
 /** Wire-frozen internal header carrying the outer URL on WS upgrades. */
 const SUB_AGENT_OUTER_URL_HEADER = "x-cf-agents-subagent-url";
+/**
+* The close frame a rejected sub-agent WebSocket receives in place of the
+* `onBeforeSubAgent` response, which a browser cannot read from a failed
+* handshake. A 4xx closes with `4000 + status`, which clients treat as
+* final; anything else closes with 1011 so the client retries.
+*/
+function subAgentRejectionClose(response) {
+	const { status } = response;
+	return {
+		code: status >= 400 && status < 500 ? 4e3 + status : 1011,
+		reason: `Sub-agent connection rejected (${status})`
+	};
+}
+/**
+* Upgrade a rejected sub-agent WebSocket only to close it, so the client
+* sees a close frame instead of a failed handshake that reconnects forever.
+*/
+function rejectSubAgentWebSocket(response) {
+	const { code, reason } = subAgentRejectionClose(response);
+	const [client, server] = Object.values(new WebSocketPair());
+	server.accept();
+	server.close(code, reason);
+	return new Response(null, {
+		status: 101,
+		webSocket: client
+	});
+}
 var _host = /* @__PURE__ */ new WeakMap();
 var _facetKeepAliveTokens = /* @__PURE__ */ new WeakMap();
 var _bridgeContext = /* @__PURE__ */ new WeakMap();
 var _virtualConnections = /* @__PURE__ */ new WeakMap();
+var _virtualConnectionsHydrated = /* @__PURE__ */ new WeakMap();
+var _virtualConnectionsHydration = /* @__PURE__ */ new WeakMap();
 var _connectionOperationTails = /* @__PURE__ */ new WeakMap();
 var _broadcastOperationTail = /* @__PURE__ */ new WeakMap();
 var _DynamicAgentsInternal_brand = /* @__PURE__ */ new WeakSet();
@@ -333,6 +370,8 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 		_classPrivateFieldInitSpec(this, _facetKeepAliveTokens, /* @__PURE__ */ new Set());
 		_classPrivateFieldInitSpec(this, _bridgeContext, new AsyncLocalStorage());
 		_classPrivateFieldInitSpec(this, _virtualConnections, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _virtualConnectionsHydrated, false);
+		_classPrivateFieldInitSpec(this, _virtualConnectionsHydration, void 0);
 		_classPrivateFieldInitSpec(this, _connectionOperationTails, /* @__PURE__ */ new Map());
 		_classPrivateFieldInitSpec(this, _broadcastOperationTail, void 0);
 		_classPrivateFieldSet2(_host, this, host);
@@ -387,7 +426,7 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 		if (!_classPrivateFieldGet2(_host, this).hasSubAgent(next.className, next.name)) {
 			const stalePath = targetPath.slice(0, selfPath.length + 1);
 			if (_classPrivateFieldGet2(_host, this)._isFacet) await (await this.rootAlarmOwner())._cf_cleanupFacetPrefix(stalePath);
-			else await _classPrivateFieldGet2(_host, this)._cf_cleanupFacetPrefix(stalePath);
+			else await this.cleanupPrefix(stalePath);
 			return false;
 		}
 		return (await _classPrivateFieldGet2(_host, this)._cf_resolveSubAgent(next.className, next.name))._cf_routeLifecycle(target, envelope);
@@ -401,7 +440,7 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 		if (!root) throw new Error("Facet routing requires a root parent.");
 		const binding = _classPrivateFieldGet2(_host, this).ctx.exports?.[root.className];
 		if (!binding) throw new Error(`Unable to resolve root "${root.className}" for facet routing.`);
-		return await getAgentByName(binding, root.name);
+		return binding.get(binding.idFromName(root.name));
 	}
 	rootResolvesToSelf() {
 		const root = _classPrivateFieldGet2(_host, this)._parentPath[0];
@@ -412,14 +451,16 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 	}
 	/**
 	* Clean root-owned bookkeeping for a sub-tree of facets: bulk-cancel
-	* schedules and routed Task wake mirrors under the owner-path prefix,
-	* and delete root-side facet fiber recovery leases for the same sub-tree.
+	* schedules, queue items, and routed Task wake mirrors under the
+	* owner-path prefix, and delete root-side facet fiber recovery leases for
+	* the same sub-tree.
 	*/
 	async cleanupPrefix(ownerPath) {
 		const prefix = agentPathKey(ownerPath);
 		if (prefix) {
 			await _classPrivateFieldGet2(_host, this).scheduler.__DO_NOT_USE_WILL_BREAK__cleanupRoutePrefix(prefix);
 			await _classPrivateFieldGet2(_host, this).tasks.__DO_NOT_USE_WILL_BREAK__cleanupRoutePrefix(prefix);
+			await _classPrivateFieldGet2(_host, this)._queue.__DO_NOT_USE_WILL_BREAK__cleanupRoutePrefix(prefix);
 		}
 		this.deleteRunRowsForPrefix(ownerPath);
 		await _classPrivateFieldGet2(_host, this)._syncHostJobs();
@@ -501,6 +542,7 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 	* rows on the target facet after recovery.
 	*/
 	async checkRunFibersAtPath(ownerPath) {
+		await _classPrivateFieldGet2(_host, this).__unsafe_ensureInitialized();
 		const selfPath = _classPrivateFieldGet2(_host, this).selfPath;
 		if (!_classPrivateFieldGet2(_host, this)._isSameAgentPathPrefix(selfPath, ownerPath)) throw new Error(`Facet fiber owner path does not descend from ${JSON.stringify(selfPath)}.`);
 		if (selfPath.length === ownerPath.length) {
@@ -544,11 +586,12 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 		if (targetPath.length === 0) throw new Error("_cf_destroyDescendantFacet: target path must not be empty.");
 		if (selfPath.length >= targetPath.length) throw new Error("_cf_destroyDescendantFacet: target must be a strict descendant.");
 		if (!_classPrivateFieldGet2(_host, this)._isSameAgentPathPrefix(selfPath, targetPath)) throw new Error("_cf_destroyDescendantFacet: target path does not descend from this agent.");
-		if (_classPrivateFieldGet2(_host, this)._parentPath.length === 0) await _classPrivateFieldGet2(_host, this)._cf_cleanupFacetPrefix(targetPath);
+		if (_classPrivateFieldGet2(_host, this)._parentPath.length === 0) await this.cleanupPrefix(targetPath);
 		if (selfPath.length === targetPath.length - 1) {
 			const target = targetPath[targetPath.length - 1];
 			const ctx = _classPrivateFieldGet2(_host, this).ctx;
 			if (!ctx.facets) throw new Error("destroy() (delegated from facet) is not supported in this runtime — `ctx.facets` is unavailable. Update to the latest `compatibility_date` in your wrangler.jsonc.");
+			await _assertClassBrand(_DynamicAgentsInternal_brand, this, _closeConnectionsForDeletedPath).call(this, targetPath);
 			try {
 				ctx.facets.delete(`${target.className}\0${target.name}`);
 			} catch {}
@@ -624,16 +667,31 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 			className,
 			name
 		}];
-		if (_classPrivateFieldGet2(_host, this)._isFacet) await (await this.rootAlarmOwner())._cf_cleanupFacetPrefix(childPath);
-		else await _classPrivateFieldGet2(_host, this)._cf_cleanupFacetPrefix(childPath);
+		const root = _classPrivateFieldGet2(_host, this)._isFacet ? await this.rootAlarmOwner() : void 0;
+		await _assertClassBrand(_DynamicAgentsInternal_brand, this, _closeConnectionsForDeletedPath).call(this, childPath, root);
 		try {
 			ctx.facets.delete(facetKey);
 		} catch {}
 		this.registry.forget(className, name);
+		if (root) await root._cf_cleanupFacetPrefix(childPath);
+		else await this.cleanupPrefix(childPath);
+	}
+	/** Root-side: close sockets whose `/sub/...` target is under `prefix`. */
+	closeConnectionsForPrefix(prefix, code, reason) {
+		for (const connection of _classPrivateFieldGet2(_host, this)._webSockets.getConnections()) {
+			const targetPath = this.connectionTargetPath(connection);
+			if (!targetPath) continue;
+			if (!_classPrivateFieldGet2(_host, this)._isSameAgentPathPrefix(prefix, targetPath)) continue;
+			_classPrivateFieldGet2(_host, this)._unsafe_setConnectionFlag(connection, CF_SUB_AGENT_DELETED_KEY, true);
+			try {
+				connection.close(code, reason);
+			} catch {}
+		}
 	}
 	/** Drop all facet-side virtual connections (test/rehydration hook). */
 	clearVirtualConnections() {
 		_classPrivateFieldGet2(_virtualConnections, this).clear();
+		_classPrivateFieldSet2(_virtualConnectionsHydrated, this, false);
 	}
 	/** Facet-side lookup of a virtual connection by id. */
 	getVirtualConnection(id) {
@@ -711,6 +769,7 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 		await completion;
 	}
 	async broadcastToParent(message, without) {
+		if (_assertClassBrand(_DynamicAgentsInternal_brand, this, _broadcastHasNoRecipients).call(this, without)) return;
 		await this.routeBroadcast(_classPrivateFieldGet2(_host, this).selfPath, message, without);
 	}
 	async broadcastToPath(ownerPath, message, without) {
@@ -747,12 +806,12 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 	async setConnectionState(connectionId, state) {
 		const connection = _classPrivateFieldGet2(_host, this)._webSockets.getConnection(connectionId);
 		if (!connection || !this.connectionHasChildTarget(connection)) return null;
-		_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+		ensureConnectionWrapped(connection);
 		connection.setState(state);
 		return this.getForwardedState(connection);
 	}
 	connectionTargetPath(connection) {
-		_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+		ensureConnectionWrapped(connection);
 		const outerUri = _classPrivateFieldGet2(_host, this)._unsafe_getConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY);
 		if (typeof outerUri !== "string") return null;
 		return _assertClassBrand(_DynamicAgentsInternal_brand, this, _pathFromOuterUri).call(this, outerUri)?.path ?? null;
@@ -762,7 +821,7 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 		return a.every((step, index) => step.className === b[index]?.className && step.name === b[index]?.name);
 	}
 	connectionHasChildTarget(connection) {
-		_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+		ensureConnectionWrapped(connection);
 		return typeof _classPrivateFieldGet2(_host, this)._unsafe_getConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY) === "string";
 	}
 	connectionTargetsChild(connection) {
@@ -775,21 +834,27 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 		return parseSubAgentPath(request.url, { knownClasses: ctx.exports ? Object.keys(ctx.exports) : void 0 }) !== null;
 	}
 	async forwardWebSocketConnect(connection, request, options) {
-		const routed = await _assertClassBrand(_DynamicAgentsInternal_brand, this, _resolveConnection).call(this, connection, request, options);
-		if (!routed) return false;
+		const routed = await _assertClassBrand(_DynamicAgentsInternal_brand, this, _resolveConnection).call(this, connection, {
+			create: true,
+			request,
+			gate: options.gate
+		});
+		if (routed.status !== "ok") return false;
 		await routed.child._cf_handleSubAgentWebSocketConnect(_assertClassBrand(_DynamicAgentsInternal_brand, this, _createConnectionBridge).call(this, connection), routed.meta);
 		return true;
 	}
 	async forwardWebSocketMessage(connection, message, replyBridge) {
-		const routed = await _assertClassBrand(_DynamicAgentsInternal_brand, this, _resolveConnection).call(this, connection);
-		if (!routed) return false;
+		const routed = await _assertClassBrand(_DynamicAgentsInternal_brand, this, _resolveConnection).call(this, connection, { create: false });
+		if (routed.status === "no-match") return false;
+		if (routed.status === "dropped") return true;
 		const bridge = _assertClassBrand(_DynamicAgentsInternal_brand, this, _createConnectionBridge).call(this, connection);
 		await routed.child._cf_handleSubAgentWebSocketMessage(message, bridge, routed.meta, replyBridge ?? bridge);
 		return true;
 	}
 	async forwardWebSocketClose(connection, code, reason, wasClean) {
-		const routed = await _assertClassBrand(_DynamicAgentsInternal_brand, this, _resolveConnection).call(this, connection);
-		if (!routed) return false;
+		const routed = await _assertClassBrand(_DynamicAgentsInternal_brand, this, _resolveConnection).call(this, connection, { create: false });
+		if (routed.status === "no-match") return false;
+		if (routed.status === "dropped") return true;
 		await routed.child._cf_handleSubAgentWebSocketClose(code, reason, wasClean, _assertClassBrand(_DynamicAgentsInternal_brand, this, _createConnectionBridge).call(this, connection), routed.meta);
 		return true;
 	}
@@ -799,7 +864,7 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 			const request = new Request(meta.uri ?? "http://placeholder/", { headers: meta.requestHeaders });
 			if (await this.forwardWebSocketConnect(connection, request, { gate: true })) return;
 			if (_classPrivateFieldGet2(_host, this).shouldConnectionBeReadonly(connection, { request })) _classPrivateFieldGet2(_host, this).setConnectionReadonly(connection, true);
-			if (!_classPrivateFieldGet2(_host, this).shouldSendProtocolMessages(connection, { request })) _classPrivateFieldGet2(_host, this)._setConnectionNoProtocol(connection);
+			if (!_classPrivateFieldGet2(_host, this).shouldSendProtocolMessages(connection, { request })) setConnectionProtocolEnabled(connection, false);
 			const childTags = await _classPrivateFieldGet2(_host, this).getConnectionTags(connection, { request });
 			connection.tags = [connection.id, ...childTags.filter((tag) => tag !== connection.id)];
 			this.storeVirtualConnection(connection);
@@ -881,7 +946,7 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 			removeEventListener() {}
 		};
 		stored.connection = connection;
-		_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+		ensureConnectionWrapped(connection);
 		return connection;
 	}
 	storeVirtualConnection(connection) {
@@ -918,11 +983,11 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 		if (!_classPrivateFieldGet2(_host, this)._isFacet || _classPrivateFieldGet2(_host, this)._parentPath.length === 0) return;
 		if (this.rootResolvesToSelf()) return;
 		const metas = await (await this.rootAlarmOwner())._cf_subAgentConnectionMetas(_classPrivateFieldGet2(_host, this).selfPath);
-		for (const meta of metas) _classPrivateFieldGet2(_virtualConnections, this).set(meta.id, { meta });
+		for (const meta of metas) if (!_classPrivateFieldGet2(_virtualConnections, this).has(meta.id)) _classPrivateFieldGet2(_virtualConnections, this).set(meta.id, { meta });
+		_classPrivateFieldSet2(_virtualConnectionsHydrated, this, true);
 	}
 	getRawConnectionState(connection) {
-		_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
-		return _classPrivateFieldGet2(_host, this)._rawStateAccessors.get(connection)?.getRaw() ?? null;
+		return getConnectionRawState(connection);
 	}
 	getForwardedState(connection) {
 		const raw = this.getRawConnectionState(connection);
@@ -961,6 +1026,7 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 	* one RPC method. Stateless — no cached references.
 	*/
 	async invoke(className, name, method, args) {
+		await _classPrivateFieldGet2(_host, this).__unsafe_ensureInitialized();
 		const stub = await this.resolve(className, name);
 		return await this.invokeStubMethod(stub, className, method, args);
 	}
@@ -971,6 +1037,7 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 	* to the next facet using that facet's own `ctx.facets`.
 	*/
 	async invokePath(path, method, args) {
+		await _classPrivateFieldGet2(_host, this).__unsafe_ensureInitialized();
 		const [self, next, ...rest] = path;
 		if (!self) throw new Error(`Sub-agent path invocation requires a non-empty path.`);
 		const ownClassName = _classPrivateFieldGet2(_host, this).constructor.name;
@@ -1014,6 +1081,46 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 		await _classPrivateFieldGet2(_host, this)._syncHostJobs();
 	}
 };
+/**
+* Non-creating counterpart to {@link resolve} for WebSocket message/close
+* forwarding. Returns `null` when the child has no registry row, and never
+* writes one. The connection's initial connect already went through
+* {@link resolve} on this hop, so the runtime/export checks there hold.
+*/
+async function _resolveExisting(className, name) {
+	const row = this.registry.row(className, name);
+	if (!row) return null;
+	const ctx = _classPrivateFieldGet2(_host, this).ctx;
+	const identityName = row.identity_version === "path-v2" && typeof row.identity_name === "string" ? row.identity_name : name;
+	const rootClassName = _classPrivateFieldGet2(_host, this)._parentPath[0]?.className ?? _classPrivateFieldGet2(_host, this).constructor.name;
+	const rootNs = ctx.exports[rootClassName];
+	const stub = ctx.facets.get(`${className}\0${name}`, () => ({
+		class: ctx.exports[className],
+		id: rootNs.idFromName(identityName)
+	}));
+	const childParentPath = _classPrivateFieldGet2(_host, this).selfPath;
+	try {
+		await _classPrivateFieldGet2(_host, this)._runFacetInitInvocation(async () => {
+			await stub._cf_initAsFacet(name, childParentPath, identityName);
+		});
+	} catch (error) {
+		if (!this.registry.row(className, name)) return null;
+		throw error;
+	}
+	return stub;
+}
+/**
+* Close every client socket targeting `path` or a descendant, so a client
+* attached to a deleted facet gets an explicit close instead of a socket
+* that goes nowhere (#2003). Only the root owns real sockets.
+*/
+async function _closeConnectionsForDeletedPath(path, root) {
+	if (!_classPrivateFieldGet2(_host, this)._isFacet) {
+		this.closeConnectionsForPrefix(path, 1001, "Sub-agent deleted");
+		return;
+	}
+	await (root ?? await this.rootAlarmOwner())._cf_closeSubAgentConnectionsForPrefix(path, 1001, "Sub-agent deleted");
+}
 function _reportConnectionOperationFailure(connectionId, operation, error) {
 	console.error("[Agent] Sub-agent connection operation failed:", {
 		connectionId,
@@ -1021,8 +1128,31 @@ function _reportConnectionOperationFailure(connectionId, operation, error) {
 		error
 	});
 }
+/**
+* Whether a hydrated mirror proves no root socket targets this facet
+* outside `without`. Stale mirror entries only cost a root call; a socket
+* missing from a hydrated mirror has not had its connect forwarded here
+* yet, so it has not been through `onConnect`. Synchronous so a skipped
+* broadcast never reorders later operations.
+*/
+function _broadcastHasNoRecipients(without) {
+	if (!_classPrivateFieldGet2(_virtualConnectionsHydrated, this)) {
+		_assertClassBrand(_DynamicAgentsInternal_brand, this, _hydrateVirtualConnectionsInBackground).call(this);
+		return false;
+	}
+	for (const id of _classPrivateFieldGet2(_virtualConnections, this).keys()) if (!without?.includes(id)) return false;
+	return true;
+}
+function _hydrateVirtualConnectionsInBackground() {
+	if (_classPrivateFieldGet2(_virtualConnectionsHydration, this)) return;
+	const hydration = this.hydrateConnectionsFromRoot().catch(() => {}).finally(() => {
+		_classPrivateFieldSet2(_virtualConnectionsHydration, this, void 0);
+	});
+	_classPrivateFieldSet2(_virtualConnectionsHydration, this, hydration);
+	_classPrivateFieldGet2(_host, this).ctx.waitUntil(hydration);
+}
 function _connectionMetaForPath(connection, ownerPath) {
-	_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+	ensureConnectionWrapped(connection);
 	const outerUri = _classPrivateFieldGet2(_host, this)._unsafe_getConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY);
 	if (typeof outerUri !== "string") return null;
 	const target = _assertClassBrand(_DynamicAgentsInternal_brand, this, _pathFromOuterUri).call(this, outerUri, ownerPath);
@@ -1071,20 +1201,31 @@ function _createConnectionBridge(connection) {
 		return _classPrivateFieldGet2(_host, this)._cf_broadcastToSubAgent(ownerPath, message, without);
 	});
 }
-async function _resolveConnection(connection, request, options = { gate: false }) {
-	_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+/**
+* Resolve a connection's `/sub/{class}/{name}` target.
+*
+* `create: true` (the initial connect) may wake or create the child, like
+* `subAgent()`. `create: false` (message/close on an already-forwarded
+* connection) only attaches to a child that still has a registry row; a
+* deleted child resolves to `"dropped"`, which the caller must treat as
+* consumed so a stale frame can't recreate it (#2003).
+*/
+async function _resolveConnection(connection, options) {
+	ensureConnectionWrapped(connection);
 	const outerUri = _classPrivateFieldGet2(_host, this)._unsafe_getConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY);
 	const uri = typeof outerUri === "string" ? outerUri : connection.uri;
-	if (!uri) return null;
+	if (!uri) return { status: "no-match" };
+	if (_classPrivateFieldGet2(_host, this)._unsafe_getConnectionFlag(connection, "_cf_subAgentDeleted")) return { status: "dropped" };
 	const ctx = _classPrivateFieldGet2(_host, this).ctx;
 	let match = parseSubAgentPath(uri, { knownClasses: ctx.exports ? Object.keys(ctx.exports) : void 0 });
-	if (!match) return null;
+	if (!match) return { status: "no-match" };
 	if (_classPrivateFieldGet2(_host, this)._ParentClass.name === match.childClass && _classPrivateFieldGet2(_host, this).name === match.childName) {
 		const tailUri = new URL(uri);
 		tailUri.pathname = match.remainingPath;
 		match = parseSubAgentPath(tailUri.toString(), { knownClasses: ctx.exports ? Object.keys(ctx.exports) : void 0 });
-		if (!match) return null;
+		if (!match) return { status: "no-match" };
 	}
+	const { request } = options;
 	let forwardReq = request;
 	if (request && options.gate) {
 		const decision = await _classPrivateFieldGet2(_host, this).onBeforeSubAgent(request, {
@@ -1092,25 +1233,28 @@ async function _resolveConnection(connection, request, options = { gate: false }
 			name: match.childName
 		});
 		if (decision instanceof Response) {
-			connection.close(1008, "Sub-agent connection rejected");
-			return null;
+			const { code, reason } = subAgentRejectionClose(decision);
+			connection.close(code, reason);
+			return { status: "dropped" };
 		}
 		forwardReq = decision instanceof Request ? decision : request;
 	}
-	const child = await this.resolve(match.childClass, match.childName);
+	const child = options.create ? await this.resolve(match.childClass, match.childName) : await _assertClassBrand(_DynamicAgentsInternal_brand, this, _resolveExisting).call(this, match.childClass, match.childName);
+	if (!child) return { status: "dropped" };
 	const childUri = new URL(forwardReq?.url ?? uri);
 	childUri.pathname = match.remainingPath;
 	const raw = this.getRawConnectionState(connection);
 	const rawTags = raw != null && typeof raw === "object" ? raw[CF_SUB_AGENT_TAGS_KEY] : void 0;
 	const tags = Array.isArray(rawTags) ? rawTags.filter((tag) => typeof tag === "string") : [...connection.tags];
 	return {
+		status: "ok",
 		child,
 		meta: {
 			id: connection.id,
 			uri: childUri.toString(),
 			tags,
 			state: this.getForwardedState(connection),
-			requestHeaders: forwardReq ? [...forwardReq.headers] : void 0
+			requestHeaders: forwardReq ? [...forwardReq.headers].filter(([name]) => name !== SUB_AGENT_OUTER_URL_HEADER) : void 0
 		}
 	};
 }
@@ -1213,12 +1357,6 @@ function sendRpcResponseIfOpen(connection, response) {
 function isRPCRequest(msg) {
 	return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "rpc" && "id" in msg && typeof msg.id === "string" && "method" in msg && typeof msg.method === "string" && "args" in msg && Array.isArray(msg.args);
 }
-/**
-* Type guard for state update messages
-*/
-function isStateUpdateMessage(msg) {
-	return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "cf_agent_state" && "state" in msg;
-}
 const _fiberALS = new AsyncLocalStorage();
 const DEFAULT_KEEP_ALIVE_INTERVAL_MS = 3e4;
 const DEFAULT_AGENT_TOOL_RECOVERY_TIMEOUT_MS = 2e3;
@@ -1247,57 +1385,15 @@ const DETACHED_NOTIFY_CALLBACK = "_cfDetachedNotifyFinish";
 /**
 * Schema version for the Agent's internal SQLite tables.
 * Bump this when adding new tables, columns, or migrations.
-* The constructor stores this as a row in cf_agents_state and checks it
-* on wake to skip DDL on established DOs.
+* The constructor stores this under a namespaced KV key (the same convention
+* every capability uses for its own schema version) and checks it on wake to
+* skip DDL on established DOs.
 */
-const CURRENT_SCHEMA_VERSION = 11;
-const SCHEMA_VERSION_ROW_ID = "cf_schema_version";
-const STATE_ROW_ID = "cf_state_row_id";
-const STATE_WAS_CHANGED = "cf_state_was_changed";
+const CURRENT_SCHEMA_VERSION = 14;
+const SCHEMA_VERSION_KEY = "cf_agents:schema_version";
+const LEGACY_SCHEMA_VERSION_ROW_ID = "cf_schema_version";
 const DEFAULT_STATE = {};
-/**
-* Internal key used to store the readonly flag in connection state.
-* Prefixed with _cf_ to avoid collision with user state keys.
-*/
-const CF_READONLY_KEY = "_cf_readonly";
-/**
-* Internal key used to store the no-protocol flag in connection state.
-* When set, protocol messages (identity, state sync, MCP servers) are not
-* sent to this connection — neither on connect nor via broadcasts.
-*/
-const CF_NO_PROTOCOL_KEY = "_cf_no_protocol";
-/**
-* The set of all internal keys stored in connection state that must be
-* hidden from user code and preserved across setState calls.
-*/
-const CF_INTERNAL_KEYS = /* @__PURE__ */ new Set([
-	CF_READONLY_KEY,
-	CF_NO_PROTOCOL_KEY,
-	"_cf_voiceInCall",
-	CF_SUB_AGENT_OUTER_URL_KEY,
-	CF_SUB_AGENT_TAGS_KEY
-]);
-/** Check if a raw connection state object contains any internal keys. */
-function rawHasInternalKeys(raw) {
-	for (const key of Object.keys(raw)) if (CF_INTERNAL_KEYS.has(key)) return true;
-	return false;
-}
-/** Return a copy of `raw` with all internal keys removed, or null if no user keys remain. */
-function stripInternalKeys(raw) {
-	const result = {};
-	let hasUserKeys = false;
-	for (const key of Object.keys(raw)) if (!CF_INTERNAL_KEYS.has(key)) {
-		result[key] = raw[key];
-		hasUserKeys = true;
-	}
-	return hasUserKeys ? result : null;
-}
-/** Return a copy containing only the internal keys present in `raw`. */
-function extractInternalFlags(raw) {
-	const result = {};
-	for (const key of Object.keys(raw)) if (CF_INTERNAL_KEYS.has(key)) result[key] = raw[key];
-	return result;
-}
+registerInternalConnectionKeys("_cf_voiceInCall", CF_SUB_AGENT_OUTER_URL_KEY, CF_SUB_AGENT_TAGS_KEY);
 /** Max length for error strings broadcast to clients. */
 const MAX_ERROR_STRING_LENGTH = 500;
 /**
@@ -1368,9 +1464,9 @@ const DEFAULT_AGENT_STATIC_OPTIONS = {
 	/**
 	* Optional hard wall-clock ceiling (ms) on a single agent-tool re-attach
 	* (#1630). Caps the total wait even as the no-progress budget re-arms across
-	* stream-closes. Defaults to `Infinity` (no implicit cap), mirroring
-	* chat-recovery's `maxRecoveryWork` (#1672): a healthy, still-advancing child
-	* is followed for as long as it makes progress — a hung child is bounded by
+	* stream-closes. Defaults to `Infinity` (no implicit cap, #1672): a healthy,
+	* still-advancing child is followed for as long as it makes progress — a
+	* hung child is bounded by
 	* the no-progress budget, and a content-runaway by the child's own
 	* `maxRecoveryWork` / `shouldKeepRecovering`. Set a finite value to impose a
 	* wall-clock cap (which also tears the child down on `window-exceeded`).
@@ -1388,36 +1484,23 @@ const DEFAULT_AGENT_STATIC_OPTIONS = {
 	*/
 	maxAlarmMemoryLimitStrikes: 3
 };
-/**
-* Parse the raw `retry_options` TEXT column from a SQLite row into a
-* typed `RetryOptions` object, or `undefined` if not set.
-*/
-function parseRetryOptions(row) {
-	const raw = row.retry_options;
-	if (typeof raw !== "string") return void 0;
-	return JSON.parse(raw);
-}
-/**
-* Resolve per-task retry options against class-level defaults and call
-* `tryN`. This is the retry-execution path for queue flush; Scheduler owns
-* its own copy for schedule callbacks.
-*/
-function resolveRetryConfig(taskRetry, defaults) {
-	return {
-		maxAttempts: taskRetry?.maxAttempts ?? defaults.maxAttempts,
-		baseDelayMs: taskRetry?.baseDelayMs ?? defaults.baseDelayMs,
-		maxDelayMs: taskRetry?.maxDelayMs ?? defaults.maxDelayMs
-	};
-}
 /** Compatibility alias for the lifecycle-owned current Agent accessor. */
 const getCurrentAgent = getCurrentAgent$1;
+const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
+/** Functions produced by {@link withAgentContext}, so they are wrapped once. */
+const agentContextWrappers = /* @__PURE__ */ new WeakSet();
 /**
 * Restore Agent context when a public method is entered outside a Lifecycle
 * hook, notably through native Durable Object RPC or cross-Agent re-entry.
 * Lifecycle already owns context for its capability and semantic user hooks.
+*
+* Native RPC bypasses the lifecycle's runtime handlers, so an `async` method
+* entered from outside this Agent's context first starts the lifecycle when
+* the call is the one that wakes a cold instance. Synchronous methods are
+* never deferred, so they keep their synchronous return type.
 */
 function withAgentContext(method) {
-	return function(...args) {
+	const enter = function(...args) {
 		const { agent } = getCurrentAgent();
 		if (agent === this) return method.apply(this, args);
 		return runInInvocation({
@@ -1429,11 +1512,21 @@ function withAgentContext(method) {
 			return method.apply(this, args);
 		});
 	};
+	if (!(method instanceof AsyncFunction)) {
+		agentContextWrappers.add(enter);
+		return enter;
+	}
+	const enterStarted = async function(...args) {
+		if (getCurrentAgent().agent !== this && !this.lifecycle.isStarted()) await this.lifecycle.start();
+		return enter.apply(this, args);
+	};
+	agentContextWrappers.add(enterStarted);
+	return enterStarted;
 }
 /**
 * Base class for creating Agent implementations
 * @template Env Environment type containing bindings
-* @template State State type to store within the Agent
+* @template TState State type to store within the Agent
 */
 var Agent = class Agent extends DurableObject {
 	/** Run user initialization after lifecycle components have started. */
@@ -1505,31 +1598,16 @@ var Agent = class Agent extends DurableObject {
 		return this.ctx.id.toString();
 	}
 	/**
-	* Current state of the Agent
+	* Current state of the Agent.
+	*
+	* Delegates to the State capability, which owns lazy load and the
+	* in-memory cache; Agent seeds `initialState` on first access.
 	*/
 	get state() {
-		if (this._state !== DEFAULT_STATE) return this._state;
-		const result = this.sql`
-      SELECT state FROM cf_agents_state WHERE id = ${STATE_ROW_ID}
-    `;
-		if (result.length > 0) {
-			const state = result[0].state;
-			try {
-				this._state = JSON.parse(state);
-			} catch (e) {
-				console.error("Failed to parse stored state, falling back to initialState:", e);
-				if (this.initialState !== DEFAULT_STATE) {
-					this._state = this.initialState;
-					this._setStateInternal(this.initialState);
-				} else {
-					this.sql`DELETE FROM cf_agents_state WHERE id = ${STATE_ROW_ID}`;
-					return;
-				}
-			}
-			return this._state;
-		}
-		if (this.initialState === DEFAULT_STATE) return;
-		this._setStateInternal(this.initialState);
+		const stored = this._state.get();
+		if (stored !== void 0) return stored;
+		if (this.initialState === DEFAULT_STATE) return void 0;
+		this._state.set(this.initialState, "server");
 		return this.initialState;
 	}
 	get _resolvedOptions() {
@@ -1615,26 +1693,9 @@ var Agent = class Agent extends DurableObject {
 	* local dev and the constructor only runs once per DO instance).
 	*/
 	_ensureSchema() {
-		this.sql`
-      CREATE TABLE IF NOT EXISTS cf_agents_state (
-        id TEXT PRIMARY KEY NOT NULL,
-        state TEXT
-      )
-    `;
-		const versionRow = this.sql`
-      SELECT state FROM cf_agents_state WHERE id = ${SCHEMA_VERSION_ROW_ID}
-    `;
-		const schemaVersion = versionRow.length > 0 ? Number(versionRow[0].state) : 0;
+		const schemaVersion = this._readSchemaVersion();
 		if (schemaVersion < CURRENT_SCHEMA_VERSION) {
 			ensureMcpServerTable(this.ctx.storage);
-			this.sql`
-        CREATE TABLE IF NOT EXISTS cf_agents_queues (
-          id TEXT PRIMARY KEY NOT NULL,
-          payload TEXT,
-          callback TEXT,
-          created_at INTEGER DEFAULT (unixepoch())
-        )
-      `;
 			const addColumnIfNotExists = (sql) => {
 				try {
 					this.ctx.storage.sql.exec(sql);
@@ -1642,7 +1703,6 @@ var Agent = class Agent extends DurableObject {
 					if (!(error instanceof Error ? error.message : String(error)).toLowerCase().includes("duplicate column")) throw error;
 				}
 			};
-			addColumnIfNotExists("ALTER TABLE cf_agents_queues ADD COLUMN retry_options TEXT");
 			this.sql`
         CREATE TABLE IF NOT EXISTS cf_agents_workflows (
           id TEXT PRIMARY KEY NOT NULL,
@@ -1667,13 +1727,15 @@ var Agent = class Agent extends DurableObject {
 			this.sql`
         CREATE INDEX IF NOT EXISTS idx_workflows_name ON cf_agents_workflows(workflow_name)
       `;
-			this.ctx.storage.sql.exec("DELETE FROM cf_agents_state WHERE id = ?", STATE_WAS_CHANGED);
 			this.sql`
         CREATE TABLE IF NOT EXISTS cf_agents_runs (
           id TEXT PRIMARY KEY NOT NULL,
           name TEXT NOT NULL,
           snapshot TEXT,
-          created_at INTEGER NOT NULL
+          created_at INTEGER NOT NULL,
+          completed_at INTEGER,
+          outcome TEXT,
+          error_message TEXT
         )
       `;
 			this.sql`
@@ -1752,10 +1814,11 @@ var Agent = class Agent extends DurableObject {
 			addColumnIfNotExists("ALTER TABLE cf_agent_tool_runs ADD COLUMN detached_no_progress_budget_ms INTEGER");
 			addColumnIfNotExists("ALTER TABLE cf_agent_tool_runs ADD COLUMN last_progress_at INTEGER");
 			addColumnIfNotExists("ALTER TABLE cf_agent_tool_runs ADD COLUMN detached_on_milestones TEXT");
-			this.sql`
-        INSERT OR REPLACE INTO cf_agents_state (id, state)
-        VALUES (${SCHEMA_VERSION_ROW_ID}, ${String(CURRENT_SCHEMA_VERSION)})
-      `;
+			addColumnIfNotExists("ALTER TABLE cf_agents_runs ADD COLUMN completed_at INTEGER");
+			addColumnIfNotExists("ALTER TABLE cf_agents_runs ADD COLUMN outcome TEXT");
+			addColumnIfNotExists("ALTER TABLE cf_agents_runs ADD COLUMN error_message TEXT");
+			addColumnIfNotExists("ALTER TABLE cf_agent_tool_runs ADD COLUMN event_delivery TEXT");
+			this.ctx.storage.kv.put(SCHEMA_VERSION_KEY, CURRENT_SCHEMA_VERSION);
 		}
 		this._schemaInitialization = {
 			previousVersion: schemaVersion,
@@ -1763,9 +1826,31 @@ var Agent = class Agent extends DurableObject {
 			migrated: schemaVersion < CURRENT_SCHEMA_VERSION
 		};
 	}
+	/**
+	* Read the Agent's schema version from its KV key. A DO created before the
+	* State capability owned `cf_agents_state` has the version as a row in that
+	* table instead: read it once, move it to the key, and delete the row so the
+	* table is left with a single owner. Synchronous (`storage.kv`) because the
+	* constructor gates DDL on it.
+	*/
+	_readSchemaVersion() {
+		const stored = this.ctx.storage.kv.get(SCHEMA_VERSION_KEY);
+		if (stored !== void 0) return stored;
+		if (!(this.ctx.storage.sql.exec("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'cf_agents_state'").toArray().length > 0)) return 0;
+		const rows = this.ctx.storage.sql.exec("SELECT state FROM cf_agents_state WHERE id = ?", LEGACY_SCHEMA_VERSION_ROW_ID).toArray();
+		if (rows.length === 0) return 0;
+		const version = Number(rows[0].state) || 0;
+		this.ctx.storage.kv.put(SCHEMA_VERSION_KEY, version);
+		this.ctx.storage.sql.exec("DELETE FROM cf_agents_state WHERE id = ?", LEGACY_SCHEMA_VERSION_ROW_ID);
+		return version;
+	}
 	constructor(ctx, env) {
 		super(ctx, env);
 		this.lifecycle = Lifecycle.install(this, { maxAlarmMemoryLimitStrikes: this._resolvedOptions.maxAlarmMemoryLimitStrikes });
+		this._state = new State({
+			validateStateChange: (nextState, source) => this.validateStateChange(nextState, source),
+			onChanged: (nextState, source) => this._handleStateChanged(nextState, source)
+		});
 		this._webSockets = new WebSockets({
 			handlers: {
 				onConnect: (connection, ctx) => this.onConnect(connection, ctx),
@@ -1773,13 +1858,12 @@ var Agent = class Agent extends DurableObject {
 				onClose: (connection, code, reason, wasClean) => this.onClose(connection, code, reason, wasClean),
 				onError: (connection, error) => this.onError(connection, error)
 			},
-			callables: callablesFromDecorated(this),
+			protocol: false,
+			state: this._state,
 			getConnectionTags: (connection, ctx) => this.getConnectionTags(connection, ctx)
 		});
-		this._state = DEFAULT_STATE;
 		this._disposables = new DisposableStore();
 		this._destroyed = false;
-		this._rawStateAccessors = /* @__PURE__ */ new WeakMap();
 		this._persistenceHookMode = "none";
 		this._isFacet = false;
 		this._protocolBroadcastExcludeIds = /* @__PURE__ */ new Set();
@@ -1797,7 +1881,6 @@ var Agent = class Agent extends DurableObject {
 		this._ParentClass = Object.getPrototypeOf(this).constructor;
 		this.initialState = DEFAULT_STATE;
 		this.observability = genericObservability;
-		this._flushingQueue = false;
 		this.maxConcurrentAgentTools = Infinity;
 		const routeHost = this;
 		setLifecycleRouteTransport(this.lifecycle, {
@@ -1832,6 +1915,20 @@ var Agent = class Agent extends DurableObject {
 			if (typeof method !== "function") return void 0;
 			return (payload, schedule) => method.call(this, payload, schedule);
 		});
+		this._queue = new Queue({
+			retry: this._resolvedOptions.retry,
+			onError: (error) => runInInvocation({
+				agent: this,
+				connection: void 0,
+				request: void 0,
+				email: void 0
+			}, () => this.onError(error))
+		});
+		setQueueCallbackResolver(this._queue, (name) => {
+			const method = this[name];
+			if (typeof method !== "function") return void 0;
+			return (payload, item) => method.call(this, payload, item);
+		});
 		this.tasks = new Tasks({ onError: (error) => this.onError(error) });
 		setTaskRoutedMemoryLimitHandler(this.tasks, (context) => {
 			return this.onAlarmMemoryLimit?.call(this, context);
@@ -1857,7 +1954,7 @@ var Agent = class Agent extends DurableObject {
 				createAuthProvider: (callbackUrl) => this.createMcpOAuthProvider(callbackUrl)
 			});
 		});
-		this.lifecycle.use(this.scheduler).use(this.mcp).use(this._webSockets, { fallback: true }).use(this.tasks).use(this._dynamicAgents);
+		this.lifecycle.use(this.scheduler).use(this._queue).use(this.mcp).use(this._state).use(this._webSockets).use(this.tasks).use(this._dynamicAgents);
 		let mcpBroadcastReady = false;
 		this._disposables.add(this.mcp.onServerStateChanged(() => {
 			if (mcpBroadcastReady) this.broadcastMcpServers();
@@ -1907,7 +2004,7 @@ var Agent = class Agent extends DurableObject {
 		this.onMessage = async (connection, message) => {
 			const replyBridge = dynamicAgentRpcReplyContext.getStore()?.bridge;
 			if (await __DO_NOT_USE_WILL_BREAK__agentContext.exit(() => this._cf_forwardSubAgentWebSocketMessage(connection, message, replyBridge))) return;
-			this._ensureConnectionWrapped(connection);
+			ensureConnectionWrapped(connection);
 			return runInInvocation({
 				agent: this,
 				connection,
@@ -1921,25 +2018,7 @@ var Agent = class Agent extends DurableObject {
 				} catch (_e) {
 					return this._tryCatch(() => _onMessage(connection, message));
 				}
-				if (isStateUpdateMessage(parsed)) {
-					if (this.isConnectionReadonly(connection)) {
-						connection.send(JSON.stringify({
-							type: "cf_agent_state_error",
-							error: "Connection is readonly"
-						}));
-						return;
-					}
-					try {
-						this._setStateInternal(parsed.state, connection);
-					} catch (e) {
-						console.error("[Agent] State update rejected:", e);
-						connection.send(JSON.stringify({
-							type: "cf_agent_state_error",
-							error: "State update rejected"
-						}));
-					}
-					return;
-				}
+				if (this._webSockets.applyStateFrame(connection, parsed)) return;
 				if (isRPCRequest(parsed)) {
 					try {
 						const { id, method, args } = parsed;
@@ -2003,7 +2082,7 @@ var Agent = class Agent extends DurableObject {
 		};
 		const _onConnect = this.onConnect.bind(this);
 		this.onConnect = async (connection, ctx) => {
-			this._ensureConnectionWrapped(connection);
+			ensureConnectionWrapped(connection);
 			const subAgentOuterUrl = ctx.request.headers.get(SUB_AGENT_OUTER_URL_HEADER);
 			if (subAgentOuterUrl) this._unsafe_setConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY, subAgentOuterUrl);
 			if (await __DO_NOT_USE_WILL_BREAK__agentContext.exit(() => this._cf_forwardSubAgentWebSocketConnect(connection, ctx.request, { gate: false }))) return;
@@ -2015,6 +2094,14 @@ var Agent = class Agent extends DurableObject {
 			}, async () => {
 				if (this.shouldConnectionBeReadonly(connection, ctx)) this.setConnectionReadonly(connection, true);
 				if (this.shouldSendProtocolMessages(connection, ctx)) {
+					const wasExcludedFromStateInitBroadcast = this._protocolBroadcastExcludeIds.has(connection.id);
+					let currentState;
+					this._protocolBroadcastExcludeIds.add(connection.id);
+					try {
+						currentState = this.state;
+					} finally {
+						if (!wasExcludedFromStateInitBroadcast) this._protocolBroadcastExcludeIds.delete(connection.id);
+					}
 					if (this._resolvedOptions.sendIdentityOnConnect) {
 						const ctor = this.constructor;
 						if (ctor.options?.sendIdentityOnConnect === void 0 && !_sendIdentityWarnedClasses.has(ctor) && !this._isFacet) {
@@ -2023,29 +2110,16 @@ var Agent = class Agent extends DurableObject {
 								console.warn(`[Agent] ${ctor.name}: sending instance name "${this.name}" to clients via sendIdentityOnConnect (the name is not visible in the URL with custom routing). If this name is sensitive, add \`static options = { sendIdentityOnConnect: false }\` to opt out. Set it to true to silence this message.`);
 							}
 						}
-						connection.send(JSON.stringify({
+						this._webSockets.sendConnectFrames(connection, {
 							name: this.name,
-							agent: camelCaseToKebabCase(this._ParentClass.name),
-							type: "cf_agent_identity"
-						}));
-					}
-					const wasExcludedFromStateInitBroadcast = this._protocolBroadcastExcludeIds.has(connection.id);
-					let currentState;
-					this._protocolBroadcastExcludeIds.add(connection.id);
-					try {
-						currentState = this.state;
-					} finally {
-						if (!wasExcludedFromStateInitBroadcast) this._protocolBroadcastExcludeIds.delete(connection.id);
-					}
-					if (currentState !== void 0) connection.send(JSON.stringify({
-						state: currentState,
-						type: "cf_agent_state"
-					}));
+							agent: camelCaseToKebabCase(this._ParentClass.name)
+						});
+					} else if (currentState !== void 0) this._webSockets.sendState(connection);
 					connection.send(JSON.stringify({
 						mcp: this.getMcpServers(),
 						type: "cf_agent_mcp_servers"
 					}));
-				} else this._setConnectionNoProtocol(connection);
+				} else this._webSockets.setProtocolEnabled(connection, false);
 				this._emit("connect", { connectionId: connection.id });
 				await this._replayAgentToolRuns(connection);
 				return this._tryCatch(() => _onConnect(connection, ctx));
@@ -2142,13 +2216,14 @@ var Agent = class Agent extends DurableObject {
 		for (const conn of this.getConnections()) if (!this.isConnectionProtocolEnabled(conn)) exclude.push(conn.id);
 		this.broadcast(msg, exclude);
 	}
-	_setStateInternal(nextState, source = "server") {
-		this.validateStateChange(nextState, source);
-		this._state = nextState;
-		this.sql`
-      INSERT OR REPLACE INTO cf_agents_state (id, state)
-      VALUES (${STATE_ROW_ID}, ${JSON.stringify(nextState)})
-    `;
+	/**
+	* React to a persisted state change from the State capability.
+	*
+	* Reproduces the pre-migration steps 3-4: broadcast the new state to
+	* protocol-enabled connections (excluding the originating connection) and
+	* run the notification hook off the invocation tail.
+	*/
+	_handleStateChanged(nextState, source) {
 		this._broadcastProtocol(JSON.stringify({
 			state: nextState,
 			type: "cf_agent_state"
@@ -2180,69 +2255,7 @@ var Agent = class Agent extends DurableObject {
 	setState(state) {
 		const store = __DO_NOT_USE_WILL_BREAK__agentContext.getStore();
 		if (store?.connection && this.isConnectionReadonly(store.connection)) throw new Error("Connection is readonly");
-		this._setStateInternal(state, "server");
-	}
-	/**
-	* Wraps connection.state and connection.setState so that internal
-	* _cf_-prefixed flags (readonly, no-protocol) are hidden from user code
-	* and cannot be accidentally overwritten.
-	*
-	* Idempotent — safe to call multiple times on the same connection.
-	* After hibernation, the _rawStateAccessors WeakMap is empty but the
-	* connection's state getter still reads from the persisted WebSocket
-	* attachment. Calling this method re-captures the raw getter so that
-	* predicate methods (isConnectionReadonly, isConnectionProtocolEnabled)
-	* work correctly post-hibernation.
-	*/
-	_ensureConnectionWrapped(connection) {
-		if (this._rawStateAccessors.has(connection)) return;
-		const descriptor = Object.getOwnPropertyDescriptor(connection, "state");
-		let getRaw;
-		let setRaw;
-		if (descriptor?.get) {
-			getRaw = descriptor.get.bind(connection);
-			setRaw = connection.setState.bind(connection);
-		} else {
-			let rawState = connection.state ?? null;
-			getRaw = () => rawState;
-			setRaw = (state) => {
-				rawState = state;
-				return rawState;
-			};
-		}
-		this._rawStateAccessors.set(connection, {
-			getRaw,
-			setRaw
-		});
-		Object.defineProperty(connection, "state", {
-			configurable: true,
-			enumerable: true,
-			get() {
-				const raw = getRaw();
-				if (raw != null && typeof raw === "object" && rawHasInternalKeys(raw)) return stripInternalKeys(raw);
-				return raw;
-			}
-		});
-		Object.defineProperty(connection, "setState", {
-			configurable: true,
-			writable: true,
-			value(stateOrFn) {
-				const raw = getRaw();
-				const flags = raw != null && typeof raw === "object" ? extractInternalFlags(raw) : {};
-				const hasFlags = Object.keys(flags).length > 0;
-				let newUserState;
-				if (typeof stateOrFn === "function") newUserState = stateOrFn(hasFlags ? stripInternalKeys(raw) : raw);
-				else newUserState = stateOrFn;
-				if (hasFlags) {
-					if (newUserState != null && typeof newUserState === "object") return setRaw({
-						...newUserState,
-						...flags
-					});
-					return setRaw(flags);
-				}
-				return setRaw(newUserState);
-			}
-		});
+		this._state.set(state, "server");
 	}
 	/**
 	* Mark a connection as readonly or readwrite
@@ -2250,17 +2263,7 @@ var Agent = class Agent extends DurableObject {
 	* @param readonly Whether the connection should be readonly (default: true)
 	*/
 	setConnectionReadonly(connection, readonly = true) {
-		this._ensureConnectionWrapped(connection);
-		const accessors = this._rawStateAccessors.get(connection);
-		const raw = accessors.getRaw() ?? {};
-		if (readonly) accessors.setRaw({
-			...raw,
-			[CF_READONLY_KEY]: true
-		});
-		else {
-			const { [CF_READONLY_KEY]: _, ...rest } = raw;
-			accessors.setRaw(Object.keys(rest).length > 0 ? rest : null);
-		}
+		setConnectionReadonly(connection, readonly);
 	}
 	/**
 	* Check if a connection is marked as readonly.
@@ -2271,8 +2274,7 @@ var Agent = class Agent extends DurableObject {
 	* @returns True if the connection is readonly
 	*/
 	isConnectionReadonly(connection) {
-		this._ensureConnectionWrapped(connection);
-		return !!this._rawStateAccessors.get(connection).getRaw()?.[CF_READONLY_KEY];
+		return isConnectionReadonly(connection);
 	}
 	/**
 	* ⚠️ INTERNAL — DO NOT USE IN APPLICATION CODE. ⚠️
@@ -2287,30 +2289,20 @@ var Agent = class Agent extends DurableObject {
 	* @internal
 	*/
 	_unsafe_getConnectionFlag(connection, key) {
-		this._ensureConnectionWrapped(connection);
-		return this._rawStateAccessors.get(connection).getRaw()?.[key];
+		return getConnectionFlag(connection, key);
 	}
 	/**
 	* ⚠️ INTERNAL — DO NOT USE IN APPLICATION CODE. ⚠️
 	*
 	* Write an internal `_cf_`-prefixed flag to the raw connection state,
 	* bypassing the user-facing state wrapper. The key must be registered
-	* in `CF_INTERNAL_KEYS` so it is preserved across user `setState` calls
-	* and hidden from `connection.state`.
+	* with `registerInternalConnectionKeys` so it is preserved across user
+	* `setState` calls and hidden from `connection.state`.
 	*
 	* @internal
 	*/
 	_unsafe_setConnectionFlag(connection, key, value) {
-		this._ensureConnectionWrapped(connection);
-		const accessors = this._rawStateAccessors.get(connection);
-		const raw = accessors.getRaw() ?? {};
-		if (value === void 0) {
-			const { [key]: _, ...rest } = raw;
-			accessors.setRaw(Object.keys(rest).length > 0 ? rest : null);
-		} else accessors.setRaw({
-			...raw,
-			[key]: value
-		});
+		setConnectionFlag(connection, key, value);
 	}
 	/**
 	* Override this method to determine if a connection should be readonly on connect
@@ -2351,21 +2343,7 @@ var Agent = class Agent extends DurableObject {
 	* @returns True if the connection receives protocol messages
 	*/
 	isConnectionProtocolEnabled(connection) {
-		this._ensureConnectionWrapped(connection);
-		return !this._rawStateAccessors.get(connection).getRaw()?.[CF_NO_PROTOCOL_KEY];
-	}
-	/**
-	* Mark a connection as having protocol messages disabled.
-	* Called internally when shouldSendProtocolMessages returns false.
-	*/
-	_setConnectionNoProtocol(connection) {
-		this._ensureConnectionWrapped(connection);
-		const accessors = this._rawStateAccessors.get(connection);
-		const raw = accessors.getRaw() ?? {};
-		accessors.setRaw({
-			...raw,
-			[CF_NO_PROTOCOL_KEY]: true
-		});
+		return isConnectionProtocolEnabled(connection);
 	}
 	/**
 	* Called before the Agent's state is persisted and broadcast.
@@ -2553,19 +2531,21 @@ var Agent = class Agent extends DurableObject {
 				proto = Object.getPrototypeOf(proto);
 			}
 		}
+		const seen = /* @__PURE__ */ new Set();
 		let proto = Object.getPrototypeOf(this);
-		let depth = 0;
-		while (proto && proto !== Object.prototype && depth < 10) {
+		while (proto && proto !== Agent.prototype && proto !== Object.prototype) {
 			const methodNames = Object.getOwnPropertyNames(proto);
 			for (const methodName of methodNames) {
+				if (seen.has(methodName)) continue;
+				seen.add(methodName);
 				const descriptor = Object.getOwnPropertyDescriptor(proto, methodName);
-				if (baseMethods.has(methodName) || methodName.startsWith("_") || !descriptor || !!descriptor.get || typeof descriptor.value !== "function") continue;
-				const wrappedFunction = withAgentContext(this[methodName]);
-				if (this._isCallable(methodName)) copyCallableMetadata(this[methodName], wrappedFunction);
+				if (baseMethods.has(methodName) || methodName.startsWith("_") || !descriptor || !!descriptor.get || typeof descriptor.value !== "function" || agentContextWrappers.has(descriptor.value)) continue;
+				const method = descriptor.value;
+				const wrappedFunction = withAgentContext(method);
+				if (this._isCallable(methodName)) copyCallableMetadata(method, wrappedFunction);
 				this.constructor.prototype[methodName] = wrappedFunction;
 			}
 			proto = Object.getPrototypeOf(proto);
-			depth++;
 		}
 	}
 	onError(connectionOrError, error) {
@@ -2610,111 +2590,42 @@ var Agent = class Agent extends DurableObject {
 		});
 	}
 	/**
-	* Queue a task to be executed in the future
+	* Queue a task to run in the background.
+	*
+	* The item is durable: it runs from the Lifecycle alarm event loop after
+	* this call returns, in push order, one at a time, with retries per
+	* `options.retry`, and survives the Durable Object leaving memory.
 	* @param callback Name of the method to call
 	* @param payload Payload to pass to the callback
 	* @param options Options for the queued task
 	* @param options.retry Retry options for the callback execution
+	* @param options.id Stable id; a push with an existing id replaces that item
 	* @returns The ID of the queued task
 	*/
 	async queue(callback, payload, options) {
-		const id = nanoid(9);
 		if (typeof callback !== "string") throw new Error("Callback must be a string");
 		if (typeof this[callback] !== "function") throw new Error(`this.${callback} is not a function`);
-		if (options?.retry) validateRetryOptions(options.retry, this._resolvedOptions.retry);
-		const retryJson = options?.retry ? JSON.stringify(options.retry) : null;
-		this.sql`
-      INSERT OR REPLACE INTO cf_agents_queues (id, payload, callback, retry_options)
-      VALUES (${id}, ${JSON.stringify(payload)}, ${callback}, ${retryJson})
-    `;
-		this._emit("queue:create", {
-			callback,
-			id
-		});
-		this._flushQueue().catch((e) => {
-			console.error("Error flushing queue:", e);
-		});
-		return id;
-	}
-	async _flushQueue() {
-		if (this._flushingQueue) return;
-		this._flushingQueue = true;
-		try {
-			while (true) {
-				const result = this.sql`
-        SELECT * FROM cf_agents_queues
-        ORDER BY created_at ASC
-      `;
-				if (!result || result.length === 0) break;
-				for (const row of result || []) {
-					const callback = this[row.callback];
-					if (!callback) {
-						console.error(`callback ${row.callback} not found`);
-						await this.dequeue(row.id);
-						continue;
-					}
-					const { connection, request, email } = __DO_NOT_USE_WILL_BREAK__agentContext.getStore() || {};
-					await runInInvocation({
-						agent: this,
-						connection,
-						request,
-						email
-					}, async () => {
-						const { maxAttempts, baseDelayMs, maxDelayMs } = resolveRetryConfig(parseRetryOptions(row), this._resolvedOptions.retry);
-						const parsedPayload = JSON.parse(row.payload);
-						try {
-							await tryN(maxAttempts, async (attempt) => {
-								if (attempt > 1) this._emit("queue:retry", {
-									callback: row.callback,
-									id: row.id,
-									attempt,
-									maxAttempts
-								});
-								await callback.bind(this)(parsedPayload, row);
-							}, {
-								baseDelayMs,
-								maxDelayMs
-							});
-						} catch (e) {
-							console.error(`queue callback "${row.callback}" failed after ${maxAttempts} attempts`, e);
-							this._emit("queue:error", {
-								callback: row.callback,
-								id: row.id,
-								error: e instanceof Error ? e.message : String(e),
-								attempts: maxAttempts
-							});
-							try {
-								await this.onError(e);
-							} catch {}
-						} finally {
-							this.dequeue(row.id);
-						}
-					}, { detached: true });
-				}
-			}
-		} finally {
-			this._flushingQueue = false;
-		}
+		return (await this._queue.push(callback, payload, options)).id;
 	}
 	/**
 	* Dequeue a task by ID
 	* @param id ID of the task to dequeue
 	*/
 	dequeue(id) {
-		this.sql`DELETE FROM cf_agents_queues WHERE id = ${id}`;
+		return this._queue.cancel(id);
 	}
 	/**
 	* Dequeue all tasks
 	*/
 	dequeueAll() {
-		this.sql`DELETE FROM cf_agents_queues`;
+		return this._queue.cancelAll();
 	}
 	/**
 	* Dequeue all tasks by callback
 	* @param callback Name of the callback to dequeue
 	*/
 	dequeueAllByCallback(callback) {
-		this.sql`DELETE FROM cf_agents_queues WHERE callback = ${callback}`;
+		return this._queue.cancelAll(callback);
 	}
 	/**
 	* Get a queued task by ID
@@ -2722,31 +2633,16 @@ var Agent = class Agent extends DurableObject {
 	* @returns The task or undefined if not found
 	*/
 	getQueue(id) {
-		const result = this.sql`
-      SELECT * FROM cf_agents_queues WHERE id = ${id}
-    `;
-		if (!result || result.length === 0) return void 0;
-		const row = result[0];
-		return {
-			...row,
-			payload: JSON.parse(row.payload),
-			retry: parseRetryOptions(row)
-		};
+		return this._queue.get(id);
 	}
 	/**
-	* Get all queues by key and value
+	* Get all queued tasks whose payload has `key` equal to `value`
 	* @param key Key to filter by
 	* @param value Value to filter by
 	* @returns Array of matching QueueItem objects
 	*/
-	getQueues(key, value) {
-		return this.sql`
-      SELECT * FROM cf_agents_queues
-    `.filter((row) => JSON.parse(row.payload)[key] === value).map((row) => ({
-			...row,
-			payload: JSON.parse(row.payload),
-			retry: parseRetryOptions(row)
-		}));
+	async getQueues(key, value) {
+		return (await this._queue.list()).filter((item) => typeof item.payload === "object" && item.payload !== null && item.payload[key] === value);
 	}
 	_lifecycleRouteAddress() {
 		return this._dynamicAgents.lifecycleRouteAddress();
@@ -2758,7 +2654,8 @@ var Agent = class Agent extends DurableObject {
 		return this._dynamicAgents.routeLifecycleToTarget(target, envelope);
 	}
 	/** Single native-RPC aperture for routed Lifecycle capabilities. */
-	_cf_routeLifecycle(target, envelope) {
+	async _cf_routeLifecycle(target, envelope) {
+		await this.__unsafe_ensureInitialized();
 		return this._dynamicAgents.routeLifecycle(target, envelope);
 	}
 	_rootAlarmOwner() {
@@ -2775,6 +2672,7 @@ var Agent = class Agent extends DurableObject {
 	* @internal
 	*/
 	async _cf_cleanupFacetPrefix(ownerPath) {
+		await this.__unsafe_ensureInitialized();
 		await this._dynamicAgents.cleanupPrefix(ownerPath);
 	}
 	/**
@@ -2783,7 +2681,8 @@ var Agent = class Agent extends DurableObject {
 	* physical alarm, so this lets facet work use the root alarm heartbeat.
 	* @internal
 	*/
-	_cf_acquireFacetKeepAlive(ownerPath) {
+	async _cf_acquireFacetKeepAlive(ownerPath) {
+		await this.__unsafe_ensureInitialized();
 		return this._dynamicAgents.acquireKeepAlive(ownerPath);
 	}
 	/**
@@ -2791,8 +2690,9 @@ var Agent = class Agent extends DurableObject {
 	* Idempotent so disposer calls can safely race or run twice.
 	* @internal
 	*/
-	_cf_releaseFacetKeepAlive(token) {
-		return this._dynamicAgents.releaseKeepAlive(token);
+	async _cf_releaseFacetKeepAlive(token) {
+		await this.__unsafe_ensureInitialized();
+		await this._dynamicAgents.releaseKeepAlive(token);
 	}
 	/**
 	* Register a facet's durable run row in the root-side index so root
@@ -2800,15 +2700,17 @@ var Agent = class Agent extends DurableObject {
 	* The facet remains authoritative for snapshots and recovery hooks.
 	* @internal
 	*/
-	_cf_registerFacetRun(ownerPath, runId) {
-		return this._dynamicAgents.registerRun(ownerPath, runId);
+	async _cf_registerFacetRun(ownerPath, runId) {
+		await this.__unsafe_ensureInitialized();
+		await this._dynamicAgents.registerRun(ownerPath, runId);
 	}
 	/**
 	* Remove a completed facet fiber from the root-side index.
 	* @internal
 	*/
-	_cf_unregisterFacetRun(ownerPath, runId) {
-		return this._dynamicAgents.unregisterRun(ownerPath, runId);
+	async _cf_unregisterFacetRun(ownerPath, runId) {
+		await this.__unsafe_ensureInitialized();
+		await this._dynamicAgents.unregisterRun(ownerPath, runId);
 	}
 	/**
 	* Schedule a task to be executed in the future
@@ -3493,6 +3395,7 @@ var Agent = class Agent extends DurableObject {
 		};
 		let root;
 		let registeredFacetRun = false;
+		let bodyOutcome;
 		let dispose = () => {};
 		try {
 			if ("initialSnapshot" in (options ?? {})) writeSnapshot(options?.initialSnapshot);
@@ -3506,16 +3409,29 @@ var Agent = class Agent extends DurableObject {
 				writeSnapshot(options?.wrapStash ? options.wrapStash(data) : data);
 			};
 			try {
-				const result = await _fiberALS.run({
-					id,
-					signal,
-					stash
-				}, () => fn({
-					id,
-					signal,
-					stash,
-					snapshot: null
-				}));
+				let result;
+				try {
+					result = await _fiberALS.run({
+						id,
+						signal,
+						stash
+					}, () => fn({
+						id,
+						signal,
+						stash,
+						snapshot: null
+					}));
+				} catch (error) {
+					bodyOutcome = {
+						status: signal.aborted ? "aborted" : "error",
+						error: this._fiberErrorMessage(error)
+					};
+					throw error;
+				}
+				bodyOutcome = {
+					status: "completed",
+					error: null
+				};
 				options?.beforeRunCleanup?.({ ok: true });
 				this._emit("fiber:run:completed", {
 					fiberId: id,
@@ -3540,14 +3456,29 @@ var Agent = class Agent extends DurableObject {
 			}
 		} finally {
 			this._runFiberActiveFibers.delete(id);
-			this._withAgentSpan("finalize_fiber", "fiber", {
-				"cloudflare.agents.fiber.id": id,
-				"cloudflare.agents.fiber.name": name
-			}, () => {
-				this.sql`DELETE FROM cf_agents_runs WHERE id = ${id}`;
-			});
+			let rowDeleted = false;
+			try {
+				this._withAgentSpan("finalize_fiber", "fiber", {
+					"cloudflare.agents.fiber.id": id,
+					"cloudflare.agents.fiber.name": name
+				}, () => {
+					if (bodyOutcome) try {
+						this.sql`
+                  UPDATE cf_agents_runs
+                  SET completed_at = ${Date.now()},
+                      outcome = ${bodyOutcome.status},
+                      error_message = ${bodyOutcome.error}
+                  WHERE id = ${id}
+                `;
+					} catch {}
+					this.sql`DELETE FROM cf_agents_runs WHERE id = ${id}`;
+				});
+				rowDeleted = true;
+			} catch (error) {
+				console.error(`[Agent] Failed to finalize fiber "${name}" (${id}); leaving run row for recovery:`, error);
+			}
 			dispose();
-			if (root && registeredFacetRun) try {
+			if (root && registeredFacetRun && rowDeleted) try {
 				await root._cf_unregisterFacetRun(this.selfPath, id);
 			} catch (e) {
 				console.error("[Agent] Failed to unregister facet fiber:", e);
@@ -3604,7 +3535,11 @@ var Agent = class Agent extends DurableObject {
 		const fiberRecoveryMaxAgeMs = this._resolvedOptions.fiberRecoveryMaxAgeMs;
 		let madeProgress = false;
 		try {
-			const rows = this.sql`SELECT id, name, snapshot, created_at FROM cf_agents_runs`;
+			const rows = this.sql`
+        SELECT id, name, snapshot, created_at, completed_at, outcome,
+               error_message
+        FROM cf_agents_runs
+      `;
 			for (const row of rows) {
 				if (scanDeadlineMs > 0 && Date.now() - scanStartedAt > scanDeadlineMs) {
 					this._emit("fiber:recovery:skipped", {
@@ -3616,6 +3551,27 @@ var Agent = class Agent extends DurableObject {
 					break;
 				}
 				if (this._runFiberActiveFibers.has(row.id)) continue;
+				const managedRow = this._readFiber(row.id);
+				if (row.completed_at !== null && (!managedRow || row.outcome !== null)) {
+					if (managedRow) this.sql`
+              UPDATE cf_agents_fibers
+              SET status = ${row.outcome},
+                  error_message = ${row.error_message},
+                  completed_at = ${row.completed_at}
+              WHERE fiber_id = ${row.id}
+                AND status IN ('pending', 'running')
+            `;
+					this.sql`DELETE FROM cf_agents_runs WHERE id = ${row.id}`;
+					madeProgress = true;
+					if (managedRow) this._notifyManagedFiberTerminal(row.id);
+					continue;
+				}
+				if (managedRow && this._isTerminalFiberStatus(managedRow.status)) {
+					this.sql`DELETE FROM cf_agents_runs WHERE id = ${row.id}`;
+					madeProgress = true;
+					this._notifyManagedFiberTerminal(row.id);
+					continue;
+				}
 				const snapshot = this._parseFiberRecoverySnapshot(row.id, row.snapshot);
 				const ctx = {
 					id: row.id,
@@ -3624,7 +3580,6 @@ var Agent = class Agent extends DurableObject {
 					createdAt: row.created_at,
 					recoveryReason: "interrupted"
 				};
-				const managedRow = this._readFiber(row.id);
 				this._emit("fiber:recovery:detected", {
 					...this._fiberRecoveryPayload(ctx, managedRow),
 					elapsedMs: Date.now() - row.created_at
@@ -3637,12 +3592,6 @@ var Agent = class Agent extends DurableObject {
 					elapsedMs: Date.now() - row.created_at
 				});
 				if (managedRow) {
-					if (this._isTerminalFiberStatus(managedRow.status)) {
-						this.sql`DELETE FROM cf_agents_runs WHERE id = ${row.id}`;
-						madeProgress = true;
-						this._notifyManagedFiberTerminal(row.id);
-						continue;
-					}
 					const completedAt = Date.now();
 					this.sql`
             UPDATE cf_agents_fibers
@@ -3780,8 +3729,9 @@ var Agent = class Agent extends DurableObject {
 	* cleanup as `parent.deleteSubAgent(Cls, name)` from the parent.
 	* @internal
 	*/
-	_cf_destroyDescendantFacet(targetPath) {
-		return this._dynamicAgents.destroyDescendant(targetPath);
+	async _cf_destroyDescendantFacet(targetPath) {
+		await this.__unsafe_ensureInitialized();
+		await this._dynamicAgents.destroyDescendant(targetPath);
 	}
 	/**
 	* Whether any runFiber recovery work is still outstanding: orphaned
@@ -3819,6 +3769,15 @@ var Agent = class Agent extends DurableObject {
 	*/
 	async _syncHostJobs() {
 		if (this._destroyed) return;
+		if (this._isFacet) {
+			const work = this.lifecycle.jobs;
+			for (const id of [
+				HOST_JOB_DESTROY_ID,
+				HOST_JOB_KEEP_ALIVE_ID,
+				HOST_JOB_HOUSEKEEPING_ID
+			]) if (work.get(id)) await work.cancel(id);
+			return;
+		}
 		await this._withAgentSpan("schedule_agent_alarm", "alarm", {}, async () => {
 			const work = this.lifecycle.jobs;
 			const nowMs = Date.now();
@@ -3950,9 +3909,10 @@ var Agent = class Agent extends DurableObject {
 			className: match.childClass,
 			name: match.childName
 		});
-		if (decision instanceof Response) return decision;
+		const isWebSocketUpgrade = request.headers.get("Upgrade")?.toLowerCase() === "websocket";
+		if (decision instanceof Response) return isWebSocketUpgrade && !decision.webSocket ? rejectSubAgentWebSocket(decision) : decision;
 		const forwardReq = decision instanceof Request ? decision : request;
-		if (request.headers.get("Upgrade")?.toLowerCase() === "websocket") {
+		if (isWebSocketUpgrade) {
 			const acceptHeaders = new Headers(forwardReq.headers);
 			const routedUrl = new URL(forwardReq.url);
 			routedUrl.pathname = new URL(request.url).pathname;
@@ -3989,18 +3949,27 @@ var Agent = class Agent extends DurableObject {
 		}
 	}
 	async _cf_broadcastToSubAgent(ownerPath, message, without) {
+		await this.__unsafe_ensureInitialized();
 		await this._dynamicAgents.broadcastToPath(ownerPath, message, without);
 	}
-	_cf_subAgentConnectionMetas(ownerPath) {
+	async _cf_subAgentConnectionMetas(ownerPath) {
+		await this.__unsafe_ensureInitialized();
 		return this._dynamicAgents.connectionMetas(ownerPath);
 	}
-	_cf_sendToSubAgentConnection(connectionId, message) {
-		return this._dynamicAgents.sendToConnection(connectionId, message);
+	async _cf_sendToSubAgentConnection(connectionId, message) {
+		await this.__unsafe_ensureInitialized();
+		await this._dynamicAgents.sendToConnection(connectionId, message);
+	}
+	async _cf_closeSubAgentConnection(connectionId, code, reason) {
+		await this.__unsafe_ensureInitialized();
+		await this._dynamicAgents.closeConnection(connectionId, code, reason);
 	}
-	_cf_closeSubAgentConnection(connectionId, code, reason) {
-		return this._dynamicAgents.closeConnection(connectionId, code, reason);
+	async _cf_closeSubAgentConnectionsForPrefix(prefix, code, reason) {
+		await this.__unsafe_ensureInitialized();
+		this._dynamicAgents.closeConnectionsForPrefix(prefix, code, reason);
 	}
-	_cf_setSubAgentConnectionState(connectionId, state) {
+	async _cf_setSubAgentConnectionState(connectionId, state) {
+		await this.__unsafe_ensureInitialized();
 		return this._dynamicAgents.setConnectionState(connectionId, state);
 	}
 	_cf_connectionTargetsSubAgent(connection) {
@@ -4316,6 +4285,9 @@ var Agent = class Agent extends DurableObject {
 		const runId = options.runId ?? nanoid(12);
 		const agentType = cls.name;
 		const detached = this._parseDetachedOption(options.detached);
+		const eventDelivery = options.eventDelivery ?? "full";
+		if (eventDelivery !== "full" && eventDelivery !== "terminal") throw new Error(`runAgentTool: eventDelivery must be "full" or "terminal", got ${JSON.stringify(eventDelivery)}.`);
+		if (detached && eventDelivery === "terminal") throw new Error("runAgentTool: eventDelivery \"terminal\" is not supported for detached runs.");
 		const existing = this._readAgentToolRun(runId);
 		if (existing) {
 			if (detached) {
@@ -4406,13 +4378,14 @@ var Agent = class Agent extends DurableObject {
         input_redacted, status, display_metadata, display_order, started_at,
         detached, detached_on_finish, detached_notify_source,
         detached_max_budget_at, detached_no_progress_budget_ms,
-        detached_on_milestones
+        detached_on_milestones, event_delivery
       ) VALUES (
         ${runId}, ${options.parentToolCallId ?? null}, ${agentType},
         ${inputPreviewJson}, 1, 'starting', ${displayJson}, ${displayOrder},
         ${startedAt}, ${detached ? 1 : 0}, ${detached?.onFinishName ?? null},
         ${detached?.notifySource ?? null}, ${detachedMaxBudgetAt},
-        ${detachedNoProgressBudgetMs}, ${detachedOnMilestonesJson}
+        ${detachedNoProgressBudgetMs}, ${detachedOnMilestonesJson},
+        ${eventDelivery === "terminal" ? "terminal" : null}
       )
     `;
 		const runInfo = {
@@ -4437,7 +4410,10 @@ var Agent = class Agent extends DurableObject {
 		});
 		const child = await this.subAgent(cls, runId);
 		const adapter = this._asAgentToolChildAdapter(child);
-		const childStart = await adapter.startAgentToolRun(options.input, { runId });
+		const childStart = await adapter.startAgentToolRun(options.input, {
+			runId,
+			...eventDelivery === "terminal" ? { eventDelivery } : {}
+		});
 		this._markAgentToolRunning(runId);
 		if (detached) {
 			if (options.signal) console.warn(`[agents] runAgentTool: \`signal\` is ignored for a detached run (${runId}); a detached child must outlive the spawning turn. Use cancelAgentTool(runId) to cancel it.`);
@@ -5048,29 +5024,79 @@ var Agent = class Agent extends DurableObject {
 		else this.broadcast(body);
 	}
 	_broadcastAgentToolChunks(parentToolCallId, runId, chunks, sequence, replay, connection) {
+		const terminalOnly = this._isTerminalOnlyAgentToolRun(runId);
 		let next = sequence;
-		for (const chunk of chunks) this._broadcastAgentToolEvent(parentToolCallId, next++, {
-			kind: "chunk",
-			runId,
-			body: chunk.body
-		}, replay, connection);
+		for (const chunk of chunks) {
+			const chunkSequence = next++;
+			if (terminalOnly && !isAgentToolLifecycleChunk(chunk.body)) continue;
+			this._broadcastAgentToolEvent(parentToolCallId, chunkSequence, {
+				kind: "chunk",
+				runId,
+				body: chunk.body
+			}, replay, connection);
+		}
 		return next;
 	}
-	async _broadcastAgentToolStoredChunks(row, sequence, replay, connection) {
-		const child = await this._cf_resolveSubAgent(row.agent_type, row.run_id);
+	_isTerminalOnlyAgentToolRun(runId) {
+		return this.sql`
+      SELECT event_delivery FROM cf_agent_tool_runs WHERE run_id = ${runId}
+    `[0]?.event_delivery === "terminal";
+	}
+	async _broadcastAgentToolStoredChunks(row, sequence, replay, connection, timeoutMs) {
+		const deadline = this._agentToolRecoveryDeadline(timeoutMs);
+		const resolving = this._cf_resolveSubAgent(row.agent_type, row.run_id);
+		const child = deadline === void 0 ? await resolving : await this._settleWithinRecoveryTimeout(resolving, deadline());
+		if (child === void 0) return sequence;
 		const adapter = this._asAgentToolChildAdapter(child);
-		return this._broadcastAgentToolStoredChunksFromAdapter(adapter, row, sequence, replay, connection);
+		return this._broadcastAgentToolStoredChunksFromAdapter(adapter, row, sequence, replay, connection, deadline?.());
+	}
+	/**
+	* One budget shared by every step of a bounded recovery read, so a run's
+	* total time stays within `timeoutMs`. Returns the remaining milliseconds,
+	* never below 1 because a non-positive timeout means "unbounded".
+	*/
+	_agentToolRecoveryDeadline(timeoutMs) {
+		if (timeoutMs === void 0 || timeoutMs <= 0) return void 0;
+		const deadline = Date.now() + timeoutMs;
+		return () => Math.max(1, deadline - Date.now());
 	}
 	async _broadcastAgentToolStoredChunksFromAdapter(adapter, row, sequence, replay, connection, timeoutMs) {
-		const chunks = await this._getAgentToolChunksForRecovery(adapter, row.run_id, timeoutMs);
-		if (!chunks) return sequence;
-		return this._broadcastAgentToolChunks(row.parent_tool_call_id ?? void 0, row.run_id, chunks, sequence, replay, connection);
+		const deadline = this._agentToolRecoveryDeadline(timeoutMs);
+		const chunks = await this._getAgentToolChunksForRecovery(adapter, row.run_id, deadline?.());
+		const next = chunks ? this._broadcastAgentToolChunks(row.parent_tool_call_id ?? void 0, row.run_id, chunks, sequence, replay, connection) : sequence;
+		return this._broadcastAgentToolMilestones(adapter, row, next, replay, connection, deadline?.());
+	}
+	/**
+	* Milestones are persisted on the child run rather than in its chunk log, so
+	* replay re-emits them from the child's inspection. The client dedupes them
+	* on the milestone's own sequence, so a milestone already seen live is a no-op.
+	* They carry the next stored-chunk sequence without consuming it, matching
+	* the live path.
+	*/
+	async _broadcastAgentToolMilestones(adapter, row, sequence, replay, connection, timeoutMs) {
+		const milestones = (await this._settleWithinRecoveryTimeout(adapter.inspectAgentToolRun(row.run_id, { reconcile: false }), timeoutMs))?.milestones ?? [];
+		for (const milestone of milestones) this._broadcastAgentToolEvent(row.parent_tool_call_id ?? void 0, sequence, {
+			kind: "chunk",
+			runId: row.run_id,
+			body: JSON.stringify({
+				type: AGENT_TOOL_MILESTONE_PART,
+				data: {
+					name: milestone.name,
+					sequence: milestone.sequence,
+					at: milestone.at,
+					...milestone.data !== void 0 ? { data: milestone.data } : {}
+				}
+			})
+		}, replay, connection);
+		return sequence;
 	}
 	async _forwardAgentToolStream(stream, parentToolCallId, runId, sequence, signal, idleTimeoutMs) {
 		let next = sequence;
+		let forwarded = false;
 		if (signal?.aborted) return {
 			next,
-			ended: "aborted"
+			ended: "aborted",
+			forwarded
 		};
 		let ended = "done";
 		const reader = stream.getReader();
@@ -5098,12 +5124,18 @@ var Agent = class Agent extends DurableObject {
 			idleTimer = setTimeout(() => resolveIdle?.(), idleTimeoutMs);
 		};
 		let forwardedSinceProgress = false;
+		const terminalOnly = this._isTerminalOnlyAgentToolRun(runId);
 		try {
 			const forwardChunk = (chunk) => {
-				this._broadcastAgentToolEvent(parentToolCallId, next++, {
+				const lifecycle = isAgentToolLifecycleChunk(chunk.body);
+				const unstoredId = typeof chunk.unstoredId === "string" ? chunk.unstoredId : void 0;
+				const chunkSequence = lifecycle || unstoredId !== void 0 ? next : next++;
+				forwarded = true;
+				if (!terminalOnly || lifecycle) this._broadcastAgentToolEvent(parentToolCallId, chunkSequence, {
 					kind: "chunk",
 					runId,
-					body: chunk.body
+					body: chunk.body,
+					...unstoredId !== void 0 ? { unstoredId } : {}
 				});
 				this._observeForwardedProgress(runId, chunk.body);
 				forwardedSinceProgress = true;
@@ -5171,7 +5203,8 @@ var Agent = class Agent extends DurableObject {
 		}
 		return {
 			next,
-			ended
+			ended,
+			forwarded
 		};
 	}
 	/**
@@ -5372,9 +5405,9 @@ var Agent = class Agent extends DurableObject {
 	* dies and recovers again during deploy churn is still collected. A genuinely
 	* silent/hung child can never block recovery forever: it seals `interrupted`
 	* after one `noProgressTimeoutMs` window. `maxWindowMs` is an OPTIONAL hard
-	* wall-clock ceiling (default `Infinity` — uncapped, mirroring #1672's
-	* `maxRecoveryWork`); set it finite to also bound a child that keeps
-	* progressing, which seals `window-exceeded` and tears the child down.
+	* wall-clock ceiling (default `Infinity` — uncapped, #1672); set it finite
+	* to also bound a child that keeps progressing, which seals
+	* `window-exceeded` and tears the child down.
 	*
 	* Returns the terminal `result` (and `completedAt`) when the child reaches a
 	* terminal status, plus the advanced broadcast `sequence`. Returns
@@ -5419,18 +5452,22 @@ var Agent = class Agent extends DurableObject {
 		try {
 			while (!ceilingController.signal.aborted) {
 				let afterSequence = -1;
+				let storedCount = 0;
 				try {
 					const existing = await adapter.getAgentToolChunks(row.run_id);
 					const last = existing[existing.length - 1];
 					if (last) afterSequence = last.sequence;
+					storedCount = existing.length;
 				} catch {}
-				const beforeSequence = nextSequence;
+				nextSequence = storedCount + 1;
 				let streamEnded = "idle";
+				let forwardedAny = false;
 				try {
 					const stream = await adapter.tailAgentToolRun(row.run_id, { afterSequence });
 					const forwarded = await this._forwardAgentToolStream(stream, row.parent_tool_call_id ?? void 0, row.run_id, nextSequence, ceilingController.signal, noProgressTimeoutMs);
 					nextSequence = forwarded.next;
 					streamEnded = forwarded.ended;
+					forwardedAny = forwarded.forwarded;
 				} catch {}
 				const terminal = await collectTerminal(nextSequence);
 				if (terminal) return terminal;
@@ -5439,7 +5476,7 @@ var Agent = class Agent extends DurableObject {
 					break;
 				}
 				if (streamEnded !== "done") break;
-				if (nextSequence <= beforeSequence) break;
+				if (!forwardedAny) break;
 			}
 		} finally {
 			if (ceilingTimer !== void 0) clearTimeout(ceilingTimer);
@@ -5469,7 +5506,7 @@ var Agent = class Agent extends DurableObject {
 				display: this._parseAgentToolJson(row.display_metadata)
 			}, true, connection);
 			try {
-				sequence = await this._broadcastAgentToolStoredChunks(row, sequence, true, connection);
+				sequence = await this._broadcastAgentToolStoredChunks(row, sequence, true, connection, DEFAULT_AGENT_TOOL_RECOVERY_TIMEOUT_MS);
 			} catch {}
 			if (this._isAgentToolTerminal(row.status)) this._broadcastAgentToolTerminal(parentToolCallId, sequence, {
 				runId: row.run_id,
@@ -5656,13 +5693,17 @@ var Agent = class Agent extends DurableObject {
     `.map((row) => row.run_id);
 	}
 	async _getAgentToolChunksForRecovery(adapter, runId, timeoutMs) {
-		const chunks = adapter.getAgentToolChunks(runId).catch(() => void 0);
-		if (timeoutMs === void 0 || timeoutMs <= 0) return chunks;
+		return this._settleWithinRecoveryTimeout(adapter.getAgentToolChunks(runId), timeoutMs);
+	}
+	/** Resolve to `undefined` when `promise` rejects or outlasts `timeoutMs`. */
+	async _settleWithinRecoveryTimeout(promise, timeoutMs) {
+		const settled = promise.catch(() => void 0);
+		if (timeoutMs === void 0 || timeoutMs <= 0) return settled;
 		let timeoutId;
 		const timeout = new Promise((resolve) => {
 			timeoutId = setTimeout(() => resolve(void 0), timeoutMs);
 		});
-		const result = await Promise.race([chunks, timeout]);
+		const result = await Promise.race([settled, timeout]);
 		if (timeoutId !== void 0) clearTimeout(timeoutId);
 		return result;
 	}
@@ -6960,4 +7001,4 @@ var StreamingResponse = class {
 //#endregion
 export { routeAgentEmail as a, getCurrentAgent as i, DEFAULT_AGENT_STATIC_OPTIONS as n, StreamingResponse as r, Agent as t };
 
-//# sourceMappingURL=src-DlSHshb2.js.map
+//# sourceMappingURL=src-BZeu-SCD.js.map