agents 0.22.0 → 0.24.0

package/dist/{src-5W6JNKVb.js → src-BNU3ZiJM.js}

@@ -3,58 +3,35 @@ import { getAgentByName } from "./agent-routing.js";
 import { AGENT_TOOL_MILESTONE_PART } 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 { signAgentHeaders } from "./email.js";
 import { sendAgentEmail } from "./email-send.js";
-import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, 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 { i as setLifecycleRouteTransport, n as setLifecycleEventSink, r as setLifecycleHostInvoker, t as Lifecycle } from "./durable-object-lifecycle-D6nNQJJd.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-D7IzWbZb.js";
+import { t as LifecycleCapability } from "./capability-B4WbF81e.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-Mm_jQh7r.js";
+import { isErrorRetryable, tryN, validateRetryOptions } from "./retries.js";
 import { SqlError } from "./sql-error.js";
-import { isDurableObjectMemoryLimitReset, isErrorRetryable, tryN, validateRetryOptions } from "./retries.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 ensureScheduleTable, r as setSchedulerCallbackResolver, t as Scheduler } from "./scheduler-CR9RHGos.js";
+import { n as setSchedulerCallbackResolver, t as Scheduler } from "./scheduler-D_KHqxBa.js";
+import { n as setQueueCallbackResolver, t as Queue } from "./queue-BC9F5cUo.js";
+import { n as setTaskDefinitionResolver, r as setTaskRoutedMemoryLimitHandler, t as Tasks } from "./tasks-D4nLqVSI.js";
+import { State } from "./state/index.js";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { DurableObject, RpcTarget, exports } from "cloudflare:workers";
 import { nanoid } from "nanoid";
 import { EmailMessage } from "cloudflare:email";
-import { DurableObject, RpcTarget, exports } from "cloudflare:workers";
-//#region src/observability/agent-span-attributes.ts
-function agentSpanAttributes(input) {
-	return {
-		"instrumentation_scope.name": "agents",
-		"instrumentation_scope.version": "1",
-		"cloudflare.agents.session.id": input.sessionId,
-		"cloudflare.agents.session.name": input.sessionName,
-		"gen_ai.agent.name": input.agentClassName
-	};
-}
-//#endregion
-//#region src/index.ts
-let _Symbol$dispose;
-/**
-* Enters an agent invocation: the context every handler reads, plus the span
-* scope that stops invocation-bounded spans from outliving it. Scopes do not
-* nest, so the outermost live entry point owns the boundary — pass
-* `detached` for work that deliberately runs on past its caller.
-*/
-function runInInvocation(store, body, options) {
-	return __DO_NOT_USE_WILL_BREAK__agentContext.run(store, () => withInvocationScope(body, options));
-}
+//#region src/dynamic-agents/bridges.ts
 function isClosedWebSocketSendError(error) {
 	return error instanceof TypeError && error.message.includes("WebSocket send() after close");
 }
-function sendRpcResponseIfOpen(connection, response) {
-	try {
-		connection.send(JSON.stringify(response));
-		return true;
-	} catch (error) {
-		if (isClosedWebSocketSendError(error)) return false;
-		throw error;
-	}
-}
-const subAgentRpcReplyContext = new AsyncLocalStorage();
+const dynamicAgentRpcReplyContext = new AsyncLocalStorage();
 function sendFacetRpcResponseIfOpen(target, response) {
 	try {
 		return {
@@ -72,19 +49,29 @@ function sendFacetRpcResponseIfOpen(target, response) {
 	}
 }
 const facetStreamingResponseDeliveryStates = /* @__PURE__ */ new WeakMap();
-function createStreamingResponse(connection, id, facetReplyTarget) {
-	const stream = new StreamingResponse(connection, id);
-	if (facetReplyTarget) facetStreamingResponseDeliveryStates.set(stream, {
-		replyTarget: facetReplyTarget,
+/**
+* Mark a StreamingResponse as facet-bridged: its chunks are delivered to
+* `replyTarget` (the RPC frame that carried the request into the facet)
+* instead of the connection's native WebSocket.
+*/
+function registerFacetStreamingDelivery(stream, replyTarget) {
+	facetStreamingResponseDeliveryStates.set(stream, {
+		replyTarget,
 		pending: /* @__PURE__ */ new Set()
 	});
-	return stream;
 }
-function trackFacetStreamingResponseDelivery(stream, completion) {
+/**
+* Deliver one streamed RPC response for a facet-bridged stream, tracking
+* its completion. Returns null when the stream is not facet-bridged (the
+* caller should send on the native connection instead).
+*/
+function sendFacetStreamingResponse(stream, response) {
 	const state = facetStreamingResponseDeliveryStates.get(stream);
-	if (!state) return;
-	state.pending.add(completion);
-	completion.finally(() => state.pending.delete(completion));
+	if (!state) return null;
+	const delivery = sendFacetRpcResponseIfOpen(state.replyTarget, response);
+	state.pending.add(delivery.completion);
+	delivery.completion.finally(() => state.pending.delete(delivery.completion));
+	return delivery.sent;
 }
 async function waitForFacetStreamingResponseDeliveries(stream) {
 	const state = facetStreamingResponseDeliveryStates.get(stream);
@@ -95,37 +82,29 @@ async function waitForFacetStreamingResponseDeliveries(stream) {
 		facetStreamingResponseDeliveryStates.delete(stream);
 	}
 }
+var _connection = /* @__PURE__ */ new WeakMap();
+var _broadcast = /* @__PURE__ */ new WeakMap();
 /**
-* Type guard for RPC request messages
-*/
-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
+* Parent-side bridge handed to a facet over RPC: wraps a live root-owned
+* `Connection` so the facet can send/close/setState on it, and carries
+* the root's broadcast entry point for facet-scoped broadcasts.
 */
-function isStateUpdateMessage(msg) {
-	return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "cf_agent_state" && "state" in msg;
-}
-const callableMetadata = /* @__PURE__ */ new WeakMap();
-var _connection2 = /* @__PURE__ */ new WeakMap();
-var _broadcast = /* @__PURE__ */ new WeakMap();
-var SubAgentConnectionBridge = class extends RpcTarget {
+var DynamicAgentConnectionBridge = class extends RpcTarget {
 	constructor(connection, broadcast) {
 		super();
-		_classPrivateFieldInitSpec(this, _connection2, void 0);
+		_classPrivateFieldInitSpec(this, _connection, void 0);
 		_classPrivateFieldInitSpec(this, _broadcast, void 0);
-		_classPrivateFieldSet2(_connection2, this, connection);
+		_classPrivateFieldSet2(_connection, this, connection);
 		_classPrivateFieldSet2(_broadcast, this, broadcast);
 	}
 	send(message) {
-		_classPrivateFieldGet2(_connection2, this).send(message);
+		_classPrivateFieldGet2(_connection, this).send(message);
 	}
 	close(code, reason) {
-		_classPrivateFieldGet2(_connection2, this).close(code, reason);
+		_classPrivateFieldGet2(_connection, this).close(code, reason);
 	}
 	setState(state) {
-		return _classPrivateFieldGet2(_connection2, this).setState(state);
+		return _classPrivateFieldGet2(_connection, this).setState(state);
 	}
 	broadcast(ownerPath, message, without) {
 		return _classPrivateFieldGet2(_broadcast, this)?.call(this, ownerPath, message, without);
@@ -133,58 +112,1118 @@ var SubAgentConnectionBridge = class extends RpcTarget {
 };
 var _root = /* @__PURE__ */ new WeakMap();
 var _connectionId = /* @__PURE__ */ new WeakMap();
-var RootSubAgentConnectionBridge = class {
+/**
+* Facet-side bridge used after the originating RPC frame has completed:
+* routes connection operations back to the root over a fresh RPC call.
+*/
+var RootDynamicAgentConnectionBridge = class {
 	constructor(root, connectionId) {
 		_classPrivateFieldInitSpec(this, _root, void 0);
 		_classPrivateFieldInitSpec(this, _connectionId, void 0);
 		_classPrivateFieldSet2(_root, this, root);
 		_classPrivateFieldSet2(_connectionId, this, connectionId);
 	}
-	send(message) {
-		return _classPrivateFieldGet2(_root, this)._cf_sendToSubAgentConnection(_classPrivateFieldGet2(_connectionId, this), message);
+	send(message) {
+		return _classPrivateFieldGet2(_root, this)._cf_sendToSubAgentConnection(_classPrivateFieldGet2(_connectionId, this), message);
+	}
+	close(code, reason) {
+		return _classPrivateFieldGet2(_root, this)._cf_closeSubAgentConnection(_classPrivateFieldGet2(_connectionId, this), code, reason);
+	}
+	setState(state) {
+		return _classPrivateFieldGet2(_root, this)._cf_setSubAgentConnectionState(_classPrivateFieldGet2(_connectionId, this), state);
+	}
+	broadcast(ownerPath, message, without) {
+		return _classPrivateFieldGet2(_root, this)._cf_broadcastToSubAgent(ownerPath, message, without);
+	}
+};
+//#endregion
+//#region src/dynamic-agents/identity.ts
+const SUB_AGENT_IDENTITY_VERSION_LEGACY = "legacy";
+const SUB_AGENT_IDENTITY_VERSION_PATH_V2 = "path-v2";
+const SUB_AGENT_IDENTITY_PATH_V2_PREFIX = "cf-agents:v2:";
+async function sha256Hex(value) {
+	const bytes = new TextEncoder().encode(value);
+	const digest = await crypto.subtle.digest("SHA-256", bytes);
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function pathV2IdentityName(logicalName, digest) {
+	return `${SUB_AGENT_IDENTITY_PATH_V2_PREFIX}${encodeURIComponent(logicalName)}:${digest}`;
+}
+function logicalNameFromPathV2Identity(identityName) {
+	if (!identityName.startsWith("cf-agents:v2:")) return null;
+	const rest = identityName.slice(13);
+	const separator = rest.lastIndexOf(":");
+	if (separator === -1) return null;
+	try {
+		return decodeURIComponent(rest.slice(0, separator));
+	} catch {
+		return null;
+	}
+}
+/**
+* Validate that a stored `parentPath` has the expected shape. Used
+* when restoring from DO storage to guard against corrupted data.
+*/
+function isValidParentPath(value) {
+	if (!Array.isArray(value)) return false;
+	return value.every((entry) => entry != null && typeof entry === "object" && typeof entry.className === "string" && typeof entry.name === "string");
+}
+function agentPathKey(path) {
+	if (!path) return null;
+	return path.map((step) => `${encodeURIComponent(step.className)}:${encodeURIComponent(step.name)}`).join("/");
+}
+//#endregion
+//#region src/dynamic-agents/registry.ts
+var _host$1 = /* @__PURE__ */ new WeakMap();
+var _ready = /* @__PURE__ */ new WeakMap();
+var _DynamicAgentRegistry_brand = /* @__PURE__ */ new WeakSet();
+/**
+* The parent-side registry of spawned dynamic agents (facets), stored
+* in the parent's own SQLite. Backs `hasSubAgent` / `listSubAgents`
+* and the identity-versioning decision (legacy bare-name facets vs
+* path-scoped v2 identities).
+*
+* Table and column names are storage-frozen — never rename them.
+*/
+var DynamicAgentRegistry = class {
+	constructor(host) {
+		_classPrivateMethodInitSpec(this, _DynamicAgentRegistry_brand);
+		_classPrivateFieldInitSpec(this, _host$1, void 0);
+		_classPrivateFieldInitSpec(this, _ready, false);
+		_classPrivateFieldSet2(_host$1, this, host);
+	}
+	ensure() {
+		if (_classPrivateFieldGet2(_ready, this)) return;
+		_classPrivateFieldGet2(_host$1, this).sql`
+      CREATE TABLE IF NOT EXISTS cf_agents_sub_agents (
+        class TEXT NOT NULL,
+        name TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        identity_version TEXT,
+        identity_name TEXT,
+        PRIMARY KEY (class, name)
+      )
+    `;
+		_assertClassBrand(_DynamicAgentRegistry_brand, this, _addColumnIfNotExists).call(this, "ALTER TABLE cf_agents_sub_agents ADD COLUMN identity_version TEXT");
+		_assertClassBrand(_DynamicAgentRegistry_brand, this, _addColumnIfNotExists).call(this, "ALTER TABLE cf_agents_sub_agents ADD COLUMN identity_name TEXT");
+		_classPrivateFieldSet2(_ready, this, true);
+	}
+	record(className, name, identity) {
+		this.ensure();
+		_classPrivateFieldGet2(_host$1, this).sql`
+      INSERT OR IGNORE INTO cf_agents_sub_agents
+        (class, name, created_at, identity_version, identity_name)
+      VALUES
+        (${className}, ${name}, ${Date.now()}, ${identity.version}, ${identity.name})
+    `;
+	}
+	row(className, name) {
+		this.ensure();
+		return _classPrivateFieldGet2(_host$1, this).sql`
+      SELECT identity_version, identity_name
+      FROM cf_agents_sub_agents
+      WHERE class = ${className} AND name = ${name}
+      LIMIT 1
+    `[0] ?? null;
+	}
+	async identity(className, name, childPath) {
+		const row = this.row(className, name);
+		if (row) {
+			if (row.identity_version === "path-v2" && typeof row.identity_name === "string") return {
+				version: SUB_AGENT_IDENTITY_VERSION_PATH_V2,
+				name: row.identity_name,
+				existing: true
+			};
+			return {
+				version: SUB_AGENT_IDENTITY_VERSION_LEGACY,
+				name,
+				existing: true
+			};
+		}
+		return {
+			version: SUB_AGENT_IDENTITY_VERSION_PATH_V2,
+			name: pathV2IdentityName(name, await sha256Hex(JSON.stringify(childPath))),
+			existing: false
+		};
+	}
+	forget(className, name) {
+		this.ensure();
+		_classPrivateFieldGet2(_host$1, this).sql`
+      DELETE FROM cf_agents_sub_agents
+      WHERE class = ${className} AND name = ${name}
+    `;
+	}
+	has(className, name) {
+		this.ensure();
+		return (_classPrivateFieldGet2(_host$1, this).sql`
+      SELECT COUNT(*) AS n FROM cf_agents_sub_agents
+      WHERE class = ${className} AND name = ${name}
+    `[0]?.n ?? 0) > 0;
+	}
+	list(className) {
+		this.ensure();
+		return (className ? _classPrivateFieldGet2(_host$1, this).sql`
+          SELECT class, name, created_at FROM cf_agents_sub_agents
+          WHERE class = ${className}
+          ORDER BY created_at ASC
+        ` : _classPrivateFieldGet2(_host$1, this).sql`
+          SELECT class, name, created_at FROM cf_agents_sub_agents
+          ORDER BY created_at ASC
+        `).map((r) => ({
+			className: r.class,
+			name: r.name,
+			createdAt: r.created_at
+		}));
+	}
+};
+function _addColumnIfNotExists(sql) {
+	try {
+		_classPrivateFieldGet2(_host$1, this).execRawSql(sql);
+	} catch (e) {
+		if (!(e instanceof Error ? e.message : String(e)).toLowerCase().includes("duplicate column")) throw e;
+	}
+}
+//#endregion
+//#region src/dynamic-agents/dynamic-agents.ts
+/**
+* Internal key used to remember the outer `/sub/...` URL for a
+* WebSocket accepted by the parent on behalf of a child facet.
+* Hibernated events then wake the parent, which forwards frames to
+* the child over serializable RPC while keeping native WebSocket I/O
+* parent-owned.
+*
+* Storage-frozen — never rename.
+*/
+const CF_SUB_AGENT_OUTER_URL_KEY = "_cf_subAgentOuterUrl";
+const CF_SUB_AGENT_TAGS_KEY = "_cf_subAgentTags";
+/** Wire-frozen internal header carrying the outer URL on WS upgrades. */
+const SUB_AGENT_OUTER_URL_HEADER = "x-cf-agents-subagent-url";
+var _host = /* @__PURE__ */ new WeakMap();
+var _facetKeepAliveTokens = /* @__PURE__ */ new WeakMap();
+var _bridgeContext = /* @__PURE__ */ new WeakMap();
+var _virtualConnections = /* @__PURE__ */ new WeakMap();
+var _connectionOperationTails = /* @__PURE__ */ new WeakMap();
+var _broadcastOperationTail = /* @__PURE__ */ new WeakMap();
+var _DynamicAgentsInternal_brand = /* @__PURE__ */ new WeakSet();
+/**
+* The facet-backed dynamic-agent machinery, extracted from the Agent
+* class. One instance per Agent, installed as a Lifecycle capability
+* (`capabilityId: "dynamic-agents"`); the host port documents exactly
+* which Agent internals it touches.
+*
+* The capability claims no runner hooks — four integration points are
+* deliberately wired directly through the Agent composition root
+* instead, because the runner's dispatch contract cannot express them:
+* the `/sub/` upgrade path rewrites the request and *continues* into
+* `lifecycle.fetch` (onRequest can only claim), forwarded WS frames run
+* inside the host's onMessage wrapper *after* the WebSockets capability
+* has claimed the wake, this module *implements* the lifecycle route
+* transport rather than consuming it, and facet-context restore has
+* load-bearing startup ordering inside the host's startup span.
+*
+* Nothing here renames any wire- or storage-visible identifier: the
+* `cf_agents_facet_runs` table, `_cf_*` RPC method names, and route
+* key formats are frozen.
+*
+* @internal
+*/
+var DynamicAgentsInternal = class extends LifecycleCapability {
+	constructor(host) {
+		super("dynamic-agents");
+		_classPrivateMethodInitSpec(this, _DynamicAgentsInternal_brand);
+		_classPrivateFieldInitSpec(this, _host, void 0);
+		_classPrivateFieldInitSpec(this, _facetKeepAliveTokens, /* @__PURE__ */ new Set());
+		_classPrivateFieldInitSpec(this, _bridgeContext, new AsyncLocalStorage());
+		_classPrivateFieldInitSpec(this, _virtualConnections, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _connectionOperationTails, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _broadcastOperationTail, void 0);
+		_classPrivateFieldSet2(_host, this, host);
+		this.registry = new DynamicAgentRegistry({
+			sql: host.sql.bind(host),
+			execRawSql: (sql) => void host.ctx.storage.sql.exec(sql)
+		});
+	}
+	runRowsForPrefix(ownerPath) {
+		return _classPrivateFieldGet2(_host, this).sql`
+      SELECT owner_path, owner_path_key, run_id, created_at
+      FROM cf_agents_facet_runs
+    `.filter((row) => {
+			try {
+				const rowOwnerPath = JSON.parse(row.owner_path);
+				return _classPrivateFieldGet2(_host, this)._isSameAgentPathPrefix(ownerPath, rowOwnerPath);
+			} catch {
+				return false;
+			}
+		});
+	}
+	deleteRunRowsForPrefix(ownerPath) {
+		for (const row of this.runRowsForPrefix(ownerPath)) _classPrivateFieldGet2(_host, this).sql`
+        DELETE FROM cf_agents_facet_runs
+        WHERE owner_path_key = ${row.owner_path_key}
+          AND run_id = ${row.run_id}
+      `;
+	}
+	lifecycleRouteAddress() {
+		if (!_classPrivateFieldGet2(_host, this)._isFacet) return void 0;
+		const key = agentPathKey(_classPrivateFieldGet2(_host, this).selfPath);
+		return key ? {
+			key,
+			data: JSON.stringify(_classPrivateFieldGet2(_host, this).selfPath)
+		} : void 0;
+	}
+	async routeLifecycleToRoot(envelope) {
+		if (!_classPrivateFieldGet2(_host, this)._isFacet) return _classPrivateFieldGet2(_host, this).lifecycle.route(envelope);
+		return (await this.rootAlarmOwner())._cf_routeLifecycle(void 0, envelope);
+	}
+	async routeLifecycleToTarget(target, envelope) {
+		let targetPath;
+		try {
+			targetPath = JSON.parse(target.data);
+		} catch {
+			throw new Error("Lifecycle route target is not a valid Agent path");
+		}
+		const selfPath = _classPrivateFieldGet2(_host, this).selfPath;
+		if (!_classPrivateFieldGet2(_host, this)._isSameAgentPathPrefix(selfPath, targetPath)) throw new Error(`Lifecycle route does not descend from ${JSON.stringify(selfPath)}.`);
+		if (selfPath.length === targetPath.length) return _classPrivateFieldGet2(_host, this).lifecycle.route(envelope);
+		const next = targetPath[selfPath.length];
+		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);
+			return false;
+		}
+		return (await _classPrivateFieldGet2(_host, this)._cf_resolveSubAgent(next.className, next.name))._cf_routeLifecycle(target, envelope);
+	}
+	/** Body of the single native-RPC aperture for routed Lifecycle capabilities. */
+	routeLifecycle(target, envelope) {
+		return target ? this.routeLifecycleToTarget(target, envelope) : _classPrivateFieldGet2(_host, this).lifecycle.route(envelope);
+	}
+	async rootAlarmOwner() {
+		const root = _classPrivateFieldGet2(_host, this)._parentPath[0];
+		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);
+	}
+	rootResolvesToSelf() {
+		const root = _classPrivateFieldGet2(_host, this)._parentPath[0];
+		if (!root) return false;
+		const binding = _classPrivateFieldGet2(_host, this).ctx.exports?.[root.className];
+		if (!binding?.idFromName) return false;
+		return binding.idFromName(root.name).equals(_classPrivateFieldGet2(_host, this).ctx.id);
+	}
+	/**
+	* Clean root-owned bookkeeping for a sub-tree of facets: bulk-cancel
+	* 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();
+	}
+	/**
+	* Acquire a root-owned keepAlive ref on behalf of a descendant facet.
+	*/
+	async acquireKeepAlive(ownerPath) {
+		const token = `${agentPathKey(ownerPath) ?? "unknown"}:${nanoid(9)}`;
+		_classPrivateFieldGet2(_facetKeepAliveTokens, this).add(token);
+		_classPrivateFieldGet2(_host, this)._keepAliveRefs++;
+		if (_classPrivateFieldGet2(_host, this)._keepAliveRefs === 1) await _classPrivateFieldGet2(_host, this)._syncHostJobs();
+		return token;
+	}
+	/**
+	* Release a root-owned keepAlive ref previously acquired for a facet.
+	* Idempotent so disposer calls can safely race or run twice.
+	*/
+	async releaseKeepAlive(token) {
+		if (!_classPrivateFieldGet2(_facetKeepAliveTokens, this).delete(token)) return;
+		_classPrivateFieldGet2(_host, this)._keepAliveRefs = Math.max(0, _classPrivateFieldGet2(_host, this)._keepAliveRefs - 1);
+		await _classPrivateFieldGet2(_host, this)._syncHostJobs();
+	}
+	/**
+	* Register a facet's durable run row in the root-side index so root
+	* alarm housekeeping can dispatch recovery checks into idle facets.
+	*/
+	async registerRun(ownerPath, runId) {
+		const ownerPathJson = JSON.stringify(ownerPath);
+		const ownerPathKey = agentPathKey(ownerPath);
+		if (!ownerPathKey) throw new Error("_cf_registerFacetRun requires a non-empty owner path.");
+		_classPrivateFieldGet2(_host, this).sql`
+      INSERT OR REPLACE INTO cf_agents_facet_runs
+        (owner_path, owner_path_key, run_id, created_at)
+      VALUES
+        (${ownerPathJson}, ${ownerPathKey}, ${runId}, ${Date.now()})
+    `;
+		await _classPrivateFieldGet2(_host, this)._syncHostJobs();
+	}
+	/**
+	* Root-side scan for durable fibers owned by descendant facets.
+	* `cf_agents_facet_runs` is only an index; actual snapshots and
+	* recovery hooks live in each facet's own `cf_agents_runs` table.
+	*/
+	async checkRunFibers() {
+		if (_classPrivateFieldGet2(_host, this)._parentPath.length > 0) return;
+		const rows = _classPrivateFieldGet2(_host, this).sql`
+      SELECT owner_path, owner_path_key, run_id, created_at
+      FROM cf_agents_facet_runs
+      ORDER BY created_at ASC
+    `;
+		const firstRowByOwner = /* @__PURE__ */ new Map();
+		for (const row of rows) if (!firstRowByOwner.has(row.owner_path_key)) firstRowByOwner.set(row.owner_path_key, row);
+		for (const row of firstRowByOwner.values()) {
+			let ownerPath;
+			try {
+				ownerPath = JSON.parse(row.owner_path);
+			} catch (e) {
+				console.warn(`[Agent] Corrupted facet fiber owner path for ${row.owner_path_key}; pruning stale lease.`, e);
+				_classPrivateFieldGet2(_host, this).sql`
+          DELETE FROM cf_agents_facet_runs
+          WHERE owner_path_key = ${row.owner_path_key}
+        `;
+				continue;
+			}
+			try {
+				if (await _classPrivateFieldGet2(_host, this)._cf_checkRunFibersForFacet(ownerPath) === 0) _classPrivateFieldGet2(_host, this).sql`
+            DELETE FROM cf_agents_facet_runs
+            WHERE owner_path_key = ${row.owner_path_key}
+          `;
+			} catch (e) {
+				console.error(`[Agent] Facet fiber recovery check failed for ${row.owner_path_key}:`, e);
+			}
+		}
+	}
+	/**
+	* Dispatch a runFiber recovery check into the facet identified by
+	* `ownerPath`. Returns the number of remaining local `cf_agents_runs`
+	* rows on the target facet after recovery.
+	*/
+	async checkRunFibersAtPath(ownerPath) {
+		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) {
+			await _classPrivateFieldGet2(_host, this)._checkRunFibers();
+			return _classPrivateFieldGet2(_host, this).sql`
+        SELECT COUNT(*) as count FROM cf_agents_runs
+      `[0]?.count ?? 0;
+		}
+		const next = ownerPath[selfPath.length];
+		if (!_classPrivateFieldGet2(_host, this).hasSubAgent(next.className, next.name)) return 0;
+		return (await this.resolve(next.className, next.name))._cf_checkRunFibersForFacet(ownerPath);
+	}
+	/**
+	* Invoke an RPC method on the host Agent or a descendant facet
+	* identified by a root-first path. Used by AgentWorkflow to route
+	* callbacks and `this.agent` calls back to the exact sub-agent that
+	* started a workflow.
+	*/
+	async invokeAgentPath(targetPath, method, args) {
+		await _classPrivateFieldGet2(_host, this).__unsafe_ensureInitialized();
+		const selfPath = _classPrivateFieldGet2(_host, this).selfPath;
+		if (!_classPrivateFieldGet2(_host, this)._isSameAgentPathPrefix(selfPath, targetPath)) throw new Error(`Workflow origin path does not descend from ${JSON.stringify(selfPath)}.`);
+		if (selfPath.length === targetPath.length) {
+			const fn = _classPrivateFieldGet2(_host, this)[method];
+			if (isInternalJsStubProp(method) || method in Object.prototype || typeof fn !== "function") throw new Error(`Workflow origin method "${method}" is not callable on ${_classPrivateFieldGet2(_host, this).constructor.name}.`);
+			return await fn.apply(_classPrivateFieldGet2(_host, this), args);
+		}
+		const next = targetPath[selfPath.length];
+		if (!_classPrivateFieldGet2(_host, this).hasSubAgent(next.className, next.name)) throw new Error(`Workflow origin sub-agent ${next.className} "${next.name}" no longer exists.`);
+		return await (await this.resolve(next.className, next.name))._cf_invokeAgentPath(targetPath, method, args);
+	}
+	/**
+	* Recursively destroy a descendant facet identified by `targetPath`.
+	* Walks down from `selfPath` until reaching the target's immediate
+	* parent, where it cancels the target's parent-owned schedules (and
+	* any descendants), removes the target from the registry, and calls
+	* `ctx.facets.delete` to wipe the target's storage.
+	*/
+	async destroyDescendant(targetPath) {
+		const selfPath = _classPrivateFieldGet2(_host, this).selfPath;
+		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 (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.");
+			try {
+				ctx.facets.delete(`${target.className}\0${target.name}`);
+			} catch {}
+			this.registry.forget(target.className, target.name);
+			return;
+		}
+		const next = targetPath[selfPath.length];
+		if (!_classPrivateFieldGet2(_host, this).hasSubAgent(next.className, next.name)) return;
+		await (await this.resolve(next.className, next.name))._cf_destroyDescendantFacet(targetPath);
+	}
+	/**
+	* Shared facet resolution — takes a CamelCase class name string
+	* (matching `ctx.exports`) rather than a class reference. Both
+	* `subAgent(cls, name)` and `_cf_invokeSubAgent(className, ...)`
+	* funnel through here so registry bookkeeping and the
+	* `_cf_initAsFacet` handshake are consistent.
+	*/
+	async resolve(className, name) {
+		const ctx = _classPrivateFieldGet2(_host, this).ctx;
+		if (!ctx.facets || !ctx.exports) throw new Error("subAgent() is not supported in this runtime — `ctx.facets` / `ctx.exports` are unavailable. Update to the latest `compatibility_date` in your wrangler.jsonc.");
+		if (camelCaseToKebabCase(className) === "sub") throw new Error(`Sub-agent class name "${className}" kebab-cases to "sub", which collides with the reserved URL separator — rename the class (e.g. "SubThing" or "Subtask").`);
+		const Cls = ctx.exports[className];
+		if (!Cls) throw new Error(`Sub-agent class "${className}" not found in worker exports. Make sure the class is exported from your worker entry point and that the export name matches the class name.`);
+		if (name.includes("\0")) throw new Error(`Sub-agent name contains null character (\\0), which is reserved.`);
+		const facetKey = `${className}\0${name}`;
+		const childParentPath = _classPrivateFieldGet2(_host, this).selfPath;
+		const childPath = [...childParentPath, {
+			className,
+			name
+		}];
+		const rootClassName = _classPrivateFieldGet2(_host, this)._parentPath[0]?.className ?? _classPrivateFieldGet2(_host, this).constructor.name;
+		const rootNs = ctx.exports[rootClassName];
+		if (!rootNs?.idFromName) {
+			const minificationHint = /^_*[a-z][a-z0-9]{0,2}$/.test(rootClassName) ? ` The class name "${rootClassName}" looks minified — make sure your bundler preserves class names (e.g. esbuild's \`keepNames: true\`).` : "";
+			throw new Error(`Sub-agent bootstrap requires the root agent class "${rootClassName}" to be available as a Durable Object namespace, but ctx.exports["${rootClassName}"] is missing or doesn't expose idFromName.${minificationHint} Make sure the root agent class is exported under that class name and registered in your wrangler.jsonc durable_objects.bindings.`);
+		}
+		const identity = await this.registry.identity(className, name, childPath);
+		const facetId = rootNs.idFromName(identity.name);
+		const stub = ctx.facets.get(facetKey, () => ({
+			class: Cls,
+			id: facetId
+		}));
+		this.registry.record(className, name, identity);
+		try {
+			await _classPrivateFieldGet2(_host, this)._runFacetInitInvocation(async () => {
+				await stub._cf_initAsFacet(name, childParentPath, identity.name);
+			});
+		} catch (error) {
+			if (!identity.existing) this.registry.forget(className, name);
+			throw error;
+		}
+		return stub;
+	}
+	/**
+	* Forcefully abort a running facet. Transitively aborts the child's
+	* own children; storage is preserved.
+	*/
+	abort(className, name, reason) {
+		const ctx = _classPrivateFieldGet2(_host, this).ctx;
+		if (!ctx.facets) throw new Error("abort() is not supported in this runtime — `ctx.facets` is unavailable. Update to the latest `compatibility_date` in your wrangler.jsonc.");
+		const facetKey = `${className}\0${name}`;
+		ctx.facets.abort(facetKey, reason);
+	}
+	/**
+	* Delete a facet: abort it if running, then permanently wipe its
+	* storage. Transitively deletes the child's own children.
+	*/
+	async delete(className, name) {
+		const ctx = _classPrivateFieldGet2(_host, this).ctx;
+		if (!ctx.facets) throw new Error("delete() is not supported in this runtime — `ctx.facets` is unavailable. Update to the latest `compatibility_date` in your wrangler.jsonc.");
+		const facetKey = `${className}\0${name}`;
+		const childPath = [..._classPrivateFieldGet2(_host, this).selfPath, {
+			className,
+			name
+		}];
+		if (_classPrivateFieldGet2(_host, this)._isFacet) await (await this.rootAlarmOwner())._cf_cleanupFacetPrefix(childPath);
+		else await _classPrivateFieldGet2(_host, this)._cf_cleanupFacetPrefix(childPath);
+		try {
+			ctx.facets.delete(facetKey);
+		} catch {}
+		this.registry.forget(className, name);
+	}
+	/** Drop all facet-side virtual connections (test/rehydration hook). */
+	clearVirtualConnections() {
+		_classPrivateFieldGet2(_virtualConnections, this).clear();
+	}
+	/** Facet-side lookup of a virtual connection by id. */
+	getVirtualConnection(id) {
+		const stored = _classPrivateFieldGet2(_virtualConnections, this).get(id);
+		if (!stored) return void 0;
+		return this.createBridgeConnection(stored.meta);
+	}
+	/** Facet-side iteration over virtual connections, optionally by tag. */
+	*getVirtualConnections(tag) {
+		for (const stored of _classPrivateFieldGet2(_virtualConnections, this).values()) if (!tag || stored.meta.tags.includes(tag)) yield this.createBridgeConnection(stored.meta);
+	}
+	activeBridge(connectionId) {
+		const context = _classPrivateFieldGet2(_bridgeContext, this).getStore();
+		if (connectionId !== void 0 && context?.connectionId !== connectionId) return;
+		return context?.bridge;
+	}
+	/**
+	* Route a virtual sub-agent connection operation through its live frame
+	* bridge, or through the durable root Agent after that frame completes.
+	* All operations share one per-connection queue. Facet broadcasts wait for
+	* older queued operations; failures do not block later work.
+	*/
+	routeConnectionOperation(connectionId, operationName, operation) {
+		const activeBridge = this.activeBridge(connectionId);
+		const previousConnectionOperation = _classPrivateFieldGet2(_connectionOperationTails, this).get(connectionId);
+		let pending;
+		if (activeBridge && !previousConnectionOperation) try {
+			pending = Promise.resolve(operation(activeBridge)).then(() => {});
+		} catch (error) {
+			pending = Promise.reject(error);
+		}
+		else pending = (previousConnectionOperation ?? Promise.resolve()).then(async () => {
+			await operation(new RootDynamicAgentConnectionBridge(await this.rootAlarmOwner(), connectionId));
+		});
+		const completion = pending.catch((error) => {
+			_assertClassBrand(_DynamicAgentsInternal_brand, this, _reportConnectionOperationFailure).call(this, connectionId, operationName, error);
+		});
+		_classPrivateFieldGet2(_connectionOperationTails, this).set(connectionId, completion);
+		_classPrivateFieldGet2(_host, this).ctx.waitUntil(completion);
+		completion.then(() => {
+			if (_classPrivateFieldGet2(_connectionOperationTails, this).get(connectionId) === completion) _classPrivateFieldGet2(_connectionOperationTails, this).delete(connectionId);
+		});
+	}
+	/**
+	* Route a facet broadcast after every older connection operation.
+	*
+	* This barrier is intentionally one-way: facet startup can broadcast before
+	* a child connection has finished initializing its tags and protocol flags.
+	* Making those later connection operations wait would let the next frame
+	* observe stale root-owned metadata.
+	*/
+	async routeBroadcast(ownerPath, message, without, upstreamBridge) {
+		const activeBridge = upstreamBridge ?? this.activeBridge();
+		const previousOperations = /* @__PURE__ */ new Set([..._classPrivateFieldGet2(_broadcastOperationTail, this) ? [_classPrivateFieldGet2(_broadcastOperationTail, this)] : [], ..._classPrivateFieldGet2(_connectionOperationTails, this).values()]);
+		let pending;
+		if (activeBridge && previousOperations.size === 0) try {
+			pending = Promise.resolve(activeBridge.broadcast(ownerPath, message, without));
+		} catch (error) {
+			pending = Promise.reject(error);
+		}
+		else pending = Promise.all(previousOperations).then(async () => {
+			await (await this.rootAlarmOwner())._cf_broadcastToSubAgent(ownerPath, message, without);
+		});
+		const completion = pending.catch((error) => {
+			console.error("[Agent] Sub-agent broadcast operation failed:", {
+				operation: "broadcast",
+				error
+			});
+		});
+		_classPrivateFieldSet2(_broadcastOperationTail, this, completion);
+		_classPrivateFieldGet2(_host, this).ctx.waitUntil(completion);
+		completion.then(() => {
+			if (_classPrivateFieldGet2(_broadcastOperationTail, this) === completion) _classPrivateFieldSet2(_broadcastOperationTail, this, void 0);
+		});
+		await completion;
+	}
+	async broadcastToParent(message, without) {
+		await this.routeBroadcast(_classPrivateFieldGet2(_host, this).selfPath, message, without);
+	}
+	async broadcastToPath(ownerPath, message, without) {
+		if (_classPrivateFieldGet2(_host, this)._isFacet) {
+			await this.routeBroadcast(ownerPath, message, without);
+			return;
+		}
+		for (const connection of _classPrivateFieldGet2(_host, this)._webSockets.getConnections()) {
+			if (without?.includes(connection.id)) continue;
+			const targetPath = this.connectionTargetPath(connection);
+			if (!targetPath) continue;
+			if (!this.isSameAgentPath(targetPath, ownerPath)) continue;
+			connection.send(message);
+		}
+	}
+	async connectionMetas(ownerPath) {
+		const metas = [];
+		for (const connection of _classPrivateFieldGet2(_host, this)._webSockets.getConnections()) {
+			const meta = _assertClassBrand(_DynamicAgentsInternal_brand, this, _connectionMetaForPath).call(this, connection, ownerPath);
+			if (meta) metas.push(meta);
+		}
+		return metas;
+	}
+	async sendToConnection(connectionId, message) {
+		const connection = _classPrivateFieldGet2(_host, this)._webSockets.getConnection(connectionId);
+		if (!connection || !this.connectionHasChildTarget(connection)) return;
+		connection.send(message);
+	}
+	async closeConnection(connectionId, code, reason) {
+		const connection = _classPrivateFieldGet2(_host, this)._webSockets.getConnection(connectionId);
+		if (!connection || !this.connectionHasChildTarget(connection)) return;
+		connection.close(code, reason);
+	}
+	async setConnectionState(connectionId, state) {
+		const connection = _classPrivateFieldGet2(_host, this)._webSockets.getConnection(connectionId);
+		if (!connection || !this.connectionHasChildTarget(connection)) return null;
+		ensureConnectionWrapped(connection);
+		connection.setState(state);
+		return this.getForwardedState(connection);
+	}
+	connectionTargetPath(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;
+	}
+	isSameAgentPath(a, b) {
+		if (a.length !== b.length) return false;
+		return a.every((step, index) => step.className === b[index]?.className && step.name === b[index]?.name);
+	}
+	connectionHasChildTarget(connection) {
+		ensureConnectionWrapped(connection);
+		return typeof _classPrivateFieldGet2(_host, this)._unsafe_getConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY) === "string";
+	}
+	connectionTargetsChild(connection) {
+		if (!connection.uri) return false;
+		const ctx = _classPrivateFieldGet2(_host, this).ctx;
+		return parseSubAgentPath(connection.uri, { knownClasses: ctx.exports ? Object.keys(ctx.exports) : void 0 }) !== null;
+	}
+	requestTargetsChild(request) {
+		const ctx = _classPrivateFieldGet2(_host, this).ctx;
+		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;
+		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 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;
+		await routed.child._cf_handleSubAgentWebSocketClose(code, reason, wasClean, _assertClassBrand(_DynamicAgentsInternal_brand, this, _createConnectionBridge).call(this, connection), routed.meta);
+		return true;
+	}
+	async handleWebSocketConnect(bridge, meta) {
+		await this.runWithBridge(bridge, meta.id, async () => {
+			const connection = this.createBridgeConnection(meta);
+			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 })) 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);
+			await _classPrivateFieldGet2(_host, this).onConnect(connection, { request });
+			this.storeVirtualConnection(connection);
+			await _classPrivateFieldGet2(_connectionOperationTails, this).get(meta.id);
+		});
+	}
+	async handleWebSocketMessage(message, bridge, meta, replyBridge = bridge) {
+		const connection = this.createBridgeConnection(meta);
+		this.storeVirtualConnection(connection);
+		const replyContext = { bridge: replyBridge };
+		try {
+			await dynamicAgentRpcReplyContext.run(replyContext, () => this.runWithBridge(bridge, meta.id, () => _classPrivateFieldGet2(_host, this).onMessage(connection, message)));
+		} finally {
+			replyContext.bridge = void 0;
+		}
+	}
+	async handleWebSocketClose(code, reason, wasClean, bridge, meta) {
+		const connection = this.createBridgeConnection(meta);
+		this.storeVirtualConnection(connection);
+		await this.runWithBridge(bridge, meta.id, () => _classPrivateFieldGet2(_host, this).onClose(connection, code, reason, wasClean));
+		_classPrivateFieldGet2(_virtualConnections, this).delete(meta.id);
+	}
+	async runWithBridge(bridge, connectionId, fn) {
+		const context = {
+			bridge,
+			connectionId
+		};
+		try {
+			return await _classPrivateFieldGet2(_bridgeContext, this).run(context, fn);
+		} finally {
+			context.bridge = void 0;
+		}
+	}
+	createBridgeConnection(meta) {
+		let stored = _classPrivateFieldGet2(_virtualConnections, this).get(meta.id);
+		if (stored) {
+			stored.meta = meta;
+			if (stored.connection) {
+				stored.connection.uri = meta.uri;
+				stored.connection.tags = meta.tags;
+				return stored.connection;
+			}
+		} else {
+			stored = { meta };
+			_classPrivateFieldGet2(_virtualConnections, this).set(meta.id, stored);
+		}
+		const owner = this;
+		const getStored = () => _classPrivateFieldGet2(_virtualConnections, this).get(meta.id) ?? stored;
+		const updateStoredState = (nextState) => {
+			const current = _classPrivateFieldGet2(_virtualConnections, this).get(meta.id);
+			if (current) current.meta = {
+				...current.meta,
+				state: nextState
+			};
+		};
+		const connection = {
+			id: meta.id,
+			uri: meta.uri,
+			tags: meta.tags,
+			get state() {
+				return getStored().meta.state;
+			},
+			setState(next) {
+				const currentState = getStored().meta.state;
+				const state = typeof next === "function" ? next(currentState) : next;
+				updateStoredState(state);
+				owner.routeConnectionOperation(meta.id, "setState", (bridge) => bridge.setState(state));
+				return state;
+			},
+			send(message) {
+				owner.routeConnectionOperation(meta.id, "send", (bridge) => bridge.send(message));
+			},
+			close(code, reason) {
+				owner.routeConnectionOperation(meta.id, "close", (bridge) => bridge.close(code, reason));
+			},
+			addEventListener() {},
+			removeEventListener() {}
+		};
+		stored.connection = connection;
+		ensureConnectionWrapped(connection);
+		return connection;
+	}
+	storeVirtualConnection(connection) {
+		_classPrivateFieldGet2(_host, this)._unsafe_setConnectionFlag(connection, CF_SUB_AGENT_TAGS_KEY, [...connection.tags]);
+		const stored = _classPrivateFieldGet2(_virtualConnections, this).get(connection.id);
+		_classPrivateFieldGet2(_virtualConnections, this).set(connection.id, {
+			meta: {
+				id: connection.id,
+				uri: connection.uri,
+				tags: [...connection.tags],
+				state: this.getRawConnectionState(connection)
+			},
+			connection: stored?.connection ?? connection
+		});
+	}
+	/**
+	* Restore the facet identity persisted by `init` (wake after
+	* hibernation), then best-effort hydrate the virtual connections
+	* from the root's WebSocket state.
+	*/
+	async restoreFacetContext() {
+		if (await _classPrivateFieldGet2(_host, this).ctx.storage.get("cf_agents_is_facet")) _classPrivateFieldGet2(_host, this)._isFacet = true;
+		const storedFacetName = await _classPrivateFieldGet2(_host, this).ctx.storage.get("cf_agents_facet_name");
+		if (typeof storedFacetName === "string") _classPrivateFieldGet2(_host, this)._facetName = storedFacetName;
+		const storedParentPath = await _classPrivateFieldGet2(_host, this).ctx.storage.get("cf_agents_parent_path");
+		if (isValidParentPath(storedParentPath)) _classPrivateFieldGet2(_host, this)._parentPath = storedParentPath;
+		try {
+			await this.hydrateConnectionsFromRoot();
+		} catch (error) {
+			console.warn("[Agent] Unable to hydrate sub-agent WebSocket connections:", error);
+		}
+	}
+	async hydrateConnectionsFromRoot() {
+		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 });
+	}
+	getRawConnectionState(connection) {
+		return getConnectionRawState(connection);
+	}
+	getForwardedState(connection) {
+		const raw = this.getRawConnectionState(connection);
+		if (raw == null || typeof raw !== "object") return raw;
+		const { [CF_SUB_AGENT_OUTER_URL_KEY]: _, ...rest } = raw;
+		return Object.keys(rest).length > 0 ? rest : null;
+	}
+	/**
+	* Resolve the facet Fetcher for the match and forward the request to
+	* it with `/sub/{class}/{name}` stripped.
+	*/
+	async forward(req, match) {
+		let fetcher;
+		try {
+			fetcher = await this.resolve(match.childClass, match.childName);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			console.error("[agents] sub-agent route failed:", message);
+			if (/null character/i.test(message) || /reserved/i.test(message)) return new Response("Bad Request", { status: 400 });
+			return new Response("Not Found", { status: 404 });
+		}
+		const rewritten = new URL(req.url);
+		rewritten.pathname = match.remainingPath;
+		const forwardedHeaders = new Headers(req.headers);
+		const forwardedInit = {
+			method: req.method,
+			headers: forwardedHeaders
+		};
+		if (req.headers.get("Upgrade")?.toLowerCase() === "websocket") forwardedHeaders.set(SUB_AGENT_OUTER_URL_HEADER, req.url);
+		if (req.body && req.method !== "GET" && req.method !== "HEAD") forwardedInit.body = req.body;
+		const forwarded = new Request(rewritten, forwardedInit);
+		return fetcher.fetch(forwarded);
+	}
+	/**
+	* Bridge used by `getSubAgentByName`: resolve the facet and dispatch
+	* one RPC method. Stateless — no cached references.
+	*/
+	async invoke(className, name, method, args) {
+		const stub = await this.resolve(className, name);
+		return await this.invokeStubMethod(stub, className, method, args);
+	}
+	/**
+	* Bridge used by `parentAgent()` when the requested parent is itself
+	* a facet (and therefore has no top-level env namespace). The root
+	* receives the full root-first target path, then each hop delegates
+	* to the next facet using that facet's own `ctx.facets`.
+	*/
+	async invokePath(path, method, args) {
+		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;
+		if (self.className !== ownClassName || self.name !== _classPrivateFieldGet2(_host, this).name) throw new Error(`Sub-agent path invocation reached ${ownClassName}("${_classPrivateFieldGet2(_host, this).name}") but expected ${self.className}("${self.name}").`);
+		if (!next) return await this.invokeStubMethod(_classPrivateFieldGet2(_host, this), ownClassName, method, args);
+		const child = await this.resolve(next.className, next.name);
+		if (rest.length === 0) return await this.invokeStubMethod(child, next.className, method, args);
+		return await child._cf_invokeSubAgentPath([next, ...rest], method, args);
+	}
+	async invokeStubMethod(stub, className, method, args) {
+		const handle = stub;
+		if (typeof handle[method] !== "function") throw new Error(`Method "${method}" not found on ${className}.`);
+		return await handle[method](...args);
+	}
+	/**
+	* Initialize the host agent as a facet in a single RPC. Runs entirely
+	* inside the child's isolate, so every storage write and `onStart()`
+	* I/O is owned by the child DO.
+	*/
+	async init(name, parentPath = [], identityName = name) {
+		const routedName = _classPrivateFieldGet2(_host, this).lifecycle.name;
+		if (routedName !== identityName) throw new Error(`Facet bootstrap mismatch: expected routed identity "${identityName}" but got "${routedName}". This usually means the parent passed the wrong id to ctx.facets.get(). See _cf_resolveSubAgent.`);
+		_classPrivateFieldGet2(_host, this)._isFacet = true;
+		_classPrivateFieldGet2(_host, this)._facetName = name;
+		_classPrivateFieldGet2(_host, this)._parentPath = parentPath;
+		await Promise.all([
+			_classPrivateFieldGet2(_host, this).ctx.storage.put("cf_agents_is_facet", true),
+			_classPrivateFieldGet2(_host, this).ctx.storage.put("cf_agents_facet_name", name),
+			_classPrivateFieldGet2(_host, this).ctx.storage.put("cf_agents_parent_path", parentPath)
+		]);
+		await _classPrivateFieldGet2(_host, this).__unsafe_ensureInitialized();
+	}
+	/** Remove a completed facet fiber from the root-side index. */
+	async unregisterRun(ownerPath, runId) {
+		const ownerPathKey = agentPathKey(ownerPath);
+		_classPrivateFieldGet2(_host, this).sql`
+      DELETE FROM cf_agents_facet_runs
+      WHERE owner_path_key IS ${ownerPathKey}
+        AND run_id = ${runId}
+    `;
+		await _classPrivateFieldGet2(_host, this)._syncHostJobs();
+	}
+};
+function _reportConnectionOperationFailure(connectionId, operation, error) {
+	console.error("[Agent] Sub-agent connection operation failed:", {
+		connectionId,
+		operation,
+		error
+	});
+}
+function _connectionMetaForPath(connection, ownerPath) {
+	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);
+	if (!target) return null;
+	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 {
+		id: connection.id,
+		uri: target.uri,
+		tags,
+		state: this.getForwardedState(connection)
+	};
+}
+function _pathFromOuterUri(outerUri, stopAt) {
+	const ctx = _classPrivateFieldGet2(_host, this).ctx;
+	const knownClasses = ctx.exports ? Object.keys(ctx.exports) : void 0;
+	const path = [..._classPrivateFieldGet2(_host, this).selfPath];
+	let currentUrl = outerUri;
+	while (true) {
+		const match = parseSubAgentPath(currentUrl, { knownClasses });
+		if (!match) break;
+		path.push({
+			className: match.childClass,
+			name: match.childName
+		});
+		const rewritten = new URL(currentUrl);
+		rewritten.pathname = match.remainingPath;
+		currentUrl = rewritten.toString();
+		if (stopAt && this.isSameAgentPath(path, stopAt)) return {
+			path,
+			uri: currentUrl
+		};
+	}
+	if (path.length === _classPrivateFieldGet2(_host, this).selfPath.length) return null;
+	if (stopAt) return null;
+	return {
+		path,
+		uri: currentUrl
+	};
+}
+function _createConnectionBridge(connection) {
+	const upstreamBroadcastBridge = _classPrivateFieldGet2(_host, this)._isFacet ? this.activeBridge(connection.id) : void 0;
+	return new DynamicAgentConnectionBridge(connection, (ownerPath, message, without) => {
+		if (upstreamBroadcastBridge) return this.routeBroadcast(ownerPath, message, without, upstreamBroadcastBridge);
+		return _classPrivateFieldGet2(_host, this)._cf_broadcastToSubAgent(ownerPath, message, without);
+	});
+}
+async function _resolveConnection(connection, request, options = { gate: false }) {
+	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;
+	const ctx = _classPrivateFieldGet2(_host, this).ctx;
+	let match = parseSubAgentPath(uri, { knownClasses: ctx.exports ? Object.keys(ctx.exports) : void 0 });
+	if (!match) return null;
+	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;
+	}
+	let forwardReq = request;
+	if (request && options.gate) {
+		const decision = await _classPrivateFieldGet2(_host, this).onBeforeSubAgent(request, {
+			className: match.childClass,
+			name: match.childName
+		});
+		if (decision instanceof Response) {
+			connection.close(1008, "Sub-agent connection rejected");
+			return null;
+		}
+		forwardReq = decision instanceof Request ? decision : request;
+	}
+	const child = await this.resolve(match.childClass, match.childName);
+	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 {
+		child,
+		meta: {
+			id: connection.id,
+			uri: childUri.toString(),
+			tags,
+			state: this.getForwardedState(connection),
+			requestHeaders: forwardReq ? [...forwardReq.headers] : void 0
+		}
+	};
+}
+//#endregion
+//#region src/dynamic-agents/api.ts
+var _internal = /* @__PURE__ */ new WeakMap();
+/**
+* The public dynamic-agents capability surface, reached via
+* `this.dynamicAgents` on an Agent.
+*
+* A dynamic agent is a facet-backed child: it runs in its own isolate
+* with its own SQLite database, colocated with — and supervised by —
+* its parent Agent. Use dynamic agents for code whose class or
+* lifecycle the parent owns (dynamically-loaded/generated code,
+* per-run tool agents, sandboxed components). For independent peers
+* such as one-DO-per-chat, use `getAgentByName` instead.
+*
+* @experimental The API surface may change before stabilizing.
+*/
+var DynamicAgents = class {
+	/** @internal Constructed by Agent; do not instantiate directly. */
+	constructor(internal) {
+		_classPrivateFieldInitSpec(this, _internal, void 0);
+		_classPrivateFieldSet2(_internal, this, internal);
+	}
+	/**
+	* Get (creating or waking if needed) the dynamic agent of the given
+	* class and name, as a typed RPC stub. Idempotent — repeated calls
+	* with the same class and name return the same child.
+	*
+	* @experimental
+	*/
+	async get(cls, name) {
+		return await _classPrivateFieldGet2(_internal, this).resolve(cls.name, name);
+	}
+	/**
+	* Forcefully abort a running dynamic agent. The child stops
+	* executing immediately and restarts on the next {@link get} call;
+	* its storage is preserved. Transitively aborts the child's own
+	* children. Pending RPC calls receive the reason as an error.
+	*
+	* @experimental
+	*/
+	abort(cls, name, reason) {
+		_classPrivateFieldGet2(_internal, this).abort(cls.name, name, reason);
 	}
-	close(code, reason) {
-		return _classPrivateFieldGet2(_root, this)._cf_closeSubAgentConnection(_classPrivateFieldGet2(_connectionId, this), code, reason);
+	/**
+	* Delete a dynamic agent: abort it if running, then permanently wipe
+	* its storage. Transitively deletes the child's own children.
+	*
+	* @experimental
+	*/
+	delete(cls, name) {
+		return _classPrivateFieldGet2(_internal, this).delete(cls.name, name);
 	}
-	setState(state) {
-		return _classPrivateFieldGet2(_root, this)._cf_setSubAgentConnectionState(_classPrivateFieldGet2(_connectionId, this), state);
+	has(classOrName, name) {
+		const className = typeof classOrName === "string" ? classOrName : classOrName.name;
+		return _classPrivateFieldGet2(_internal, this).registry.has(className, name);
 	}
-	broadcast(ownerPath, message, without) {
-		return _classPrivateFieldGet2(_root, this)._cf_broadcastToSubAgent(ownerPath, message, without);
+	list(classOrName) {
+		const className = typeof classOrName === "string" ? classOrName : classOrName?.name;
+		return _classPrivateFieldGet2(_internal, this).registry.list(className);
 	}
 };
-/**
-* Decorator that marks a method as callable by clients
-* @param metadata Optional metadata about the callable method
-*/
-function callable(metadata = {}) {
-	return function callableDecorator(target, _context) {
-		if (!callableMetadata.has(target)) callableMetadata.set(target, metadata);
-		return target;
+//#endregion
+//#region src/observability/agent-span-attributes.ts
+function agentSpanAttributes(input) {
+	return {
+		"instrumentation_scope.name": "agents",
+		"instrumentation_scope.version": "1",
+		"cloudflare.agents.session.id": input.sessionId,
+		"cloudflare.agents.session.name": input.sessionName,
+		"gen_ai.agent.name": input.agentClassName
 	};
 }
-let didWarnAboutUnstableCallable = false;
+//#endregion
+//#region src/index.ts
+let _Symbol$dispose;
 /**
-* Decorator that marks a method as callable by clients
-* @deprecated this has been renamed to callable, and unstable_callable will be removed in the next major version
-* @param metadata Optional metadata about the callable method
+* Enters an agent invocation: the context every handler reads, plus the span
+* scope that stops invocation-bounded spans from outliving it. Scopes do not
+* nest, so the outermost live entry point owns the boundary — pass
+* `detached` for work that deliberately runs on past its caller.
 */
-const unstable_callable = (metadata = {}) => {
-	if (!didWarnAboutUnstableCallable) {
-		didWarnAboutUnstableCallable = true;
-		console.warn("unstable_callable is deprecated, use callable instead. unstable_callable will be removed in the next major version.");
+function runInInvocation(store, body, options) {
+	return __DO_NOT_USE_WILL_BREAK__agentContext.run(store, () => withInvocationScope(body, options));
+}
+function sendRpcResponseIfOpen(connection, response) {
+	try {
+		connection.send(JSON.stringify(response));
+		return true;
+	} catch (error) {
+		if (isClosedWebSocketSendError(error)) return false;
+		throw error;
 	}
-	return callable(metadata);
-};
-function agentPathKey(path) {
-	if (!path) return null;
-	return path.map((step) => `${encodeURIComponent(step.className)}:${encodeURIComponent(step.name)}`).join("/");
+}
+/**
+* Type guard for RPC request messages
+*/
+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);
 }
 const _fiberALS = new AsyncLocalStorage();
 const DEFAULT_KEEP_ALIVE_INTERVAL_MS = 3e4;
 const DEFAULT_AGENT_TOOL_RECOVERY_TIMEOUT_MS = 2e3;
 const DEFAULT_AGENT_TOOL_RECOVERY_TOTAL_TIMEOUT_MS = 5e3;
 const DESTROY_PENDING_KEY = "cf_agents_destroy_pending";
+const HOST_JOB_KEEP_ALIVE_ID = "cf:keep-alive";
+const HOST_JOB_HOUSEKEEPING_ID = "cf:housekeeping";
+const HOST_JOB_DESTROY_ID = "cf:destroy";
 const DESTROY_ALARM_DELAY_MS = 1e3;
 const FIBER_RECOVERY_MAX_BACKOFF_MS = 5 * 6e4;
 const FIBER_RECOVERY_BACKOFF_MAX_EXP = 20;
@@ -202,105 +1241,18 @@ const DETACHED_BACKBONE_CADENCE_S = [
 const DETACHED_LIVE_COUNT_WARN_THRESHOLD = 50;
 const DETACHED_RECONCILE_CALLBACK = "_cfDetachedReconcileTick";
 const DETACHED_NOTIFY_CALLBACK = "_cfDetachedNotifyFinish";
-const SUB_AGENT_IDENTITY_VERSION_LEGACY = "legacy";
-const SUB_AGENT_IDENTITY_VERSION_PATH_V2 = "path-v2";
-const SUB_AGENT_IDENTITY_PATH_V2_PREFIX = "cf-agents:v2:";
 /**
 * 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 SCHEMA_VERSION_KEY = "cf_agents:schema_version";
+const LEGACY_SCHEMA_VERSION_ROW_ID = "cf_schema_version";
 const DEFAULT_STATE = {};
-async function sha256Hex(value) {
-	const bytes = new TextEncoder().encode(value);
-	const digest = await crypto.subtle.digest("SHA-256", bytes);
-	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-function pathV2IdentityName(logicalName, digest) {
-	return `${SUB_AGENT_IDENTITY_PATH_V2_PREFIX}${encodeURIComponent(logicalName)}:${digest}`;
-}
-function logicalNameFromPathV2Identity(identityName) {
-	if (!identityName.startsWith(SUB_AGENT_IDENTITY_PATH_V2_PREFIX)) return null;
-	const rest = identityName.slice(13);
-	const separator = rest.lastIndexOf(":");
-	if (separator === -1) return null;
-	try {
-		return decodeURIComponent(rest.slice(0, separator));
-	} catch {
-		return null;
-	}
-}
-/**
-* Validate that a stored `parentPath` has the expected shape. Used
-* when restoring from DO storage to guard against corrupted data.
-*/
-function isValidParentPath(value) {
-	if (!Array.isArray(value)) return false;
-	return value.every((entry) => entry != null && typeof entry === "object" && typeof entry.className === "string" && typeof entry.name === "string");
-}
-/**
-* 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";
-/**
-* Internal key used to store voice call state in connection state.
-* Used by the voice mixin to track whether a connection is in an active call.
-*/
-const CF_VOICE_IN_CALL_KEY = "_cf_voiceInCall";
-/**
-* Internal key used to remember the outer `/sub/...` URL for a
-* WebSocket accepted by the parent on behalf of a child facet.
-* Hibernated events then wake the parent, which forwards frames to
-* the child over serializable RPC while keeping native WebSocket I/O
-* parent-owned.
-*/
-const CF_SUB_AGENT_OUTER_URL_KEY = "_cf_subAgentOuterUrl";
-const CF_SUB_AGENT_TAGS_KEY = "_cf_subAgentTags";
-const SUB_AGENT_OUTER_URL_HEADER = "x-cf-agents-subagent-url";
-/**
-* 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_VOICE_IN_CALL_KEY,
-	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;
 /**
@@ -391,27 +1343,6 @@ 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;
 /**
@@ -436,7 +1367,7 @@ function withAgentContext(method) {
 /**
 * 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. */
@@ -459,6 +1390,34 @@ var Agent = class Agent extends DurableObject {
 	async __unsafe_ensureInitialized(props) {
 		await this.lifecycle.start(props);
 	}
+	/** @internal */
+	get _dynamicAgents() {
+		this._dynamicAgentsInstance ??= new DynamicAgentsInternal(this);
+		return this._dynamicAgentsInstance;
+	}
+	/**
+	* The dynamic-agents capability: facet-backed child agents that run
+	* in their own isolate with their own SQLite database, colocated
+	* with — and supervised by — this agent.
+	*
+	* Use dynamic agents for code whose class or lifecycle this agent
+	* owns: dynamically-loaded or AI-generated code, per-run tool
+	* agents, sandboxed components. For independent peers (for example
+	* one Durable Object per chat), use `getAgentByName` instead.
+	*
+	* ```ts
+	* const child = await this.dynamicAgents.get(Researcher, id);
+	* await child.doWork();
+	* this.dynamicAgents.abort(Researcher, id, reason);
+	* await this.dynamicAgents.delete(Researcher, id);
+	* ```
+	*
+	* @experimental The API surface may change before stabilizing.
+	*/
+	get dynamicAgents() {
+		this._dynamicAgentsApi ??= new DynamicAgents(this._dynamicAgents);
+		return this._dynamicAgentsApi;
+	}
 	/**
 	* Stable key for Workers AI session affinity (prefix-cache optimization).
 	*
@@ -480,31 +1439,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() {
@@ -590,26 +1534,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);
@@ -617,7 +1544,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,
@@ -642,8 +1568,6 @@ 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);
-			ensureScheduleTable(this.ctx.storage);
 			this.sql`
         CREATE TABLE IF NOT EXISTS cf_agents_runs (
           id TEXT PRIMARY KEY NOT NULL,
@@ -728,10 +1652,7 @@ 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)})
-      `;
+			this.ctx.storage.kv.put(SCHEMA_VERSION_KEY, CURRENT_SCHEMA_VERSION);
 		}
 		this._schemaInitialization = {
 			previousVersion: schemaVersion,
@@ -739,23 +1660,50 @@ 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);
-		this._state = DEFAULT_STATE;
+		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),
+				onMessage: (connection, message) => this.onMessage(connection, message),
+				onClose: (connection, code, reason, wasClean) => this.onClose(connection, code, reason, wasClean),
+				onError: (connection, error) => this.onError(connection, error)
+			},
+			protocol: false,
+			state: this._state,
+			getConnectionTags: (connection, ctx) => this.getConnectionTags(connection, ctx)
+		});
 		this._disposables = new DisposableStore();
 		this._destroyed = false;
-		this._rawStateAccessors = /* @__PURE__ */ new WeakMap();
 		this._persistenceHookMode = "none";
 		this._isFacet = false;
 		this._protocolBroadcastExcludeIds = /* @__PURE__ */ new Set();
-		this._cf_subAgentBridgeContext = new AsyncLocalStorage();
-		this._cf_virtualSubAgentConnections = /* @__PURE__ */ new Map();
-		this._cf_subAgentConnectionOperationTails = /* @__PURE__ */ new Map();
 		this._parentPath = [];
 		this._warnedChatRecoveryInOnStart = false;
 		this._keepAliveRefs = 0;
-		this._facetKeepAliveTokens = /* @__PURE__ */ new Set();
 		this._runFiberActiveFibers = /* @__PURE__ */ new Set();
 		this._managedFiberAbortControllers = /* @__PURE__ */ new Map();
 		this._managedFiberExecutions = /* @__PURE__ */ new Map();
@@ -767,9 +1715,7 @@ 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;
-		this._subAgentRegistryReady = false;
 		const routeHost = this;
 		setLifecycleRouteTransport(this.lifecycle, {
 			get source() {
@@ -782,10 +1728,10 @@ var Agent = class Agent extends DurableObject {
 			const payload = event.payload !== null && typeof event.payload === "object" && !Array.isArray(event.payload) ? event.payload : { value: event.payload };
 			this._emit(event.type, payload);
 		});
-		setLifecycleHostInvoker(this.lifecycle, (run) => runInInvocation({
+		setLifecycleHostInvoker(this.lifecycle, (run, scope) => runInInvocation({
 			agent: this,
-			connection: void 0,
-			request: void 0,
+			connection: scope?.connection,
+			request: scope?.request,
 			email: void 0
 		}, run));
 		this.scheduler = new Scheduler({
@@ -803,6 +1749,25 @@ 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);
+		});
+		setTaskDefinitionResolver(this.tasks, (name) => this.taskDefinitions?.[name]);
 		this.mcp = this._withAgentSpan("agent_initialization", "initialization", {}, (update) => {
 			if (!wrappedClasses.has(this.constructor)) {
 				this._autoWrapCustomMethods();
@@ -823,7 +1788,7 @@ var Agent = class Agent extends DurableObject {
 				createAuthProvider: (callbackUrl) => this.createMcpOAuthProvider(callbackUrl)
 			});
 		});
-		this.lifecycle.use(this.scheduler).use(this.mcp);
+		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();
@@ -857,6 +1822,8 @@ var Agent = class Agent extends DurableObject {
 			await _onAlarm();
 			if (this._destroyed) return;
 			await this._onAlarmHousekeeping();
+			if (this._destroyed) return;
+			await this._syncHostJobs();
 		};
 		const _onRequest = this.onRequest.bind(this);
 		this.onRequest = (request) => {
@@ -869,9 +1836,9 @@ var Agent = class Agent extends DurableObject {
 		};
 		const _onMessage = this.onMessage.bind(this);
 		this.onMessage = async (connection, message) => {
-			const replyBridge = subAgentRpcReplyContext.getStore()?.bridge;
+			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,
@@ -885,34 +1852,17 @@ 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;
 						const methodFn = this[method];
 						if (typeof methodFn !== "function") throw new Error(`Method ${method} does not exist`);
 						if (!this._isCallable(method)) throw new Error(`Method ${method} is not callable`);
-						const metadata = callableMetadata.get(methodFn);
+						const metadata = getCallableMetadata(methodFn);
 						if (metadata?.streaming) {
-							const stream = createStreamingResponse(connection, id, replyBridge);
+							const stream = new StreamingResponse(connection, id);
+							if (replyBridge) registerFacetStreamingDelivery(stream, replyBridge);
 							this._emit("rpc", {
 								method,
 								streaming: true
@@ -966,7 +1916,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;
@@ -986,11 +1936,10 @@ 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.sendIdentity(connection, {
 							name: this.name,
-							agent: camelCaseToKebabCase(this._ParentClass.name),
-							type: "cf_agent_identity"
-						}));
+							agent: camelCaseToKebabCase(this._ParentClass.name)
+						});
 					}
 					const wasExcludedFromStateInitBroadcast = this._protocolBroadcastExcludeIds.has(connection.id);
 					let currentState;
@@ -1000,15 +1949,12 @@ var Agent = class Agent extends DurableObject {
 					} finally {
 						if (!wasExcludedFromStateInitBroadcast) this._protocolBroadcastExcludeIds.delete(connection.id);
 					}
-					if (currentState !== void 0) connection.send(JSON.stringify({
-						state: currentState,
-						type: "cf_agent_state"
-					}));
+					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));
@@ -1061,6 +2007,7 @@ var Agent = class Agent extends DurableObject {
 						console.warn("[Agent] `chatRecovery` was assigned during onStart(). Chat recovery evaluates its budgets (and may seal an interrupted turn, firing onExhausted) on wake BEFORE onStart() runs, so a config set here is applied too late and the built-in defaults are used for the recovery that matters. Assign `chatRecovery` as a class field or in the constructor instead.");
 					}
 					this._scheduleAgentToolRunRecovery({ runIds: startupAgentToolRunIds });
+					await this._syncHostJobs();
 					return result;
 				});
 			});
@@ -1068,18 +2015,7 @@ var Agent = class Agent extends DurableObject {
 		this.onStart = (props) => this._withAgentSpan("agent_start", "startup", {}, (update) => startAgent(props, update));
 	}
 	async _restoreAgentFacetContext() {
-		await this._withAgentSpan("restore_agent_state", "startup", {}, async () => {
-			if (await this.ctx.storage.get("cf_agents_is_facet")) this._isFacet = true;
-			const storedFacetName = await this.ctx.storage.get("cf_agents_facet_name");
-			if (typeof storedFacetName === "string") this._facetName = storedFacetName;
-			const storedParentPath = await this.ctx.storage.get("cf_agents_parent_path");
-			if (isValidParentPath(storedParentPath)) this._parentPath = storedParentPath;
-			try {
-				await this._cf_hydrateSubAgentConnectionsFromRoot();
-			} catch (error) {
-				console.warn("[Agent] Unable to hydrate sub-agent WebSocket connections:", error);
-			}
-		});
+		await this._withAgentSpan("restore_agent_state", "startup", {}, () => this._dynamicAgents.restoreFacetContext());
 	}
 	/**
 	* Check for workflows referencing unknown bindings and warn with migration suggestion.
@@ -1115,13 +2051,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"
@@ -1153,69 +2090,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
@@ -1223,17 +2098,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.
@@ -1244,8 +2109,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. ⚠️
@@ -1260,30 +2124,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
@@ -1324,21 +2178,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.
@@ -1534,7 +2374,7 @@ var Agent = class Agent extends DurableObject {
 				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)) callableMetadata.set(wrappedFunction, callableMetadata.get(this[methodName]));
+				if (this._isCallable(methodName)) copyCallableMetadata(this[methodName], wrappedFunction);
 				this.constructor.prototype[methodName] = wrappedFunction;
 			}
 			proto = Object.getPrototypeOf(proto);
@@ -1583,111 +2423,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
@@ -1695,100 +2466,32 @@ 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)
-		}));
-	}
-	_facetRunRowsForPrefix(ownerPath) {
-		return this.sql`
-      SELECT owner_path, owner_path_key, run_id, created_at
-      FROM cf_agents_facet_runs
-    `.filter((row) => {
-			try {
-				const rowOwnerPath = JSON.parse(row.owner_path);
-				return this._isSameAgentPathPrefix(ownerPath, rowOwnerPath);
-			} catch {
-				return false;
-			}
-		});
-	}
-	_deleteFacetRunRowsForPrefix(ownerPath) {
-		for (const row of this._facetRunRowsForPrefix(ownerPath)) this.sql`
-        DELETE FROM cf_agents_facet_runs
-        WHERE owner_path_key = ${row.owner_path_key}
-          AND run_id = ${row.run_id}
-      `;
+	async getQueues(key, value) {
+		return (await this._queue.list()).filter((item) => typeof item.payload === "object" && item.payload !== null && item.payload[key] === value);
 	}
 	_lifecycleRouteAddress() {
-		if (!this._isFacet) return void 0;
-		const key = agentPathKey(this.selfPath);
-		return key ? {
-			key,
-			data: JSON.stringify(this.selfPath)
-		} : void 0;
+		return this._dynamicAgents.lifecycleRouteAddress();
 	}
-	async _routeLifecycleToRoot(envelope) {
-		if (!this._isFacet) return this.lifecycle.route(envelope);
-		return (await this._rootAlarmOwner())._cf_routeLifecycle(void 0, envelope);
+	_routeLifecycleToRoot(envelope) {
+		return this._dynamicAgents.routeLifecycleToRoot(envelope);
 	}
-	async _routeLifecycleToTarget(target, envelope) {
-		let targetPath;
-		try {
-			targetPath = JSON.parse(target.data);
-		} catch {
-			throw new Error("Lifecycle route target is not a valid Agent path");
-		}
-		const selfPath = this.selfPath;
-		if (!this._isSameAgentPathPrefix(selfPath, targetPath)) throw new Error(`Lifecycle route does not descend from ${JSON.stringify(selfPath)}.`);
-		if (selfPath.length === targetPath.length) return this.lifecycle.route(envelope);
-		const next = targetPath[selfPath.length];
-		if (!this.hasSubAgent(next.className, next.name)) {
-			const stalePath = targetPath.slice(0, selfPath.length + 1);
-			if (this._isFacet) await (await this._rootAlarmOwner())._cf_cleanupFacetPrefix(stalePath);
-			else await this._cf_cleanupFacetPrefix(stalePath);
-			return false;
-		}
-		return (await this._cf_resolveSubAgent(next.className, next.name))._cf_routeLifecycle(target, envelope);
+	_routeLifecycleToTarget(target, envelope) {
+		return this._dynamicAgents.routeLifecycleToTarget(target, envelope);
 	}
 	/** Single native-RPC aperture for routed Lifecycle capabilities. */
-	_cf_routeLifecycle(target, envelope) {
-		return target ? this._routeLifecycleToTarget(target, envelope) : this.lifecycle.route(envelope);
-	}
-	async _rootAlarmOwner() {
-		const root = this._parentPath[0];
-		if (!root) throw new Error("Facet routing requires a root parent.");
-		const binding = 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);
+	_cf_routeLifecycle(target, envelope) {
+		return this._dynamicAgents.routeLifecycle(target, envelope);
 	}
-	_cf_rootResolvesToSelf() {
-		const root = this._parentPath[0];
-		if (!root) return false;
-		const binding = this.ctx.exports?.[root.className];
-		if (!binding?.idFromName) return false;
-		return binding.idFromName(root.name).equals(this.ctx.id);
+	_rootAlarmOwner() {
+		return this._dynamicAgents.rootAlarmOwner();
 	}
 	/**
 	* Clean root-owned bookkeeping for a sub-tree of facets. This
@@ -1801,33 +2504,24 @@ var Agent = class Agent extends DurableObject {
 	* @internal
 	*/
 	async _cf_cleanupFacetPrefix(ownerPath) {
-		const prefix = agentPathKey(ownerPath);
-		if (prefix) this.scheduler.__DO_NOT_USE_WILL_BREAK__cleanupRoutePrefix(prefix);
-		this._deleteFacetRunRowsForPrefix(ownerPath);
-		await this._rearmAlarm();
+		await this._dynamicAgents.cleanupPrefix(ownerPath);
 	}
 	/**
 	* Acquire a root-owned keepAlive ref on behalf of a descendant facet.
-	* Facets share the root isolate but cannot set their own physical
-	* alarm, so this lets facet work use the root alarm heartbeat.
+	* Facets run in separate colocated isolates but cannot set their own
+	* physical alarm, so this lets facet work use the root alarm heartbeat.
 	* @internal
 	*/
-	async _cf_acquireFacetKeepAlive(ownerPath) {
-		const token = `${agentPathKey(ownerPath) ?? "unknown"}:${nanoid(9)}`;
-		this._facetKeepAliveTokens.add(token);
-		this._keepAliveRefs++;
-		if (this._keepAliveRefs === 1) await this._rearmAlarm();
-		return token;
+	_cf_acquireFacetKeepAlive(ownerPath) {
+		return this._dynamicAgents.acquireKeepAlive(ownerPath);
 	}
 	/**
 	* Release a root-owned keepAlive ref previously acquired for a facet.
 	* Idempotent so disposer calls can safely race or run twice.
 	* @internal
 	*/
-	async _cf_releaseFacetKeepAlive(token) {
-		if (!this._facetKeepAliveTokens.delete(token)) return;
-		this._keepAliveRefs = Math.max(0, this._keepAliveRefs - 1);
-		await this._rearmAlarm();
+	_cf_releaseFacetKeepAlive(token) {
+		return this._dynamicAgents.releaseKeepAlive(token);
 	}
 	/**
 	* Register a facet's durable run row in the root-side index so root
@@ -1835,30 +2529,15 @@ var Agent = class Agent extends DurableObject {
 	* The facet remains authoritative for snapshots and recovery hooks.
 	* @internal
 	*/
-	async _cf_registerFacetRun(ownerPath, runId) {
-		const ownerPathJson = JSON.stringify(ownerPath);
-		const ownerPathKey = agentPathKey(ownerPath);
-		if (!ownerPathKey) throw new Error("_cf_registerFacetRun requires a non-empty owner path.");
-		this.sql`
-      INSERT OR REPLACE INTO cf_agents_facet_runs
-        (owner_path, owner_path_key, run_id, created_at)
-      VALUES
-        (${ownerPathJson}, ${ownerPathKey}, ${runId}, ${Date.now()})
-    `;
-		await this._rearmAlarm();
+	_cf_registerFacetRun(ownerPath, runId) {
+		return this._dynamicAgents.registerRun(ownerPath, runId);
 	}
 	/**
 	* Remove a completed facet fiber from the root-side index.
 	* @internal
 	*/
-	async _cf_unregisterFacetRun(ownerPath, runId) {
-		const ownerPathKey = agentPathKey(ownerPath);
-		this.sql`
-      DELETE FROM cf_agents_facet_runs
-      WHERE owner_path_key IS ${ownerPathKey}
-        AND run_id = ${runId}
-    `;
-		await this._rearmAlarm();
+	_cf_unregisterFacetRun(ownerPath, runId) {
+		return this._dynamicAgents.unregisterRun(ownerPath, runId);
 	}
 	/**
 	* Schedule a task to be executed in the future
@@ -2018,13 +2697,13 @@ var Agent = class Agent extends DurableObject {
 			};
 		}
 		this._keepAliveRefs++;
-		if (this._keepAliveRefs === 1) await this._rearmAlarm();
+		if (this._keepAliveRefs === 1) await this._syncHostJobs();
 		let disposed = false;
 		return () => {
 			if (disposed) return;
 			disposed = true;
 			this._keepAliveRefs = Math.max(0, this._keepAliveRefs - 1);
-			if (this._keepAliveRefs === 0) this.ctx.waitUntil(this._rearmAlarm().catch((e) => {
+			if (this._keepAliveRefs === 0) this.ctx.waitUntil(this._syncHostJobs().catch((e) => {
 				console.error("[Agent] Failed to reschedule alarm after keepAlive dispose:", e);
 			}));
 		};
@@ -2590,12 +3269,16 @@ 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}`;
-			});
+			try {
+				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}`;
+				});
+			} catch (error) {
+				console.error(`[Agent] Failed to finalize fiber "${name}" (${id}); leaving run row for recovery:`, error);
+			}
 			dispose();
 			if (root && registeredFacetRun) try {
 				await root._cf_unregisterFacetRun(this.selfPath, id);
@@ -2617,6 +3300,15 @@ var Agent = class Agent extends DurableObject {
 		ctx.stash(data);
 	}
 	/**
+	* Run `fn` inside the fiber stash context so `this.stash()` keeps working
+	* for turns executing on the `tasks` capability exactly as it does inside
+	* legacy `runFiber()` closures.
+	* @internal
+	*/
+	_withFiberStash(context, fn) {
+		return _fiberALS.run(context, fn);
+	}
+	/**
 	* Called when an interrupted fiber is detected after restart.
 	* Override to implement recovery (re-invoke work, notify clients, etc.).
 	*
@@ -2787,36 +3479,8 @@ var Agent = class Agent extends DurableObject {
 	* recovery hooks live in each facet's own `cf_agents_runs` table.
 	* @internal
 	*/
-	async _checkFacetRunFibers() {
-		if (this._parentPath.length > 0) return;
-		const rows = this.sql`
-      SELECT owner_path, owner_path_key, run_id, created_at
-      FROM cf_agents_facet_runs
-      ORDER BY created_at ASC
-    `;
-		const firstRowByOwner = /* @__PURE__ */ new Map();
-		for (const row of rows) if (!firstRowByOwner.has(row.owner_path_key)) firstRowByOwner.set(row.owner_path_key, row);
-		for (const row of firstRowByOwner.values()) {
-			let ownerPath;
-			try {
-				ownerPath = JSON.parse(row.owner_path);
-			} catch (e) {
-				console.warn(`[Agent] Corrupted facet fiber owner path for ${row.owner_path_key}; pruning stale lease.`, e);
-				this.sql`
-          DELETE FROM cf_agents_facet_runs
-          WHERE owner_path_key = ${row.owner_path_key}
-        `;
-				continue;
-			}
-			try {
-				if (await this._cf_checkRunFibersForFacet(ownerPath) === 0) this.sql`
-            DELETE FROM cf_agents_facet_runs
-            WHERE owner_path_key = ${row.owner_path_key}
-          `;
-			} catch (e) {
-				console.error(`[Agent] Facet fiber recovery check failed for ${row.owner_path_key}:`, e);
-			}
-		}
+	_checkFacetRunFibers() {
+		return this._dynamicAgents.checkRunFibers();
 	}
 	/**
 	* Dispatch a runFiber recovery check into the facet identified by
@@ -2824,18 +3488,8 @@ var Agent = class Agent extends DurableObject {
 	* rows on the target facet after recovery.
 	* @internal
 	*/
-	async _cf_checkRunFibersForFacet(ownerPath) {
-		const selfPath = this.selfPath;
-		if (!this._isSameAgentPathPrefix(selfPath, ownerPath)) throw new Error(`Facet fiber owner path does not descend from ${JSON.stringify(selfPath)}.`);
-		if (selfPath.length === ownerPath.length) {
-			await this._checkRunFibers();
-			return this.sql`
-        SELECT COUNT(*) as count FROM cf_agents_runs
-      `[0]?.count ?? 0;
-		}
-		const next = ownerPath[selfPath.length];
-		if (!this.hasSubAgent(next.className, next.name)) return 0;
-		return (await this._cf_resolveSubAgent(next.className, next.name))._cf_checkRunFibersForFacet(ownerPath);
+	_cf_checkRunFibersForFacet(ownerPath) {
+		return this._dynamicAgents.checkRunFibersAtPath(ownerPath);
 	}
 	/**
 	* Invoke an RPC method on this Agent or a descendant facet identified
@@ -2843,18 +3497,8 @@ var Agent = class Agent extends DurableObject {
 	* `this.agent` calls back to the exact sub-agent that started a workflow.
 	* @internal
 	*/
-	async _cf_invokeAgentPath(targetPath, method, args) {
-		await this.__unsafe_ensureInitialized();
-		const selfPath = this.selfPath;
-		if (!this._isSameAgentPathPrefix(selfPath, targetPath)) throw new Error(`Workflow origin path does not descend from ${JSON.stringify(selfPath)}.`);
-		if (selfPath.length === targetPath.length) {
-			const fn = this[method];
-			if (isInternalJsStubProp(method) || method in Object.prototype || typeof fn !== "function") throw new Error(`Workflow origin method "${method}" is not callable on ${this.constructor.name}.`);
-			return await fn.apply(this, args);
-		}
-		const next = targetPath[selfPath.length];
-		if (!this.hasSubAgent(next.className, next.name)) throw new Error(`Workflow origin sub-agent ${next.className} "${next.name}" no longer exists.`);
-		return await (await this._cf_resolveSubAgent(next.className, next.name))._cf_invokeAgentPath(targetPath, method, args);
+	_cf_invokeAgentPath(targetPath, method, args) {
+		return this._dynamicAgents.invokeAgentPath(targetPath, method, args);
 	}
 	/**
 	* Recursively destroy a descendant facet identified by
@@ -2869,25 +3513,8 @@ var Agent = class Agent extends DurableObject {
 	* cleanup as `parent.deleteSubAgent(Cls, name)` from the parent.
 	* @internal
 	*/
-	async _cf_destroyDescendantFacet(targetPath) {
-		const selfPath = this.selfPath;
-		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 (!this._isSameAgentPathPrefix(selfPath, targetPath)) throw new Error("_cf_destroyDescendantFacet: target path does not descend from this agent.");
-		if (this._parentPath.length === 0) await this._cf_cleanupFacetPrefix(targetPath);
-		if (selfPath.length === targetPath.length - 1) {
-			const target = targetPath[targetPath.length - 1];
-			const ctx = 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.");
-			try {
-				ctx.facets.delete(`${target.className}\0${target.name}`);
-			} catch {}
-			this._forgetSubAgent(target.className, target.name);
-			return;
-		}
-		const next = targetPath[selfPath.length];
-		if (!this.hasSubAgent(next.className, next.name)) return;
-		await (await this._cf_resolveSubAgent(next.className, next.name))._cf_destroyDescendantFacet(targetPath);
+	_cf_destroyDescendantFacet(targetPath) {
+		return this._dynamicAgents.destroyDescendant(targetPath);
 	}
 	/**
 	* Whether any runFiber recovery work is still outstanding: orphaned
@@ -2895,7 +3522,7 @@ var Agent = class Agent extends DurableObject {
 	* executing in memory, which already hold a keepAlive ref) or managed
 	* ledger fibers stuck in a non-terminal state with no live run row.
 	*
-	* Used by `_rearmAlarm` to arm a follow-up alarm so multi-pass
+	* Used by `_syncHostJobs` to arm a follow-up alarm so multi-pass
 	* recovery (e.g. after a scan-deadline yield, or while retrying a throwing
 	* recovery hook) resumes instead of starving.
 	* @internal
@@ -2913,28 +3540,57 @@ var Agent = class Agent extends DurableObject {
         AND r.id IS NULL
     `[0]?.count ?? 0) > 0;
 	}
-	async _rearmAlarm() {
-		await this._withAgentSpan("schedule_agent_alarm", "alarm", {}, () => this.lifecycle.rearmAlarm());
-	}
 	/**
-	* Contribute Agent-owned alarm work that has not yet been extracted into its
-	* own capability. Scheduler contributes independently.
+	* Synchronize Agent-owned host jobs with current durable state.
+	*
+	* Replaces the old pull-based `getNextAlarm()` contribution: keep-alive
+	* refs hold a `cf:keep-alive` job, and fiber-recovery / facet-run state
+	* holds a `cf:housekeeping` job. Every state change that used to trigger
+	* an alarm recalculation now re-pushes or cancels these jobs; queue
+	* mutations re-arm the physical alarm automatically.
 	* @internal
 	*/
-	async getNextAlarm() {
-		const pendingDestroy = await this._pendingDestroyAlarm();
-		if (pendingDestroy !== null) return {
-			time: pendingDestroy,
-			exclusive: true
-		};
-		const nowMs = Date.now();
+	async _syncHostJobs() {
+		if (this._destroyed) return;
+		await this._withAgentSpan("schedule_agent_alarm", "alarm", {}, async () => {
+			const work = this.lifecycle.jobs;
+			const nowMs = Date.now();
+			const pendingDestroy = await this._pendingDestroyAlarm();
+			if (pendingDestroy !== null) {
+				await work.push({
+					id: HOST_JOB_DESTROY_ID,
+					fn: "destroy",
+					time: pendingDestroy,
+					exclusive: true
+				});
+				return;
+			}
+			if (work.get(HOST_JOB_DESTROY_ID)) await work.cancel(HOST_JOB_DESTROY_ID);
+			if (this._keepAliveRefs > 0) await work.push({
+				id: HOST_JOB_KEEP_ALIVE_ID,
+				fn: "keepAlive",
+				time: nowMs + this._resolvedOptions.keepAliveIntervalMs
+			});
+			else if (work.get(HOST_JOB_KEEP_ALIVE_ID)) await work.cancel(HOST_JOB_KEEP_ALIVE_ID);
+			const housekeepingAt = this._nextHousekeepingWakeMs(nowMs);
+			if (housekeepingAt !== null) await work.push({
+				id: HOST_JOB_HOUSEKEEPING_ID,
+				fn: "housekeeping",
+				time: housekeepingAt
+			});
+			else if (work.get(HOST_JOB_HOUSEKEEPING_ID)) await work.cancel(HOST_JOB_HOUSEKEEPING_ID);
+		});
+	}
+	/**
+	* The next wake fiber-recovery or facet-run housekeeping needs, or `null`
+	* when neither has pending durable state.
+	*/
+	_nextHousekeepingWakeMs(nowMs) {
 		let nextTimeMs = null;
-		if (this._keepAliveRefs > 0) nextTimeMs = nowMs + this._resolvedOptions.keepAliveIntervalMs;
 		if (this._hasPendingFiberRecovery()) {
 			const base = this._resolvedOptions.keepAliveIntervalMs;
 			const exp = Math.min(this._recoveryNoProgressScans, FIBER_RECOVERY_BACKOFF_MAX_EXP);
-			const recoveryMs = nowMs + Math.min(FIBER_RECOVERY_MAX_BACKOFF_MS, base * 2 ** exp);
-			nextTimeMs = nextTimeMs === null ? recoveryMs : Math.min(nextTimeMs, recoveryMs);
+			nextTimeMs = nowMs + Math.min(FIBER_RECOVERY_MAX_BACKOFF_MS, base * 2 ** exp);
 		}
 		if ((this.sql`
       SELECT COUNT(*) as count FROM cf_agents_facet_runs
@@ -2942,132 +3598,68 @@ var Agent = class Agent extends DurableObject {
 			const facetRecoveryMs = nowMs + this._resolvedOptions.keepAliveIntervalMs;
 			nextTimeMs = nextTimeMs === null ? facetRecoveryMs : Math.min(nextTimeMs, facetRecoveryMs);
 		}
-		const extensionAlarm = await this._getExtensionAlarm();
-		if (extensionAlarm !== null) nextTimeMs = nextTimeMs === null ? extensionAlarm : Math.min(nextTimeMs, extensionAlarm);
 		return nextTimeMs;
 	}
-	/** @internal Transitional alarm contribution for Agent subclasses. */
-	_getExtensionAlarm() {
-		return null;
-	}
 	/** Lifecycle alarm callback; Agent housekeeping runs after user alarm work. */
 	onAlarm() {}
 	/**
-	* Run Lifecycle's alarm phase inside Agent's memory-limit circuit breaker.
-	*
-	* @remarks Use `this.schedule()` for named Agent callbacks. Reusable durable
-	* work belongs in a capability with `getNextAlarm()` and `onAlarm()`.
+	* Drive one Agent-owned host job from the Lifecycle queue.
+	* @internal Dispatched by Lifecycle's alarm event loop; extensions add
+	* job fns through {@link _onHostJob}.
 	*/
-	async alarm() {
-		if (await this._hasPendingDestroy()) {
-			await this.destroy();
-			return;
-		}
-		try {
-			await this._cf_runAlarmBody();
-			await this._cf_clearAlarmMemoryLimitStrikes();
-		} catch (error) {
-			if (!isDurableObjectMemoryLimitReset(error)) throw error;
-			await this._cf_handleAlarmMemoryLimitReset(error);
-		}
-	}
-	/** Run the Lifecycle alarm phase inside Agent's OOM circuit breaker. */
-	async _cf_runAlarmBody() {
-		await this.lifecycle.alarm();
+	onJob(context) {
+		return this._onHostJob(context.job.fn, context);
 	}
 	/**
-	* The schedule-callback names whose alarm rows drive a recovery loop that can
-	* deterministically OOM. The base agent has none; chat hosts (`Think`,
-	* `AIChatAgent`) override this to return their recovery continuation callbacks
-	* so the circuit breaker can surgically back them off / purge them WITHOUT
-	* disturbing unrelated scheduled tasks. See {@link _cf_handleAlarmMemoryLimitReset}.
+	* @internal Dispatch one host job fn. Agent extensions (Think) override
+	* this to add fns and delegate unknown ones to `super`.
 	*/
-	_cf_recoveryAlarmCallbacks() {
-		return [];
+	_onHostJob(fn, _context) {
+		switch (fn) {
+			case "keepAlive": return this._keepAliveRefs > 0 ? { rescheduleAt: Date.now() + this._resolvedOptions.keepAliveIntervalMs } : void 0;
+			case "housekeeping": {
+				const next = this._nextHousekeepingWakeMs(Date.now());
+				return next === null ? void 0 : { rescheduleAt: next };
+			}
+			case "destroy": return;
+			default:
+				console.warn(`Unknown Agent host job fn ${JSON.stringify(fn)}`);
+				return;
+		}
 	}
 	/**
-	* Hook for a host to terminalize ("seal") any in-flight recovery work as an
-	* out-of-memory exhaustion when the alarm circuit breaker trips at its strike
-	* budget (#1825). Runs at the outermost alarm frame (post-unwind, so writes
-	* can land). Default: no-op. Chat hosts override to fire `onExhausted` + the
-	* terminal banner and persist the sealed incident.
-	*/
-	async _cf_sealMemoryLimitedRecovery() {}
-	/**
-	* Clear the durable memory-limit strike counter after a clean alarm so the
-	* circuit breaker counts CONSECUTIVE resets rather than lifetime ones
-	* (#1825). Reads first (cheap, usually cached) and only writes when a strike
-	* is actually recorded, so the common no-strike path costs no write.
-	* Best-effort: a stale strike only costs one extra tolerated spike later.
+	* Apply host policy after the alarm memory-limit breaker records a strike.
+	*
+	* New chat hosts override this hook directly. The sealed-only fallback keeps
+	* `agents` 0.23 compatible with already-published chat packages whose peer
+	* ranges accept it but which implement only the former
+	* `_cf_sealMemoryLimitedRecovery` template method. Queue membership remains
+	* job-row policy; this invokes terminalization only and can be removed once
+	* old chat releases no longer accept the current `agents` range.
+	*
+	* @internal
 	*/
-	async _cf_clearAlarmMemoryLimitStrikes() {
-		try {
-			const prior = await this.ctx.storage.get(Agent._CF_OOM_ALARM_STRIKES_KEY);
-			if (typeof prior === "number" && prior > 0) await this.ctx.storage.delete(Agent._CF_OOM_ALARM_STRIKES_KEY);
-		} catch {}
+	async onAlarmMemoryLimit(context) {
+		if (!context.sealed) return;
+		await this._cf_sealMemoryLimitedRecovery?.call(this);
 	}
 	/**
-	* Alarm-boundary circuit breaker for Durable Object memory-limit resets
-	* (#1825). The in-DO recovery budgets (`chatRecovery.maxOomRetries` /
-	* `maxRecoveryWork`) only engage if their code runs AND its writes land; a
-	* severe OOM can defeat both — thrown before the budget runs (boot hydration),
-	* or its own small writes also OOM under memory pressure. In that case the
-	* error reaches {@link alarm} and, unhandled, the platform auto-retries the
-	* alarm indefinitely (re-running the doomed, billable turn each cycle).
-	*
-	* This runs at the OUTERMOST frame: the heavy turn has unwound and GC has
-	* reclaimed its footprint, so the small writes here can land where mid-turn
-	* ones (e.g. give-up's incident read) OOMed. A durable strike counter tolerates
-	* a few resets (a transient spike may clear), backing off the recovery rows so
-	* the retry is not a hot loop. At the `maxAlarmMemoryLimitStrikes` budget it
-	* seals the recovery work and purges the looping rows so the loop — and the
-	* bill — stops. Each step is best-effort: even these tiny writes can OOM, but
-	* swallowing (not re-throwing) still halts the platform's auto-retry, and a
-	* later wake re-arms legitimate schedules.
-	*/
-	async _cf_handleAlarmMemoryLimitReset(error) {
-		const key = Agent._CF_OOM_ALARM_STRIKES_KEY;
-		let strikes = 1;
-		try {
-			const prior = await this.ctx.storage.get(key);
-			strikes = (typeof prior === "number" ? prior : 0) + 1;
-			await this.ctx.storage.put(key, strikes);
-		} catch {}
-		const limit = this._resolvedOptions.maxAlarmMemoryLimitStrikes;
-		const sealed = strikes >= limit;
-		const recoveryCallbacks = this._cf_recoveryAlarmCallbacks();
-		console.error(`Alarm hit a Durable Object memory-limit reset (strike ${strikes}/${limit}${sealed ? ", sealing recovery" : ", will retry with backoff"}). Breaking the platform alarm-retry loop (#1825).`, error instanceof Error ? error.message : String(error));
-		if (sealed) {
-			this.scheduler.__DO_NOT_USE_WILL_BREAK__handleAlarmMemoryLimit({
-				callbacks: recoveryCallbacks,
-				sealed: true
-			});
-			try {
-				await this._cf_sealMemoryLimitedRecovery();
-			} catch {}
-			try {
-				await this.ctx.storage.delete(key);
-			} catch {}
-		} else {
-			const backoffSeconds = Math.min(300, 30 * strikes);
-			const nextTime = Math.floor(Date.now() / 1e3) + backoffSeconds;
-			this.scheduler.__DO_NOT_USE_WILL_BREAK__handleAlarmMemoryLimit({
-				callbacks: recoveryCallbacks,
-				sealed: false,
-				nextTime
-			});
+	* Run Lifecycle's alarm event loop after the pending-destroy preamble.
+	*
+	* The alarm memory-limit circuit breaker (#1825) lives inside
+	* `Lifecycle.alarm()`; capabilities and hosts opt into extra domain
+	* policy via their `onMemoryLimit` / `onAlarmMemoryLimit` hooks and the
+	* `recoveryLoop` schedule option.
+	*
+	* @remarks Use `this.schedule()` for named Agent callbacks. Reusable durable
+	* work belongs in a capability that pushes jobs and implements `onJob()`.
+	*/
+	async alarm() {
+		if (await this._hasPendingDestroy()) {
+			await this.destroy();
+			return;
 		}
-		try {
-			this._emit("alarm:memory_limit_reset", {
-				strikes,
-				limit,
-				sealed,
-				error: error instanceof Error ? error.message : String(error)
-			});
-		} catch {}
-		try {
-			await this._rearmAlarm();
-		} catch {}
+		await this.lifecycle.alarm();
 	}
 	/**
 	* Intercept incoming HTTP/WS requests whose URL contains a
@@ -3077,9 +3669,9 @@ var Agent = class Agent extends DurableObject {
 	* Response, the framework resolves the facet and hands the
 	* request off.
 	*
-	* After a WebSocket upgrade completes, subsequent frames route
-	* directly to the child — the parent is only on the path for the
-	* initial request.
+	* The parent owns an upgraded WebSocket for its lifetime. Subsequent
+	* frames wake the root parent, which forwards them to the child over
+	* RPC and routes replies back to the native socket.
 	*
 	* @experimental The API surface may change before stabilizing.
 	*/
@@ -3104,409 +3696,80 @@ var Agent = class Agent extends DurableObject {
 	}
 	broadcast(msg, without) {
 		if (this._isFacet) {
-			this._cf_broadcastToParentSubAgent(msg, without);
+			this._dynamicAgents.broadcastToParent(msg, without);
 			return;
 		}
-		for (const connection of this.lifecycle.getConnections()) {
+		for (const connection of this._webSockets.getConnections()) {
 			if (without?.includes(connection.id)) continue;
-			if (this._cf_connectionHasSubAgentTarget(connection)) continue;
+			if (this._dynamicAgents.connectionHasChildTarget(connection)) continue;
 			connection.send(msg);
 		}
 	}
 	getConnection(id) {
-		if (this._isFacet) {
-			const stored = this._cf_virtualSubAgentConnections.get(id);
-			if (stored) return this._cf_createSubAgentBridgeConnection(stored.meta);
-			return;
-		}
-		const connection = this.lifecycle.getConnection(id);
-		if (!connection || this._cf_connectionHasSubAgentTarget(connection)) return;
+		if (this._isFacet) return this._dynamicAgents.getVirtualConnection(id);
+		const connection = this._webSockets.getConnection(id);
+		if (!connection || this._dynamicAgents.connectionHasChildTarget(connection)) return;
 		return connection;
 	}
 	*getConnections(tag) {
 		if (this._isFacet) {
-			for (const stored of this._cf_virtualSubAgentConnections.values()) if (!tag || stored.meta.tags.includes(tag)) yield this._cf_createSubAgentBridgeConnection(stored.meta);
+			yield* this._dynamicAgents.getVirtualConnections(tag);
 			return;
 		}
-		for (const connection of this.lifecycle.getConnections(tag)) {
-			if (this._cf_connectionHasSubAgentTarget(connection)) continue;
+		for (const connection of this._webSockets.getConnections(tag)) {
+			if (this._dynamicAgents.connectionHasChildTarget(connection)) continue;
 			yield connection;
 		}
 	}
-	_cf_activeSubAgentBridge(connectionId) {
-		const context = this._cf_subAgentBridgeContext.getStore();
-		if (connectionId !== void 0 && context?.connectionId !== connectionId) return;
-		return context?.bridge;
-	}
-	/**
-	* Route a virtual sub-agent connection operation through its live frame
-	* bridge, or through the durable root Agent after that frame completes.
-	* All operations share one per-connection queue. Facet broadcasts wait for
-	* older queued operations; failures do not block later work.
-	*/
-	_cf_routeSubAgentConnectionOperation(connectionId, operationName, operation) {
-		const activeBridge = this._cf_activeSubAgentBridge(connectionId);
-		const previousConnectionOperation = this._cf_subAgentConnectionOperationTails.get(connectionId);
-		let pending;
-		if (activeBridge && !previousConnectionOperation) try {
-			pending = Promise.resolve(operation(activeBridge)).then(() => {});
-		} catch (error) {
-			pending = Promise.reject(error);
-		}
-		else pending = (previousConnectionOperation ?? Promise.resolve()).then(async () => {
-			await operation(new RootSubAgentConnectionBridge(await this._rootAlarmOwner(), connectionId));
-		});
-		const completion = pending.catch((error) => {
-			this._cf_reportSubAgentConnectionOperationFailure(connectionId, operationName, error);
-		});
-		this._cf_subAgentConnectionOperationTails.set(connectionId, completion);
-		this.ctx.waitUntil(completion);
-		completion.then(() => {
-			if (this._cf_subAgentConnectionOperationTails.get(connectionId) === completion) this._cf_subAgentConnectionOperationTails.delete(connectionId);
-		});
-	}
-	/**
-	* Route a facet broadcast after every older connection operation.
-	*
-	* This barrier is intentionally one-way: facet startup can broadcast before
-	* a child connection has finished initializing its tags and protocol flags.
-	* Making those later connection operations wait would let the next frame
-	* observe stale root-owned metadata.
-	*/
-	async _cf_routeSubAgentBroadcast(ownerPath, message, without, upstreamBridge) {
-		const activeBridge = upstreamBridge ?? this._cf_activeSubAgentBridge();
-		const previousOperations = /* @__PURE__ */ new Set([...this._cf_subAgentBroadcastOperationTail ? [this._cf_subAgentBroadcastOperationTail] : [], ...this._cf_subAgentConnectionOperationTails.values()]);
-		let pending;
-		if (activeBridge && previousOperations.size === 0) try {
-			pending = Promise.resolve(activeBridge.broadcast(ownerPath, message, without));
-		} catch (error) {
-			pending = Promise.reject(error);
-		}
-		else pending = Promise.all(previousOperations).then(async () => {
-			await (await this._rootAlarmOwner())._cf_broadcastToSubAgent(ownerPath, message, without);
-		});
-		const completion = pending.catch((error) => {
-			console.error("[Agent] Sub-agent broadcast operation failed:", {
-				operation: "broadcast",
-				error
-			});
-		});
-		this._cf_subAgentBroadcastOperationTail = completion;
-		this.ctx.waitUntil(completion);
-		completion.then(() => {
-			if (this._cf_subAgentBroadcastOperationTail === completion) this._cf_subAgentBroadcastOperationTail = void 0;
-		});
-		await completion;
-	}
-	_cf_reportSubAgentConnectionOperationFailure(connectionId, operation, error) {
-		console.error("[Agent] Sub-agent connection operation failed:", {
-			connectionId,
-			operation,
-			error
-		});
-	}
-	async _cf_broadcastToParentSubAgent(message, without) {
-		await this._cf_routeSubAgentBroadcast(this.selfPath, message, without);
-	}
 	async _cf_broadcastToSubAgent(ownerPath, message, without) {
-		if (this._isFacet) {
-			await this._cf_routeSubAgentBroadcast(ownerPath, message, without);
-			return;
-		}
-		for (const connection of this.lifecycle.getConnections()) {
-			if (without?.includes(connection.id)) continue;
-			const targetPath = this._cf_subAgentTargetPath(connection);
-			if (!targetPath) continue;
-			if (!this._isSameAgentPath(targetPath, ownerPath)) continue;
-			connection.send(message);
-		}
-	}
-	async _cf_subAgentConnectionMetas(ownerPath) {
-		const metas = [];
-		for (const connection of this.lifecycle.getConnections()) {
-			const meta = this._cf_subAgentConnectionMetaForPath(connection, ownerPath);
-			if (meta) metas.push(meta);
-		}
-		return metas;
-	}
-	async _cf_sendToSubAgentConnection(connectionId, message) {
-		const connection = this.lifecycle.getConnection(connectionId);
-		if (!connection || !this._cf_connectionHasSubAgentTarget(connection)) return;
-		connection.send(message);
-	}
-	async _cf_closeSubAgentConnection(connectionId, code, reason) {
-		const connection = this.lifecycle.getConnection(connectionId);
-		if (!connection || !this._cf_connectionHasSubAgentTarget(connection)) return;
-		connection.close(code, reason);
-	}
-	async _cf_setSubAgentConnectionState(connectionId, state) {
-		const connection = this.lifecycle.getConnection(connectionId);
-		if (!connection || !this._cf_connectionHasSubAgentTarget(connection)) return null;
-		this._ensureConnectionWrapped(connection);
-		connection.setState(state);
-		return this._cf_getForwardedSubAgentState(connection);
-	}
-	_cf_subAgentConnectionMetaForPath(connection, ownerPath) {
-		this._ensureConnectionWrapped(connection);
-		const outerUri = this._unsafe_getConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY);
-		if (typeof outerUri !== "string") return null;
-		const target = this._cf_subAgentPathFromOuterUri(outerUri, ownerPath);
-		if (!target) return null;
-		const raw = this._cf_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 {
-			id: connection.id,
-			uri: target.uri,
-			tags,
-			state: this._cf_getForwardedSubAgentState(connection)
-		};
-	}
-	_cf_subAgentTargetPath(connection) {
-		this._ensureConnectionWrapped(connection);
-		const outerUri = this._unsafe_getConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY);
-		if (typeof outerUri !== "string") return null;
-		return this._cf_subAgentPathFromOuterUri(outerUri)?.path ?? null;
-	}
-	_cf_subAgentPathFromOuterUri(outerUri, stopAt) {
-		const ctx = this.ctx;
-		const knownClasses = ctx.exports ? Object.keys(ctx.exports) : void 0;
-		const path = [...this.selfPath];
-		let currentUrl = outerUri;
-		while (true) {
-			const match = parseSubAgentPath(currentUrl, { knownClasses });
-			if (!match) break;
-			path.push({
-				className: match.childClass,
-				name: match.childName
-			});
-			const rewritten = new URL(currentUrl);
-			rewritten.pathname = match.remainingPath;
-			currentUrl = rewritten.toString();
-			if (stopAt && this._isSameAgentPath(path, stopAt)) return {
-				path,
-				uri: currentUrl
-			};
-		}
-		if (path.length === this.selfPath.length) return null;
-		if (stopAt) return null;
-		return {
-			path,
-			uri: currentUrl
-		};
-	}
-	_isSameAgentPath(a, b) {
-		if (a.length !== b.length) return false;
-		return a.every((step, index) => step.className === b[index]?.className && step.name === b[index]?.name);
-	}
-	_cf_connectionHasSubAgentTarget(connection) {
-		this._ensureConnectionWrapped(connection);
-		return typeof this._unsafe_getConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY) === "string";
-	}
-	_cf_connectionTargetsSubAgent(connection) {
-		if (!connection.uri) return false;
-		const ctx = this.ctx;
-		return parseSubAgentPath(connection.uri, { knownClasses: ctx.exports ? Object.keys(ctx.exports) : void 0 }) !== null;
-	}
-	/**
-	* Returns true when the current request is addressed to a child facet of
-	* this agent rather than to this agent itself.
-	*
-	* Chat-style subclasses wrap `onConnect` before the base Agent forwarding
-	* wrapper runs, so they need a request-level check to avoid sending their
-	* own protocol frames on sockets that are about to be forwarded to a child.
-	*/
-	_cf_requestTargetsSubAgent(request) {
-		const ctx = this.ctx;
-		return parseSubAgentPath(request.url, { knownClasses: ctx.exports ? Object.keys(ctx.exports) : void 0 }) !== null;
-	}
-	async _cf_forwardSubAgentWebSocketConnect(connection, request, options) {
-		const routed = await this._cf_resolveSubAgentConnection(connection, request, options);
-		if (!routed) return false;
-		await routed.child._cf_handleSubAgentWebSocketConnect(this._cf_createSubAgentConnectionBridge(connection), routed.meta);
-		return true;
+		await this._dynamicAgents.broadcastToPath(ownerPath, message, without);
 	}
-	_cf_createSubAgentConnectionBridge(connection) {
-		const upstreamBroadcastBridge = this._isFacet ? this._cf_activeSubAgentBridge(connection.id) : void 0;
-		return new SubAgentConnectionBridge(connection, (ownerPath, message, without) => {
-			if (upstreamBroadcastBridge) return this._cf_routeSubAgentBroadcast(ownerPath, message, without, upstreamBroadcastBridge);
-			return this._cf_broadcastToSubAgent(ownerPath, message, without);
-		});
+	_cf_subAgentConnectionMetas(ownerPath) {
+		return this._dynamicAgents.connectionMetas(ownerPath);
 	}
-	async _cf_forwardSubAgentWebSocketMessage(connection, message, replyBridge) {
-		const routed = await this._cf_resolveSubAgentConnection(connection);
-		if (!routed) return false;
-		const bridge = this._cf_createSubAgentConnectionBridge(connection);
-		await routed.child._cf_handleSubAgentWebSocketMessage(message, bridge, routed.meta, replyBridge ?? bridge);
-		return true;
+	_cf_sendToSubAgentConnection(connectionId, message) {
+		return this._dynamicAgents.sendToConnection(connectionId, message);
 	}
-	async _cf_forwardSubAgentWebSocketClose(connection, code, reason, wasClean) {
-		const routed = await this._cf_resolveSubAgentConnection(connection);
-		if (!routed) return false;
-		await routed.child._cf_handleSubAgentWebSocketClose(code, reason, wasClean, this._cf_createSubAgentConnectionBridge(connection), routed.meta);
-		return true;
+	_cf_closeSubAgentConnection(connectionId, code, reason) {
+		return this._dynamicAgents.closeConnection(connectionId, code, reason);
 	}
-	async _cf_resolveSubAgentConnection(connection, request, options = { gate: false }) {
-		this._ensureConnectionWrapped(connection);
-		const outerUri = this._unsafe_getConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY);
-		const uri = typeof outerUri === "string" ? outerUri : connection.uri;
-		if (!uri) return null;
-		const ctx = this.ctx;
-		let match = parseSubAgentPath(uri, { knownClasses: ctx.exports ? Object.keys(ctx.exports) : void 0 });
-		if (!match) return null;
-		if (this._ParentClass.name === match.childClass && 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;
-		}
-		let forwardReq = request;
-		if (request && options.gate) {
-			const decision = await this.onBeforeSubAgent(request, {
-				className: match.childClass,
-				name: match.childName
-			});
-			if (decision instanceof Response) {
-				connection.close(1008, "Sub-agent connection rejected");
-				return null;
-			}
-			forwardReq = decision instanceof Request ? decision : request;
-		}
-		const child = await this._cf_resolveSubAgent(match.childClass, match.childName);
-		const childUri = new URL(forwardReq?.url ?? uri);
-		childUri.pathname = match.remainingPath;
-		const raw = this._cf_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 {
-			child,
-			meta: {
-				id: connection.id,
-				uri: childUri.toString(),
-				tags,
-				state: this._cf_getForwardedSubAgentState(connection),
-				requestHeaders: forwardReq ? [...forwardReq.headers] : void 0
-			}
-		};
+	_cf_setSubAgentConnectionState(connectionId, state) {
+		return this._dynamicAgents.setConnectionState(connectionId, state);
 	}
-	async _cf_handleSubAgentWebSocketConnect(bridge, meta) {
-		await this._cf_runWithSubAgentBridge(bridge, meta.id, async () => {
-			const connection = this._cf_createSubAgentBridgeConnection(meta);
-			const request = new Request(meta.uri ?? "http://placeholder/", { headers: meta.requestHeaders });
-			if (await this._cf_forwardSubAgentWebSocketConnect(connection, request, { gate: true })) return;
-			if (this.shouldConnectionBeReadonly(connection, { request })) this.setConnectionReadonly(connection, true);
-			if (!this.shouldSendProtocolMessages(connection, { request })) this._setConnectionNoProtocol(connection);
-			const childTags = await this.getConnectionTags(connection, { request });
-			connection.tags = [connection.id, ...childTags.filter((tag) => tag !== connection.id)];
-			this._cf_storeVirtualSubAgentConnection(connection);
-			await this.onConnect(connection, { request });
-			this._cf_storeVirtualSubAgentConnection(connection);
-		});
+	_cf_connectionTargetsSubAgent(connection) {
+		return this._dynamicAgents.connectionTargetsChild(connection);
 	}
-	async _cf_handleSubAgentWebSocketMessage(message, bridge, meta, replyBridge = bridge) {
-		const connection = this._cf_createSubAgentBridgeConnection(meta);
-		this._cf_storeVirtualSubAgentConnection(connection);
-		const replyContext = { bridge: replyBridge };
-		try {
-			await subAgentRpcReplyContext.run(replyContext, () => this._cf_runWithSubAgentBridge(bridge, meta.id, () => this.onMessage(connection, message)));
-		} finally {
-			replyContext.bridge = void 0;
-		}
+	/**
+	* Returns true when the current request is addressed to a child facet of
+	* this agent rather than to this agent itself.
+	*
+	* Chat-style subclasses wrap `onConnect` before the base Agent forwarding
+	* wrapper runs, so they need a request-level check to avoid sending their
+	* own protocol frames on sockets that are about to be forwarded to a child.
+	*/
+	_cf_requestTargetsSubAgent(request) {
+		return this._dynamicAgents.requestTargetsChild(request);
 	}
-	async _cf_handleSubAgentWebSocketClose(code, reason, wasClean, bridge, meta) {
-		const connection = this._cf_createSubAgentBridgeConnection(meta);
-		this._cf_storeVirtualSubAgentConnection(connection);
-		await this._cf_runWithSubAgentBridge(bridge, meta.id, () => this.onClose(connection, code, reason, wasClean));
-		this._cf_virtualSubAgentConnections.delete(meta.id);
+	_cf_forwardSubAgentWebSocketConnect(connection, request, options) {
+		return this._dynamicAgents.forwardWebSocketConnect(connection, request, options);
 	}
-	async _cf_runWithSubAgentBridge(bridge, connectionId, fn) {
-		const context = {
-			bridge,
-			connectionId
-		};
-		try {
-			return await this._cf_subAgentBridgeContext.run(context, fn);
-		} finally {
-			context.bridge = void 0;
-		}
+	_cf_forwardSubAgentWebSocketMessage(connection, message, replyBridge) {
+		return this._dynamicAgents.forwardWebSocketMessage(connection, message, replyBridge);
 	}
-	_cf_createSubAgentBridgeConnection(meta) {
-		let stored = this._cf_virtualSubAgentConnections.get(meta.id);
-		if (stored) {
-			stored.meta = meta;
-			if (stored.connection) {
-				stored.connection.uri = meta.uri;
-				stored.connection.tags = meta.tags;
-				return stored.connection;
-			}
-		} else {
-			stored = { meta };
-			this._cf_virtualSubAgentConnections.set(meta.id, stored);
-		}
-		const owner = this;
-		const getStored = () => this._cf_virtualSubAgentConnections.get(meta.id) ?? stored;
-		const updateStoredState = (nextState) => {
-			const current = this._cf_virtualSubAgentConnections.get(meta.id);
-			if (current) current.meta = {
-				...current.meta,
-				state: nextState
-			};
-		};
-		const connection = {
-			id: meta.id,
-			uri: meta.uri,
-			tags: meta.tags,
-			get state() {
-				return getStored().meta.state;
-			},
-			setState(next) {
-				const currentState = getStored().meta.state;
-				const state = typeof next === "function" ? next(currentState) : next;
-				updateStoredState(state);
-				owner._cf_routeSubAgentConnectionOperation(meta.id, "setState", (bridge) => bridge.setState(state));
-				return state;
-			},
-			send(message) {
-				owner._cf_routeSubAgentConnectionOperation(meta.id, "send", (bridge) => bridge.send(message));
-			},
-			close(code, reason) {
-				owner._cf_routeSubAgentConnectionOperation(meta.id, "close", (bridge) => bridge.close(code, reason));
-			},
-			addEventListener() {},
-			removeEventListener() {}
-		};
-		stored.connection = connection;
-		this._ensureConnectionWrapped(connection);
-		return connection;
+	_cf_forwardSubAgentWebSocketClose(connection, code, reason, wasClean) {
+		return this._dynamicAgents.forwardWebSocketClose(connection, code, reason, wasClean);
 	}
-	_cf_storeVirtualSubAgentConnection(connection) {
-		this._unsafe_setConnectionFlag(connection, CF_SUB_AGENT_TAGS_KEY, [...connection.tags]);
-		const stored = this._cf_virtualSubAgentConnections.get(connection.id);
-		this._cf_virtualSubAgentConnections.set(connection.id, {
-			meta: {
-				id: connection.id,
-				uri: connection.uri,
-				tags: [...connection.tags],
-				state: this._cf_getRawConnectionState(connection)
-			},
-			connection: stored?.connection ?? connection
-		});
+	_cf_handleSubAgentWebSocketConnect(bridge, meta) {
+		return this._dynamicAgents.handleWebSocketConnect(bridge, meta);
 	}
-	async _cf_hydrateSubAgentConnectionsFromRoot() {
-		if (!this._isFacet || this._parentPath.length === 0) return;
-		if (this._cf_rootResolvesToSelf()) return;
-		const metas = await (await this._rootAlarmOwner())._cf_subAgentConnectionMetas(this.selfPath);
-		for (const meta of metas) this._cf_virtualSubAgentConnections.set(meta.id, { meta });
+	_cf_handleSubAgentWebSocketMessage(message, bridge, meta, replyBridge = bridge) {
+		return this._dynamicAgents.handleWebSocketMessage(message, bridge, meta, replyBridge);
 	}
-	_cf_getRawConnectionState(connection) {
-		this._ensureConnectionWrapped(connection);
-		return this._rawStateAccessors.get(connection)?.getRaw() ?? null;
+	_cf_handleSubAgentWebSocketClose(code, reason, wasClean, bridge, meta) {
+		return this._dynamicAgents.handleWebSocketClose(code, reason, wasClean, bridge, meta);
 	}
-	_cf_getForwardedSubAgentState(connection) {
-		const raw = this._cf_getRawConnectionState(connection);
-		if (raw == null || typeof raw !== "object") return raw;
-		const { [CF_SUB_AGENT_OUTER_URL_KEY]: _, ...rest } = raw;
-		return Object.keys(rest).length > 0 ? rest : null;
+	_cf_hydrateSubAgentConnectionsFromRoot() {
+		return this._dynamicAgents.hydrateConnectionsFromRoot();
 	}
 	/**
 	* Parent-side middleware hook. Fires before a request is
@@ -3543,7 +3806,7 @@ var Agent = class Agent extends DurableObject {
 	* class Inbox extends Agent {
 	*   override async onBeforeSubAgent(req, { className, name }) {
 	*     // Strict registry gate
-	*     if (!this.hasSubAgent(className, name)) {
+	*     if (!this.dynamicAgents.has(className, name)) {
 	*       return new Response("Not found", { status: 404 });
 	*     }
 	*   }
@@ -3557,27 +3820,8 @@ var Agent = class Agent extends DurableObject {
 	*
 	* @internal
 	*/
-	async _cf_forwardToFacet(req, match) {
-		let fetcher;
-		try {
-			fetcher = await this._cf_resolveSubAgent(match.childClass, match.childName);
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			console.error("[agents] sub-agent route failed:", message);
-			if (/null character/i.test(message) || /reserved/i.test(message)) return new Response("Bad Request", { status: 400 });
-			return new Response("Not Found", { status: 404 });
-		}
-		const rewritten = new URL(req.url);
-		rewritten.pathname = match.remainingPath;
-		const forwardedHeaders = new Headers(req.headers);
-		const forwardedInit = {
-			method: req.method,
-			headers: forwardedHeaders
-		};
-		if (req.headers.get("Upgrade")?.toLowerCase() === "websocket") forwardedHeaders.set(SUB_AGENT_OUTER_URL_HEADER, req.url);
-		if (req.body && req.method !== "GET" && req.method !== "HEAD") forwardedInit.body = req.body;
-		const forwarded = new Request(rewritten, forwardedInit);
-		return fetcher.fetch(forwarded);
+	_cf_forwardToFacet(req, match) {
+		return this._dynamicAgents.forward(req, match);
 	}
 	/**
 	* Bridge method used by `getSubAgentByName`. Resolves the facet
@@ -3586,9 +3830,8 @@ var Agent = class Agent extends DurableObject {
 	*
 	* @internal
 	*/
-	async _cf_invokeSubAgent(className, name, method, args) {
-		const stub = await this._cf_resolveSubAgent(className, name);
-		return await this._cf_invokeStubMethod(stub, className, method, args);
+	_cf_invokeSubAgent(className, name, method, args) {
+		return this._dynamicAgents.invoke(className, name, method, args);
 	}
 	/**
 	* Bridge method used by `parentAgent()` when the requested parent is
@@ -3598,20 +3841,8 @@ var Agent = class Agent extends DurableObject {
 	*
 	* @internal
 	*/
-	async _cf_invokeSubAgentPath(path, method, args) {
-		const [self, next, ...rest] = path;
-		if (!self) throw new Error(`Sub-agent path invocation requires a non-empty path.`);
-		const ownClassName = this.constructor.name;
-		if (self.className !== ownClassName || self.name !== this.name) throw new Error(`Sub-agent path invocation reached ${ownClassName}("${this.name}") but expected ${self.className}("${self.name}").`);
-		if (!next) return await this._cf_invokeStubMethod(this, this.constructor.name, method, args);
-		const child = await this._cf_resolveSubAgent(next.className, next.name);
-		if (rest.length === 0) return await this._cf_invokeStubMethod(child, next.className, method, args);
-		return await child._cf_invokeSubAgentPath([next, ...rest], method, args);
-	}
-	async _cf_invokeStubMethod(stub, className, method, args) {
-		const handle = stub;
-		if (typeof handle[method] !== "function") throw new Error(`Method "${method}" not found on ${className}.`);
-		return await handle[method](...args);
+	_cf_invokeSubAgentPath(path, method, args) {
+		return this._dynamicAgents.invokePath(path, method, args);
 	}
 	/**
 	* Initialize this agent as a facet in a single RPC.
@@ -3637,18 +3868,8 @@ var Agent = class Agent extends DurableObject {
 	*
 	* @internal Called by {@link subAgent}.
 	*/
-	async _cf_initAsFacet(name, parentPath = [], identityName = name) {
-		const routedName = this.lifecycle.name;
-		if (routedName !== identityName) throw new Error(`Facet bootstrap mismatch: expected routed identity "${identityName}" but got "${routedName}". This usually means the parent passed the wrong id to ctx.facets.get(). See _cf_resolveSubAgent.`);
-		this._isFacet = true;
-		this._facetName = name;
-		this._parentPath = parentPath;
-		await Promise.all([
-			this.ctx.storage.put("cf_agents_is_facet", true),
-			this.ctx.storage.put("cf_agents_facet_name", name),
-			this.ctx.storage.put("cf_agents_parent_path", parentPath)
-		]);
-		await this.__unsafe_ensureInitialized();
+	_cf_initAsFacet(name, parentPath = [], identityName = name) {
+		return this._dynamicAgents.init(name, parentPath, identityName);
 	}
 	get name() {
 		const routedName = this.lifecycle.name;
@@ -3796,9 +4017,11 @@ var Agent = class Agent extends DurableObject {
 	* const searcher = await this.subAgent(SearchAgent, "main-search");
 	* const results = await searcher.search("cloudflare agents");
 	* ```
+	*
+	* @deprecated Use {@link Agent.dynamicAgents | this.dynamicAgents.get()} instead.
 	*/
 	async subAgent(cls, name) {
-		return await this._cf_resolveSubAgent(cls.name, name);
+		return this.dynamicAgents.get(cls, name);
 	}
 	async onAgentToolStart(_run) {}
 	async onAgentToolFinish(_run, _result) {}
@@ -5185,46 +5408,22 @@ var Agent = class Agent extends DurableObject {
 	*
 	* @internal
 	*/
-	async _cf_resolveSubAgent(className, name) {
-		const ctx = this.ctx;
-		if (!ctx.facets || !ctx.exports) throw new Error("subAgent() is not supported in this runtime — `ctx.facets` / `ctx.exports` are unavailable. Update to the latest `compatibility_date` in your wrangler.jsonc.");
-		if (camelCaseToKebabCase(className) === "sub") throw new Error(`Sub-agent class name "${className}" kebab-cases to "sub", which collides with the reserved URL separator — rename the class (e.g. "SubThing" or "Subtask").`);
-		const Cls = ctx.exports[className];
-		if (!Cls) throw new Error(`Sub-agent class "${className}" not found in worker exports. Make sure the class is exported from your worker entry point and that the export name matches the class name.`);
-		if (name.includes("\0")) throw new Error(`Sub-agent name contains null character (\\0), which is reserved.`);
-		const facetKey = `${className}\0${name}`;
-		const childParentPath = this.selfPath;
-		const childPath = [...childParentPath, {
-			className,
-			name
-		}];
-		const rootClassName = this._parentPath[0]?.className ?? this.constructor.name;
-		const rootNs = ctx.exports[rootClassName];
-		if (!rootNs?.idFromName) {
-			const minificationHint = /^_*[a-z][a-z0-9]{0,2}$/.test(rootClassName) ? ` The class name "${rootClassName}" looks minified — make sure your bundler preserves class names (e.g. esbuild's \`keepNames: true\`).` : "";
-			throw new Error(`Sub-agent bootstrap requires the root agent class "${rootClassName}" to be available as a Durable Object namespace, but ctx.exports["${rootClassName}"] is missing or doesn't expose idFromName.${minificationHint} Make sure the root agent class is exported under that class name and registered in your wrangler.jsonc durable_objects.bindings.`);
-		}
-		const identity = await this._cf_subAgentIdentity(className, name, childPath);
-		const facetId = rootNs.idFromName(identity.name);
-		const stub = ctx.facets.get(facetKey, () => ({
-			class: Cls,
-			id: facetId
-		}));
-		this._recordSubAgent(className, name, identity);
-		try {
-			await runInInvocation({
-				agent: this,
-				connection: void 0,
-				request: void 0,
-				email: void 0
-			}, async () => {
-				await stub._cf_initAsFacet(name, childParentPath, identity.name);
-			});
-		} catch (error) {
-			if (!identity.existing) this._forgetSubAgent(className, name);
-			throw error;
-		}
-		return stub;
+	_cf_resolveSubAgent(className, name) {
+		return this._dynamicAgents.resolve(className, name);
+	}
+	/**
+	* Run `body` in a fresh invocation scope with no native request/
+	* connection context attached, so a child-facet RPC never sees
+	* parent-owned I/O handles.
+	* @internal
+	*/
+	_runFacetInitInvocation(body) {
+		return runInInvocation({
+			agent: this,
+			connection: void 0,
+			request: void 0,
+			email: void 0
+		}, body);
 	}
 	/**
 	* Forcefully abort a running sub-agent. The child stops executing
@@ -5237,12 +5436,11 @@ var Agent = class Agent extends DurableObject {
 	* @param cls The Agent subclass used when creating the child
 	* @param name Name of the child to abort
 	* @param reason Error thrown to pending/future RPC callers
+	*
+	* @deprecated Use {@link Agent.dynamicAgents | this.dynamicAgents.abort()} instead.
 	*/
 	abortSubAgent(cls, name, reason) {
-		const ctx = this.ctx;
-		if (!ctx.facets) throw new Error("abortSubAgent() is not supported in this runtime — `ctx.facets` is unavailable. Update to the latest `compatibility_date` in your wrangler.jsonc.");
-		const facetKey = `${cls.name}\0${name}`;
-		ctx.facets.abort(facetKey, reason);
+		this.dynamicAgents.abort(cls, name, reason);
 	}
 	/**
 	* Delete a sub-agent: abort it if running, then permanently wipe its
@@ -5252,117 +5450,18 @@ var Agent = class Agent extends DurableObject {
 	*
 	* @param cls The Agent subclass used when creating the child
 	* @param name Name of the child to delete
+	*
+	* @deprecated Use {@link Agent.dynamicAgents | this.dynamicAgents.delete()} instead.
 	*/
-	async deleteSubAgent(cls, name) {
-		const ctx = this.ctx;
-		if (!ctx.facets) throw new Error("deleteSubAgent() is not supported in this runtime — `ctx.facets` is unavailable. Update to the latest `compatibility_date` in your wrangler.jsonc.");
-		const facetKey = `${cls.name}\0${name}`;
-		const childPath = [...this.selfPath, {
-			className: cls.name,
-			name
-		}];
-		if (this._isFacet) await (await this._rootAlarmOwner())._cf_cleanupFacetPrefix(childPath);
-		else await this._cf_cleanupFacetPrefix(childPath);
-		try {
-			ctx.facets.delete(facetKey);
-		} catch {}
-		this._forgetSubAgent(cls.name, name);
-	}
-	_addColumnIfNotExists(sql) {
-		try {
-			this.ctx.storage.sql.exec(sql);
-		} catch (e) {
-			if (!(e instanceof Error ? e.message : String(e)).toLowerCase().includes("duplicate column")) throw e;
-		}
-	}
-	/** @internal */
-	_ensureSubAgentRegistry() {
-		if (this._subAgentRegistryReady) return;
-		this.sql`
-      CREATE TABLE IF NOT EXISTS cf_agents_sub_agents (
-        class TEXT NOT NULL,
-        name TEXT NOT NULL,
-        created_at INTEGER NOT NULL,
-        identity_version TEXT,
-        identity_name TEXT,
-        PRIMARY KEY (class, name)
-      )
-    `;
-		this._addColumnIfNotExists("ALTER TABLE cf_agents_sub_agents ADD COLUMN identity_version TEXT");
-		this._addColumnIfNotExists("ALTER TABLE cf_agents_sub_agents ADD COLUMN identity_name TEXT");
-		this._subAgentRegistryReady = true;
-	}
-	/** @internal */
-	_recordSubAgent(className, name, identity) {
-		this._ensureSubAgentRegistry();
-		this.sql`
-      INSERT OR IGNORE INTO cf_agents_sub_agents
-        (class, name, created_at, identity_version, identity_name)
-      VALUES
-        (${className}, ${name}, ${Date.now()}, ${identity.version}, ${identity.name})
-    `;
-	}
-	/** @internal */
-	_subAgentRegistryRow(className, name) {
-		this._ensureSubAgentRegistry();
-		return this.sql`
-      SELECT identity_version, identity_name
-      FROM cf_agents_sub_agents
-      WHERE class = ${className} AND name = ${name}
-      LIMIT 1
-    `[0] ?? null;
-	}
-	async _cf_subAgentIdentity(className, name, childPath) {
-		const row = this._subAgentRegistryRow(className, name);
-		if (row) {
-			if (row.identity_version === SUB_AGENT_IDENTITY_VERSION_PATH_V2 && typeof row.identity_name === "string") return {
-				version: SUB_AGENT_IDENTITY_VERSION_PATH_V2,
-				name: row.identity_name,
-				existing: true
-			};
-			return {
-				version: SUB_AGENT_IDENTITY_VERSION_LEGACY,
-				name,
-				existing: true
-			};
-		}
-		return {
-			version: SUB_AGENT_IDENTITY_VERSION_PATH_V2,
-			name: pathV2IdentityName(name, await sha256Hex(JSON.stringify(childPath))),
-			existing: false
-		};
-	}
-	/** @internal */
-	_forgetSubAgent(className, name) {
-		this._ensureSubAgentRegistry();
-		this.sql`
-      DELETE FROM cf_agents_sub_agents
-      WHERE class = ${className} AND name = ${name}
-    `;
+	deleteSubAgent(cls, name) {
+		return this.dynamicAgents.delete(cls, name);
 	}
 	hasSubAgent(classOrName, name) {
-		const className = typeof classOrName === "string" ? classOrName : classOrName.name;
-		this._ensureSubAgentRegistry();
-		return (this.sql`
-      SELECT COUNT(*) AS n FROM cf_agents_sub_agents
-      WHERE class = ${className} AND name = ${name}
-    `[0]?.n ?? 0) > 0;
+		return typeof classOrName === "string" ? this.dynamicAgents.has(classOrName, name) : this.dynamicAgents.has(classOrName, name);
 	}
 	listSubAgents(classOrName) {
-		const className = typeof classOrName === "string" ? classOrName : classOrName?.name;
-		this._ensureSubAgentRegistry();
-		return (className ? this.sql`
-          SELECT class, name, created_at FROM cf_agents_sub_agents
-          WHERE class = ${className}
-          ORDER BY created_at ASC
-        ` : this.sql`
-          SELECT class, name, created_at FROM cf_agents_sub_agents
-          ORDER BY created_at ASC
-        `).map((r) => ({
-			className: r.class,
-			name: r.name,
-			createdAt: r.created_at
-		}));
+		if (typeof classOrName === "string" || classOrName === void 0) return this.dynamicAgents.list(classOrName);
+		return this.dynamicAgents.list(classOrName);
 	}
 	/**
 	* Destroy the Agent, removing all state and scheduled tasks.
@@ -5392,7 +5491,7 @@ var Agent = class Agent extends DurableObject {
 		await this.ctx.storage.deleteAll();
 		this._destroyed = true;
 		setTimeout(() => {
-			this.ctx.abort("destroyed");
+			abortWithoutAlarmRetry(this.ctx, "destroyed");
 		}, 0);
 		this._emit("destroy");
 	}
@@ -5423,7 +5522,12 @@ var Agent = class Agent extends DurableObject {
 		}
 		const destroyAt = Date.now() + DESTROY_ALARM_DELAY_MS;
 		await this.ctx.storage.put(DESTROY_PENDING_KEY, destroyAt);
-		await this.lifecycle.rearmAlarm();
+		await this.lifecycle.jobs.push({
+			id: HOST_JOB_DESTROY_ID,
+			fn: "destroy",
+			time: destroyAt,
+			exclusive: true
+		});
 	}
 	/**
 	* Whether a (deferred or interrupted) destroy is pending. Reads the
@@ -5444,32 +5548,14 @@ var Agent = class Agent extends DurableObject {
 	* @returns True if the method is marked as callable
 	*/
 	_isCallable(method) {
-		return callableMetadata.has(this[method]);
+		return isCallableMethod(this[method]);
 	}
 	/**
 	* Get all methods marked as callable on this Agent
 	* @returns A map of method names to their metadata
 	*/
 	getCallableMethods() {
-		const result = /* @__PURE__ */ new Map();
-		let prototype = Object.getPrototypeOf(this);
-		while (prototype && prototype !== Object.prototype) {
-			for (const name of Object.getOwnPropertyNames(prototype)) {
-				if (name === "constructor") continue;
-				if (result.has(name)) continue;
-				try {
-					const fn = prototype[name];
-					if (typeof fn === "function") {
-						const meta = callableMetadata.get(fn);
-						if (meta) result.set(name, meta);
-					}
-				} catch (e) {
-					if (!(e instanceof TypeError)) throw e;
-				}
-			}
-			prototype = Object.getPrototypeOf(prototype);
-		}
-		return result;
+		return new Map(decoratedMethods(this));
 	}
 	/**
 	* Start a workflow and track it in this Agent's database.
@@ -6447,7 +6533,6 @@ var Agent = class Agent extends DurableObject {
 	}
 };
 Agent.options = {};
-Agent._CF_OOM_ALARM_STRIKES_KEY = "cf_agents:oom_alarm_strikes";
 const wrappedClasses = /* @__PURE__ */ new Set();
 var _email = /* @__PURE__ */ new WeakMap();
 _Symbol$dispose = Symbol.dispose;
@@ -6542,11 +6627,9 @@ var StreamingResponse = class {
 		this._id = id;
 	}
 	_send(response) {
-		const state = facetStreamingResponseDeliveryStates.get(this);
-		if (!state) return sendRpcResponseIfOpen(this._connection, response);
-		const delivery = sendFacetRpcResponseIfOpen(state.replyTarget, response);
-		trackFacetStreamingResponseDelivery(this, delivery.completion);
-		return delivery.sent;
+		const facetSent = sendFacetStreamingResponse(this, response);
+		if (facetSent !== null) return facetSent;
+		return sendRpcResponseIfOpen(this._connection, response);
 	}
 	/**
 	* Whether the stream has been closed (via end() or error())
@@ -6608,6 +6691,6 @@ var StreamingResponse = class {
 	}
 };
 //#endregion
-export { getCurrentAgent as a, callable as i, DEFAULT_AGENT_STATIC_OPTIONS as n, routeAgentEmail as o, StreamingResponse as r, unstable_callable as s, Agent as t };
+export { routeAgentEmail as a, getCurrentAgent as i, DEFAULT_AGENT_STATIC_OPTIONS as n, StreamingResponse as r, Agent as t };
 
-//# sourceMappingURL=src-5W6JNKVb.js.map
+//# sourceMappingURL=src-BNU3ZiJM.js.map