@deepseek-ai/dsh-subagent 0.1.2-alpha.5 → 0.1.3-alpha.2

package/lib/types/continuation.js

@@ -1,22 +1,14 @@
 /**
- * Internal continuable-subagent manager: stable child ids, descriptor
- * persistence, activation admission, the live ownership graph, cold resume,
- * child-first disposal, and settlement delivery to the parent, behind
- * `ctx.subagents`.
+ * Continuable-subagent orchestration behind `ctx.subagents`: stable child ids,
+ * descriptor persistence, provider preparation, cold resume, authorization,
+ * and message routing. {@link ContinuableActivationRegistry} owns the mutable
+ * process-local Activation graph and its settlement and disposal lifecycle.
  *
  * A continuable child has one durable Session and at most one process-local
- * {@link Activation} — one residency epoch for a reconstructed child Agent. An
- * Activation is not a request, result, cancellation, or Task boundary: it may
- * execute many FIFO turns and stays resident while descendants it created are
- * still running. The Agent inbox is the only turn queue, so this manager owns
- * residency while the Agent loop owns all turn ordering and execution. No
- * continuable path creates a Task or an intermediate result-bearing wrapper.
- *
- * Because residency is this manager's alone to end, telling the parent that a
- * child settled is its job too. An external `subagent/end` listener cannot do
- * it correctly: that payload names no parent, the child handle is already
- * disposed by then, and the release that wakes the parent's own settlement
- * watcher has already run. See {@link SubagentContinuationManager.notifySettlement}.
+ * Activation. The Agent inbox is the only turn queue, so this manager owns
+ * durable orchestration while the Agent loop owns all turn ordering and
+ * execution. No continuable path creates a Task or an intermediate
+ * result-bearing wrapper.
  *
  * @module @deepseek-ai/dsh-subagent
  */
@@ -74,109 +66,15 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { randomUUID } from 'node:crypto';
 import { brandString } from '@deepseek-ai/dsh-brand';
-import { ReasoningEffortId, boundContextSummary, contentHasImage, createUserMessage, errorChain } from '@deepseek-ai/dsh-llm';
+import { ReasoningEffortId, contentHasImage, createUserMessage } from '@deepseek-ai/dsh-llm';
 import { SessionLogOffset } from '@deepseek-ai/dsh-session';
-import { foldSubagentDescriptor, snapshotSubagentDescriptor } from "./descriptor.js";
-import { appendDelegatedPolicyOverrides, applyChildComposition, captureDelegatedPolicyOverrides, childSessionMeta, resolveChildAgentOptions, resolveChildDepth, } from "./child-agent.js";
+import { childSessionMeta, captureDelegatedPolicyOverrides, resolveChildAgentOptions, resolveChildDepth, } from "./child-agent.js";
+import { ContinuableActivationRegistry, } from "./continuation-activation.js";
+import { createAgentMessage, withContinuableReturnGuidance, } from "./continuation-messages.js";
 import { assertSubagentMaxDepth } from "./depth.js";
-import { seedDescriptorTurn } from "./descriptor-seed.js";
+import { foldSubagentDescriptor, snapshotSubagentDescriptor } from "./descriptor.js";
 import { SubagentError } from "./error.js";
 import { isAdjacentAgentSendMessageTool } from "./internal.js";
-/**
- * Read one Activation's current disposal transaction. This indirection exists
- * because TypeScript would otherwise narrow repeated reads of the mutable field
- * inside a long-lived closure to constants instead of re-reading runtime state.
- * @param activation - the Activation to inspect.
- * @returns the in-flight or settled disposal, or `undefined` while resident.
- */
-function disposalOf(activation) {
-    return activation.disposal;
-}
-/** Build durable attribution for one adjacent-Agent message. */
-function agentMessageSource(sender) {
-    return {
-        kind: 'agent-message',
-        form: 'relay',
-        senderSessionId: sender.id,
-    };
-}
-/** Build the model-visible and durable representation of one adjacent-Agent message. */
-function agentMessage(sender, content) {
-    return createUserMessage({
-        content: [
-            { type: 'text', text: `Agent ${sender.id} sent a message:` },
-            ...content,
-        ],
-        source: agentMessageSource(sender),
-    });
-}
-/** Append adjacent-Agent return guidance to a continuable child's initial task. */
-function continuableInitialPrompt(parentId, prompt) {
-    const encodedParentId = JSON.stringify(parentId);
-    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.',
-        },
-    ];
-}
-/**
- * One line telling a parent that a background child is finished and why, in
- * the parent's own task vocabulary.
- * @param childId - the durable child the parent knows by id.
- * @param stopReason - how the child's last ordinary turn ended.
- * @returns the model-facing opening line of the settlement notice.
- */
-function settlementSummary(childId, stopReason) {
-    const subject = `Background subagent ${childId}`;
-    switch (stopReason) {
-        case 'completed':
-            return `${subject} finished and will do no further work unless you send it more.`;
-        case 'aborted':
-            return `${subject} was stopped before it finished.`;
-        case 'max-tokens':
-            return `${subject} ran out of room before it finished.`;
-        // A pre-step rejection — a hook deny, a policy plugin — discarded input
-        // the child had claimed, so the parent must not treat the task as done.
-        case 'refusal':
-            return `${subject} declined the task.`;
-        case 'error':
-            return `${subject} failed before it finished.`;
-        /* v8 ignore next 4 -- `SubagentResult['stopReason']` is merge-extensible, so this arm
-         * needs a backend that adds a variant; an unnameable ending is reported as unfinished
-         * rather than silently as success. */
-        default:
-            return `${subject} ended abnormally (${String(stopReason)}) before it finished.`;
-    }
-}
-/** Serialize each durable child's delivery, release, and disposal. */
-class ChildLock {
-    tails = new Map();
-    /**
-     * Run `operation` after every previously queued operation for `childId`.
-     * @param childId - the durable child whose operations are linearized.
-     * @param operation - the critical section to run in order.
-     * @returns the operation's own settlement.
-     */
-    run(childId, operation) {
-        const previous = this.tails.get(childId) ?? Promise.resolve();
-        const result = previous.then(operation, operation);
-        // Absorb rejections in the chaining tail so one failed critical section
-        // cannot reject an unrelated later caller.
-        const tail = result.then(() => undefined, () => undefined);
-        this.tails.set(childId, tail);
-        void tail.then(() => {
-            if (this.tails.get(childId) === tail)
-                this.tails.delete(childId);
-        });
-        return result;
-    }
-}
 /**
  * The continuable-subagent orchestration service behind `ctx.subagents`. Tool
  * schema and host adapters are consumers of this one contract; foreground
@@ -186,63 +84,27 @@ class ChildLock {
 export class SubagentContinuationManager {
     ctx;
     host;
-    /** Child session id → its live Activation. Process-local, never durable. */
-    activations = new Map();
-    /** Materializations admitted before drain, tracked through publication or rollback. */
-    materializations = new Set();
-    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();
-    draining = false;
+    activations;
     constructor(ctx, host) {
         this.ctx = ctx;
         this.host = host;
-        // 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.
-        const scope = ctx.plugin(function activationOwner() { });
-        this.ownerCtx = scope.ctx;
-        ctx.on('agent/disposed', ({ agent }) => {
-            this.closingScopes.delete(agent);
-        });
-        ctx.effect(function* () {
-            yield scope.dispose;
-            yield () => this.drain();
-        }.bind(this), 'subagents.continuations()');
+        this.activations = new ContinuableActivationRegistry(ctx, (provider, childId, parent) => host.observeActivation(provider, childId, parent));
     }
     /**
-     * Start one continuable background child: reserve its durable identity,
-     * resolve the provider's detached creation spec, create the child Agent
-     * through the private activation-owner scope, establish any continuable-parent
-     * ownership, and submit the initial prompt. Resolves when inbox acceptance
-     * yields the message id — without waiting for the turn to start or for the
-     * message to reach the Session log.
-     *
-     * Every failure before that acceptance rejects without either id, disposing
-     * any created handle and rolling back the Activation and parent ownership.
-     * The caller signal owns lookup, materialization, and admission only until
-     * acceptance; afterwards the manager owns the Activation independently.
+     * 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.
      * @param spec - provider, delegation request, and caller cancellation.
-     * @returns the durable child id and the accepted initial prompt's message id.
+     * @returns the durable child id and accepted initial prompt message id.
      */
     async startContinuable(spec) {
         const request = spec.request;
         const parent = request.parent;
-        this.assertAdmitting(parent);
+        this.activations.assertAdmitting(parent);
         const persistence = this.requirePersistence();
         assertSubagentMaxDepth(request.maxDepth);
         const childId = spec.childId ?? brandString(randomUUID());
-        this.assertChildIdAvailable(childId);
+        this.activations.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.
@@ -263,72 +125,74 @@ export class SubagentContinuationManager {
         // Capture before the first await: a later parent switch belongs to the
         // parent's future, not to this child.
         const delegatedPolicies = captureDelegatedPolicyOverrides(parent);
-        const prepared = await this.host.prepareContinuable(spec.provider, {
-            sessionId: childId,
-            parent,
-            signal: spec.signal,
-        });
-        spec.signal.throwIfAborted();
-        this.assertAdmitting(parent);
-        const inheritedEventCount = SessionLogOffset(prepared.seed?.length ?? 0);
-        const seed = seedDescriptorTurn(childId, prepared.seed, descriptor);
-        const messageId = await this.locks.run(childId, async () => {
+        // 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.activations.holdOwnership(parent, childId);
+        try {
+            const prepared = await this.host.prepareContinuable(spec.provider, {
+                sessionId: childId,
+                parent,
+                signal: spec.signal,
+            });
             spec.signal.throwIfAborted();
-            this.assertAdmitting(parent);
-            this.assertChildIdAvailable(childId);
-            if (spec.childId !== undefined) {
-                const persisted = await persistence.listSnapshots(spec.signal);
+            this.activations.assertAdmitting(parent);
+            const inheritedEventCount = SessionLogOffset(prepared.seed?.length ?? 0);
+            const seed = prepared.seed;
+            const messageId = await this.activations.locks.run(childId, async () => {
                 spec.signal.throwIfAborted();
-                this.assertAdmitting(parent);
-                this.assertChildIdAvailable(childId);
-                if (persisted.some(snapshot => snapshot.header.id === childId)) {
-                    throw new SubagentError(`subagent "${childId}" already exists`, 'DUPLICATE_CHILD');
+                this.activations.assertAdmitting(parent);
+                this.activations.assertChildIdAvailable(childId);
+                if (spec.childId !== undefined) {
+                    const persisted = await persistence.stat(childId, { signal: spec.signal });
+                    spec.signal.throwIfAborted();
+                    this.activations.assertAdmitting(parent);
+                    this.activations.assertChildIdAvailable(childId);
+                    if (persisted !== undefined) {
+                        throw new SubagentError(`subagent "${childId}" already exists`, 'DUPLICATE_CHILD');
+                    }
                 }
-            }
-            const activation = await this.materialize({
-                childId,
-                provider: spec.provider,
-                parent,
-                create: {
-                    seed,
-                    meta: childSessionMeta(parent, childDepth, prepared.seed !== undefined),
-                    inheritedEventCount,
-                    delegatedPolicies,
-                },
-                agentOptions,
-                composition: { persona: request.persona, toolFilter: request.toolFilter },
-                signal: spec.signal,
+                const activation = await this.activations.materialize({
+                    childId,
+                    provider: spec.provider,
+                    parent,
+                    create: {
+                        seed,
+                        meta: childSessionMeta(parent, childDepth, prepared.seed !== undefined),
+                        inheritedEventCount,
+                        delegatedPolicies,
+                        descriptor,
+                    },
+                    agentOptions,
+                    composition: { persona: request.persona, toolFilter: request.toolFilter },
+                    signal: spec.signal,
+                });
+                return this.submitMaterialized(activation, isAdjacentAgentSendMessageTool(this.ctx.get('tools')?.get('send_message', activation.handle.agent))
+                    ? withContinuableReturnGuidance(parent.id, request.prompt)
+                    : request.prompt, { source: { kind: 'user' }, signal: spec.signal, delivery: 'queue' }, parent);
             });
-            return this.submitMaterialized(activation, isAdjacentAgentSendMessageTool(this.ctx.get('tools')?.get('send_message', activation.handle.agent))
-                ? continuableInitialPrompt(parent.id, request.prompt)
-                : request.prompt, { source: { kind: 'user' }, signal: spec.signal, delivery: 'queue' }, parent);
-        });
-        return { childId, messageId };
-    }
-    /** Reject one child identity already owned by a live Agent or Session. */
-    assertChildIdAvailable(childId) {
-        if (this.ctx.agents.get(childId) !== undefined || this.ctx.get('sessions')?.get(childId) !== undefined) {
-            throw new SubagentError(`subagent "${childId}" already exists`, 'DUPLICATE_CHILD');
+            return { childId, messageId };
+        }
+        catch (error) {
+            releaseHold();
+            throw error;
         }
     }
     /**
      * Deliver one model-authored message to a direct continuable child or to the
-     * sender's direct parent. Both directions use Steer: a running target admits
-     * the message at its nearest step boundary, while an idle target starts a
-     * turn. A missing direct child cold-resumes through the ordinary continuation
-     * lifecycle. The caller signal owns the operation only until inbox acceptance.
+     * 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.
-     * @throws when adjacency, availability, or admission rejects delivery.
      */
     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');
         }
-        this.assertAdmitting(sender);
+        this.activations.assertAdmitting(sender);
         const senderActivation = this.activations.get(sender.id);
         if (senderActivation !== undefined
             && senderActivation.handle.agent === sender
@@ -348,358 +212,124 @@ export class SubagentContinuationManager {
      * 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 - human-authored content to deliver.
-     * @param source - durable host-protocol provenance.
+     * @param content - model-visible prompt blocks.
+     * @param source - durable attribution for the human prompt.
      * @param signal - caller cancellation before inbox acceptance.
-     * @returns the accepted message's inbox id.
+     * @returns the accepted durable message id.
      */
     async queuePrompt(parent, childId, content, source, signal) {
         return this.deliverToChild(parent, childId, content, { source, signal, delivery: 'queue' });
     }
+    /**
+     * 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.
+     * @param content - model-visible prompt blocks.
+     * @param source - durable attribution for the host prompt.
+     * @param signal - caller cancellation before inbox acceptance.
+     * @returns the accepted durable message id.
+     */
+    async steerPrompt(parent, childId, content, source, signal) {
+        return this.deliverToChild(parent, childId, content, { source, signal, delivery: 'steer' });
+    }
     /** Route one parent-originated delivery through residency and cold resume. */
     async deliverToChild(parent, childId, content, options) {
-        this.assertAdmitting(parent);
+        this.activations.assertAdmitting(parent);
+        const releaseHold = this.activations.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) {
         while (true) {
-            const live = await this.locks.run(childId, async () => {
+            const live = await this.activations.locks.run(childId, async () => {
                 const activation = this.activations.get(childId);
                 if (activation === undefined)
                     return this.coldResume(parent, childId, content, options);
-                // A delivery that arrives after the disposal transaction began must not
-                // reach a handle being torn down; wait for release, then cold-resume.
-                const disposal = activation.disposal;
-                /* v8 ignore next 3 -- the send-versus-dispose cutoff: reaching this arm needs a
-                 * delivery to observe the transaction inside the same critical section that opened it,
-                 * which no test can schedule deterministically. The behavior is covered end-to-end by
-                 * "cold-resumes a delivery that lost the race with final disposal". */
+                const disposal = activation.inbox.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);
                 }
-                // Text-only delivery stays await-free, so the disposal-cutoff check
-                // above and the submit share one critical window. The image path
-                // awaits a capability read, so it re-checks the cutoff afterwards; a
-                // disposal that began during the read is waited out and retried like
-                // one observed on entry.
                 if (contentHasImage(content)) {
                     await this.assertImageCapable(activation.handle.agent, options.signal);
-                    if (activation.disposal !== undefined) {
-                        await Promise.allSettled([activation.disposal]);
+                    if (activation.inbox.closing !== undefined) {
+                        await Promise.allSettled([activation.inbox.closing]);
                         return undefined;
                     }
                 }
                 return this.submitAdmitted(activation, content, options, parent);
             });
-            /* v8 ignore start -- only the lost-cutoff arm above returns undefined, so only that
-             * race reaches the retry below, which then cold-resumes a new Activation. */
+            /* v8 ignore start -- only a delivery that lost the disposal cutoff retries. */
             if (live !== undefined)
                 return live;
-            this.assertAdmitting(parent);
+            this.activations.assertAdmitting(parent);
             options.signal.throwIfAborted();
             /* v8 ignore stop */
         }
     }
     /**
      * Interrupt one live continuable child's current turn. Admission is
-     * synchronous and the effect is asynchronous: this authorizes the caller,
-     * requests `Agent.cancel(cause, { keepInbox: true })` on the target, and
-     * returns without waiting for the target to observe the signal or reach
-     * quiescence. The Activation, its handle, accepted unclaimed inbox work, and
-     * already-published descendants are untouched; work already claimed into the
-     * interrupted turn is not requeued. Once the interrupted driver is idle, a
-     * waking send resumes the parked queue.
-     *
-     * An absent target is an accepted no-op, which uniformly covers natural
-     * completion races, repeated requests, one-shot ids, and unknown ids without
-     * consulting the durable catalog. A target whose disposal transaction is
-     * already open is likewise an accepted no-op after authorization.
+     * synchronous and the cancellation effect is asynchronous. An absent or
+     * already-closing target is an accepted no-op after authority checks.
      * @param targetSessionId - the durable child session id to interrupt.
      * @param authority - the human parent address or exact live ancestor Agent.
-     * @throws {SubagentError} `UNAUTHORIZED` when the presented authority does
-     *   not own the live target: a stale or self-targeting ancestor caller, a
-     *   parent address that is not the live target's durable direct parent, or
-     *   an ancestor outside the target's recorded live lineage.
      */
     interrupt(targetSessionId, authority) {
-        if (authority.kind === 'ancestor') {
-            const caller = authority.agent;
-            // A stale caller is rejected even when the target is absent, so a
-            // replaced same-id Agent can never probe this manager's state.
-            if (this.ctx.agents.get(caller.id) !== caller) {
-                throw new SubagentError(`interrupting "${targetSessionId}" requires the exact live ancestor agent`, 'UNAUTHORIZED');
-            }
-            if (caller.id === targetSessionId) {
-                throw new SubagentError(`agent "${caller.id}" cannot interrupt itself`, 'UNAUTHORIZED');
-            }
-        }
-        const activation = this.activations.get(targetSessionId);
-        if (activation === undefined)
-            return;
-        if (authority.kind === 'user') {
-            if (activation.handle.agent.session.header.parentSession !== 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');
-        }
-        // Disposal already stopped the target with a whole-Activation teardown;
-        // a second cancel would be a redundant signal on a closing handle.
-        if (activation.disposal !== undefined)
-            return;
-        activation.handle.agent.cancel(authority.kind === 'user' ? { kind: 'user' } : { kind: 'parent' }, { keepInbox: true });
+        this.activations.interrupt(targetSessionId, authority);
     }
     /** 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.disposal !== undefined) {
+        if (activation.inbox.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.parentSession);
         if (parent === undefined) {
             throw new SubagentError('direct parent is not live; the message was not delivered', 'PARENT_UNAVAILABLE');
         }
-        const message = agentMessage(sender, content);
-        this.sendWaking(parent, message, () => { this.sendAgentMessage(parent, message); });
+        const message = createAgentMessage(sender, content);
+        this.sendAgentMessage(parent, message);
         return message.id;
     }
-    /**
-     * Perform one waking send to a parent, accounted against that parent's own
-     * Activation when it has one. Registering the id before the send is what
-     * keeps a continuation-managed parent from being judged quiescent in the
-     * window between a waking send and the microtask that admits it.
-     * @param parent - the exact live parent receiving the waking message.
-     * @param message - the message whose id is accounted.
-     * @param send - the synchronous waking send to perform.
-     */
-    sendWaking(parent, message, send) {
-        const parentActivation = this.activations.get(parent.id);
-        if (parentActivation !== undefined && parentActivation.handle.agent === parent) {
-            this.admitWaking(parentActivation, message.id, send);
-        }
-        else {
-            send();
-        }
-    }
     /** Send one Agent message while translating only the target's own rejection. */
     sendAgentMessage(parent, message) {
         try {
-            parent.steer(message);
+            this.activations.sendWaking(parent, message, 'steer');
         }
         catch (error) {
             throw new SubagentError('direct parent is not live; the message was not delivered', 'PARENT_UNAVAILABLE', { cause: error });
         }
     }
-    /**
-     * Close admission, await every already-admitted materialization through
-     * publication or rollback, then dispose the stable live Activation forest
-     * child-first. Sibling branches drain independently: one failure is recorded
-     * but never prevents the remaining handles from being attempted, and the
-     * aggregate rejects only after every branch settles.
-     * @returns once materialization is quiescent and every live Activation released its handle.
-     * @throws an aggregate error when any branch failed to release.
-     */
+    /** Close manager-wide admission and release every live Activation. */
     async drain() {
-        // Close admission synchronously before the first await. Materializations
-        // already past that cutoff remain tracked until their handle is installed
-        // or rollback completes, producing a stable forest for the later snapshot.
-        this.draining = true;
-        await Promise.all([...this.materializations].map(materialization => materialization.settled));
-        // Snapshot roots after closing admission: a root is an Activation no live
-        // Activation owns, so disposing roots recurses child-first into the forest.
-        const owned = new Set();
-        for (const activation of this.activations.values()) {
-            for (const child of activation.ownedChildren)
-                owned.add(child);
-        }
-        const roots = [...this.activations.values()].filter(activation => !owned.has(activation.childId));
-        await this.disposeRoots(roots, 'activation(s)');
+        await this.activations.drain();
     }
     /**
      * Stop only the continuable descendants of exact live host-owned parents.
-     * Admission stays closed for those parent trees until each exact parent
-     * leaves the Agent registry; unrelated trees and manager-wide admission stay
-     * live.
      * @param parents - exact live roots whose continuable descendants must stop.
-     * @returns once every retained descendant Activation released its handle.
-     * @throws an aggregate error after all scoped branches settle when any failed.
      */
     async drainDescendants(parents) {
-        const roots = new Set(parents.filter(parent => this.ctx.agents.get(parent.id) === parent));
-        if (roots.size === 0)
-            return;
-        // Publish the scoped admission cutoff before the first await. Merge with an
-        // earlier call for the same exact root so a converging drain cannot forget
-        // descendants whose release is already in flight.
-        for (const root of roots) {
-            this.closingMembers(root).add(root);
-        }
-        const targets = [];
-        for (const activation of this.activations.values()) {
-            const lineage = this.liveLineage(activation.handle.agent);
-            // Strict descendants only: a continuable Agent may itself be a
-            // host-owned root, and its host remains responsible for that root handle.
-            const owners = [...roots].filter(root => activation.handle.agent !== root
-                && activation.ancestry.has(root));
-            if (owners.length === 0)
-                continue;
-            targets.push(activation);
-            for (const owner of owners) {
-                const members = this.closingMembers(owner);
-                members.add(activation.handle.agent);
-                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);
-            }
-            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));
-        // Open every selected transaction before the materialization barrier.
-        // Disposal propagates cancellation top-down in the same synchronous span;
-        // handle release remains child-first.
-        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)');
+        await this.activations.drainDescendants(parents);
     }
     /**
-     * Release selected resident direct children of one exact live parent without
-     * closing admission for the parent's other continuable children. Owned
-     * descendants are released recursively through the same lifecycle.
+     * 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.
-     * @returns once every selected Activation released its handle.
-     * @throws {SubagentError} `UNAUTHORIZED` when a resident target is not the
-     *   parent's direct continuable child or the parent identity is stale.
      */
     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.activations.get(childId);
-            if (activation === undefined)
-                continue;
-            if (activation.parentSession !== parent.id || !activation.ancestry.has(parent)) {
-                throw new SubagentError(`subagent "${childId}" is not a direct child of agent "${parent.id}"`, 'UNAUTHORIZED');
-            }
-            targets.push(activation);
-        }
-        // Open every transaction before the first await so cancellation propagates
-        // across the selected roots in one synchronous span.
-        for (const activation of targets) {
-            const disposal = this.dispose(activation);
-            void disposal.catch(() => undefined);
-        }
-        await this.disposeRoots(targets, 'selected activation(s)');
-    }
-    /** Dispose independent roots and report every branch failure after all settle. */
-    async disposeRoots(roots, failureSubject) {
-        const failures = await Promise.all(roots.map(async (activation) => {
-            try {
-                await this.dispose(activation);
-                return undefined;
-            }
-            catch (error) {
-                return error;
-            }
-        }));
-        const reasons = failures.filter(failure => failure !== undefined);
-        if (reasons.length > 0) {
-            throw new SubagentError(`continuable subagent teardown failed for ${reasons.length} ${failureSubject}: `
-                + reasons.map(reason => errorChain(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. The
-     * first element is always the supplied identity, even when it is already
-     * stale; each ancestor after it must be the registry's current exact entry.
-     */
-    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;
+        await this.activations.drainChildren(parent, childIds);
     }
     /**
-     * The teardown that closed continuable admission for this agent's lineage.
-     * `'manager'` is the whole manager draining; an Agent is the exact scoped root
-     * whose forest is closing.
-     * @param agent - the agent whose lineage is tested.
-     * @returns the closing teardown, or `undefined` while admission is open.
-     */
-    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;
-    }
-    /** Reject new admission once the manager or this exact parent tree began draining. */
-    assertAdmitting(agent) {
-        const closing = this.closingTeardownFor(agent);
-        if (closing === undefined)
-            return;
-        throw new SubagentError(closing === 'manager'
-            ? 'continuable subagents are draining; the operation was not admitted'
-            : `continuable subagents below parent "${closing.id}" are draining; the operation was not admitted`, 'DRAINING');
-    }
-    /**
-     * Derive residency from Agent quiescence and the owned-child set. `running`
-     * covers an active admission, an open turn, or accepted waking inbox work.
-     *
-     * `Agent.status` alone is insufficient: it stays `idle` between an accepted
-     * waking send and the microtask that admits it, so a synchronous inbox
-     * observer would see `settled` while a turn is already queued. `accepted`
-     * holds the ids this manager admitted but has not yet seen drained.
-     */
-    stateOf(activation) {
-        if (activation.handle.agent.status === 'running' || activation.accepted.size > 0)
-            return 'running';
-        if (activation.ownedChildren.size > 0)
-            return 'waiting';
-        return 'settled';
-    }
-    /**
-     * Cold-resume a persisted child: retain and authorize its prepared Session, fold the
-     * generic descriptor, create the Activation through `ctx.agents.resume()`,
-     * and submit the waiting turn. This never dispatches through a subagent
-     * provider — the persisted Session already holds the initial prefix and the
-     * descriptor is the whole reconstruction input.
+     * 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 };
@@ -716,20 +346,15 @@ export class SubagentContinuationManager {
                 throw new SubagentError(`subagent "${childId}" is unavailable`, 'NOT_RESUMABLE', { cause: error });
             }
             const source = __addDisposableResource(env_1, observation, false);
-            this.assertAdmitting(parent);
-            // Authorize the persisted header before folding: only the durable child's
-            // exact live direct parent may continue it.
-            this.authorizeLineage(parent, childId, source.header.parentSession);
-            // Fold only the child's own suffix: a fork seed replays the parent's log,
-            // which may carry an ANCESTOR's descriptor when the parent is itself a
-            // continuable child.
+            this.activations.assertAdmitting(parent);
+            this.activations.authorizeLineage(parent, childId, source.header.parentSession);
             const descriptor = foldSubagentDescriptor(source.events.slice(source.inheritedEventCount));
             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 {
-                activation = await this.materialize({
+                activation = await this.activations.materialize({
                     childId,
                     provider: descriptor.provider,
                     parent,
@@ -760,22 +385,12 @@ export class SubagentContinuationManager {
             __disposeResources(env_1);
         }
     }
-    /**
-     * Submit to a freshly materialized Activation or roll it back completely.
-     * @param activation - the just-published Activation to admit or release.
-     * @param content - the initial or resumed message content.
-     * @param options - durable source, scheduling, and pre-acceptance cancellation.
-     * @param parent - the live direct parent authorizing admission.
-     * @returns the accepted inbox message id.
-     */
+    /** Submit to a freshly materialized Activation or roll it back completely. */
     async submitMaterialized(activation, content, options, parent) {
         try {
             if (contentHasImage(content)) {
-                // The capability read awaits with the activation already published, so
-                // the disposal cutoff is re-checked before the submit; a drain that
-                // began during the read turns into a clean closing rejection.
                 await this.assertImageCapable(activation.handle.agent, options.signal);
-                if (activation.disposal !== undefined) {
+                if (activation.inbox.closing !== undefined) {
                     throw new SubagentError(`subagent "${activation.childId}" is closing`, 'ACTIVATION_CLOSING');
                 }
             }
@@ -784,29 +399,24 @@ export class SubagentContinuationManager {
         catch (error) {
             /* v8 ignore next -- rollback disposal failures must not mask the
              * pre-acceptance signal, drain, or lifecycle failure. */
-            await this.dispose(activation).catch(() => undefined);
+            await this.activations.dispose(activation).catch(() => undefined);
             throw error;
         }
     }
-    /**
-     * Refuse image content addressed to a child whose model accepts text only.
-     * Callers guard with `contentHasImage`, so text-only delivery never awaits.
-     * The check runs inside the per-child delivery lock, before the message
-     * exists, so a rejection leaves no partial user message. When the child's
-     * route is not fixed by its options (a request-waterfall listener owns it)
-     * or no LLM registry is composed, delivery proceeds and the LLM layer's
-     * text-only projection replaces each image with its stable placeholder.
-     * @param agent - the live or freshly materialized child agent.
-     * @param signal - caller cancellation bounding the model-info read.
-     * @throws {SubagentError} `MODEL_DOES_NOT_SUPPORT_IMAGES` when the child's resolved model declines image input.
-     */
+    /** 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 });
+        return this.activations.submitAdmitted(activation, message, options.delivery, parent, options.signal);
+    }
+    /** Refuse image content for a child whose fixed model accepts text only. */
     async assertImageCapable(agent, signal) {
         const { provider, model } = agent.options;
         if (provider === undefined || model === undefined)
             return;
         const llm = this.ctx.get('llm');
-        /* v8 ignore next -- a deployment without the LLM registry serves no model
-         * to refuse against; delivery then defers to the text-only projection. */
+        /* v8 ignore next -- without an LLM registry, delivery defers to projection. */
         if (llm === undefined)
             return;
         const info = await llm.resolveModelInfo(provider, model, signal);
@@ -814,468 +424,6 @@ export class SubagentContinuationManager {
             throw new SubagentError(`Model "${model}" does not support image input.`, 'MODEL_DOES_NOT_SUPPORT_IMAGES');
         }
     }
-    /**
-     * Create or resume the child Agent through the private activation-owner
-     * scope, install the handle in a fresh Activation, and register ownership on
-     * a continuation-managed parent. Rejection leaves no Activation, no handle,
-     * and no ownership membership.
-     */
-    materialize(inputs) {
-        this.assertAdmitting(inputs.parent);
-        const settled = Promise.withResolvers();
-        const lineage = this.liveLineage(inputs.parent);
-        const materialization = {
-            lineage,
-            settled: settled.promise,
-        };
-        this.materializations.add(materialization);
-        return this.materializeTracked(inputs, lineage).finally(() => {
-            this.materializations.delete(materialization);
-            settled.resolve();
-        });
-    }
-    /**
-     * Perform one tracked materialization. The caller keeps the drain barrier
-     * registered until this either returns a resident Activation or finishes
-     * rollback.
-     */
-    async materializeTracked(inputs, parentLineage) {
-        const { childId, provider, parent, create } = inputs;
-        // No id pre-check here: the child lock serializes each durable child, both
-        // callers reach this only after confirming no Activation exists, and
-        // `AgentRegistry.enter()` is the authoritative collision boundary for an id
-        // some other owner holds — a duplicate would reject there with rollback.
-        inputs.signal.throwIfAborted();
-        const setup = (childCtx) => {
-            // Only fresh creation seeds the delegation policy onto the child's own
-            // log (after any fork seed, so fresh policy wins stale seed state); a
-            // cold resume replays those persisted events instead.
-            if (create !== undefined) {
-                appendDelegatedPolicyOverrides(childCtx.agent.session, create.delegatedPolicies);
-            }
-            applyChildComposition(childCtx, parent, inputs.composition);
-        };
-        const observer = this.host.observeActivation(provider, childId, parent);
-        // Agent creation owns rollback before handle transfer. A rejection leaves
-        // no resident Activation and therefore publishes no lifecycle edge.
-        const handle = create === undefined
-            ? await this.ownerCtx.agents.resume({
-                resumeSessionId: childId,
-                agentOptions: inputs.agentOptions,
-                signal: inputs.signal,
-                setup,
-            })
-            : await this.ownerCtx.agents.create({
-                sessionId: childId,
-                meta: create.meta,
-                seed: create.seed,
-                inheritedEventCount: create.inheritedEventCount,
-                agentOptions: inputs.agentOptions,
-                signal: inputs.signal,
-                setup,
-            });
-        const activation = {
-            childId,
-            // The durable lineage, not merely the caller: creation stamps this same
-            // agent into the child's header, and cold resume authorized it against
-            // the persisted header before materializing.
-            parentSession: parent.id,
-            provider,
-            handle,
-            ancestry: new WeakSet([handle.agent, ...parentLineage]),
-            ownedChildren: new Set(),
-            observer,
-            disposal: undefined,
-            accepted: new Set(),
-            announced: false,
-            poke: Promise.withResolvers(),
-        };
-        // After transfer, any failure must dispose the created handle, remove the
-        // Activation, and roll back parent ownership before rejecting.
-        this.activations.set(childId, activation);
-        try {
-            inputs.signal.throwIfAborted();
-            this.assertAdmitting(parent);
-            this.acquireOwnership(parent, childId);
-            // Every accepted id leaves the inbox exactly once, through dequeue or
-            // discard. Clearing it there is what lets `stateOf()` distinguish a truly
-            // quiet Agent from one whose accepted turn has not been admitted yet.
-            // Registered through the child's own scoped context, so scope filtering
-            // already restricts both listeners to this exact agent.
-            handle.agent.ctx.on('agent/inbox/claimed', ({ message }) => {
-                /* v8 ignore next -- a claim of an id this manager never admitted needs
-                 * another sender on the same child, which no current path allows. */
-                if (activation.accepted.delete(message.id))
-                    this.wake(activation);
-            });
-            handle.agent.ctx.on('agent/inbox/discarded', ({ message }) => {
-                if (activation.accepted.delete(message.id))
-                    this.wake(activation);
-            });
-            // Agent creation committed setup at its publication boundary;
-            // revocations from here on are immediate live revocation.
-            // Publish the start edge before any turn can run, so observers see this
-            // epoch before its first request.
-            observer.start(handle.agent);
-        }
-        catch (error) {
-            // Listener exceptions are contained by the lifecycle emitter; a start
-            // publication throw therefore leaves no residency edge to pair.
-            /* v8 ignore next -- rollback failure must not mask the admission failure
-             * that prevented this operation from returning an accepted message id. */
-            await this.rollbackUnpublished(activation).catch(() => undefined);
-            throw error;
-        }
-        this.watchSettlement(activation);
-        return activation;
-    }
-    /**
-     * Release an Activation whose start edge was not published. The memoized
-     * transaction remains in the live map until handle disposal settles, so a
-     * concurrent drain or delivery observes the same closing boundary.
-     */
-    rollbackUnpublished(activation) {
-        return (activation.disposal ??= (async () => {
-            try {
-                await activation.handle.dispose();
-            }
-            finally {
-                this.activations.delete(activation.childId);
-                this.releaseOwnership(activation.childId);
-            }
-        })());
-    }
-    /**
-     * Register the child in a continuation-managed parent's owned set before the
-     * child can run, so that parent cannot settle while the child is live. A
-     * top-level or other non-continuation Agent has no Activation and stays
-     * outside the waiting graph.
-     */
-    acquireOwnership(parent, childId) {
-        const parentActivation = this.activations.get(parent.id);
-        if (parentActivation === undefined)
-            return;
-        if (parentActivation.disposal !== undefined) {
-            throw new SubagentError(`subagent parent "${parent.id}" is being disposed; the child was not established`, 'ACTIVATION_CLOSING');
-        }
-        parentActivation.ownedChildren.add(childId);
-    }
-    /** Remove one child from its live owner's set and let that owner re-check settlement. */
-    releaseOwnership(childId) {
-        for (const candidate of this.activations.values()) {
-            if (candidate.ownedChildren.delete(childId))
-                this.wake(candidate);
-        }
-    }
-    /** Let a settlement watcher re-observe quiescence after ownership or inbox changes. */
-    wake(activation) {
-        activation.poke.resolve();
-        activation.poke = Promise.withResolvers();
-    }
-    /**
-     * Submit one message as the child's next FIFO turn and return its accepted
-     * inbox id. Acceptance is the operation's success boundary; the manager owns
-     * the Activation independently afterwards.
-     */
-    submit(activation, content, options, parent) {
-        // Parent-originated delivery keeps the parent live through ownership, so
-        // establish it before the message can enter the child's inbox.
-        this.acquireOwnership(parent, activation.childId);
-        const message = options.delivery === 'steer'
-            ? agentMessage(parent, content)
-            : createUserMessage({ content, source: options.source });
-        const accepted = this.admitWaking(activation, message.id, () => {
-            if (options.delivery === 'steer')
-                activation.handle.agent.steer(message);
-            else
-                activation.handle.agent.followup(message);
-        });
-        // Past this point the caller has an id for this child, so its eventual
-        // settlement is something the parent is owed an account of.
-        activation.announced = true;
-        return accepted;
-    }
-    /**
-     * Account one waking send across a resident Activation's settlement window.
-     * @param activation - Activation receiving waking inbox work.
-     * @param messageId - stable identity of the message about to be sent.
-     * @param send - synchronous send that publishes one enqueue occurrence.
-     * @returns the accepted message id.
-     */
-    admitWaking(activation, messageId, send) {
-        // Waking Agent sends publish inbox events synchronously, so observers must
-        // see this Activation as busy before the call begins.
-        activation.accepted.add(messageId);
-        try {
-            send();
-        }
-        catch (error) {
-            activation.accepted.delete(messageId);
-            throw error;
-        }
-        // Accepted waking work keeps this Activation live until whenIdle() observes
-        // the complete waking suffix.
-        this.wake(activation);
-        return messageId;
-    }
-    /**
-     * Cross the final admission cutoff and submit without yielding. Signal abort,
-     * manager drain, or Activation disposal that wins before this synchronous
-     * span rejects without inbox acceptance.
-     */
-    submitAdmitted(activation, content, options, parent) {
-        options.signal.throwIfAborted();
-        this.assertAdmitting(parent);
-        /* v8 ignore next 6 -- only a synchronous re-entrant disposer can change
-         * this field between the caller's live check and this no-await boundary. */
-        if (disposalOf(activation) !== undefined) {
-            throw new SubagentError(`subagent "${activation.childId}" activation is being disposed; the message was not accepted`, 'ACTIVATION_CLOSING');
-        }
-        this.authorizeLineage(parent, activation.childId, activation.handle.agent.session.header.parentSession);
-        return this.submit(activation, content, options, parent);
-    }
-    /**
-     * Authorize one operation against the durable direct-parent lineage. Other
-     * agents, ancestors, teams, workflows, and hosts remain rejected until an
-     * explicit authority protocol has a production consumer.
-     */
-    authorizeLineage(parent, childId, parentSession) {
-        if (this.ctx.agents.get(parent.id) !== parent) {
-            throw new SubagentError(`subagent "${childId}" delivery requires the exact live parent agent`, 'UNAUTHORIZED');
-        }
-        if (parentSession !== parent.id) {
-            throw new SubagentError(`subagent "${childId}" belongs to another parent session`, 'UNAUTHORIZED');
-        }
-    }
-    /**
-     * Follow one Activation to settlement: wait for Agent quiescence, then for
-     * every owned child to complete disposal, and dispose the handle once both
-     * hold. A `next-turn` delivered while `waiting` wakes the same Agent and
-     * returns it to `running`, so this re-observes rather than settling early.
-     */
-    watchSettlement(activation) {
-        void (async () => {
-            while (disposalOf(activation) === undefined) {
-                const poked = activation.poke.promise;
-                await Promise.race([activation.handle.agent.whenIdle(), poked]);
-                if (disposalOf(activation) !== undefined)
-                    return;
-                // Re-check settlement INSIDE the child lock and begin disposal in the
-                // same critical section, so a concurrent delivery either wins admission
-                // before the transaction opens or waits for release and cold-resumes.
-                // Deciding outside the lock would let a delivery observe a not-yet
-                // resident handle that this watcher is already about to tear down.
-                const settling = await this.locks.run(activation.childId, () => {
-                    if (disposalOf(activation) !== undefined || this.stateOf(activation) !== 'settled') {
-                        return Promise.resolve({ settling: false });
-                    }
-                    // `dispose()` assigns its memoized transaction synchronously, so
-                    // admission is closed before this critical section releases.
-                    return Promise.resolve({ settling: true, done: this.dispose(activation) });
-                });
-                if (!settling.settling) {
-                    // Still running, or waiting on descendants: re-observe after the next
-                    // accepted message or ownership release.
-                    if (activation.handle.agent.status !== 'running')
-                        await poked;
-                    continue;
-                }
-                try {
-                    await settling.done;
-                }
-                catch (error) {
-                    this.ctx.logger.warn(`subagent "${activation.childId}" activation teardown failed: ${errorChain(error)}`);
-                }
-                return;
-            }
-        })();
-    }
-    /**
-     * Stop one Activation immediately, then release it child-first. The memoized
-     * transaction is installed before cancellation or recursive callbacks, so
-     * admission and reentrant teardown converge on the same owner.
-     *
-     * The final session flush is best effort and never prevents handle disposal
-     * or ownership release, because retaining a child would permanently pin its
-     * ancestors in `waiting`.
-     * @param activation - the residency epoch to stop and release.
-     * @returns the one disposal transaction owned by this Activation.
-     */
-    dispose(activation) {
-        const existing = activation.disposal;
-        if (existing !== undefined)
-            return existing;
-        const completion = Promise.withResolvers();
-        // Presence is the admission cutoff. Assign it before the async helper starts
-        // because that helper cancels Agents and may synchronously re-enter callers.
-        activation.disposal = completion.promise;
-        void this.finishDisposal(activation).then(completion.resolve, completion.reject);
-        return completion.promise;
-    }
-    /**
-     * Propagate stop synchronously, then finish the child-first release.
-     * @param activation - the Activation whose disposal transaction is installed.
-     * @returns once the handle and ownership edge are released.
-     */
-    async finishDisposal(activation) {
-        this.wake(activation);
-        const { childId } = activation;
-        // Stop top-down before the first await. Slow descendant cleanup may delay
-        // release, but it cannot let this ancestor continue model or tool work.
-        activation.handle.agent.cancel({ kind: 'parent' });
-        const idle = activation.handle.agent.whenIdle();
-        const children = [...activation.ownedChildren]
-            .map(child => this.activations.get(child))
-            .filter((child) => child !== undefined);
-        const childDisposals = children.map(child => this.dispose(child));
-        const failures = [];
-        try {
-            // Release remains child-first even though cancellation propagated
-            // top-down: every owned child completes before this handle is removed.
-            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 => errorChain(reason)).join('; ')}`, 'ACTIVATION_TEARDOWN_FAILED'));
-            }
-            // Quiesce before the flush: a turn still running would keep
-            // appending events the flush cannot cover.
-            await idle;
-            await this.flushFinalState(activation);
-            // Capture the child-dependent edge data while the child is still live:
-            // handle disposal unregisters it, and consumers read its log and scope.
-            activation.observer.capture(activation.handle.agent);
-        }
-        catch (error) {
-            failures.push(new SubagentError(`subagent "${childId}" activation teardown failed: ${errorChain(error)}`, 'ACTIVATION_TEARDOWN_FAILED', { cause: error }));
-        }
-        try {
-            await activation.handle.dispose();
-        }
-        catch (error) {
-            failures.push(new SubagentError(`subagent "${childId}" activation handle disposal failed: ${errorChain(error)}`, 'ACTIVATION_TEARDOWN_FAILED', { cause: error }));
-        }
-        let failure;
-        if (failures.length === 1) {
-            failure = failures[0];
-        }
-        else if (failures.length > 1) {
-            failure = new SubagentError(`subagent "${childId}" activation teardown failed at ${failures.length} boundaries: `
-                + failures.map(item => errorChain(item)).join('; '), 'ACTIVATION_TEARDOWN_FAILED', { cause: new AggregateError(failures) });
-        }
-        // Only now is the Activation gone: keeping the entry until disposal settles
-        // makes a racing delivery wait for release rather than cold-resume into the
-        // still-registered agent.
-        this.activations.delete(childId);
-        // BEFORE releasing ownership, while the parent still counts this child and
-        // therefore cannot be judged settled. Delivering after the release would
-        // race a parent watcher that resumes one microtask later, finds itself
-        // childless and quiet, and disposes an Agent whose `cancel()` clears the
-        // inbox this notice is sitting in.
-        this.notifySettlement(activation, activation.observer.terminal(failure));
-        // Release ownership even on failure: a retained failed child would pin its
-        // ancestors in `waiting` forever.
-        this.releaseOwnership(childId);
-        // Emit once the disposal outcome is known, so a rejecting scoped cleanup
-        // cannot be reported as a successful epoch.
-        activation.observer.settle(failure);
-        if (failure !== undefined)
-            throw failure;
-    }
-    /**
-     * Tell the durable direct parent that this child produced everything it is
-     * going to. Unconditional for every child the caller received an id for: it
-     * does not consider whether the child reported, because the cases that most
-     * need it — a token ceiling, a model failure, cancellation, teardown — are
-     * exactly the ones where the child never got to choose. A materialization
-     * rolled back before its first acceptance stays silent, since the caller was
-     * told that child was not established. A parent that is no longer live is not
-     * an error; the child's own Session remains the durable record either way.
-     * A parent whose own lineage is already closing receives the notice without a
-     * wake, because teardown is not a reason to start a turn.
-     *
-     * Never blocks disposal. A delivery failure is logged and dropped, because
-     * retaining a child to retry a notice would pin its whole ancestry in
-     * `waiting` forever.
-     * @param activation - the settling Activation, still owned by its parent.
-     * @param terminal - how this epoch ended, as the terminal edge will report it.
-     */
-    notifySettlement(activation, terminal) {
-        if (!activation.announced)
-            return;
-        try {
-            const parent = this.ctx.agents.get(activation.parentSession);
-            if (parent === undefined)
-                return;
-            const summary = settlementSummary(activation.childId, terminal.stopReason);
-            const message = createUserMessage({
-                content: [
-                    { type: 'text', text: summary },
-                    ...terminal.output === undefined
-                        ? [{ type: 'text', text: 'It left no closing message.' }]
-                        : [{ type: 'text', text: 'Its closing message:' }, ...terminal.output],
-                ],
-                source: {
-                    kind: 'subagent-settled',
-                    form: 'notice',
-                    summary: boundContextSummary(summary),
-                    senderSessionId: activation.childId,
-                },
-            });
-            // A parent whose own teardown already began must not be woken. Waking is
-            // not a queue operation: `followup()` on a quiescent Agent starts a turn,
-            // and `cancel()` does not arm against a later one, so a notice arriving
-            // during teardown would spend a model request on an Agent its host is
-            // about to dispose — once per tree layer, since each layer's own notice
-            // then wakes the layer above it. Injecting delivers to a parent still
-            // reading its inbox and records the account in the log either way; it
-            // does NOT survive that parent's own disposal, whose `keepInbox: false`
-            // cancel durably clears whatever it never claimed.
-            if (this.closingTeardownFor(parent) !== undefined) {
-                parent.inject(message);
-                return;
-            }
-            // An idle parent has nothing else to look at, so it gets one ordinary
-            // turn. A busy parent is steered instead of woken: `Inbox.claim()` takes
-            // the whole next-step batch at one boundary, so several children settling
-            // together cost one step rather than one turn each. Steering rather than
-            // injecting closes the window where a driver retires between this status
-            // read and the send, which would strand the notice unclaimed.
-            this.sendWaking(parent, message, () => {
-                if (parent.status === 'idle')
-                    parent.followup(message);
-                else
-                    parent.steer(message);
-            });
-        }
-        catch (error) {
-            this.ctx.logger.warn(`subagent "${activation.childId}" settlement notice was not delivered to its parent: `
-                + errorChain(error));
-        }
-    }
-    /**
-     * Request a best-effort final session flush after the child is quiescent.
-     * Listener failure is logged because flush participation cannot identify a
-     * particular persistence backend, and teardown must still release ownership.
-     * @param activation - the Activation whose final events should be flushed.
-     */
-    async flushFinalState(activation) {
-        const child = activation.handle.agent;
-        try {
-            await child.ctx.sessions.flush(child.session);
-        }
-        catch (error) {
-            this.ctx.logger.warn(`subagent "${activation.childId}" best-effort final session flush failed; `
-                + `the persisted state may be unavailable or stale on resume: ${errorChain(error)}`);
-        }
-    }
     /** Resolve the persistence service continuable children require, or fail loud. */
     requirePersistence() {
         const persistence = this.ctx.get('sessionPersistence');