@fishwithcat/dsh-subagent 0.2.2-alpha.2 → 0.2.2-alpha.3

package/lib/index.js

@@ -7,8 +7,8 @@ import { Remote, RemoteError, TypertRemoteService, principalOf } from "@deepseek
 import { AttachmentError } from "@deepseek-ai/dsh-attachment";
 import { z as z$1 } from "zod";
 import { HarnessError, ReasoningEffortId, boundContextSummary, contentHasImage, createUserMessage, errorChain, joinAssistantStreamText } from "@deepseek-ai/dsh-llm";
-import { randomUUID } from "node:crypto";
 import { foldConsumedWork } from "@deepseek-ai/dsh-agent";
+import { randomUUID } from "node:crypto";
 import { isAbsolute, resolve } from "node:path";
 import { brandString } from "@deepseek-ai/dsh-brand";
 import { SessionLogOffset, SessionSeq } from "@deepseek-ai/dsh-session";
@@ -39,16 +39,10 @@ var SubagentError = class extends HarnessError {
 const SESSION_ID_SCHEMA = z$1.string().min(1);
 const CONTROL_ID_SCHEMAS = {
 	"subagent.prompt": z$1.object({
-		parentSessionId: SESSION_ID_SCHEMA,
 		childSessionId: SESSION_ID_SCHEMA,
-		mode: z$1.literal("continuable"),
 		delivery: z$1.enum(["queue", "steer"])
 	}),
-	"subagent.interrupt": z$1.object({
-		parentSessionId: SESSION_ID_SCHEMA,
-		childSessionId: SESSION_ID_SCHEMA,
-		mode: z$1.literal("continuable")
-	})
+	"subagent.interrupt": z$1.object({ childSessionId: SESSION_ID_SCHEMA })
 };
 /**
 * Apply the subagent payload checks that are stricter than generated
@@ -77,7 +71,7 @@ function rejectPrompt(error, childSessionId, signal) {
 	if (error instanceof SubagentError) switch (error.code) {
 		case "MODEL_DOES_NOT_SUPPORT_IMAGES": throw new RemoteError("subagent/attachment-invalid", error.message, { reason: error.code }, { cause: error });
 		case "NOT_RESUMABLE": throw new RemoteError("subagent/not-resumable", "subagent cannot be resumed", { childSessionId }, { cause: error });
-		case "UNAUTHORIZED": throw new RemoteError("subagent/unauthorized", "subagent does not belong to this parent", { childSessionId }, { cause: error });
+		case "UNAUTHORIZED": throw new RemoteError("subagent/unauthorized", "subagent membership in the active tree could not be verified", { childSessionId }, { cause: error });
 		case "DRAINING":
 		case "ACTIVATION_CLOSING":
 		case "ACTIVATION_LIMIT_REACHED":
@@ -122,32 +116,12 @@ function assertSubagentMaxDepth(maxDepth) {
 	if (maxDepth !== void 0 && (typeof maxDepth !== "number" || !Number.isSafeInteger(maxDepth) || maxDepth < 0 || Object.is(maxDepth, -0))) throw new TypeError("subagent maxDepth must be a non-negative safe integer");
 }
 //#endregion
-//#region lib/types/types.js
-/**
-* The seam's consumer-facing contracts: request, result, and capability types
-* for {@link SubagentProvider}, plus the `subagent/start` and `subagent/end`
-* payloads that plugins and hosts observe. Internal control interfaces belong
-* with their implementation — the lifecycle observer in `./lifecycle.ts`, the
-* manager host in `./manager.ts` — so this module stays the published
-* surface rather than a bag of everything type-shaped.
-*
-* @module @deepseek-ai/dsh-subagent/types
-*/
-/**
-* Brand a string as a {@link SubagentRunId}.
-* @param id - the raw run id.
-* @returns the same string, branded.
-*/
-function SubagentRunId(id) {
-	return id;
-}
-//#endregion
 //#region lib/types/lifecycle.js
 /**
-* Lifecycle-edge publication for managed subagent activations.
+* Contained lifecycle notifications for subagents.
 *
-* Public event payloads live in `./types.ts`; the package-private observer
-* retains only the identity shared by each start/end pair.
+* The service owns scoped dispatch and listener containment; the manager
+* supplies event payloads from each activation.
 *
 * @module @deepseek-ai/dsh-subagent/lifecycle
 */
@@ -157,8 +131,8 @@ function SubagentRunId(id) {
 * returned promise is logged without starving peer listeners, changing the run,
 * or — for provider removal, which fires from a disposer — breaking teardown.
 * @param ctx - the service's own context, owning dispatch and the logger.
-* @param carrier - resolve the scoped dispatch carrier for one delegating parent.
-* @returns the emitter both observers and the provider registry publish through.
+* @param carrier - resolve the scoped dispatch carrier for one subagent tree root.
+* @returns the emitter the manager and provider registry publish through.
 */
 function createLifecycleEmitter(ctx, carrier) {
 	return (name, info, parent) => {
@@ -178,35 +152,6 @@ function createLifecycleEmitter(ctx, carrier) {
 	};
 }
 /**
-* Build the observer for one local or external activation's residency epoch. Creation failure before residency emits no lifecycle edge.
-* @param emit - the contained lifecycle emitter.
-* @param provider - the provider name recorded in the durable descriptor.
-* @param childId - the durable child session id.
-* @param parent - the exact live direct parent keying scoped dispatch.
-* @returns the observer whose edges this epoch publishes.
-*/
-function createActivationObserver(emit, provider, childId, parent) {
-	const identity = {
-		runId: SubagentRunId(randomUUID()),
-		provider,
-		id: childId,
-		local: false
-	};
-	return {
-		start: (child) => {
-			identity.local = child !== void 0;
-			emit("subagent/start", identity, parent);
-		},
-		settle: ({ stopReason, output }) => {
-			emit("subagent/end", {
-				...identity,
-				stopReason,
-				...output.length === 0 ? {} : { lastAssistantMessage: output }
-			}, parent);
-		}
-	};
-}
-/**
 * Why this child's epoch ended, for the terminal lifecycle edge and the
 * manager's own parent delivery. The child's own log is authoritative:
 * teardown succeeding says nothing about whether the model errored, hit its
@@ -371,10 +316,11 @@ const SUBAGENT_DELEGATION_CONTEXT = "You are a delegated subagent: your permissi
 const SUBAGENT_DELEGATION_INTERACTIVE_CONTEXT = "You are a delegated subagent: your permission scope was fixed when you were started and cannot be widened from inside this session. An operation that needs access beyond that scope may request approval from the user, who can allow or reject it. Do not retry a rejected or denied operation; state the limitation in your reply so the delegating agent can handle it.";
 /**
 * Compose a child before publication and restore historical descriptor overrides.
-* Explicit selection mounts the named preset; omission synchronously joins the
-* parent's current generation. Registrations belong to the child's scope.
+* Explicit selection mounts the named preset. Omission joins a supplied creator's
+* current generation; a restored child without a saved preset uses host composition.
+* Registrations belong to the child's scope.
 * @param childCtx - the child agent's scoped creation context.
-* @param parent - the delegating parent used when no preset is selected.
+* @param parent - creator for fresh delegation; absent during target-only restoration.
 * @param composition - independent preset and any overrides read from a historical descriptor.
 * @param approvalPolicy - the child's effective approval policy, selecting its delegation statement.
 * @returns A promise when mounting an independent preset; otherwise completes synchronously.
@@ -387,7 +333,7 @@ function applyChildComposition(childCtx, parent, composition, approvalPolicy) {
 			applyChildOverrides(childCtx, composition, approvalPolicy);
 		});
 	}
-	childCtx.get("agentPresets")?.composeFrom(childCtx, parent.ctx);
+	if (parent !== void 0) childCtx.get("agentPresets")?.composeFrom(childCtx, parent.ctx);
 	applyChildOverrides(childCtx, composition, approvalPolicy);
 }
 function applyChildOverrides(childCtx, composition, approvalPolicy) {
@@ -453,7 +399,7 @@ function appendDelegatedPolicyOverrides(childSession, overrides) {
 *
 * @module @deepseek-ai/dsh-subagent/continuation-messages
 */
-/** Build durable attribution for one adjacent-Agent message. */
+/** Build durable attribution for one Agent message. */
 function agentMessageSource(sender) {
 	return {
 		kind: "agent-message",
@@ -462,7 +408,7 @@ function agentMessageSource(sender) {
 	};
 }
 /**
-* Build the model-visible and durable representation of one adjacent-Agent message.
+* Build the model-visible and durable representation of one Agent message.
 * @param sender - exact live Agent that authored the message.
 * @param content - model-visible message blocks supplied by the sender.
 * @returns the durable user-message representation delivered to the recipient.
@@ -477,16 +423,14 @@ function createAgentMessage(sender, content) {
 	});
 }
 /**
-* Append adjacent-Agent return guidance to a continuable child's initial task.
-* @param parentId - durable parent session id named in the guidance.
+* Append automatic result-delivery guidance to a parent-delivered child's initial task.
 * @param prompt - initial model-visible task blocks.
-* @returns task blocks followed by the continuable return guidance.
+* @returns task blocks followed by the result-delivery guidance.
 */
-function withContinuableReturnGuidance(parentId, prompt) {
-	const encodedParentId = JSON.stringify(parentId);
+function withResultDeliveryGuidance(prompt) {
 	return [...prompt, {
 		type: "text",
-		text: `Your parent agent id is ${encodedParentId}. Before you finish, send your result to that agent with send_message({ agent_id: ${encodedParentId}, message: "<self-contained result>" }). The parent shares your workspace but does not automatically receive your transcript, tool output, or reasoning. Send earlier messages as well when a finding changes what the parent should do next; sending a message does not end your turn.`
+		text: "Your final answer is delivered automatically if your parent is still online. Include the result and relevant evidence in that answer; the parent does not receive your full transcript, tool output, or reasoning. If your last action is a message to your parent, the completion notice omits your final answer; include the result and relevant evidence in that message."
 	}];
 }
 /**
@@ -516,8 +460,8 @@ function settlementSummary(childId, stopReason, continuable) {
 * @param childId - durable child session id named in the notice.
 * @param terminal - recorded terminal state for the settled Activation.
 * @param continuable - whether the child can accept another task.
-* @param omitClosingText - replace the closing text with a note that the child's
-*   last message to the parent already carries it.
+* @param omitClosingText - replace the closing text when the child's last action
+*   was a message to its direct parent.
 * @returns the durable user-message representation delivered to the parent.
 */
 function createSettlementMessage(childId, terminal, continuable = true, omitClosingText = false) {
@@ -552,11 +496,84 @@ function createSettlementMessage(childId, terminal, continuable = true, omitClos
 			kind: "subagent-settled",
 			form: "notice",
 			summary: boundContextSummary(summary),
+			stopReason: terminal.stopReason,
 			senderSessionId: childId
 		}
 	});
 }
 //#endregion
+//#region lib/types/archive-admission.js
+/**
+* The `subagent` family of the Workspace registry's archive admission: which
+* subagent descendants of a Session are still inside a turn, and how they
+* stop when the Session is archived with its work. Archived ancestors also
+* block later model steps, including when their Sessions have been released.
+*
+* @module @deepseek-ai/dsh-subagent
+*/
+/**
+* Answer `workspace/session-activity` with the running subagent descendants of
+* the asked Session, and `workspace/session-stop` by cancelling each of them
+* as their parent would. Reject subsequent steps beneath archived ancestors.
+* All listeners live as long as `ctx`'s fiber.
+* @param ctx - context carrying the Agent registry.
+* @param residentAncestors - verified creation ancestors for an exact managed Agent, absent before publication or for unmanaged Agents.
+* @param identityOf - ready service-owned descriptor identity reader; absent or invalid descriptors yield no identity.
+*/
+function installSubagentArchiveAdmission(ctx, residentAncestors, identityOf) {
+	const ancestorsOf = (agent) => residentAncestors(agent) ?? headerAncestors(ctx, agent);
+	const runningDescendants = (sessionId) => ctx.agents.list().filter((agent) => agent.status === "running" && ancestorsOf(agent).includes(sessionId));
+	ctx.on("workspace/session-activity", async ({ sessionId }, next) => {
+		const running = runningDescendants(sessionId);
+		const rest = await next();
+		if (running.length === 0) return rest;
+		return [{
+			kind: "subagent",
+			items: running.map((child) => describe(child, identityOf(child.session)))
+		}, ...rest];
+	});
+	ctx.on("workspace/session-stop", ({ sessionId }) => {
+		for (const child of runningDescendants(sessionId)) try {
+			child.cancel({ kind: "parent" });
+		} catch (error) {
+			ctx.logger.warn(`subagent: cancelling "${child.id}" for an archived Session failed: ${String(error)}`);
+		}
+	});
+	ctx.on("agent/pre-step", ({ agent }, next) => {
+		const archived = ctx.get("workspaceRegistry")?.archivedSessionIds;
+		return archived !== void 0 && ancestorsOf(agent).some((id) => archived.includes(id)) ? Promise.resolve({ kind: "reject" }) : next();
+	});
+}
+/**
+* Header-only ancestry for Agents without a published Activation. Include an
+* offline direct creator; ordinary forks stop the chain and cycles terminate.
+*/
+function headerAncestors(ctx, agent) {
+	const ancestors = [];
+	const visited = new Set([agent.id]);
+	let header = agent.session.header;
+	while (header.origin === "subagent" && header.parentSession !== void 0 && !visited.has(header.parentSession)) {
+		const parentId = header.parentSession;
+		ancestors.push(parentId);
+		visited.add(parentId);
+		const parent = ctx.agents.get(parentId)?.session;
+		if (parent === void 0) break;
+		header = parent.header;
+	}
+	return ancestors;
+}
+/**
+* Report the child's current projected label only when its descriptor belongs
+* to the child's own log; inherited, absent, or invalid identities yield the id alone.
+*/
+function describe(child, identity) {
+	const label = identity !== void 0 && child.session.isOwnSeq(identity.seq) ? identity.label : void 0;
+	return label === void 0 ? { id: child.id } : {
+		id: child.id,
+		label
+	};
+}
+//#endregion
 //#region lib/types/descriptor.js
 /**
 * The durable subagent-child descriptor: the versioned, model-hidden
@@ -574,7 +591,7 @@ function createSettlementMessage(childId, terminal, continuable = true, omitClos
 * to one activation's result contract rather than durable child composition.
 * Per-activation knobs such as `maxTokens` are omitted for the same reason as
 * `outputSchema`: they budget one activation. Cold resume requires the exact
-* live parent for authorization but reconstructs child options only from the
+* live subagent tree root for authorization but reconstructs child options only from the
 * durable descriptor, so it neither restores the prior budget nor inherits
 * the parent's current one; the resumed route's defaults apply instead.
 *
@@ -852,28 +869,23 @@ function establishExternalCatalogChild(parent, childId, label) {
 	});
 }
 //#endregion
-//#region lib/types/internal.js
+//#region lib/types/types.js
 /**
-* Continuation integration markers and host adapters outside the public
-* Service Definition and model-facing Agent messaging contract.
-* @module @deepseek-ai/dsh-subagent/internal
+* The seam's consumer-facing contracts: request, result, and capability types
+* for {@link SubagentProvider}, plus the `subagent/start` and `subagent/end`
+* payloads that plugins and hosts observe. Internal control interfaces, such
+* as the manager host, belong with their implementation.
+*
+* @module @deepseek-ai/dsh-subagent/types
 */
-/** Process-stable identity carried only by the standard adjacent-Agent messaging tool. */
-const adjacentAgentSendMessageTool = Symbol.for("dsh.subagent.adjacentAgentSendMessageTool");
 /**
-* Test whether one visible definition is the standard adjacent-Agent messaging tool.
-* @param definition - the scope-resolved `send_message` candidate.
-* @returns whether the definition carries the internal standard-tool identity.
+* Brand a string as a {@link SubagentRunId}.
+* @param id - the raw run id.
+* @returns the same string, branded.
 */
-function isAdjacentAgentSendMessageTool(definition) {
-	return definition !== void 0 && definition[adjacentAgentSendMessageTool] === true;
+function SubagentRunId(id) {
+	return id;
 }
-/**
-* Process-stable symbol-keyed host delivery shared by the bundled runtime
-* entry and this unbundled internal subpath.
-* @internal
-*/
-const deliverSubagentPrompt = Symbol.for("dsh.subagent.deliverPrompt");
 //#endregion
 //#region lib/types/structured.js
 /**
@@ -901,7 +913,7 @@ const STRUCTURED_OUTPUT_INSTRUCTION = `When you have your final answer, you MUST
 * @param childCtx - the child agent's scope context (`setup`'s argument).
 * @param schema - the trusted, already-asserted schema subset to enforce (see
 *   `assertObjectJsonSchema` in dsh-tools).
-* @param canComplete - whether accepted input and owned child work have finished.
+* @param canComplete - whether accepted input has been processed.
 * @returns the attachment handle (read `captured()` after the child settles).
 */
 function attachStructuredRuntime(childCtx, schema, canComplete) {
@@ -943,7 +955,7 @@ function attachStructuredRuntime(childCtx, schema, canComplete) {
 		execute(args, exec) {
 			const violations = validateJsonSchemaValue(schema, args);
 			if (violations.length > 0) throw new ToolArgsError(violations);
-			if (!canComplete()) throw new Error("Wait for all delegated child tasks to finish and process pending messages before submitting structured output.");
+			if (!canComplete()) throw new Error("Process pending messages before submitting structured output.");
 			staged.set(exec, { value: args });
 			exec.concludeTurn();
 			return Promise.resolve({ recorded: true });
@@ -1053,7 +1065,7 @@ function finalAssistantOutput(events) {
 /** Execution-period records, capacity slots, child serialization, and local output capture.
 * @module @deepseek-ai/dsh-subagent/activation
 */
-/** Process-local slots shared through uninterrupted continuable parent links. */
+/** Process-local capacity shared by every member of a subagent tree. */
 var ActivationPool = class {
 	slots = /* @__PURE__ */ new Set();
 	/**
@@ -1159,11 +1171,11 @@ var ChildLock = class {
 /**
 * Owns subagent startup, message admission, cold resume, and execution lifetimes.
 * One child lock orders input acceptance and closure; one activation map owns
-* capacity, parent relationships, and resource release across all providers.
+* capacity, runtime ownership, and resource release across all providers.
 *
 * @module @deepseek-ai/dsh-subagent/manager
 */
-var __addDisposableResource$2 = function(env, value, async) {
+var __addDisposableResource$1 = function(env, value, async) {
 	if (value !== null && value !== void 0) {
 		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
 		var dispose, inner;
@@ -1192,7 +1204,7 @@ var __addDisposableResource$2 = function(env, value, async) {
 	} else if (async) env.stack.push({ async: true });
 	return value;
 };
-var __disposeResources$2 = (function(SuppressedError) {
+var __disposeResources$1 = (function(SuppressedError) {
 	return function(env) {
 		function fail(e) {
 			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
@@ -1241,18 +1253,13 @@ var SubagentManager = class {
 	locks = new ChildLock();
 	/** Structural Cordis owner of every Activation handle. */
 	ownerCtx;
-	/**
-	* Exact roots whose host teardown has begun, with the live lineage members
-	* observed under each root. Entries remain until that exact root leaves the
-	* Agent registry, closing admission throughout its host's teardown without
-	* poisoning a later same-id replacement.
-	*/
-	closingScopes = /* @__PURE__ */ new Map();
+	/** Exact subagent tree roots whose host teardown has closed admission. */
+	closingRoots = /* @__PURE__ */ new Set();
 	draining = false;
 	/**
 	* Build one manager inside the service's Agent-injected context.
 	* @param ctx - context providing Agents, Sessions, and teardown ownership.
-	* @param host - provider dispatch and lifecycle observation owned by the service.
+	* @param host - descriptor reads and lifecycle publication owned by the service.
 	* @param maxActiveSubagents - the current configured child capacity.
 	* @param delegatedApproval - the configured approval policy seed for each local child.
 	*/
@@ -1263,8 +1270,12 @@ var SubagentManager = class {
 		this.delegatedApproval = delegatedApproval;
 		const scope = ctx.plugin(function activationOwner() {});
 		this.ownerCtx = scope.ctx;
+		installSubagentArchiveAdmission(ctx, (agent) => {
+			const activation = this.resident.get(agent.id);
+			return activation !== void 0 && activationAgent(activation) === agent ? activation.ancestors : void 0;
+		}, (session) => host.identityOf(session));
 		ctx.on("agent/disposed", ({ agent }) => {
-			this.closingScopes.delete(agent);
+			this.closingRoots.delete(agent);
 		});
 		ctx.effect(function* () {
 			yield scope.dispose;
@@ -1274,7 +1285,7 @@ var SubagentManager = class {
 	/**
 	* Interrupt one live continuable child's current turn under the supplied authority.
 	* @param targetSessionId - the durable child session id to interrupt.
-	* @param authority - the human parent address or exact live ancestor Agent.
+	* @param authority - a trusted user operation or exact live ancestor Agent.
 	*/
 	interrupt(targetSessionId, authority) {
 		if (authority.kind === "ancestor") {
@@ -1284,9 +1295,7 @@ var SubagentManager = class {
 		}
 		const activation = this.resident.get(targetSessionId);
 		if (activation === void 0) return;
-		if (authority.kind === "user") {
-			if (activation.parent.id !== authority.parentSessionId) throw new SubagentError(`subagent "${targetSessionId}" belongs to another parent session`, "UNAUTHORIZED");
-		} else if (!activation.ancestry.has(authority.agent)) throw new SubagentError(`subagent "${targetSessionId}" is not a live descendant of agent "${authority.agent.id}"`, "UNAUTHORIZED");
+		if (authority.kind === "ancestor" && (this.rootOf(authority.agent) !== activation.root || !activation.ancestors.includes(authority.agent.id))) throw new SubagentError(`subagent "${targetSessionId}" is not a live descendant of agent "${authority.agent.id}"`, "UNAUTHORIZED");
 		if (activation.closing !== void 0) return;
 		const kind = authority.kind === "user" ? "user" : "parent";
 		if (activation.kind === "local") activation.handle.agent.cancel({ kind }, { keepInbox: true });
@@ -1297,28 +1306,25 @@ var SubagentManager = class {
 	}
 	/**
 	* Close admission, await every already-admitted materialization through
-	* publication or rollback, then dispose the stable live Activation graph
-	* child-first.
+	* publication or rollback, then dispose every agent in the subagent tree.
 	*/
 	async drain() {
 		this.draining = true;
 		for (const pending of this.materializations) pending.controller.abort();
 		await Promise.all([...this.materializations].map((materialization) => materialization.settled));
-		const owned = /* @__PURE__ */ new Set();
-		for (const activation of this.resident.values()) for (const child of activation.ownedChildren) owned.add(child);
-		const roots = [...this.resident.values()].filter((activation) => !owned.has(activation.childId));
-		await this.disposeRoots(roots, "activation(s)");
+		await this.disposeRoots([...this.resident.values()], "activation(s)");
 	}
 	/**
-	* Join progressing child work, leaving idle parked inboxes resident.
-	* @param parent - exact live parent whose descendants are observed.
-	* @returns whether work was joined and the host must recheck parent completion.
+	* Join progressing subagent tree work for its root, leaving idle parked inboxes resident.
+	* @param root - exact live subagent tree root; ordinary members return false.
+	* @returns whether work was joined and the host must recheck root completion.
 	*/
-	async waitForChildren(parent) {
+	async waitForTreeWork(root) {
+		if (this.rootOf(root) !== root) return false;
 		let observed = false;
 		while (true) {
-			const pending = [...this.materializations].filter((item) => item.lineage.includes(parent));
-			const children = [...this.resident.values()].filter((item) => activationAgent(item) !== parent && item.ancestry.has(parent));
+			const pending = [...this.materializations].filter((item) => item.root === root);
+			const children = [...this.resident.values()].filter((item) => item.root === root);
 			observed ||= children.some((item) => item.kind === "local" && item.handle.agent.status !== "idle");
 			await Promise.all(children.flatMap((item) => item.kind === "local" ? [item.handle.agent.whenIdle()] : []));
 			const waits = pending.map((item) => item.settled);
@@ -1331,10 +1337,6 @@ var SubagentManager = class {
 					waits.push(item.handle.agent.whenIdle());
 					continue;
 				}
-				if (item.ownedChildren.size > 0) {
-					if ([...item.ownedChildren].some((id) => !this.resident.has(id))) waits.push(item.poke.promise);
-					continue;
-				}
 				const inbox = item.handle.agent.inbox;
 				if (item.failureAt === void 0 && (inbox.nextTurn.length > 0 || inbox.nextStep.length > 0)) continue;
 				waits.push(Promise.race([item.result.promise.catch(() => void 0), item.poke.promise]));
@@ -1344,114 +1346,73 @@ var SubagentManager = class {
 				await Promise.all(waits);
 				continue;
 			}
-			if ([...this.materializations].some((item) => item.lineage.includes(parent) && !pending.includes(item)) || [...this.resident.values()].some((item) => activationAgent(item) !== parent && item.ancestry.has(parent) && !children.includes(item))) continue;
+			if ([...this.materializations].some((item) => item.root === root && !pending.includes(item)) || [...this.resident.values()].some((item) => item.root === root && !children.includes(item))) continue;
 			return observed;
 		}
 	}
 	/**
-	* Stop the managed descendants of exact live host-owned parents.
-	* @param parents - exact live roots whose managed descendants must stop.
+	* Stop every member of the selected subagent trees; ordinary members do not close a subagent tree.
+	* @param parents - exact live subagent tree roots whose instances must stop.
 	*/
 	async drainDescendants(parents) {
-		const roots = new Set(parents.filter((parent) => this.ctx.agents.get(parent.id) === parent));
-		if (roots.size === 0) return;
-		for (const root of roots) this.closingMembers(root).add(root);
-		const targets = [];
-		for (const activation of this.resident.values()) {
-			const child = activationAgent(activation);
-			const lineage = this.liveLineage(child ?? activation.parent);
-			const owners = [...roots].filter((root) => child !== root && activation.ancestry.has(root));
-			if (owners.length === 0) continue;
-			targets.push(activation);
-			for (const owner of owners) {
-				const members = this.closingMembers(owner);
-				if (child !== void 0) members.add(child);
-				for (const agent of lineage) members.add(agent);
-			}
-		}
-		const materializations = [...this.materializations].filter((materialization) => {
-			const owners = [...roots].filter((root) => materialization.lineage.includes(root));
-			for (const owner of owners) {
-				const members = this.closingMembers(owner);
-				for (const agent of materialization.lineage) members.add(agent);
-			}
-			if (owners.length > 0) materialization.controller.abort();
-			return owners.length > 0;
-		});
-		const ownedTargets = /* @__PURE__ */ new Set();
-		for (const activation of targets) for (const child of activation.ownedChildren) ownedTargets.add(child);
-		const targetRoots = targets.filter((activation) => !ownedTargets.has(activation.childId));
-		for (const activation of targets) this.dispose(activation).catch(() => void 0);
-		await Promise.all(materializations.map((materialization) => materialization.settled));
-		await this.disposeRoots(targetRoots, "scoped activation(s)");
-	}
-	/**
-	* Release selected resident direct children of one exact live parent.
-	* @param parent - exact live direct parent authorizing the selected release.
-	* @param childIds - durable direct-child ids to release when resident.
-	*/
-	async drainChildren(parent, childIds) {
-		if (this.ctx.agents.get(parent.id) !== parent) throw new SubagentError("selected child teardown requires the exact live parent agent", "UNAUTHORIZED");
-		const targets = [];
-		for (const childId of new Set(childIds)) {
-			const activation = this.resident.get(childId);
-			if (activation === void 0) continue;
-			if (activation.parent.id !== parent.id || !activation.ancestry.has(parent)) throw new SubagentError(`subagent "${childId}" is not a direct child of agent "${parent.id}"`, "UNAUTHORIZED");
-			targets.push(activation);
-		}
-		for (const activation of targets) this.dispose(activation).catch(() => void 0);
-		await this.disposeRoots(targets, "selected activation(s)");
+		const roots = new Set(parents.filter((root) => this.ctx.agents.get(root.id) === root && this.rootOf(root) === root));
+		for (const root of roots) this.closingRoots.add(root);
+		const pending = [...this.materializations].filter((item) => roots.has(item.root));
+		for (const item of pending) item.controller.abort();
+		const targets = [...this.resident.values()].filter((item) => roots.has(item.root));
+		const disposal = this.disposeRoots(targets, "scoped activation(s)");
+		const [disposed] = await Promise.allSettled([disposal, ...pending.map((item) => item.settled)]);
+		if (disposed.status === "rejected") throw disposed.reason;
 	}
 	/**
 	* Start one continuable background child and resolve at initial inbox acceptance.
 	* Every earlier failure disposes any created handle and rolls back Activation
-	* and parent ownership without returning either id.
+	* and its capacity slot without returning either id.
 	* @param spec - provider, delegation request, and caller cancellation.
+	* @param prepare - creation contribution bound to the checked provider.
 	* @returns the durable child id and accepted initial prompt message id.
 	*/
-	async startLocal(spec) {
-		const request = spec.request;
-		const parent = request.parent;
+	async startLocal(spec, prepare) {
+		const parent = spec.parent;
 		this.assertAdmitting(parent);
-		const persistence = spec.delivery === "caller" ? this.ctx.get("sessionPersistence") : this.requirePersistence();
-		assertSubagentMaxDepth(request.maxDepth);
-		const childId = spec.childId ?? brandString(randomUUID());
-		this.assertChildIdAvailable(childId);
-		const childDepth = resolveChildDepth(parent, request.maxDepth);
-		const agentOptions = resolveChildAgentOptions(parent, request.agentOptions, childDepth);
-		const agentProvider = agentOptions.provider;
-		const agentModel = agentOptions.model;
-		const agentReasoningEffort = agentOptions.reasoningEffort;
-		const descriptor = snapshotSubagentDescriptor({
-			mode: "continuable",
-			provider: spec.provider,
-			label: spec.label,
-			...agentProvider !== void 0 ? { agentProvider } : {},
-			...agentModel !== void 0 ? { agentModel } : {},
-			...agentReasoningEffort !== void 0 ? { agentReasoningEffort } : {}
-		});
-		const delegatedPolicies = captureDelegatedPolicyOverrides(parent, this.delegatedApproval());
-		const releaseHold = this.holdOwnership(parent, childId);
-		try {
-			const cwd = await this.resolveDirectory(request, spec.signal);
-			const prepared = await this.host.prepareContinuable(spec.provider, {
+		const ancestry = this.ancestryForChild(parent);
+		return this.trackStartup(ancestry.root, spec.signal, async (signal) => {
+			const persistence = spec.delivery === "caller" ? this.ctx.get("sessionPersistence") : this.requirePersistence();
+			const childId = spec.childId ?? brandString(randomUUID());
+			this.assertChildIdAvailable(childId);
+			const childDepth = resolveChildDepth(parent, spec.maxDepth);
+			const agentOptions = resolveChildAgentOptions(parent, spec.agentOptions, childDepth);
+			const agentProvider = agentOptions.provider;
+			const agentModel = agentOptions.model;
+			const agentReasoningEffort = agentOptions.reasoningEffort;
+			const descriptor = snapshotSubagentDescriptor({
+				mode: "continuable",
+				provider: spec.provider,
+				label: spec.label,
+				...agentProvider !== void 0 ? { agentProvider } : {},
+				...agentModel !== void 0 ? { agentModel } : {},
+				...agentReasoningEffort !== void 0 ? { agentReasoningEffort } : {}
+			});
+			const delegatedPolicies = captureDelegatedPolicyOverrides(parent, this.delegatedApproval());
+			const cwd = await this.resolveDirectory(spec, signal);
+			const prepared = await prepare({
 				sessionId: childId,
 				cwd,
 				parent,
-				signal: spec.signal
+				signal
 			});
-			spec.signal.throwIfAborted();
+			signal.throwIfAborted();
 			this.assertAdmitting(parent);
 			const inheritedEventCount = SessionLogOffset(prepared.seed?.length ?? 0);
 			const seed = prepared.seed;
 			let established;
 			const messageId = await this.locks.run(childId, async () => {
-				spec.signal.throwIfAborted();
+				signal.throwIfAborted();
 				this.assertAdmitting(parent);
 				this.assertChildIdAvailable(childId);
 				if (spec.childId !== void 0) {
-					const persisted = await persistence?.stat(childId, { signal: spec.signal });
-					spec.signal.throwIfAborted();
+					const persisted = await persistence?.stat(childId, { signal });
+					signal.throwIfAborted();
 					this.assertAdmitting(parent);
 					this.assertChildIdAvailable(childId);
 					if (persisted !== void 0) throw new SubagentError(`subagent "${childId}" already exists`, "DUPLICATE_CHILD");
@@ -1460,29 +1421,33 @@ var SubagentManager = class {
 					kind: "local",
 					childId,
 					provider: spec.provider,
-					parent,
+					...ancestry,
 					create: {
+						parent,
 						cwd,
 						seed,
-						meta: childSessionMeta(parent, childDepth, prepared.seed !== void 0, request.agentPreset),
+						meta: childSessionMeta(parent, childDepth, prepared.seed !== void 0, spec.agentPreset),
 						inheritedEventCount,
 						delegatedPolicies,
 						descriptor
 					},
 					agentOptions,
-					composition: { agentPreset: request.agentPreset },
-					signal: spec.signal,
+					composition: { agentPreset: spec.agentPreset },
+					signal,
 					delivery: spec.delivery,
-					outputSchema: spec.request.outputSchema
+					outputSchema: spec.outputSchema
 				});
 				established = activation;
-				const child = requireLocalActivation(activation).handle.agent;
-				const childHeader = child.session.header;
-				return await this.submitMaterialized(activation, spec.delivery !== "caller" && isAdjacentAgentSendMessageTool(this.ctx.get("tools")?.get("send_message", child)) ? withContinuableReturnGuidance(parent.id, request.prompt) : request.prompt, {
+				const childHeader = requireLocalActivation(activation).handle.agent.session.header;
+				return await this.submitMaterialized(activation, spec.delivery !== "caller" ? withResultDeliveryGuidance(spec.prompt) : spec.prompt, {
 					source: { kind: "user" },
-					signal: spec.signal,
-					delivery: "queue"
-				}, parent, () => {
+					signal,
+					delivery: "queue",
+					authorize: () => {
+						this.assertAdmitting(parent);
+					}
+				}, ancestry.root, () => {
+					this.assertAdmitting(parent);
 					establishCatalogChild(parent.session, childHeader, descriptor);
 				});
 			});
@@ -1491,54 +1456,49 @@ var SubagentManager = class {
 				childId,
 				messageId
 			};
-		} catch (error) {
-			releaseHold();
-			throw error;
-		}
+		});
 	}
 	/**
 	* Start an external backend under activation ownership.
 	* @param spec - task, provider, cancellation, and delivery policy.
+	* @param start - execution bound to the checked provider.
 	* @returns the accepted activation and its result/disposal capabilities.
 	*/
-	async startExternal(spec) {
-		const parent = spec.request.parent;
+	async startExternal(spec, start) {
+		const { provider, delivery, childId: _childId, ...request } = spec;
+		const parent = request.parent;
 		this.assertAdmitting(parent);
-		const pendingId = brandString(randomUUID());
-		const releaseHold = this.holdOwnership(parent, pendingId);
-		let activation;
-		try {
-			const cwd = await this.resolveDirectory(spec.request, spec.signal);
-			activation = await this.materialize({
-				kind: "external",
-				childId: pendingId,
-				provider: spec.provider,
-				parent,
-				signal: spec.signal,
-				delivery: spec.delivery,
-				start: (signal) => this.host.startExternal(spec.provider, {
-					...spec.request,
-					cwd,
-					label: spec.label,
-					signal
-				})
-			});
-			this.assertAdmitting(parent);
-			this.assertLiveParent(parent, activation.childId);
-			spec.signal.throwIfAborted();
-			if (spec.delivery === "parent") establishExternalCatalogChild(parent.session, activation.childId, spec.label);
-			this.announce(activation);
-			return this.receipt(activation);
-		} catch (error) {
-			if (activation !== void 0) try {
-				await this.dispose(activation);
-			} catch (cleanupError) {
-				this.ctx.logger.warn(`subagent "${activation.childId}" admission rollback failed: ${failureMessage(cleanupError)}`);
+		const ancestry = this.ancestryForChild(parent);
+		return this.trackStartup(ancestry.root, spec.signal, async (signal) => {
+			let activation;
+			try {
+				const cwd = await this.resolveDirectory(spec, signal);
+				activation = await this.materialize({
+					kind: "external",
+					provider,
+					...ancestry,
+					signal,
+					delivery,
+					start: (signal) => start({
+						...request,
+						cwd,
+						signal
+					})
+				});
+				this.assertAdmitting(parent);
+				signal.throwIfAborted();
+				if (delivery === "parent") establishExternalCatalogChild(parent.session, activation.childId, spec.label);
+				this.accept(activation);
+				return this.receipt(activation);
+			} catch (error) {
+				if (activation !== void 0) try {
+					await this.dispose(activation);
+				} catch (cleanupError) {
+					this.ctx.logger.warn(`subagent "${activation.childId}" admission rollback failed: ${failureMessage(cleanupError)}`);
+				}
+				throw error;
 			}
-			throw error;
-		} finally {
-			releaseHold();
-		}
+		});
 	}
 	/** Capture the explicit or inherited directory while the parent still owns startup. */
 	async resolveDirectory(request, signal) {
@@ -1547,60 +1507,125 @@ var SubagentManager = class {
 		return cwd;
 	}
 	/**
-	* Deliver one model-authored message to a direct continuable child or to the
-	* sender's direct parent. A missing direct child cold-resumes through the
-	* ordinary continuation lifecycle.
-	* @param sender - exact live Agent authorizing and originating the message.
-	* @param targetId - durable direct-parent or direct-child session id.
-	* @param content - model-authored content to deliver.
-	* @param options - caller cancellation before acceptance.
-	* @returns the accepted message's inbox id.
+	* Resolve the live subagent tree root from runtime ownership, independent of creator residency.
+	* @param caller - exact live Agent selecting the subagent tree.
+	* @returns the live subagent tree root.
+	* @throws when the caller has no active runtime owner.
+	*/
+	rootOf(caller) {
+		if (this.ctx.agents.get(caller.id) !== caller) throw new SubagentError("subagent tree access requires the exact live caller", "UNAUTHORIZED");
+		const identity = this.host.identityOf(caller.session);
+		const delegated = caller.session.header.origin === "subagent" || identity != null && caller.session.isOwnSeq(identity.seq);
+		const activation = this.resident.get(caller.id);
+		if (activation !== void 0 && activationAgent(activation) === caller && this.ctx.agents.get(activation.root.id) === activation.root) return activation.root;
+		if (delegated || activation !== void 0) throw new SubagentError("agent has no active runtime owner", "UNAUTHORIZED");
+		return caller;
+	}
+	/** Capture creation ancestry separately from the root that owns the new instance. */
+	ancestryForChild(creator) {
+		return {
+			root: this.rootOf(creator),
+			ancestors: [...this.resident.get(creator.id)?.ancestors ?? [], creator.id]
+		};
+	}
+	/**
+	* Deliver to another agent in the subagent tree, restoring only the target when absent.
+	* @param sender - exact live root or resident continuable Agent.
+	* @param targetId - another member's durable Session id.
+	* @param content - model-authored message blocks.
+	* @param options - cancellation before inbox acceptance.
+	* @returns the accepted inbox message id.
 	*/
 	async sendMessage(sender, targetId, content, options) {
-		if (this.ctx.agents.get(sender.id) !== sender) throw new SubagentError("message delivery requires the exact live sender agent", "UNAUTHORIZED");
+		options.signal.throwIfAborted();
+		const root = this.rootOf(sender);
+		if (sender.id === targetId) throw new SubagentError("send_message requires another agent in the subagent tree", "UNAUTHORIZED");
 		this.assertAdmitting(sender);
-		const senderActivation = this.resident.get(sender.id);
-		if (senderActivation !== void 0 && senderActivation.kind === "local" && senderActivation.handle.agent === sender && senderActivation.parent.id === targetId) {
-			options.signal.throwIfAborted();
-			return this.sendToParent(senderActivation, sender, content);
-		}
-		if (sender.session.header.parentSession === targetId) throw new SubagentError(`agent "${sender.id}" is not a resident continuable child and cannot send to parent "${targetId}"`, "UNAUTHORIZED");
-		return this.deliverToChild(sender, targetId, content, {
+		const message = createAgentMessage(sender, content);
+		const activation = this.resident.get(sender.id);
+		return this.deliverToMember(root, targetId, [...message.content], {
 			signal: options.signal,
-			delivery: "steer"
+			delivery: "steer",
+			source: message.source,
+			authorize: () => {
+				this.assertAdmitting(sender);
+			},
+			onAccepted: () => {
+				if (activation?.kind === "local" && activation.ancestors.at(-1) === targetId) activation.omitClosingText = true;
+			}
 		});
 	}
-	/**
-	* Queue one human-authored prompt as a distinct direct-child turn.
-	* @param parent - exact live direct parent authorizing delivery.
-	* @param childId - durable direct-child session id.
-	* @param content - model-visible prompt blocks.
-	* @param source - durable attribution for the human prompt.
-	* @param signal - caller cancellation before inbox acceptance.
-	* @returns the accepted durable message id.
-	*/
-	async queuePrompt(parent, childId, content, source, signal) {
-		return this.deliverToChild(parent, childId, content, {
-			source,
-			signal,
-			delivery: "queue"
-		});
+	/** Resolve the live owner through verified creation edges without activating ancestors. */
+	async resolveCreationAncestry(source, signal, root) {
+		const ancestors = [];
+		const seen = new Set([source.header.id]);
+		let { header, projections, inheritedEventCount } = source;
+		while (true) {
+			const env_1 = {
+				stack: [],
+				error: void 0,
+				hasError: false
+			};
+			try {
+				signal.throwIfAborted();
+				const parentId = header.parentSession;
+				const identity = projections?.values.subagent;
+				if (parentId === void 0 || identity == null || identity.seq < inheritedEventCount) break;
+				if (seen.has(parentId)) throw new SubagentError("cyclic subagent creation ancestry", "UNAUTHORIZED");
+				seen.add(parentId);
+				const parent = __addDisposableResource$1(env_1, await this.observeContinuation(parentId, signal), false);
+				if (!parent.projections?.values.subagentCatalog?.some((entry) => entry.id === header.id)) throw new SubagentError("subagent is absent from its creator catalog", "UNAUTHORIZED");
+				ancestors.unshift(parentId);
+				if (parentId === root?.id) return {
+					root,
+					ancestors
+				};
+				({header, projections, inheritedEventCount} = parent);
+			} catch (e_1) {
+				env_1.error = e_1;
+				env_1.hasError = true;
+			} finally {
+				__disposeResources$1(env_1);
+			}
+		}
+		if (root === void 0 && ancestors.length > 0 && header.origin !== "subagent") {
+			const owner = this.ctx.agents.get(header.id);
+			if (owner === void 0 || this.rootOf(owner) !== owner) throw new SubagentError("subagent tree root is not live", "CONTINUATION_UNAVAILABLE");
+			return {
+				root: owner,
+				ancestors
+			};
+		}
+		throw new SubagentError(`agent "${source.header.id}" is not a member of this subagent tree`, "UNAUTHORIZED");
 	}
 	/**
-	* Steer one host-authored prompt to a direct continuable child.
-	* @param parent - exact live direct parent authorizing delivery.
-	* @param childId - durable direct-child session id.
+	* Deliver one host-authored prompt through the target's live subagent tree root.
+	* Remote callers must be authorized for the target Session before invoking this operation.
+	* @param childId - durable continuable subagent session id.
 	* @param content - model-visible prompt blocks.
-	* @param source - durable attribution for the host prompt.
-	* @param signal - caller cancellation before inbox acceptance.
+	* @param options - inbox destination, durable attribution, and cancellation before acceptance.
 	* @returns the accepted durable message id.
 	*/
-	async steerPrompt(parent, childId, content, source, signal) {
-		return this.deliverToChild(parent, childId, content, {
-			source,
-			signal,
-			delivery: "steer"
-		});
+	async deliverPrompt(childId, content, options) {
+		options.signal.throwIfAborted();
+		let root = this.resident.get(childId)?.root;
+		if (root === void 0) {
+			const env_2 = {
+				stack: [],
+				error: void 0,
+				hasError: false
+			};
+			try {
+				const source = __addDisposableResource$1(env_2, await this.observeContinuation(childId, options.signal), false);
+				({root} = await this.resolveCreationAncestry(source, options.signal));
+			} catch (e_2) {
+				env_2.error = e_2;
+				env_2.hasError = true;
+			} finally {
+				__disposeResources$1(env_2);
+			}
+		}
+		return this.deliverToMember(root, childId, content, options);
 	}
 	/** Admit local input synchronously before any teardown can begin. */
 	deliver(activation, message, delivery) {
@@ -1618,32 +1643,6 @@ var SubagentManager = class {
 		if (this.resident.has(childId) || this.ctx.agents.get(childId) !== void 0 || this.ctx.get("sessions")?.get(childId) !== void 0) throw new SubagentError(`subagent "${childId}" already exists`, "DUPLICATE_CHILD");
 	}
 	/**
-	* Pre-register `childId` in a continuation-managed parent's owned set so the
-	* parent cannot settle while a caller is still establishing or resuming that
-	* child. Returns a releaser for the failure path; it removes only a hold
-	* this call added, and leaves ownership in place once a live Activation for
-	* the child exists.
-	* @param parent - the live direct parent the operation is admitted under.
-	* @param childId - the durable child the operation addresses.
-	* @returns the failure-path releaser; a no-op when nothing was added.
-	*/
-	holdOwnership(parent, childId) {
-		const parentActivation = this.resident.get(parent.id);
-		if (parentActivation === void 0 || activationAgent(parentActivation) !== parent) return () => {};
-		if (parentActivation.closing !== void 0) throw new SubagentError(`subagent parent "${parent.id}" is being disposed; the child was not established`, "ACTIVATION_CLOSING");
-		if (parentActivation.ownedChildren.has(childId)) return () => {};
-		parentActivation.ownedChildren.add(childId);
-		return () => {
-			const live = this.resident.get(childId);
-			/* v8 ignore next 4 -- reaching this arm needs another delivery to establish the child
-			* between this operation's failure and its releaser running, which no test can schedule
-			* deterministically: the ownership edge then belongs to that live Activation, so the
-			* conservative keep leaves it for finishDisposal's releaseOwnership. */
-			if (live !== void 0 && live.closing === void 0) return;
-			if (parentActivation.ownedChildren.delete(childId)) this.wake(parentActivation);
-		};
-	}
-	/**
 	* Apply activation admission to a resident parent before delivering input.
 	* @param parent - exact live Agent receiving the message.
 	* @param message - durable user message to deliver.
@@ -1663,27 +1662,16 @@ var SubagentManager = class {
 		else parent.followup(message);
 	}
 	/**
-	* Reject new admission once the manager or this exact parent tree began draining.
-	* @param agent - exact live Agent whose lineage determines admission.
+	* Reject new work from closing members or subagent trees.
+	* @param agent - exact live caller whose instance and subagent tree must admit work.
 	*/
 	assertAdmitting(agent) {
 		const closing = this.closingTeardownFor(agent);
-		if (closing === void 0) return;
-		throw new SubagentError(closing === "manager" ? "subagents are draining; the operation was not admitted" : `subagents below parent "${closing.id}" are draining; the operation was not admitted`, "DRAINING");
-	}
-	/**
-	* Authorize one operation against the durable direct-parent lineage.
-	* @param parent - exact live Agent claiming direct-parent authority.
-	* @param childId - durable child session id addressed by the operation.
-	* @param parentSession - durable direct-parent id recorded by the child.
-	*/
-	authorizeLineage(parent, childId, parentSession) {
-		this.assertLiveParent(parent, childId);
-		if (parentSession !== parent.id) throw new SubagentError(`subagent "${childId}" belongs to another parent session`, "UNAUTHORIZED");
-	}
-	/** Reject parent authority after the live registry entry changes. */
-	assertLiveParent(parent, childId) {
-		if (this.ctx.agents.get(parent.id) !== parent) throw new SubagentError(`subagent "${childId}" delivery requires the exact live parent agent`, "UNAUTHORIZED");
+		if (closing === void 0) {
+			if (this.resident.get(agent.id)?.closing !== void 0) throw new SubagentError(`subagent "${agent.id}" is closing`, "ACTIVATION_CLOSING");
+			return;
+		}
+		throw new SubagentError(closing === "manager" ? "subagents are draining; the operation was not admitted" : `subagent tree "${closing.id}" is draining; the operation was not admitted`, "DRAINING");
 	}
 	/**
 	* Create or resume one child Agent and publish its Activation.
@@ -1691,25 +1679,28 @@ var SubagentManager = class {
 	* @returns the published process-local Activation.
 	*/
 	materialize(inputs) {
-		this.assertAdmitting(inputs.parent);
+		this.assertAdmitting(inputs.root);
 		inputs.signal.throwIfAborted();
-		const lineage = this.liveLineage(inputs.parent);
-		const pool = this.resident.get(inputs.parent.id)?.pool ?? this.rootPool(inputs.parent);
-		const releaseSlot = pool.reserve(this.maxActiveSubagents());
+		const releaseSlot = this.rootPool(inputs.root).reserve(this.maxActiveSubagents());
+		return this.materializeTracked(inputs, releaseSlot).catch((error) => {
+			releaseSlot();
+			throw error;
+		});
+	}
+	/** Keep subagent tree shutdown and host waits joined to preparation, publication, and rollback. */
+	trackStartup(root, signal, start) {
+		this.assertAdmitting(root);
+		signal.throwIfAborted();
 		const settled = Promise.withResolvers();
 		const controller = new AbortController();
 		const materialization = {
-			lineage,
+			root,
 			settled: settled.promise,
 			controller
 		};
 		this.materializations.add(materialization);
-		return this.materializeTracked({
-			...inputs,
-			signal: AbortSignal.any([inputs.signal, controller.signal])
-		}, lineage, pool, releaseSlot).catch((error) => {
-			releaseSlot();
-			if (error instanceof Error && error.name === "AbortError") this.assertAdmitting(inputs.parent);
+		return start(AbortSignal.any([signal, controller.signal])).catch((error) => {
+			if (error instanceof Error && error.name === "AbortError") this.assertAdmitting(root);
 			throw error;
 		}).finally(() => {
 			this.materializations.delete(materialization);
@@ -1744,35 +1735,13 @@ var SubagentManager = class {
 		}))).filter((failure) => failure !== void 0);
 		if (reasons.length > 0) throw new SubagentError(`subagent teardown failed for ${reasons.length} ${failureSubject}: ` + reasons.map((reason) => failureMessage(reason)).join("; "), "ACTIVATION_TEARDOWN_FAILED");
 	}
-	/** Return the retained member set for one exact scoped-teardown root. */
-	closingMembers(root) {
-		const existing = this.closingScopes.get(root);
-		if (existing !== void 0) return existing;
-		const members = /* @__PURE__ */ new Set();
-		this.closingScopes.set(root, members);
-		return members;
-	}
-	/** Return the exact currently resolvable ancestry from `agent` upward. */
-	liveLineage(agent) {
-		const lineage = [agent];
-		const seen = new Set([agent.id]);
-		let parentSession = agent.session.header.parentSession;
-		while (parentSession !== void 0) {
-			const parent = this.ctx.agents.get(parentSession);
-			if (parent === void 0 || seen.has(parent.id)) break;
-			lineage.push(parent);
-			seen.add(parent.id);
-			parentSession = parent.session.header.parentSession;
-		}
-		return lineage;
-	}
-	/** Return the teardown that closed continuable admission for this agent's lineage. */
+	/** Return the subagent tree teardown that closed admission for this exact Agent. */
 	closingTeardownFor(agent) {
 		if (this.draining) return "manager";
-		const lineage = this.liveLineage(agent);
-		for (const [root, members] of this.closingScopes) if (members.has(agent) || lineage.includes(root)) return root;
+		const root = this.rootOf(agent);
+		return this.closingRoots.has(root) ? root : void 0;
 	}
-	/** Resolve a root's pool once; descendants inherit their resident parent's pool directly. */
+	/** Share one capacity pool across every instance in a subagent tree. */
 	rootPool(parent) {
 		let pool = this.rootPools.get(parent);
 		if (pool === void 0) {
@@ -1782,9 +1751,8 @@ var SubagentManager = class {
 		return pool;
 	}
 	/** Perform one tracked materialization through publication or rollback. */
-	async materializeTracked(inputs, parentLineage, pool, releaseSlot) {
-		const { provider, parent } = inputs;
-		let childId = inputs.childId;
+	async materializeTracked(inputs, releaseSlot) {
+		const { provider, root } = inputs;
 		inputs.signal.throwIfAborted();
 		let resource;
 		if (inputs.kind === "external") {
@@ -1801,9 +1769,8 @@ var SubagentManager = class {
 					controller
 				};
 				run.result.catch(() => void 0);
-				childId = run.id;
 				try {
-					this.assertChildIdAvailable(childId);
+					this.assertChildIdAvailable(run.id);
 				} catch (error) {
 					await run.dispose();
 					throw error;
@@ -1812,11 +1779,11 @@ var SubagentManager = class {
 				inputs.signal.removeEventListener("abort", cancelStartup);
 			}
 		} else {
-			const { create } = inputs;
+			const { create, childId } = inputs;
 			let structured;
 			const setup = async (childCtx, child) => {
 				const approvalPolicy = create?.delegatedPolicies.approvalPolicy ?? childCtx.get("approval")?.effectivePolicy(child.session);
-				if (inputs.composition.agentPreset !== void 0) await applyChildComposition(childCtx, parent, inputs.composition, approvalPolicy);
+				if (inputs.composition.agentPreset !== void 0) await applyChildComposition(childCtx, create?.parent, inputs.composition, approvalPolicy);
 				if (create !== void 0) {
 					if (inputs.composition.agentPreset !== void 0) child.session.append("agent-preset/selected", { agentPreset: inputs.composition.agentPreset });
 					child.session.append("subagent/descriptor", create.descriptor);
@@ -1825,18 +1792,16 @@ var SubagentManager = class {
 					if (workingDirectory === void 0) throw new Error("local subagents require the working-directory service");
 					await workingDirectory.set(child, create.cwd, inputs.signal);
 				}
-				if (inputs.composition.agentPreset === void 0) await applyChildComposition(childCtx, parent, inputs.composition, approvalPolicy);
-				if (inputs.outputSchema !== void 0) structured = attachStructuredRuntime(childCtx, inputs.outputSchema, () => this.resident.get(childId)?.ownedChildren.size === 0 && child.inbox.nextStep.length === 0 && child.inbox.nextTurn.length === 0);
+				if (inputs.composition.agentPreset === void 0) await applyChildComposition(childCtx, create?.parent, inputs.composition, approvalPolicy);
+				if (inputs.outputSchema !== void 0) structured = attachStructuredRuntime(childCtx, inputs.outputSchema, () => child.inbox.nextStep.length === 0 && child.inbox.nextTurn.length === 0);
 			};
 			const handle = create === void 0 ? await this.ownerCtx.agents.resume({
 				resumeSessionId: childId,
-				parentAgent: parent,
 				agentOptions: inputs.agentOptions,
 				signal: inputs.signal,
 				setup
 			}) : await this.ownerCtx.agents.create({
 				sessionId: childId,
-				parentAgent: parent,
 				meta: create.meta,
 				...create.seed === void 0 ? {} : { seed: create.seed },
 				inheritedEventCount: create.inheritedEventCount,
@@ -1854,28 +1819,25 @@ var SubagentManager = class {
 				omitClosingText: false
 			};
 		}
-		const observer = this.host.observeActivation(provider, childId, parent);
+		const childId = resource.kind === "local" ? resource.handle.agent.id : resource.run.id;
 		const activation = {
-			pool,
 			releaseSlot,
 			childId,
+			runId: SubagentRunId(randomUUID()),
+			provider,
 			...resource,
-			parent,
+			root,
+			ancestors: inputs.ancestors,
 			delivery: inputs.delivery ?? "parent",
 			result: Promise.withResolvers(),
 			closing: void 0,
-			ancestry: new WeakSet(resource.kind === "external" ? parentLineage : [resource.handle.agent, ...parentLineage]),
-			ownedChildren: /* @__PURE__ */ new Set(),
-			observer,
-			announced: false
+			accepted: false
 		};
 		activation.result.promise.catch(() => void 0);
 		this.resident.set(childId, activation);
 		try {
-			this.assertAdmitting(parent);
+			this.assertAdmitting(root);
 			inputs.signal.throwIfAborted();
-			if (this.ctx.agents.get(parent.id) !== parent) throw new SubagentError("subagent parent is no longer live", "UNAUTHORIZED");
-			this.acquireOwnership(parent, childId);
 			const wakeSettlement = () => {
 				this.wake(activation);
 			};
@@ -1891,7 +1853,7 @@ var SubagentManager = class {
 					if (event.type === "tool/call") activation.omitClosingText = false;
 				});
 			}
-			observer.start(activationAgent(activation));
+			this.host.emitLifecycle("subagent/start", this.runInfo(activation), root);
 		} catch (error) {
 			/* v8 ignore next -- rollback failure must not mask the admission failure
 			* that prevented this operation from returning an accepted message id. */
@@ -1900,13 +1862,19 @@ var SubagentManager = class {
 		}
 		return activation;
 	}
-	/**
-	* Begin settlement observation after initial acceptance is recorded.
-	* @param activation - accepted activation to observe.
-	*/
-	announce(activation) {
-		if (activation.announced) return;
-		activation.announced = true;
+	/** Identity shared by one residency epoch's start/end pair, including cold resumes. */
+	runInfo(activation) {
+		return {
+			runId: activation.runId,
+			provider: activation.provider,
+			parentSessionId: activation.ancestors.at(-1),
+			id: activation.childId,
+			local: activation.kind === "local"
+		};
+	}
+	/** Record acceptance and begin settlement observation before returning the receipt. */
+	accept(activation) {
+		activation.accepted = true;
 		if (activation.kind === "local") this.watchLocalSettlement(activation);
 		else {
 			const finish = () => this.close(activation, () => this.finishDisposal(activation, false));
@@ -1923,23 +1891,10 @@ var SubagentManager = class {
 			} finally {
 				this.resident.delete(activation.childId);
 				activation.releaseSlot();
-				this.releaseOwnership(activation.childId);
 				activation.result.reject(error);
 			}
 		});
 	}
-	/** Register the child in a continuation-managed parent's owned set. */
-	acquireOwnership(parent, childId) {
-		const parentActivation = this.resident.get(parent.id);
-		if (parentActivation === void 0) return;
-		if (parentActivation.closing !== void 0) throw new SubagentError(`subagent parent "${parent.id}" is being disposed; the child was not established`, "ACTIVATION_CLOSING");
-		parentActivation.ownedChildren.add(childId);
-		this.wake(parentActivation);
-	}
-	/** Remove one child from its live owner's set and let that owner re-check settlement. */
-	releaseOwnership(childId) {
-		for (const candidate of this.resident.values()) if (candidate.ownedChildren.delete(childId)) this.wake(candidate);
-	}
 	/** Let a settlement watcher re-check residency after relevant state changes. */
 	wake(activation) {
 		if (activation.kind === "external") return;
@@ -1994,16 +1949,15 @@ var SubagentManager = class {
 	reportTeardownFailure(activation, error) {
 		this.ctx.logger.warn(`subagent "${activation.childId}" activation teardown failed: ${failureMessage(error)}`);
 	}
-	/** Check pending input and owned children before closing admission. */
+	/** Check pending input before closing admission. */
 	settlementState(activation, observation) {
 		if (activation.closing !== void 0) return "closed";
 		if (activation.poke !== observation) return "retry";
 		const inbox = activation.handle.agent.inbox;
-		if (activation.ownedChildren.size > 0) return "wait";
 		if (activation.failureAt === void 0 && (inbox.nextTurn.length > 0 || inbox.nextStep.length > 0)) return "wait";
 		return "ready";
 	}
-	/** Propagate stop synchronously and await descendant startup rollback before release. */
+	/** Stop and release one instance without affecting its creation descendants. */
 	async finishDisposal(activation, stop) {
 		this.wake(activation);
 		const { childId } = activation;
@@ -2027,22 +1981,7 @@ var SubagentManager = class {
 			} else {
 				if (stop) {
 					activation.handle.agent.cancel({ kind: "parent" });
-					const idle = activation.handle.agent.whenIdle();
-					const children = [...activation.ownedChildren].map((child) => this.resident.get(child)).filter((child) => child !== void 0);
-					const pending = [...this.materializations].filter((item) => item.lineage.includes(activation.handle.agent));
-					const childDisposals = children.map((child) => this.dispose(child));
-					for (const item of pending) item.controller.abort();
-					childDisposals.push(...pending.map((item) => item.settled));
-					const reasons = (await Promise.all(childDisposals.map(async (disposal) => {
-						try {
-							await disposal;
-							return;
-						} catch (error) {
-							return error;
-						}
-					}))).filter((reason) => reason !== void 0);
-					if (reasons.length > 0) failures.push(new SubagentError(`subagent "${childId}" child teardown failed: ${reasons.map((reason) => failureMessage(reason)).join("; ")}`, "ACTIVATION_TEARDOWN_FAILED"));
-					await idle;
+					await activation.handle.agent.whenIdle();
 					await this.flushFinalState(activation);
 				}
 				result = captureLocalResult(activation);
@@ -2067,18 +2006,22 @@ var SubagentManager = class {
 			stopReason: "error"
 		};
 		this.notifySettlement(activation, result);
-		this.releaseOwnership(childId);
-		activation.observer.settle(terminal);
+		this.host.emitLifecycle("subagent/end", {
+			...this.runInfo(activation),
+			stopReason: terminal.stopReason,
+			...terminal.output.length === 0 ? {} : { lastAssistantMessage: terminal.output }
+		}, activation.root);
 		if (resultFailure === void 0) activation.result.resolve(result);
 		else activation.result.reject(resultFailure.error);
 		if (failure !== void 0) throw failure;
 	}
 	/** Deliver the captured execution result to the durable direct parent after cleanup. */
 	notifySettlement(activation, terminal) {
-		if (!activation.announced || activation.delivery === "caller") return;
+		if (!activation.accepted || activation.delivery === "caller") return;
 		try {
-			const parent = this.ctx.agents.get(activation.parent.id);
-			if (parent !== activation.parent) return;
+			const parentId = activation.ancestors.at(-1);
+			const parent = this.ctx.agents.get(parentId);
+			if (parent === void 0 || this.rootOf(parent) !== activation.root) return;
 			const message = createSettlementMessage(activation.childId, terminal, activation.kind === "local", activation.kind === "local" && activation.omitClosingText);
 			if (this.closingTeardownFor(parent) !== void 0) {
 				parent.inject(message);
@@ -2105,124 +2048,100 @@ var SubagentManager = class {
 			dispose: () => this.dispose(activation)
 		};
 	}
-	/** Route one parent-originated delivery through residency and cold resume. */
-	async deliverToChild(parent, childId, content, options) {
-		this.assertAdmitting(parent);
-		const releaseHold = this.holdOwnership(parent, childId);
-		try {
-			return await this.deliverFollowup(parent, childId, content, options);
-		} catch (error) {
-			releaseHold();
-			throw error;
-		}
-	}
-	/** The delivery loop behind {@link deliverToChild}, run under the parent hold. */
-	async deliverFollowup(parent, childId, content, options) {
+	/** Serialize target restoration and inbox admission; closure is awaited outside the lock. */
+	async deliverToMember(root, childId, content, options) {
 		while (true) {
-			const live = await this.locks.run(childId, async () => {
+			this.assertAdmitting(root);
+			options.signal.throwIfAborted();
+			const result = await this.locks.run(childId, async () => {
+				if (childId === root.id) {
+					if (contentHasImage(content)) await this.assertImageCapable(root, options.signal);
+					options.signal.throwIfAborted();
+					options.authorize?.();
+					this.assertAdmitting(root);
+					const message = createUserMessage({
+						content,
+						source: options.source
+					});
+					this.sendWaking(root, message, options.delivery);
+					options.onAccepted?.();
+					return { messageId: message.id };
+				}
 				const activation = this.resident.get(childId);
-				if (activation === void 0) return this.coldResume(parent, childId, content, options);
-				requireLocalActivation(activation);
-				const disposal = activation.closing;
-				/* v8 ignore next 3 -- the send-versus-dispose cutoff needs a delivery to
-				* observe the transaction inside the same critical section that opened it. */
-				if (disposal !== void 0) return disposal.then(() => void 0, () => void 0);
-				if (contentHasImage(content)) {
-					await this.assertImageCapable(requireLocalActivation(activation).handle.agent, options.signal);
-					if (activation.closing !== void 0) {
-						await Promise.allSettled([activation.closing]);
-						return;
-					}
+				if (activation === void 0) {
+					const restored = await this.restoreTarget(root, childId, options.signal);
+					return { messageId: await this.submitMaterialized(restored, content, options, root) };
 				}
-				const messageId = this.submitAdmitted(activation, content, options, parent);
-				this.announce(activation);
-				return messageId;
+				if (activation.root !== root) throw new SubagentError("target belongs to another subagent tree", "UNAUTHORIZED");
+				requireLocalActivation(activation);
+				if (activation.closing === void 0 && contentHasImage(content)) await this.assertImageCapable(requireLocalActivation(activation).handle.agent, options.signal);
+				if (activation.closing !== void 0) return { closing: activation.closing };
+				return { messageId: this.submitAdmitted(activation, content, options, root) };
 			});
-			/* v8 ignore start -- only a delivery that lost the disposal cutoff retries. */
-			if (live !== void 0) return live;
-			this.assertAdmitting(parent);
-			options.signal.throwIfAborted();
+			if ("messageId" in result) return result.messageId;
+			await Promise.allSettled([result.closing]);
 		}
 	}
-	/** Deliver one resident continuable child's message to its live direct parent. */
-	sendToParent(activation, sender, content) {
-		/* v8 ignore next 6 -- only synchronous re-entrant teardown can open this
-		* transaction between exact-agent authorization and this no-await span. */
-		if (activation.closing !== void 0) throw new SubagentError(`subagent "${sender.id}" activation is being disposed; the message was not delivered`, "ACTIVATION_CLOSING");
-		const parent = this.ctx.agents.get(activation.parent.id);
-		if (parent !== activation.parent) throw new SubagentError("direct parent is not live; the message was not delivered", "PARENT_UNAVAILABLE");
-		const message = createAgentMessage(sender, content);
-		this.sendAgentMessage(parent, message);
-		activation.omitClosingText = true;
-		return message.id;
-	}
-	/** Send one Agent message while translating only the target's own rejection. */
-	sendAgentMessage(parent, message) {
+	/** Read continuation history, preserving cancellation and reporting unavailable storage. */
+	async observeContinuation(childId, signal) {
+		const query = this.requireSessionQuery();
 		try {
-			this.sendWaking(parent, message, "steer");
+			return await query.observeSession(childId, { signal });
 		} catch (error) {
-			throw new SubagentError("direct parent is not live; the message was not delivered", "PARENT_UNAVAILABLE", { cause: error });
+			signal.throwIfAborted();
+			throw new SubagentError(`subagent "${childId}" is unavailable`, "NOT_RESUMABLE", { cause: error });
 		}
 	}
-	/**
-	* Cold-resume a persisted child and submit the waiting turn. The descriptor
-	* supplies every reconstruction input; no subagent provider is dispatched.
-	*/
-	async coldResume(parent, childId, content, options) {
-		const env_1 = {
-			stack: [],
-			error: void 0,
-			hasError: false
-		};
-		try {
-			const query = this.requireSessionQuery();
-			let observation;
-			try {
-				observation = await query.observeSession(childId, { signal: options.signal });
-			} catch (error) {
-				options.signal.throwIfAborted();
-				throw new SubagentError(`subagent "${childId}" is unavailable`, "NOT_RESUMABLE", { cause: error });
-			}
-			const source = __addDisposableResource$2(env_1, observation, false);
-			this.assertAdmitting(parent);
-			this.authorizeLineage(parent, childId, source.header.parentSession);
-			const ownEvents = source.events.slice(source.inheritedEventCount);
-			const descriptor = foldSubagentDescriptor(ownEvents);
-			if (descriptor === void 0 || descriptor.mode !== "continuable") throw new SubagentError(`subagent "${childId}" has no supported continuation state and cannot be resumed; choose a different target`, "NOT_RESUMABLE");
-			let activation;
+	/** Reconstruct only the target under its subagent tree root; the caller owns acceptance or rollback. */
+	async restoreTarget(root, childId, signal) {
+		return this.trackStartup(root, signal, async (signal) => {
+			const env_3 = {
+				stack: [],
+				error: void 0,
+				hasError: false
+			};
 			try {
-				const independentlySelected = hasIndependentPresetSelection(ownEvents);
-				const agentPreset = independentlySelected ? source.projections?.values.agentPreset : void 0;
-				if (independentlySelected && typeof agentPreset !== "string") throw new SubagentError(`subagent "${childId}" has no agent preset projection for restoration`, "NOT_RESUMABLE");
-				activation = await this.materialize({
-					kind: "local",
-					childId,
-					provider: descriptor.provider,
-					parent,
-					agentOptions: {
-						...descriptor.agentProvider !== void 0 ? { provider: descriptor.agentProvider } : {},
-						...descriptor.agentModel !== void 0 ? { model: descriptor.agentModel } : {},
-						...descriptor.agentReasoningEffort !== void 0 ? { reasoningEffort: ReasoningEffortId(descriptor.agentReasoningEffort) } : {}
-					},
-					composition: {
-						agentPreset: agentPreset ?? void 0,
-						persona: descriptor.persona,
-						toolFilter: descriptor.toolFilter
-					},
-					signal: options.signal
-				});
-			} catch (error) {
-				options.signal.throwIfAborted();
-				if (error instanceof SubagentError) throw error;
-				throw new SubagentError(`subagent "${childId}" is unavailable`, "NOT_RESUMABLE", { cause: error });
+				const source = __addDisposableResource$1(env_3, await this.observeContinuation(childId, signal), false);
+				this.assertAdmitting(root);
+				const descriptor = foldSubagentDescriptor(source.events.slice(source.inheritedEventCount));
+				if (descriptor === void 0 || descriptor.mode !== "continuable") throw new SubagentError(`subagent "${childId}" has no supported continuation state and cannot be resumed; choose a different target`, "NOT_RESUMABLE");
+				const { ancestors } = await this.resolveCreationAncestry(source, signal, root);
+				let activation;
+				try {
+					const projectedPreset = source.projections?.values.agentPreset;
+					if (projectedPreset === void 0 && source.events.some((event) => event.type === "agent-preset/selected")) throw new SubagentError(`subagent "${childId}" has no agent preset projection for restoration`, "NOT_RESUMABLE");
+					const agentPreset = projectedPreset ?? source.header.agentPreset;
+					activation = await this.materialize({
+						kind: "local",
+						childId,
+						provider: descriptor.provider,
+						root,
+						ancestors,
+						agentOptions: {
+							...descriptor.agentProvider !== void 0 ? { provider: descriptor.agentProvider } : {},
+							...descriptor.agentModel !== void 0 ? { model: descriptor.agentModel } : {},
+							...descriptor.agentReasoningEffort !== void 0 ? { reasoningEffort: ReasoningEffortId(descriptor.agentReasoningEffort) } : {}
+						},
+						composition: {
+							agentPreset: agentPreset ?? void 0,
+							persona: descriptor.persona,
+							toolFilter: descriptor.toolFilter
+						},
+						signal
+					});
+				} catch (error) {
+					signal.throwIfAborted();
+					if (error instanceof SubagentError) throw error;
+					throw new SubagentError(`subagent "${childId}" is unavailable`, "NOT_RESUMABLE", { cause: error });
+				}
+				return activation;
+			} catch (e_3) {
+				env_3.error = e_3;
+				env_3.hasError = true;
+			} finally {
+				__disposeResources$1(env_3);
 			}
-			return await this.submitMaterialized(activation, content, options, parent);
-		} catch (e_1) {
-			env_1.error = e_1;
-			env_1.hasError = true;
-		} finally {
-			__disposeResources$2(env_1);
-		}
+		});
 	}
 	/** Admit a materialized child, commit its creation fact, and release it on failure. */
 	async submitMaterialized(activation, content, options, parent, commit) {
@@ -2233,7 +2152,7 @@ var SubagentManager = class {
 			}
 			const messageId = this.submitAdmitted(activation, content, options, parent);
 			commit?.();
-			this.announce(activation);
+			this.accept(activation);
 			return messageId;
 		} catch (error) {
 			try {
@@ -2246,19 +2165,19 @@ var SubagentManager = class {
 	}
 	/** Build and submit one message across the final synchronous admission cutoff. */
 	submitAdmitted(activation, content, options, parent) {
-		const message = options.source === void 0 ? createAgentMessage(parent, content) : createUserMessage({
+		const message = createUserMessage({
 			content,
 			source: options.source
 		});
 		options.signal.throwIfAborted();
+		options.authorize?.();
 		this.assertAdmitting(parent);
-		this.authorizeLineage(parent, activation.childId, activation.parent.id);
-		this.acquireOwnership(parent, activation.childId);
 		try {
 			this.deliver(activation, message, options.delivery);
 		} finally {
 			this.wake(activation);
 		}
+		options.onAccepted?.();
 		return message.id;
 	}
 	/** Refuse image content for a child whose fixed model accepts text only. */
@@ -2284,15 +2203,6 @@ var SubagentManager = class {
 		return query;
 	}
 };
-/** Creation-time selection precedes the own descriptor; historical forks can select after it. */
-function hasIndependentPresetSelection(events) {
-	for (const event of events) {
-		if (event.type === "subagent/descriptor") return false;
-		if (event.type === "agent-preset/selected") return true;
-	}
-	/* v8 ignore next -- coldResume rejects logs without a supported own descriptor before this lookup. */
-	return false;
-}
 //#endregion
 //#region lib/types/list-children.js
 /**
@@ -2300,7 +2210,7 @@ function hasIndependentPresetSelection(events) {
 * Each catalog read releases its Session observation before the next branch.
 * @module @deepseek-ai/dsh-subagent
 */
-var __addDisposableResource$1 = function(env, value, async) {
+var __addDisposableResource = function(env, value, async) {
 	if (value !== null && value !== void 0) {
 		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
 		var dispose, inner;
@@ -2329,7 +2239,7 @@ var __addDisposableResource$1 = function(env, value, async) {
 	} else if (async) env.stack.push({ async: true });
 	return value;
 };
-var __disposeResources$1 = (function(SuppressedError) {
+var __disposeResources = (function(SuppressedError) {
 	return function(env) {
 		function fail(e) {
 			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
@@ -2375,14 +2285,14 @@ async function listChildren(ctx, parentSessionId, signal) {
 	try {
 		const query = ctx.get("sessionQuery");
 		if (query === void 0) throw new SubagentError("listing subagents requires the sessionQuery service (load @deepseek-ai/dsh-session-query)", "SUBAGENT_CONTROL_QUERY_UNAVAILABLE");
-		const entries = __addDisposableResource$1(env_1, await query.observeSession(parentSessionId, { ...signal === void 0 ? {} : { signal } }), false).projections?.values.subagentCatalog;
+		const entries = __addDisposableResource(env_1, await query.observeSession(parentSessionId, { ...signal === void 0 ? {} : { signal } }), false).projections?.values.subagentCatalog;
 		if (entries === void 0) throw new SubagentError("listing subagents requires the registered subagentCatalog projection", "SUBAGENT_CONTROL_PROJECTIONS_UNAVAILABLE");
 		return entries;
 	} catch (e_1) {
 		env_1.error = e_1;
 		env_1.hasError = true;
 	} finally {
-		__disposeResources$1(env_1);
+		__disposeResources(env_1);
 	}
 }
 /**
@@ -2465,159 +2375,6 @@ function assertListingNotCancelled(signal) {
 	if (signal?.aborted) throw new SubagentError("subagent listing was cancelled", "CANCELLED");
 }
 //#endregion
-//#region lib/types/archive-admission.js
-/**
-* The `subagent` family of the Workspace registry's archive admission: which
-* subagent descendants of a Session are still inside a turn, and how they
-* stop when the Session is archived with its work.
-*
-* @module @deepseek-ai/dsh-subagent
-*/
-var __addDisposableResource = function(env, value, async) {
-	if (value !== null && value !== void 0) {
-		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-		var dispose, inner;
-		if (async) {
-			if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-			dispose = value[Symbol.asyncDispose];
-		}
-		if (dispose === void 0) {
-			if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-			dispose = value[Symbol.dispose];
-			if (async) inner = dispose;
-		}
-		if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-		if (inner) dispose = function() {
-			try {
-				inner.call(this);
-			} catch (e) {
-				return Promise.reject(e);
-			}
-		};
-		env.stack.push({
-			value,
-			dispose,
-			async
-		});
-	} else if (async) env.stack.push({ async: true });
-	return value;
-};
-var __disposeResources = (function(SuppressedError) {
-	return function(env) {
-		function fail(e) {
-			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-			env.hasError = true;
-		}
-		var r, s = 0;
-		function next() {
-			while (r = env.stack.pop()) try {
-				if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-				if (r.dispose) {
-					var result = r.dispose.call(r.value);
-					if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
-						fail(e);
-						return next();
-					});
-				} else s |= 1;
-			} catch (e) {
-				fail(e);
-			}
-			if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-			if (env.hasError) throw env.error;
-		}
-		return next();
-	};
-})(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
-	var e = new Error(message);
-	return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-/**
-* Answer `workspace/session-activity` with the running subagent descendants of
-* the asked Session, and `workspace/session-stop` by cancelling each of them
-* as their parent would. Both listeners live as long as `ctx`'s fiber.
-* @param ctx - context carrying the Agent registry; the Session query service is optional and only supplies labels.
-*/
-function installSubagentArchiveAdmission(ctx) {
-	ctx.on("workspace/session-activity", async ({ sessionId }, next) => {
-		const running = runningDescendants(ctx, sessionId);
-		const rest = await next();
-		if (running.length === 0) return rest;
-		return [{
-			kind: "subagent",
-			items: await Promise.all(running.map((child) => describe(ctx, child)))
-		}, ...rest];
-	});
-	ctx.on("workspace/session-stop", ({ sessionId }) => {
-		for (const child of runningDescendants(ctx, sessionId)) try {
-			child.cancel({ kind: "parent" });
-		} catch (error) {
-			ctx.logger.warn(`subagent: cancelling "${child.id}" for an archived Session failed: ${String(error)}`);
-		}
-	});
-}
-/**
-* Live subagent descendants inside a turn, by durable lineage: a child whose
-* header names its parent and carries the subagent origin this package
-* records, at any depth. A fork shares the lineage field without the origin
-* and is an independent conversation, so it never holds its source. Lineage
-* is read as data, so a damaged header chain that loops is visited once.
-*/
-function runningDescendants(ctx, rootId) {
-	const childrenOf = /* @__PURE__ */ new Map();
-	for (const agent of ctx.agents.list()) {
-		const { parentSession, origin } = agent.session.header;
-		if (parentSession === void 0 || origin !== "subagent") continue;
-		const siblings = childrenOf.get(parentSession) ?? [];
-		siblings.push(agent);
-		childrenOf.set(parentSession, siblings);
-	}
-	const running = [];
-	const pending = [rootId];
-	const visited = /* @__PURE__ */ new Set();
-	while (pending.length > 0) {
-		const parentId = pending.shift();
-		if (visited.has(parentId)) continue;
-		visited.add(parentId);
-		for (const child of childrenOf.get(parentId) ?? []) {
-			if (child.status === "running") running.push(child);
-			pending.push(child.id);
-		}
-	}
-	return running;
-}
-/**
-* The child's activity item: its id, plus the durable creation label its
-* descriptor carries, read through a live Session observation. Without the
-* Session query service, or with a descriptor that is absent or unreadable,
-* the item names the child by id alone.
-*/
-async function describe(ctx, child) {
-	const query = ctx.get("sessionQuery");
-	if (query === void 0) return { id: child.id };
-	try {
-		const env_1 = {
-			stack: [],
-			error: void 0,
-			hasError: false
-		};
-		try {
-			const observation = __addDisposableResource(env_1, await query.observeSession(child.id, { projectionMode: "none" }), false);
-			const label = foldSubagentDescriptor(observation.events.slice(observation.inheritedEventCount))?.label;
-			return label === void 0 ? { id: child.id } : {
-				id: child.id,
-				label
-			};
-		} catch (e_1) {
-			env_1.error = e_1;
-			env_1.hasError = true;
-		} finally {
-			__disposeResources(env_1);
-		}
-	} catch {
-		return { id: child.id };
-	}
-}
-//#endregion
 //#region lib/types/projection.js
 /**
 * Pure session projections for subagent identity (mode/label) and active-turn
@@ -2969,12 +2726,18 @@ let SubagentRuntime = (() => {
 	let _classSuper = TypertRemoteService;
 	let _instanceExtraInitializers = [];
 	let _prompt_decorators;
-	let _interruptByParent_decorators;
+	let _interruptByUser_decorators;
 	return class SubagentRuntime extends _classSuper {
 		static {
 			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-			_prompt_decorators = [Remote("prompt")];
-			_interruptByParent_decorators = [Remote("interruptByParent")];
+			_prompt_decorators = [Remote({
+				name: "prompt",
+				resources: { session: (request) => request.childSessionId }
+			})];
+			_interruptByUser_decorators = [Remote({
+				name: "interruptByUser",
+				resources: { session: (childSessionId) => childSessionId }
+			})];
 			__esDecorate(this, null, _prompt_decorators, {
 				kind: "method",
 				name: "prompt",
@@ -2986,14 +2749,14 @@ let SubagentRuntime = (() => {
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
-			__esDecorate(this, null, _interruptByParent_decorators, {
+			__esDecorate(this, null, _interruptByUser_decorators, {
 				kind: "method",
-				name: "interruptByParent",
+				name: "interruptByUser",
 				static: false,
 				private: false,
 				access: {
-					has: (obj) => "interruptByParent" in obj,
-					get: (obj) => obj.interruptByParent
+					has: (obj) => "interruptByUser" in obj,
+					get: (obj) => obj.interruptByUser
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
@@ -3023,13 +2786,17 @@ let SubagentRuntime = (() => {
 			super(ctx, "subagents");
 			this.config = config;
 			this.emitLifecycle = createLifecycleEmitter(this.ctx, (parent) => scopeTarget(this, parent));
+		}
+		async [Service.init]() {
+			const ctx = this.ctx;
+			await ctx.sessionProjections.register(subagentCatalogProjectionDefinition);
+			await ctx.sessionProjections.register(subagentTimingProjectionDefinition);
+			const identityProjection = await ctx.sessionProjections.register(subagentIdentityProjectionDefinition);
+			if (ctx.fiber.uid === null) return;
 			ctx.inject(["agents"], (childCtx) => {
 				const manager = new SubagentManager(childCtx, {
-					startExternal: (name, request) => {
-						return this.expectProvider(name).start(request);
-					},
-					prepareContinuable: (name, request) => this.prepareContinuable(name, request),
-					observeActivation: (provider, childId, parent) => this.observeActivation(provider, childId, parent)
+					identityOf: (session) => identityProjection.stateOf(session).identity,
+					emitLifecycle: this.emitLifecycle
 				}, () => this.config.maxActiveSubagents.get(), () => this.config.delegatedApproval.get());
 				this.manager = manager;
 				childCtx.effect(() => () => {
@@ -3037,15 +2804,6 @@ let SubagentRuntime = (() => {
 					if (this.manager === manager) this.manager = void 0;
 				}, "subagents.managerBinding()");
 			});
-			ctx.inject(["agents"], (agentsCtx) => {
-				installSubagentArchiveAdmission(agentsCtx);
-			});
-		}
-		async [Service.init]() {
-			const { sessionProjections } = this.ctx;
-			await sessionProjections.register(subagentCatalogProjectionDefinition);
-			await sessionProjections.register(subagentTimingProjectionDefinition);
-			await sessionProjections.register(subagentIdentityProjectionDefinition);
 		}
 		/**
 		* Resolve a delegation tool's depth policy against the current user setting.
@@ -3064,64 +2822,64 @@ let SubagentRuntime = (() => {
 		* @param spec - task, backend, and result recipient.
 		* @returns identities, execution result, and exact-activation disposal. A reserved
 		* childId requires a local backend and guarantees an accepted messageId.
+		* @throws PROVIDER_CHANGED if the selected provider is removed or replaced before dispatch.
 		*/
 		async startActivation(spec) {
 			const provider = this.expectProvider(spec.provider);
 			if (spec.childId !== void 0 && provider.prepareContinuable === void 0) throw new SubagentError("reserved child ids require a local backend", "UNSUPPORTED_CAPABILITY");
-			assertSubagentMaxDepth(spec.request.maxDepth);
-			this.assertCapabilities(provider, {
-				...spec.request,
-				signal: spec.signal
-			});
+			assertSubagentMaxDepth(spec.maxDepth);
+			this.assertCapabilities(provider, spec);
 			const manager = this.requireManager();
-			if (this.ctx.get("agents")?.get(spec.request.parent.id) !== spec.request.parent) throw new SubagentError("subagent creation requires the exact live parent agent", "UNAUTHORIZED");
-			if (spec.request.outputSchema !== void 0) assertObjectJsonSchema(spec.request.outputSchema);
-			return provider.prepareContinuable === void 0 ? manager.startExternal(spec) : manager.startLocal(spec);
+			if (this.ctx.get("agents")?.get(spec.parent.id) !== spec.parent) throw new SubagentError("subagent creation requires the exact live parent agent", "UNAUTHORIZED");
+			if (spec.outputSchema !== void 0) assertObjectJsonSchema(spec.outputSchema);
+			const prepare = provider.prepareContinuable?.bind(provider);
+			if (prepare !== void 0) return manager.startLocal(spec, (request) => {
+				this.assertProviderCurrent(provider);
+				return prepare(request);
+			});
+			const start = provider.start.bind(provider);
+			return manager.startExternal(spec, (request) => {
+				this.assertProviderCurrent(provider);
+				return start(request);
+			});
+		}
+		/**
+		* Resolve the root shared by an Agent and its other agents in its subagent tree.
+		* @param caller - exact live Agent whose subagent ancestry selects the tree.
+		* @returns the live root; ordinary Session forks lead independent trees.
+		* @throws when the caller or its runtime owner is unavailable.
+		*/
+		rootOf(caller) {
+			return this.requireManager().rootOf(caller);
 		}
 		/**
-		* Join progressing descendants without cancelling them. Idle descendants whose
-		* inboxes require a later wake stay resident and do not delay host completion.
-		* @param parent - the exact parent whose descendant work is observed.
-		* @returns whether work was joined; hosts recheck parent idle after true.
+		* Join progressing subagent tree work for its root. Idle members with parked input
+		* stay resident without delaying host completion. Ordinary members return false.
+		* @param root - exact live subagent tree root whose member work is awaited.
+		* @returns whether work was joined; hosts recheck root idle after true.
 		*/
-		async waitForChildren(parent) {
-			return this.manager?.waitForChildren(parent) ?? false;
+		async waitForTreeWork(root) {
+			return this.manager?.waitForTreeWork(root) ?? false;
 		}
 		/**
-		* Steer one model-authored message to the sender's direct parent or direct
-		* continuable child. A running target admits it at the nearest step boundary;
-		* an idle target starts a turn, and an absent direct child cold-resumes from
-		* persistence. The service derives durable sender attribution from the exact
-		* live sender. Caller cancellation stops only pre-acceptance work.
-		* @param sender - exact live Agent authorizing and originating the message.
-		* @param targetId - durable direct-parent or direct-child session id.
+		* Steer one model-authored message to another member of the same subagent tree.
+		* A running target receives it at its next step; an idle target starts a turn.
+		* A cold target resumes under its runtime subagent tree root without restoring
+		* its creation ancestors. Sender identity is rechecked before inbox acceptance; cancellation
+		* stops only pre-acceptance work and never retracts an accepted message.
+		* @param sender - exact live root or resident continuable Agent originating the message.
+		* @param targetId - another root or continuable member's durable Session id.
 		* @param content - model-authored content to deliver.
 		* @param options - caller cancellation before inbox acceptance.
 		* @returns the accepted message's inbox id.
-		* @throws when continuation services are unavailable, adjacency is rejected,
-		*   or the message was not admitted.
+		* @throws when the target is outside the tree, cannot resume, or rejects input.
 		*/
 		async sendMessage(sender, targetId, content, options) {
 			return this.requireManager().sendMessage(sender, targetId, content, options);
 		}
 		/**
-		* Deliver one host-protocol message to a direct continuable child.
-		* Symbol-keyed so host adapters can preserve their own source descriptors without
-		* widening the public Service Definition or impersonating an Agent sender.
-		* @param parent - exact live direct parent authorizing delivery.
-		* @param childId - durable direct-child session id.
-		* @param content - host-authored content to deliver.
-		* @param source - durable host-protocol source descriptor.
-		* @param signal - caller cancellation before inbox acceptance.
-		* @param delivery - Queue as a distinct turn or Steer at the nearest step.
-		* @returns the accepted message's inbox id.
-		*/
-		[deliverSubagentPrompt](parent, childId, content, source, signal, delivery) {
-			return delivery === "steer" ? this.requireManager().steerPrompt(parent, childId, content, source, signal) : this.requireManager().queuePrompt(parent, childId, content, source, signal);
-		}
-		/**
-		* Interrupt one live child's current execution under a human parent
-		* address or an exact live ancestor Agent. Fire-and-return: the cancel
+		* Interrupt one live child's current execution under a trusted user
+		* operation or an exact live ancestor Agent. Fire-and-return: the cancel
 		* signal is issued before this returns, but the target may keep running
 		* until it observes the signal. Unclaimed pending inbox work, the Activation,
 		* and published descendants are preserved; claimed work is not requeued.
@@ -3130,7 +2888,7 @@ let SubagentRuntime = (() => {
 		* is an accepted no-op, as is a manager-less composition, which cannot own a
 		* live Activation.
 		* @param targetSessionId - the durable child session id to interrupt.
-		* @param authority - the human parent address or exact live ancestor Agent.
+		* @param authority - a trusted user operation or exact live ancestor Agent.
 		* @throws {SubagentError} `UNAUTHORIZED` when the authority does not own the
 		*   live target.
 		*/
@@ -3138,13 +2896,11 @@ let SubagentRuntime = (() => {
 			this.manager?.interrupt(targetSessionId, authority);
 		}
 		/**
-		* Close subagent admission below exact live parent Agents, stop only their
-		* visible descendant Activations synchronously, then await admitted scoped
-		* materializations and release those forests child-first. The scoped cutoff
-		* lasts until each exact parent leaves the registry; unrelated parent trees
-		* remain live.
-		* @param parents - exact host-owned parent Agents entering teardown.
-		* @returns once every retained descendant activation released its execution handle.
+		* Close admission and stop all instances in the selected subagent trees, then await
+		* pending startup and cleanup. Ordinary members are ignored. The cutoff lasts
+		* until each exact root leaves the registry; unrelated subagent trees remain live.
+		* @param parents - exact live subagent tree roots entering teardown.
+		* @returns once all admitted startup and member cleanup have settled.
 		* @throws an aggregate error after all branches settle when any failed.
 		*/
 		async drainDescendants(parents) {
@@ -3153,33 +2909,6 @@ let SubagentRuntime = (() => {
 			await manager.drainDescendants(parents);
 		}
 		/**
-		* Release selected resident direct children of one exact live
-		* parent. Other children of the same parent remain admitted and resident.
-		* Absent targets and a manager-less composition are accepted no-ops.
-		* @param parent - exact live direct parent authorizing the selected release.
-		* @param childIds - durable direct-child ids to release when resident.
-		* @returns once every selected activation released its execution handle.
-		* @throws {SubagentError} `UNAUTHORIZED` when a resident target belongs to a
-		*   different parent or the supplied parent identity is stale.
-		*/
-		async drainChildren(parent, childIds) {
-			const manager = this.manager;
-			if (manager === void 0) return;
-			await manager.drainChildren(parent, childIds);
-		}
-		/**
-		* Read the parent's durable direct-child catalog without loading or resuming an Agent.
-		* The service owns and releases the live-preferred Session observation.
-		* @param parentSessionId - parent whose direct children are requested.
-		* @param signal - cancellation forwarded to the Session query.
-		* @returns catalog children in parent event order.
-		* @throws {@link SubagentError} when query or catalog projection is unavailable.
-		* @throws SessionQueryError when the parent cannot be read or the query is cancelled.
-		*/
-		listChildren(parentSessionId, signal) {
-			return listChildren(this.ctx, parentSessionId, signal);
-		}
-		/**
 		* Recursively list reachable parent catalogs in stable pre-order, preserving
 		* each catalog's event order. Each row carries its catalog parent and depth;
 		* external children are leaves; one-shot and unknown-mode children remain
@@ -3199,8 +2928,8 @@ let SubagentRuntime = (() => {
 			return listDescendants(this.ctx, rootSessionId, signal);
 		}
 		/**
-		* Deliver one browser-authored message to a continuable child through the
-		* exact live direct parent, retaining the caller-minted request identity and
+		* Deliver one browser-authored message to a continuable child through its
+		* live subagent tree root, retaining the caller-minted request identity and
 		* validated browser zone on the accepted message. Success identifies the
 		* message the child's inbox accepted; later execution is independent of this
 		* call. Queue delivery targets a later turn; steer delivery targets the
@@ -3208,21 +2937,20 @@ let SubagentRuntime = (() => {
 		* Image parts are admitted and persisted through the attachment store
 		* before delivery, and the child's model must accept image input.
 		* Cold resume at capacity rejects with `subagent/delivery-unavailable`.
-		* @param request - durable address, delivery, minted identity, content, and optional browser zone.
+		* Access is checked on the target Session before attachment admission or restoration.
+		* @param request - target id, delivery, minted identity, content, and optional browser zone.
 		* @param signal - carrier cancellation, owning the call until inbox acceptance.
 		* @returns the accepted message's inbox identity.
 		* @throws {RemoteError} `gateway/bad-request`, `subagent/attachment-invalid`,
-		*   `subagent/invalid-time-zone`, `subagent/parent-unavailable`,
+		*   `subagent/invalid-time-zone`,
 		*   `subagent/not-resumable`, `subagent/unauthorized`,
 		*   `subagent/delivery-unavailable`, `gateway/cancelled`, or `gateway/internal`.
 		*/
 		async prompt(request, signal) {
-			const { parentSessionId, childSessionId, clientTimeZone, delivery } = request;
+			const { childSessionId, clientTimeZone, delivery } = request;
 			validateControlRequest("subagent.prompt", request);
 			const canonicalTimeZone = clientTimeZone === void 0 ? void 0 : canonicalClientTimeZone(clientTimeZone);
 			if (clientTimeZone !== void 0 && canonicalTimeZone === void 0) throw new RemoteError("subagent/invalid-time-zone", "clientTimeZone must be UTC or a valid IANA Area/Location name", { value: clientTimeZone });
-			const parent = this.ctx.get("agents")?.get(parentSessionId);
-			if (parent === void 0) throw new RemoteError("subagent/parent-unavailable", `parent session "${parentSessionId}" is not live`, { parentSessionId });
 			const principal = principalOf(this.ctx.invocation);
 			const source = {
 				kind: "user",
@@ -3241,38 +2969,29 @@ let SubagentRuntime = (() => {
 					if (attachments === void 0) throw new Error("subagent image prompt requires an attachment store");
 					content = await attachments.admitPromptContent(request.content);
 				}
-				return { messageId: await this[deliverSubagentPrompt](parent, childSessionId, content, source, signal, delivery) };
+				return { messageId: await this.requireManager().deliverPrompt(childSessionId, content, {
+					source,
+					signal,
+					delivery
+				}) };
 			} catch (error) {
 				return rejectPrompt(error, childSessionId, signal);
 			}
 		}
 		/**
-		* Remote face of {@link interrupt} under one durable parent address. No
-		* catalog, history, persistence, or parent Agent lookup runs: the core
-		* primitive alone authorizes the address against the live Activation, which
-		* is what keeps a live child interruptible while its parent Agent is offline.
+		* Remote face of {@link interrupt}, authorized on the target Session by the Gateway.
+		* No catalog, history, persistence, or parent Agent lookup runs.
 		* Absent, idle, and already-completed targets are accepted no-ops there.
 		* @param childSessionId - durable child session id to interrupt.
-		* @param parentSessionId - durable direct parent whose authority is claimed.
-		* @param mode - required continuable-address discriminator.
 		* @returns acknowledgement that the cancel signal was admitted, not that the target is quiescent.
 		* @throws {RemoteError} `gateway/bad-request` for an empty id,
-		*   `subagent/unauthorized` when the address does not own the live target,
 		*   otherwise `gateway/internal`.
 		*/
-		interruptByParent(childSessionId, parentSessionId, mode) {
-			validateControlRequest("subagent.interrupt", {
-				childSessionId,
-				parentSessionId,
-				mode
-			});
+		interruptByUser(childSessionId) {
+			validateControlRequest("subagent.interrupt", { childSessionId });
 			try {
-				this.interrupt(childSessionId, {
-					kind: "user",
-					parentSessionId
-				});
+				this.interrupt(childSessionId, { kind: "user" });
 			} catch (error) {
-				if (error instanceof SubagentError && error.code === "UNAUTHORIZED") throw new RemoteError("subagent/unauthorized", "subagent does not belong to this parent", { childSessionId }, { cause: error });
 				throw new RemoteError("gateway/internal", "subagent interrupt failed", {}, { cause: error });
 			}
 			return { accepted: true };
@@ -3306,20 +3025,9 @@ let SubagentRuntime = (() => {
 		getProvider(name) {
 			return this.providers.get(name);
 		}
-		/**
-		* List registered provider names in insertion order.
-		* @returns the registered names.
-		*/
-		list() {
-			return [...this.providers.keys()];
-		}
-		/**
-		* Resolve one provider's detached continuable-creation contribution. Method
-		* presence on the provider IS the capability, so a provider without it is
-		* rejected before the manager reserves any child resources.
-		*/
-		async prepareContinuable(name, request) {
-			return this.expectProvider(name).prepareContinuable(request);
+		/** A pending start must use the exact provider whose capabilities were checked. */
+		assertProviderCurrent(provider) {
+			if (this.providers.get(provider.name) !== provider) throw new SubagentError(`subagent provider "${provider.name}" changed during startup; retry the delegation`, "PROVIDER_CHANGED");
 		}
 		/** Look up a provider for dispatch or fail loud. */
 		expectProvider(name) {
@@ -3332,13 +3040,6 @@ let SubagentRuntime = (() => {
 			if (this.manager === void 0) throw new SubagentError("continuable subagents require the agents service", "CONTINUATION_UNAVAILABLE");
 			return this.manager;
 		}
-		/**
-		* Build the lifecycle observer for one continuable Activation's residency
-		* epoch, so the manager publishes its edges without owning event dispatch.
-		*/
-		observeActivation(provider, childId, parent) {
-			return createActivationObserver(this.emitLifecycle, provider, childId, parent);
-		}
 		/** Reject the first requested capability that the provider lacks. */
 		assertCapabilities(provider, request) {
 			if (request.agentPreset !== void 0 && (!provider.capabilities.agentPreset || provider.inheritsParentContext)) throw new SubagentError(`subagent provider "${provider.name}" does not support independent agent preset selection`, "UNSUPPORTED_CAPABILITY");