agents 0.22.0 → 0.23.0

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

@@ -3,23 +3,1179 @@ 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 { 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 { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
 import { n as withInvocationScope, r as writeSpanAttributes, t as tracer } from "./cloudflare-Dzvc7V2N.js";
 import { parseSubAgentPath } from "./sub-routing.js";
-import { i as setLifecycleRouteTransport, n as setLifecycleEventSink, r as setLifecycleHostInvoker, t as Lifecycle } from "./durable-object-lifecycle-D6nNQJJd.js";
+import { t as LifecycleCapability } from "./capability-BjSKYpzg.js";
+import { t as _classPrivateMethodInitSpec } from "./classPrivateMethodInitSpec-qMjJ6sHQ.js";
+import { a as abortWithoutAlarmRetry, i as setLifecycleRouteTransport, n as setLifecycleEventSink, r as setLifecycleHostInvoker, t as Lifecycle } from "./lifecycle-CMRGjZdw.js";
+import { isErrorRetryable, tryN, validateRetryOptions } from "./retries.js";
 import { SqlError } from "./sql-error.js";
-import { isDurableObjectMemoryLimitReset, isErrorRetryable, tryN, validateRetryOptions } from "./retries.js";
+import { o as callablesFromDecorated, t as WebSockets } from "./websockets-DUfRHPRq.js";
 import { a as ensureMcpServerTable, d as DisposableStore, i as normalizeServerId, l as RPC_DO_PREFIX, o as MCPConnectionState, t as MCPClientManager } from "./client-jagG8a9_.js";
 import { 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-DD9NdYbF.js";
+import { n as setTaskDefinitionResolver, r as setTaskRoutedMemoryLimitHandler, t as Tasks } from "./tasks-ylZgBjhj.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/dynamic-agents/bridges.ts
+function isClosedWebSocketSendError(error) {
+	return error instanceof TypeError && error.message.includes("WebSocket send() after close");
+}
+const dynamicAgentRpcReplyContext = new AsyncLocalStorage();
+function sendFacetRpcResponseIfOpen(target, response) {
+	try {
+		return {
+			sent: true,
+			completion: Promise.resolve(target.send(JSON.stringify(response))).catch((error) => {
+				if (!isClosedWebSocketSendError(error)) console.error("[Agent] Facet RPC response delivery failed:", error);
+			})
+		};
+	} catch (error) {
+		if (isClosedWebSocketSendError(error)) return {
+			sent: false,
+			completion: Promise.resolve()
+		};
+		throw error;
+	}
+}
+const facetStreamingResponseDeliveryStates = /* @__PURE__ */ new WeakMap();
+/**
+* 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()
+	});
+}
+/**
+* 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 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);
+	if (!state) return;
+	try {
+		await Promise.all(state.pending);
+	} finally {
+		facetStreamingResponseDeliveryStates.delete(stream);
+	}
+}
+var _connection = /* @__PURE__ */ new WeakMap();
+var _broadcast = /* @__PURE__ */ new WeakMap();
+/**
+* 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.
+*/
+var DynamicAgentConnectionBridge = class extends RpcTarget {
+	constructor(connection, broadcast) {
+		super();
+		_classPrivateFieldInitSpec(this, _connection, void 0);
+		_classPrivateFieldInitSpec(this, _broadcast, void 0);
+		_classPrivateFieldSet2(_connection, this, connection);
+		_classPrivateFieldSet2(_broadcast, this, broadcast);
+	}
+	send(message) {
+		_classPrivateFieldGet2(_connection, this).send(message);
+	}
+	close(code, reason) {
+		_classPrivateFieldGet2(_connection, this).close(code, reason);
+	}
+	setState(state) {
+		return _classPrivateFieldGet2(_connection, this).setState(state);
+	}
+	broadcast(ownerPath, message, without) {
+		return _classPrivateFieldGet2(_broadcast, this)?.call(this, ownerPath, message, without);
+	}
+};
+var _root = /* @__PURE__ */ new WeakMap();
+var _connectionId = /* @__PURE__ */ new WeakMap();
+/**
+* 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);
+	}
+	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 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);
+		}
+		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;
+		_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+		connection.setState(state);
+		return this.getForwardedState(connection);
+	}
+	connectionTargetPath(connection) {
+		_classPrivateFieldGet2(_host, this)._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) {
+		_classPrivateFieldGet2(_host, this)._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 })) _classPrivateFieldGet2(_host, this)._setConnectionNoProtocol(connection);
+			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;
+		_classPrivateFieldGet2(_host, this)._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) {
+		_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+		return _classPrivateFieldGet2(_host, this)._rawStateAccessors.get(connection)?.getRaw() ?? null;
+	}
+	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) {
+	_classPrivateFieldGet2(_host, this)._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 }) {
+	_classPrivateFieldGet2(_host, this)._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);
+	}
+	/**
+	* 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);
+	}
+	has(classOrName, name) {
+		const className = typeof classOrName === "string" ? classOrName : classOrName.name;
+		return _classPrivateFieldGet2(_internal, this).registry.has(className, name);
+	}
+	list(classOrName) {
+		const className = typeof classOrName === "string" ? classOrName : classOrName?.name;
+		return _classPrivateFieldGet2(_internal, this).registry.list(className);
+	}
+};
+//#endregion
 //#region src/observability/agent-span-attributes.ts
 function agentSpanAttributes(input) {
 	return {
@@ -42,9 +1198,6 @@ let _Symbol$dispose;
 function runInInvocation(store, body, options) {
 	return __DO_NOT_USE_WILL_BREAK__agentContext.run(store, () => withInvocationScope(body, options));
 }
-function isClosedWebSocketSendError(error) {
-	return error instanceof TypeError && error.message.includes("WebSocket send() after close");
-}
 function sendRpcResponseIfOpen(connection, response) {
 	try {
 		connection.send(JSON.stringify(response));
@@ -54,47 +1207,6 @@ function sendRpcResponseIfOpen(connection, response) {
 		throw error;
 	}
 }
-const subAgentRpcReplyContext = new AsyncLocalStorage();
-function sendFacetRpcResponseIfOpen(target, response) {
-	try {
-		return {
-			sent: true,
-			completion: Promise.resolve(target.send(JSON.stringify(response))).catch((error) => {
-				if (!isClosedWebSocketSendError(error)) console.error("[Agent] Facet RPC response delivery failed:", error);
-			})
-		};
-	} catch (error) {
-		if (isClosedWebSocketSendError(error)) return {
-			sent: false,
-			completion: Promise.resolve()
-		};
-		throw error;
-	}
-}
-const facetStreamingResponseDeliveryStates = /* @__PURE__ */ new WeakMap();
-function createStreamingResponse(connection, id, facetReplyTarget) {
-	const stream = new StreamingResponse(connection, id);
-	if (facetReplyTarget) facetStreamingResponseDeliveryStates.set(stream, {
-		replyTarget: facetReplyTarget,
-		pending: /* @__PURE__ */ new Set()
-	});
-	return stream;
-}
-function trackFacetStreamingResponseDelivery(stream, completion) {
-	const state = facetStreamingResponseDeliveryStates.get(stream);
-	if (!state) return;
-	state.pending.add(completion);
-	completion.finally(() => state.pending.delete(completion));
-}
-async function waitForFacetStreamingResponseDeliveries(stream) {
-	const state = facetStreamingResponseDeliveryStates.get(stream);
-	if (!state) return;
-	try {
-		await Promise.all(state.pending);
-	} finally {
-		facetStreamingResponseDeliveryStates.delete(stream);
-	}
-}
 /**
 * Type guard for RPC request messages
 */
@@ -107,84 +1219,14 @@ function isRPCRequest(msg) {
 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 {
-	constructor(connection, broadcast) {
-		super();
-		_classPrivateFieldInitSpec(this, _connection2, void 0);
-		_classPrivateFieldInitSpec(this, _broadcast, void 0);
-		_classPrivateFieldSet2(_connection2, this, connection);
-		_classPrivateFieldSet2(_broadcast, this, broadcast);
-	}
-	send(message) {
-		_classPrivateFieldGet2(_connection2, this).send(message);
-	}
-	close(code, reason) {
-		_classPrivateFieldGet2(_connection2, this).close(code, reason);
-	}
-	setState(state) {
-		return _classPrivateFieldGet2(_connection2, this).setState(state);
-	}
-	broadcast(ownerPath, message, without) {
-		return _classPrivateFieldGet2(_broadcast, this)?.call(this, ownerPath, message, without);
-	}
-};
-var _root = /* @__PURE__ */ new WeakMap();
-var _connectionId = /* @__PURE__ */ new WeakMap();
-var RootSubAgentConnectionBridge = 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);
-	}
-	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);
-	}
-};
-/**
-* 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;
-	};
-}
-let didWarnAboutUnstableCallable = false;
-/**
-* 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
-*/
-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.");
-	}
-	return callable(metadata);
-};
-function agentPathKey(path) {
-	if (!path) return null;
-	return path.map((step) => `${encodeURIComponent(step.className)}:${encodeURIComponent(step.name)}`).join("/");
-}
 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,9 +1244,6 @@ 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.
@@ -216,33 +1255,6 @@ 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 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.
@@ -255,28 +1267,13 @@ const CF_READONLY_KEY = "_cf_readonly";
 */
 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_voiceInCall",
 	CF_SUB_AGENT_OUTER_URL_KEY,
 	CF_SUB_AGENT_TAGS_KEY
 ]);
@@ -459,6 +1456,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).
 	*
@@ -643,7 +1668,6 @@ var Agent = class Agent extends DurableObject {
         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,
@@ -741,7 +1765,17 @@ var Agent = class Agent extends DurableObject {
 	}
 	constructor(ctx, env) {
 		super(ctx, env);
-		this.lifecycle = Lifecycle.install(this);
+		this.lifecycle = Lifecycle.install(this, { maxAlarmMemoryLimitStrikes: this._resolvedOptions.maxAlarmMemoryLimitStrikes });
+		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)
+			},
+			callables: callablesFromDecorated(this),
+			getConnectionTags: (connection, ctx) => this.getConnectionTags(connection, ctx)
+		});
 		this._state = DEFAULT_STATE;
 		this._disposables = new DisposableStore();
 		this._destroyed = false;
@@ -749,13 +1783,9 @@ var Agent = class Agent extends DurableObject {
 		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();
@@ -769,7 +1799,6 @@ var Agent = class Agent extends DurableObject {
 		this.observability = genericObservability;
 		this._flushingQueue = false;
 		this.maxConcurrentAgentTools = Infinity;
-		this._subAgentRegistryReady = false;
 		const routeHost = this;
 		setLifecycleRouteTransport(this.lifecycle, {
 			get source() {
@@ -782,10 +1811,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 +1832,11 @@ var Agent = class Agent extends DurableObject {
 			if (typeof method !== "function") return void 0;
 			return (payload, schedule) => method.call(this, payload, schedule);
 		});
+		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 +1857,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.mcp).use(this._webSockets, { fallback: true }).use(this.tasks).use(this._dynamicAgents);
 		let mcpBroadcastReady = false;
 		this._disposables.add(this.mcp.onServerStateChanged(() => {
 			if (mcpBroadcastReady) this.broadcastMcpServers();
@@ -857,6 +1891,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,7 +1905,7 @@ 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);
 			return runInInvocation({
@@ -910,9 +1946,10 @@ var Agent = class Agent extends DurableObject {
 						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
@@ -1061,6 +2098,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 +2106,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.
@@ -1534,7 +2561,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);
@@ -1721,74 +2748,21 @@ var Agent = class Agent extends DurableObject {
 			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}
-      `;
-	}
 	_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);
+		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,64 +2775,40 @@ 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
 	* alarm housekeeping can dispatch recovery checks into idle facets.
 	* 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 +2968,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);
 			}));
 		};
@@ -2617,6 +3567,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 +3746,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 +3755,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 +3764,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 +3780,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 +3789,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 +3807,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 +3865,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 +3936,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 +3963,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);
-			return;
-		}
-		for (const connection of this.lifecycle.getConnections(tag)) {
-			if (this._cf_connectionHasSubAgentTarget(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;
-	}
-	_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);
-		});
-	}
-	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;
-	}
-	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;
-	}
-	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;
+			yield* this._dynamicAgents.getVirtualConnections(tag);
+			return;
 		}
-		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;
+		for (const connection of this._webSockets.getConnections(tag)) {
+			if (this._dynamicAgents.connectionHasChildTarget(connection)) continue;
+			yield connection;
 		}
-		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
-			}
-		};
 	}
-	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);
-		});
+	async _cf_broadcastToSubAgent(ownerPath, message, without) {
+		await this._dynamicAgents.broadcastToPath(ownerPath, message, without);
 	}
-	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;
-		}
+	_cf_subAgentConnectionMetas(ownerPath) {
+		return this._dynamicAgents.connectionMetas(ownerPath);
 	}
-	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_sendToSubAgentConnection(connectionId, message) {
+		return this._dynamicAgents.sendToConnection(connectionId, message);
 	}
-	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_closeSubAgentConnection(connectionId, code, reason) {
+		return this._dynamicAgents.closeConnection(connectionId, code, reason);
 	}
-	_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_setSubAgentConnectionState(connectionId, state) {
+		return this._dynamicAgents.setConnectionState(connectionId, state);
 	}
-	_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_connectionTargetsSubAgent(connection) {
+		return this._dynamicAgents.connectionTargetsChild(connection);
+	}
+	/**
+	* 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_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_forwardSubAgentWebSocketConnect(connection, request, options) {
+		return this._dynamicAgents.forwardWebSocketConnect(connection, request, options);
 	}
-	_cf_getRawConnectionState(connection) {
-		this._ensureConnectionWrapped(connection);
-		return this._rawStateAccessors.get(connection)?.getRaw() ?? null;
+	_cf_forwardSubAgentWebSocketMessage(connection, message, replyBridge) {
+		return this._dynamicAgents.forwardWebSocketMessage(connection, message, replyBridge);
 	}
-	_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_forwardSubAgentWebSocketClose(connection, code, reason, wasClean) {
+		return this._dynamicAgents.forwardWebSocketClose(connection, code, reason, wasClean);
+	}
+	_cf_handleSubAgentWebSocketConnect(bridge, meta) {
+		return this._dynamicAgents.handleWebSocketConnect(bridge, meta);
+	}
+	_cf_handleSubAgentWebSocketMessage(message, bridge, meta, replyBridge = bridge) {
+		return this._dynamicAgents.handleWebSocketMessage(message, bridge, meta, replyBridge);
+	}
+	_cf_handleSubAgentWebSocketClose(code, reason, wasClean, bridge, meta) {
+		return this._dynamicAgents.handleWebSocketClose(code, reason, wasClean, bridge, meta);
+	}
+	_cf_hydrateSubAgentConnectionsFromRoot() {
+		return this._dynamicAgents.hydrateConnectionsFromRoot();
 	}
 	/**
 	* Parent-side middleware hook. Fires before a request is
@@ -3543,7 +4073,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 +4087,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 +4097,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 +4108,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 +4135,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 +4284,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 +5675,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 +5703,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 +5717,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 +5758,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 +5789,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 +5815,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 +6800,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 +6894,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 +6958,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-DlSHshb2.js.map