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

package/lib/types/manager.js

@@ -1,7 +1,7 @@
 /**
  * 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
  */
@@ -63,12 +63,12 @@ import { brandString } from '@deepseek-ai/dsh-brand';
 import { ReasoningEffortId, contentHasImage, createUserMessage, errorChain } from '@deepseek-ai/dsh-llm';
 import { SessionLogOffset } from '@deepseek-ai/dsh-session';
 import { appendDelegatedPolicyOverrides, applyChildComposition, captureDelegatedPolicyOverrides, childSessionMeta, resolveChildAgentOptions, resolveChildDepth, } from "./child-agent.js";
-import { createAgentMessage, withContinuableReturnGuidance, createSettlementMessage } from "./continuation-messages.js";
-import { assertSubagentMaxDepth } from "./depth.js";
+import { createAgentMessage, createSettlementMessage, withResultDeliveryGuidance, } from "./continuation-messages.js";
+import { installSubagentArchiveAdmission } from "./archive-admission.js";
 import { foldSubagentDescriptor, snapshotSubagentDescriptor } from "./descriptor.js";
 import { establishCatalogChild, establishExternalCatalogChild } from "./catalog.js";
 import { SubagentError } from "./error.js";
-import { isAdjacentAgentSendMessageTool } from "./internal.js";
+import { SubagentRunId } from "./types.js";
 import { attachStructuredRuntime } from "./structured.js";
 import { ActivationPool, ChildLock, activationAgent, captureLocalResult, observeLocalFailure, requireLocalActivation } from "./activation.js";
 /** Render only the safe outer message from execution or teardown failures. */
@@ -91,18 +91,13 @@ export class SubagentManager {
     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 = new Map();
+    /** Exact subagent tree roots whose host teardown has closed admission. */
+    closingRoots = 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.
      */
@@ -111,16 +106,15 @@ export class SubagentManager {
         this.host = host;
         this.maxActiveSubagents = maxActiveSubagents;
         this.delegatedApproval = delegatedApproval;
-        // Ordinary Cordis owner effects unwind in reverse registration order, which
-        // cannot express the dynamic child graph. Register the private scope's
-        // structural disposer FIRST and the drain SECOND, so reverse unwind invokes
-        // the drain before releasing the scope; a cleanup effect on the same scope
-        // as the Agent handles would let structural handle disposal bypass
-        // child-first ordering.
+        // Drain managed instances before Cordis releases their owning scope.
         const scope = ctx.plugin(function activationOwner() { });
         this.ownerCtx = scope.ctx;
+        installSubagentArchiveAdmission(ctx, (agent) => {
+            const activation = this.resident.get(agent.id);
+            return activation !== undefined && activationAgent(activation) === agent ? activation.ancestors : undefined;
+        }, session => host.identityOf(session));
         ctx.on('agent/disposed', ({ agent }) => {
-            this.closingScopes.delete(agent);
+            this.closingRoots.delete(agent);
         });
         ctx.effect(function* () {
             yield scope.dispose;
@@ -130,7 +124,7 @@ export class SubagentManager {
     /**
      * 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') {
@@ -145,12 +139,8 @@ export class SubagentManager {
         const activation = this.resident.get(targetSessionId);
         if (activation === undefined)
             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)) {
+        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');
         }
         // Disposal already stopped the target with a whole-Activation teardown;
@@ -169,32 +159,27 @@ export class SubagentManager {
     }
     /**
      * 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 = 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);
@@ -207,13 +192,6 @@ export class SubagentManager {
                     waits.push(item.handle.agent.whenIdle());
                     continue;
                 }
-                if (item.ownedChildren.size > 0) {
-                    // Published descendants are observed separately; preparation holds
-                    // keep the owner pending until publication or rollback wakes it.
-                    if ([...item.ownedChildren].some(id => !this.resident.has(id)))
-                        waits.push(item.poke.promise);
-                    continue;
-                }
                 const inbox = item.handle.agent.inbox;
                 if (item.failureAt === undefined && (inbox.nextTurn.length > 0 || inbox.nextStep.length > 0))
                     continue;
@@ -225,147 +203,82 @@ export class SubagentManager {
                 continue;
             }
             // A descendant can be published while whenIdle follows another child.
-            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)))
+            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 !== undefined)
-                    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 = 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) {
-            const disposal = this.dispose(activation);
-            void disposal.catch(() => undefined);
-        }
-        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 === undefined)
-                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) {
-            const disposal = this.dispose(activation);
-            void disposal.catch(() => undefined);
-        }
-        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);
-        // Snapshot before any await: invalid descriptor JSON rejects the call
-        // before a child exists, and the detached value is what reaches the log.
-        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 !== undefined ? { agentProvider } : {},
-            ...agentModel !== undefined ? { agentModel } : {},
-            ...agentReasoningEffort !== undefined ? { agentReasoningEffort } : {},
-        });
-        // Capture before the first await: a later parent switch belongs to the
-        // parent's future, not to this child.
-        const delegatedPolicies = captureDelegatedPolicyOverrides(parent, this.delegatedApproval());
-        // An idle continuation-managed parent must not settle while a caller is
-        // still creating its child. A turn-scoped delegation does not need this,
-        // but the service is also callable outside a turn.
-        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);
+            // Snapshot before any await: invalid descriptor JSON rejects the call
+            // before a child exists, and the detached value is what reaches the log.
+            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 !== undefined ? { agentProvider } : {},
+                ...agentModel !== undefined ? { agentModel } : {},
+                ...agentReasoningEffort !== undefined ? { agentReasoningEffort } : {},
+            });
+            // Capture before the first await: a later parent switch belongs to the
+            // parent's future, not to this child.
+            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 !== undefined) {
-                    const persisted = await persistence?.stat(childId, { signal: spec.signal });
-                    spec.signal.throwIfAborted();
+                    const persisted = await persistence?.stat(childId, { signal: signal });
+                    signal.throwIfAborted();
                     this.assertAdmitting(parent);
                     this.assertChildIdAvailable(childId);
                     if (persisted !== undefined) {
@@ -376,84 +289,80 @@ export class SubagentManager {
                     kind: 'local',
                     childId,
                     provider: spec.provider,
-                    parent,
+                    ...ancestry,
                     create: {
+                        parent,
                         cwd,
                         seed,
-                        meta: childSessionMeta(parent, childDepth, prepared.seed !== undefined, request.agentPreset),
+                        meta: childSessionMeta(parent, childDepth, prepared.seed !== undefined, 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, { source: { kind: 'user' }, signal: spec.signal, delivery: 'queue' }, parent, () => {
+                return await this.submitMaterialized(activation, spec.delivery !== 'caller'
+                    ? withResultDeliveryGuidance(spec.prompt)
+                    : spec.prompt, { source: { kind: 'user' }, signal, delivery: 'queue', authorize: () => { this.assertAdmitting(parent); } }, ancestry.root, () => {
+                    this.assertAdmitting(parent);
                     establishCatalogChild(parent.session, childHeader, descriptor);
                 });
             });
             return { ...this.receipt(established), 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 !== undefined) {
-                try {
-                    await this.dispose(activation);
+        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);
                 }
-                catch (cleanupError) {
-                    this.ctx.logger.warn(`subagent "${activation.childId}" admission rollback failed: ${failureMessage(cleanupError)}`);
+                this.accept(activation);
+                return this.receipt(activation);
+            }
+            catch (error) {
+                if (activation !== undefined) {
+                    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) {
@@ -464,59 +373,126 @@ export class SubagentManager {
         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 !== undefined && activationAgent(activation) === caller
+            && this.ctx.agents.get(activation.root.id) === activation.root)
+            return activation.root;
+        if (delegated || activation !== undefined) {
+            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) {
+        const root = this.rootOf(creator);
+        const ancestors = this.resident.get(creator.id)?.ancestors ?? [];
+        return { root, ancestors: [...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 !== undefined
-            && 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, {
-            signal: options.signal,
-            delivery: 'steer',
+        const message = createAgentMessage(sender, content);
+        const activation = this.resident.get(sender.id);
+        return this.deliverToMember(root, targetId, [...message.content], {
+            signal: options.signal, 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 === undefined || identity == null || identity.seq < inheritedEventCount)
+                    break;
+                if (seen.has(parentId))
+                    throw new SubagentError('cyclic subagent creation ancestry', 'UNAUTHORIZED');
+                seen.add(parentId);
+                const parent = __addDisposableResource(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(env_1);
+            }
+        }
+        if (root === undefined && ancestors.length > 0 && header.origin !== 'subagent') {
+            const owner = this.ctx.agents.get(header.id);
+            if (owner === undefined || 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 === undefined) {
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                const source = __addDisposableResource(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(env_2);
+            }
+        }
+        return this.deliverToMember(root, childId, content, options);
     }
     /** Admit local input synchronously before any teardown can begin. */
     deliver(activation, message, delivery) {
@@ -541,38 +517,6 @@ export class SubagentManager {
             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 === undefined || activationAgent(parentActivation) !== parent)
-            return () => { };
-        if (parentActivation.closing !== undefined) {
-            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 !== undefined && live.closing === undefined)
-                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.
@@ -596,34 +540,20 @@ export class SubagentManager {
             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 === undefined)
+        if (closing === undefined) {
+            if (this.resident.get(agent.id)?.closing !== undefined) {
+                throw new SubagentError(`subagent "${agent.id}" is closing`, 'ACTIVATION_CLOSING');
+            }
             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');
-        }
+            : `subagent tree "${closing.id}" is draining; the operation was not admitted`, 'DRAINING');
     }
     /**
      * Create or resume one child Agent and publish its Activation.
@@ -631,23 +561,26 @@ export class SubagentManager {
      * @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 pool = this.rootPool(inputs.root);
         const releaseSlot = pool.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,
-            settled: settled.promise,
-            controller,
-        };
+        const materialization = { 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();
+        return start(AbortSignal.any([signal, controller.signal])).catch((error) => {
             if (error instanceof Error && error.name === 'AbortError')
-                this.assertAdmitting(inputs.parent);
+                this.assertAdmitting(root);
             throw error;
         }).finally(() => {
             this.materializations.delete(materialization);
@@ -688,42 +621,14 @@ export class SubagentManager {
                 + 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 !== undefined)
-            return existing;
-        const members = 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 !== undefined) {
-            const parent = this.ctx.agents.get(parentSession);
-            if (parent === undefined || 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;
-        }
-        return undefined;
+        const root = this.rootOf(agent);
+        return this.closingRoots.has(root) ? root : undefined;
     }
-    /** 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 === undefined) {
@@ -733,9 +638,8 @@ export class SubagentManager {
         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') {
@@ -746,9 +650,8 @@ export class SubagentManager {
                 const run = await inputs.start(controller.signal);
                 resource = { kind: 'external', run, controller };
                 void run.result.catch(() => undefined);
-                childId = run.id;
                 try {
-                    this.assertChildIdAvailable(childId);
+                    this.assertChildIdAvailable(run.id);
                 }
                 catch (error) {
                     await run.dispose();
@@ -760,7 +663,7 @@ export class SubagentManager {
             }
         }
         else {
-            const { create } = inputs;
+            const { create, childId } = inputs;
             let structured;
             const setup = async (childCtx, child) => {
                 // Only fresh creation appends the descriptor and delegated policy after
@@ -770,7 +673,7 @@ export class SubagentManager {
                 const approvalPolicy = create?.delegatedPolicies.approvalPolicy
                     ?? childCtx.get('approval')?.effectivePolicy(child.session);
                 if (inputs.composition.agentPreset !== undefined) {
-                    await applyChildComposition(childCtx, parent, inputs.composition, approvalPolicy);
+                    await applyChildComposition(childCtx, create?.parent, inputs.composition, approvalPolicy);
                 }
                 if (create !== undefined) {
                     if (inputs.composition.agentPreset !== undefined) {
@@ -784,25 +687,22 @@ export class SubagentManager {
                     await workingDirectory.set(child, create.cwd, inputs.signal);
                 }
                 if (inputs.composition.agentPreset === undefined) {
-                    await applyChildComposition(childCtx, parent, inputs.composition, approvalPolicy);
+                    await applyChildComposition(childCtx, create?.parent, inputs.composition, approvalPolicy);
                 }
                 if (inputs.outputSchema !== undefined) {
-                    structured = attachStructuredRuntime(childCtx, inputs.outputSchema, () => this.resident.get(childId)?.ownedChildren.size === 0
-                        && child.inbox.nextStep.length === 0
+                    structured = attachStructuredRuntime(childCtx, inputs.outputSchema, () => child.inbox.nextStep.length === 0
                         && child.inbox.nextTurn.length === 0);
                 }
             };
             const handle = create === undefined
                 ? 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 === undefined ? {} : { seed: create.seed }),
                     inheritedEventCount: create.inheritedEventCount,
@@ -820,29 +720,25 @@ export class SubagentManager {
                 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: undefined,
-            ancestry: new WeakSet(resource.kind === 'external' ? parentLineage : [resource.handle.agent, ...parentLineage]),
-            ownedChildren: new Set(),
-            observer,
-            announced: false,
+            accepted: false,
         };
         void activation.result.promise.catch(() => undefined);
         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); };
             if (activation.kind === 'local') {
                 observeLocalFailure(activation, wakeSettlement);
@@ -862,7 +758,9 @@ export class SubagentManager {
                         activation.omitClosingText = false;
                 });
             }
-            observer.start(activationAgent(activation));
+            // Listeners may read the resident Agent or drain it immediately. Publish
+            // after residency and inbox listeners, as the last rollback-protected step.
+            this.host.emitLifecycle('subagent/start', this.runInfo(activation), root);
         }
         catch (error) {
             /* v8 ignore next -- rollback failure must not mask the admission failure
@@ -872,14 +770,19 @@ export class SubagentManager {
         }
         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);
         }
@@ -897,29 +800,10 @@ export class SubagentManager {
             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 === undefined)
-            return;
-        if (parentActivation.closing !== undefined) {
-            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')
@@ -985,20 +869,18 @@ export class SubagentManager {
     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 !== undefined)
             return 'closed';
         if (activation.poke !== observation)
             return 'retry';
         const inbox = activation.handle.agent.inbox;
-        if (activation.ownedChildren.size > 0)
-            return 'wait';
         if (activation.failureAt === undefined && (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;
@@ -1024,27 +906,6 @@ export class SubagentManager {
                 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 !== undefined);
-                    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 childFailures = await Promise.all(childDisposals.map(async (disposal) => {
-                        try {
-                            await disposal;
-                            return undefined;
-                        }
-                        catch (error) {
-                            return error;
-                        }
-                    }));
-                    const reasons = childFailures.filter(reason => reason !== undefined);
-                    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 this.flushFinalState(activation);
                 }
@@ -1076,8 +937,13 @@ export class SubagentManager {
         activation.releaseSlot();
         const terminal = failure === undefined ? result : { output: [], stopReason: 'error' };
         this.notifySettlement(activation, result);
-        this.releaseOwnership(childId);
-        activation.observer.settle(terminal);
+        // The sole end publication follows resource release and parent notification,
+        // before result delivery. Cleanup failure changes the event, not the captured result.
+        this.host.emitLifecycle('subagent/end', {
+            ...this.runInfo(activation),
+            stopReason: terminal.stopReason,
+            ...terminal.output.length === 0 ? {} : { lastAssistantMessage: terminal.output },
+        }, activation.root);
         if (resultFailure === undefined)
             activation.result.resolve(result);
         else
@@ -1087,11 +953,12 @@ export class SubagentManager {
     }
     /** Deliver the captured execution result to the durable direct parent after cleanup. */
     notifySettlement(activation, terminal) {
-        if (!activation.announced || activation.delivery === 'caller')
+        if (!activation.accepted || activation.delivery === 'caller')
             return;
         try {
-            const parent = this.ctx.agents.get(activation.parent.id);
-            if (parent !== activation.parent)
+            const parentId = activation.ancestors.at(-1);
+            const parent = this.ctx.agents.get(parentId);
+            if (parent === undefined || this.rootOf(parent) !== activation.root)
                 return;
             const message = createSettlementMessage(activation.childId, terminal, activation.kind === 'local', activation.kind === 'local' && activation.omitClosingText);
             if (this.closingTeardownFor(parent) !== undefined) {
@@ -1123,140 +990,112 @@ export class SubagentManager {
             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 === undefined)
-                    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 !== undefined) {
-                    return disposal.then(() => undefined, () => undefined);
+                if (activation === undefined) {
+                    const restored = await this.restoreTarget(root, childId, options.signal);
+                    return { messageId: await this.submitMaterialized(restored, content, options, root) };
                 }
-                if (contentHasImage(content)) {
+                if (activation.root !== root)
+                    throw new SubagentError('target belongs to another subagent tree', 'UNAUTHORIZED');
+                requireLocalActivation(activation);
+                if (activation.closing === undefined && contentHasImage(content)) {
                     await this.assertImageCapable(requireLocalActivation(activation).handle.agent, options.signal);
-                    if (activation.closing !== undefined) {
-                        await Promise.allSettled([activation.closing]);
-                        return undefined;
-                    }
                 }
-                const messageId = this.submitAdmitted(activation, content, options, parent);
-                this.announce(activation);
-                return messageId;
+                if (activation.closing !== undefined)
+                    return { closing: activation.closing };
+                const messageId = this.submitAdmitted(activation, content, options, root);
+                return { messageId };
             });
-            /* v8 ignore start -- only a delivery that lost the disposal cutoff retries. */
-            if (live !== undefined)
-                return live;
-            this.assertAdmitting(parent);
-            options.signal.throwIfAborted();
-            /* v8 ignore stop */
-        }
-    }
-    /** 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 !== undefined) {
-            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');
+            if ('messageId' in result)
+                return result.messageId;
+            await Promise.allSettled([result.closing]);
         }
-        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;
+    /** 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 {
-                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(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 === undefined || 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;
-            try {
-                const independentlySelected = hasIndependentPresetSelection(ownEvents);
-                const agentPreset = independentlySelected ? source.projections?.values.agentPreset : undefined;
-                if (independentlySelected && typeof agentPreset !== 'string') {
-                    throw new SubagentError(`subagent "${childId}" has no agent preset projection for restoration`, 'NOT_RESUMABLE');
+                const source = __addDisposableResource(env_3, await this.observeContinuation(childId, signal), false);
+                this.assertAdmitting(root);
+                const ownEvents = source.events.slice(source.inheritedEventCount);
+                const descriptor = foldSubagentDescriptor(ownEvents);
+                if (descriptor === undefined || descriptor.mode !== 'continuable') {
+                    throw new SubagentError(`subagent "${childId}" has no supported continuation state and cannot be resumed; choose a different target`, 'NOT_RESUMABLE');
                 }
-                activation = await this.materialize({
-                    kind: 'local',
-                    childId,
-                    provider: descriptor.provider,
-                    parent,
-                    agentOptions: {
-                        ...descriptor.agentProvider !== undefined ? { provider: descriptor.agentProvider } : {},
-                        ...descriptor.agentModel !== undefined ? { model: descriptor.agentModel } : {},
-                        ...descriptor.agentReasoningEffort !== undefined
-                            ? { reasoningEffort: ReasoningEffortId(descriptor.agentReasoningEffort) }
-                            : {},
-                    },
-                    composition: { agentPreset: agentPreset ?? undefined, persona: descriptor.persona, toolFilter: descriptor.toolFilter },
-                    signal: options.signal,
-                });
+                const { ancestors } = await this.resolveCreationAncestry(source, signal, root);
+                let activation;
+                try {
+                    const projectedPreset = source.projections?.values.agentPreset;
+                    if (projectedPreset === undefined && 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 !== undefined ? { provider: descriptor.agentProvider } : {},
+                            ...descriptor.agentModel !== undefined ? { model: descriptor.agentModel } : {},
+                            ...descriptor.agentReasoningEffort !== undefined
+                                ? { reasoningEffort: ReasoningEffortId(descriptor.agentReasoningEffort) }
+                                : {},
+                        },
+                        composition: {
+                            agentPreset: agentPreset ?? undefined,
+                            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 (error) {
-                options.signal.throwIfAborted();
-                if (error instanceof SubagentError)
-                    throw error;
-                throw new SubagentError(`subagent "${childId}" is unavailable`, 'NOT_RESUMABLE', { cause: error });
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
             }
-            return await this.submitMaterialized(activation, content, options, parent);
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
-        }
+            finally {
+                __disposeResources(env_3);
+            }
+        });
     }
     /** Admit a materialized child, commit its creation fact, and release it on failure. */
     async submitMaterialized(activation, content, options, parent, commit) {
@@ -1269,7 +1108,7 @@ export class SubagentManager {
             }
             const messageId = this.submitAdmitted(activation, content, options, parent);
             commit?.();
-            this.announce(activation);
+            this.accept(activation);
             return messageId;
         }
         catch (error) {
@@ -1284,19 +1123,17 @@ export class SubagentManager {
     }
     /** Build and submit one message across the final synchronous admission cutoff. */
     submitAdmitted(activation, content, options, parent) {
-        const message = options.source === undefined
-            ? createAgentMessage(parent, content)
-            : createUserMessage({ content, source: options.source });
+        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. */
@@ -1331,15 +1168,4 @@ export class SubagentManager {
     }
 }
 export default SubagentManager;
-/** 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;
-}
 //# sourceMappingURL=manager.js.map