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

package/lib/types/continuation-messages.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Model-visible messages owned by continuable-subagent orchestration.
+ *
+ * @module @deepseek-ai/dsh-subagent/continuation-messages
+ */
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+import type { ActivationTerminal } from './lifecycle.ts';
+/** Durable attribution for one model-authored message between adjacent Agents. */
+export interface AgentMessageSource {
+    readonly kind: 'agent-message';
+    /** A message another agent addressed to this one (`relay` context form). */
+    readonly form: 'relay';
+    /** Session id of the Agent whose tool call produced the message. */
+    readonly senderSessionId: SessionId;
+}
+/**
+ * Durable attribution for the runtime's own account of a continuable child
+ * settling. Deliberately a different kind from
+ * {@link AgentMessageSource}: an Agent message is content the sender chose,
+ * while this message is the manager stating what became of the child, and a
+ * transcript that merged them would credit the child with words it never wrote.
+ */
+export interface SubagentSettledMessageSource {
+    readonly kind: 'subagent-settled';
+    /** A runtime account shown without expanding the row (`notice` context form). */
+    readonly form: 'notice';
+    /** One-line account of how the child ended. */
+    readonly summary: string;
+    /** Session id of the child that settled. */
+    readonly senderSessionId: SessionId;
+}
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'agent-message': AgentMessageSource;
+        'subagent-settled': SubagentSettledMessageSource;
+    }
+}
+/**
+ * Build the model-visible and durable representation of one adjacent-Agent message.
+ * @param sender - exact live Agent that authored the message.
+ * @param content - model-visible message blocks supplied by the sender.
+ * @returns the durable user-message representation delivered to the recipient.
+ */
+export declare function createAgentMessage(sender: Agent, content: ContentBlock[]): ReturnType<typeof createUserMessage>;
+/**
+ * Append adjacent-Agent return guidance to a continuable child's initial task.
+ * @param parentId - durable parent session id named in the guidance.
+ * @param prompt - initial model-visible task blocks.
+ * @returns task blocks followed by the continuable return guidance.
+ */
+export declare function withContinuableReturnGuidance(parentId: SessionId, prompt: ContentBlock[]): ContentBlock[];
+/**
+ * Build the runtime-owned settlement notice delivered to a child's parent.
+ * @param childId - durable child session id named in the notice.
+ * @param terminal - recorded terminal state for the settled Activation.
+ * @returns the durable user-message representation delivered to the parent.
+ */
+export declare function createSettlementMessage(childId: SessionId, terminal: ActivationTerminal): ReturnType<typeof createUserMessage>;
+//# sourceMappingURL=continuation-messages.d.ts.map

package/lib/types/continuation-messages.js

@@ -0,0 +1,102 @@
+/**
+ * Model-visible messages owned by continuable-subagent orchestration.
+ *
+ * @module @deepseek-ai/dsh-subagent/continuation-messages
+ */
+import { boundContextSummary, createUserMessage } from '@deepseek-ai/dsh-llm';
+/** 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.
+ * @param sender - exact live Agent that authored the message.
+ * @param content - model-visible message blocks supplied by the sender.
+ * @returns the durable user-message representation delivered to the recipient.
+ */
+export function createAgentMessage(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.
+ * @param parentId - durable parent session id named in the guidance.
+ * @param prompt - initial model-visible task blocks.
+ * @returns task blocks followed by the continuable return guidance.
+ */
+export function withContinuableReturnGuidance(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.`;
+    }
+}
+/**
+ * Build the runtime-owned settlement notice delivered to a child's parent.
+ * @param childId - durable child session id named in the notice.
+ * @param terminal - recorded terminal state for the settled Activation.
+ * @returns the durable user-message representation delivered to the parent.
+ */
+export function createSettlementMessage(childId, terminal) {
+    const summary = settlementSummary(childId, terminal.stopReason);
+    return 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: childId,
+        },
+    });
+}
+//# sourceMappingURL=continuation-messages.js.map

package/lib/types/continuation.d.ts

@@ -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
  */
@@ -24,105 +16,13 @@ import type { Context } from '@deepseek-ai/cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
 import type { ContentBlock, MessageId, MessageSource } from '@deepseek-ai/dsh-llm';
 import type { SessionId } from '@deepseek-ai/dsh-session';
-import type { SubagentDescriptorData } from './descriptor.ts';
-import type { ContinuableCreateRequest, ContinuableCreateSpec, SubagentStartRequest } from './types.ts';
 import type { ActivationObserver } from './lifecycle.ts';
-/** Durable attribution for one model-authored message between adjacent Agents. */
-export interface AgentMessageSource {
-    readonly kind: 'agent-message';
-    /** A message another agent addressed to this one (`relay` context form). */
-    readonly form: 'relay';
-    /** Session id of the Agent whose tool call produced the message. */
-    readonly senderSessionId: SessionId;
-}
-/**
- * Durable attribution for the runtime's own account of a continuable child
- * settling. Deliberately a different kind from
- * {@link AgentMessageSource}: an Agent message is content the sender chose,
- * while this message is the manager stating what became of the child, and a
- * transcript that merged them would credit the child with words it never wrote.
- */
-export interface SubagentSettledMessageSource {
-    readonly kind: 'subagent-settled';
-    /** A runtime account shown without expanding the row (`notice` context form). */
-    readonly form: 'notice';
-    /** One-line account of how the child ended. */
-    readonly summary: string;
-    /** Session id of the child that settled. */
-    readonly senderSessionId: SessionId;
-}
-declare module '@deepseek-ai/dsh-llm' {
-    interface MessageSourceMap {
-        'agent-message': AgentMessageSource;
-        'subagent-settled': SubagentSettledMessageSource;
-    }
-}
-/** What a caller asks for when starting a continuable background child. */
-export interface ContinuableStartSpec {
-    /** The `ctx.subagents` provider whose continuable-creation capability establishes the child. */
-    readonly provider: string;
-    /** The initial delegation's short `description`, persisted as the child's creation label. */
-    readonly label: string;
-    /**
-     * Optional caller-reserved child identity. Omission preserves the manager's
-     * UUID allocation; supplying one lets a durable parent record provisioning
-     * before child materialization without a second identity handshake.
-     */
-    readonly childId?: SessionId;
-    /**
-     * The delegation request. The manager reserves the stable child id, resolves
-     * the durable descriptor, and composes the child itself.
-     */
-    readonly request: Omit<SubagentStartRequest, 'label' | 'signal' | 'outputSchema'>;
-    /** Caller cancellation, owning the operation only until inbox acceptance. */
-    readonly signal: AbortSignal;
-}
-/** Identities returned once a continuable child accepted its initial prompt. */
-export interface ContinuableStart {
-    /** The durable child session id, stable across activations. */
-    readonly childId: SessionId;
-    /** The accepted initial prompt's inbox message id. */
-    readonly messageId: MessageId;
-}
-/**
- * Authority under which one interrupt request is admitted. `user` carries the
- * durable direct-parent address a human client presented; `ancestor` carries
- * the exact live Agent object whose recorded lineage must contain the caller.
- */
-export type SubagentInterruptAuthority = {
-    readonly kind: 'user';
-    readonly parentSessionId: SessionId;
-} | {
-    readonly kind: 'ancestor';
-    readonly agent: Agent;
-};
-/** Options for one model-authored message between adjacent Agents. */
-export interface SubagentSendMessageOptions {
-    /** Caller cancellation, owning the operation only until inbox acceptance. */
-    readonly signal: AbortSignal;
-}
-/**
- * Hooks the manager needs from the owning service. Declared here, by the
- * dependent, so the manager states exactly what it requires instead of
- * depending back on the whole {@link SubagentRuntime}. Package-private: no
- * consumer outside this package supplies a host.
- */
+import type { ContinuableCreateRequest, ContinuableCreateSpec, ContinuableStart, ContinuableStartSpec, SubagentInterruptAuthority, SubagentSendMessageOptions } from './types.ts';
+/** Package-private hooks supplied by the owning service. */
 interface ContinuationHost {
-    /**
-     * Resolve one provider's continuable-creation contribution, or reject when
-     * the provider is unknown or lacks the capability.
-     * @param name - the configured provider name.
-     * @param request - the reserved identity, delegating parent, and cancellation.
-     * @returns the provider's detached creation spec.
-     */
+    /** Resolve one provider's detached continuable-creation contribution. */
     prepareContinuable(name: string, request: ContinuableCreateRequest): Promise<ContinuableCreateSpec>;
-    /**
-     * Build the lifecycle observer for one Activation's residency epoch.
-     * @param provider - the provider name recorded in the durable descriptor.
-     * @param childId - the durable child session id.
-     * @param parent - the exact live direct parent for scoped dispatch.
-     * @returns the observer whose edges this epoch publishes.
-     */
+    /** Build the lifecycle observer for one Activation residency epoch. */
     observeActivation(provider: string, childId: SessionId, parent: Agent): ActivationObserver;
 }
 /**
@@ -134,305 +34,91 @@ interface ContinuationHost {
 export declare class SubagentContinuationManager {
     private readonly ctx;
     private readonly host;
-    /** Child session id → its live Activation. Process-local, never durable. */
-    private activations;
-    /** Materializations admitted before drain, tracked through publication or rollback. */
-    private readonly materializations;
-    private readonly locks;
-    /** Structural Cordis owner of every Activation handle. */
-    private readonly 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.
-     */
-    private readonly closingScopes;
-    private draining;
+    private readonly activations;
     constructor(ctx: Context, host: ContinuationHost);
     /**
-     * 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.
      */
     startContinuable(spec: ContinuableStartSpec): Promise<ContinuableStart>;
-    /** Reject one child identity already owned by a live Agent or Session. */
-    private assertChildIdAvailable;
     /**
      * 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.
      */
     sendMessage(sender: Agent, targetId: SessionId, content: ContentBlock[], options: SubagentSendMessageOptions): Promise<MessageId>;
     /**
      * 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.
      */
     queuePrompt(parent: Agent, childId: SessionId, content: ContentBlock[], source: MessageSource, signal: AbortSignal): Promise<MessageId>;
+    /**
+     * 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.
+     */
+    steerPrompt(parent: Agent, childId: SessionId, content: ContentBlock[], source: MessageSource, signal: AbortSignal): Promise<MessageId>;
     /** Route one parent-originated delivery through residency and cold resume. */
     private deliverToChild;
+    /** The delivery loop behind {@link deliverToChild}, run under the parent hold. */
+    private deliverFollowup;
     /**
      * 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: SessionId, authority: SubagentInterruptAuthority): void;
     /** Deliver one resident continuable child's message to its live direct parent. */
     private sendToParent;
-    /**
-     * 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.
-     */
-    private sendWaking;
     /** Send one Agent message while translating only the target's own rejection. */
     private sendAgentMessage;
-    /**
-     * 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. */
     drain(): Promise<void>;
     /**
      * 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.
      */
     drainDescendants(parents: readonly Agent[]): Promise<void>;
     /**
-     * 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.
      */
     drainChildren(parent: Agent, childIds: readonly SessionId[]): Promise<void>;
-    /** Dispose independent roots and report every branch failure after all settle. */
-    private disposeRoots;
-    /** Return the retained member set for one exact scoped-teardown root. */
-    private closingMembers;
-    /**
-     * 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.
-     */
-    private liveLineage;
     /**
-     * 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.
-     */
-    private closingTeardownFor;
-    /** Reject new admission once the manager or this exact parent tree began draining. */
-    private assertAdmitting;
-    /**
-     * 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.
-     */
-    private stateOf;
-    /**
-     * 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.
      */
     private coldResume;
-    /**
-     * 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. */
     private submitMaterialized;
-    /**
-     * 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.
-     */
-    private assertImageCapable;
-    /**
-     * 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.
-     */
-    private materialize;
-    /**
-     * Perform one tracked materialization. The caller keeps the drain barrier
-     * registered until this either returns a resident Activation or finishes
-     * rollback.
-     */
-    private materializeTracked;
-    /**
-     * 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.
-     */
-    private rollbackUnpublished;
-    /**
-     * 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.
-     */
-    private acquireOwnership;
-    /** Remove one child from its live owner's set and let that owner re-check settlement. */
-    private releaseOwnership;
-    /** Let a settlement watcher re-observe quiescence after ownership or inbox changes. */
-    private wake;
-    /**
-     * 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.
-     */
-    private submit;
-    /**
-     * 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.
-     */
-    private admitWaking;
-    /**
-     * 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.
-     */
+    /** Build and submit one message across the final synchronous admission cutoff. */
     private submitAdmitted;
-    /**
-     * 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.
-     */
-    private authorizeLineage;
-    /**
-     * 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.
-     */
-    private watchSettlement;
-    /**
-     * 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.
-     */
-    private dispose;
-    /**
-     * 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.
-     */
-    private finishDisposal;
-    /**
-     * 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.
-     */
-    private notifySettlement;
-    /**
-     * 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.
-     */
-    private flushFinalState;
+    /** Refuse image content for a child whose fixed model accepts text only. */
+    private assertImageCapable;
     /** Resolve the persistence service continuable children require, or fail loud. */
     private requirePersistence;
     /** Resolve the Session query service used for cold child observations. */
     private requireSessionQuery;
 }
-export type { SubagentDescriptorData };
 export default SubagentContinuationManager;
 //# sourceMappingURL=continuation.d.ts.map