@deepseek-ai/dsh-subagent 0.2.1-alpha.1 → 0.2.1-alpha.2

package/lib/types/catalog.js

@@ -5,7 +5,7 @@
  */
 import { z } from 'zod';
 import { appendChunkedList, chunkedListSchema, iterateChunkedList } from '@deepseek-ai/dsh-chunked-list';
-/** Catalog payload version emitted by live child creation. */
+/** Catalog payload version emitted by local child creation. */
 export const SUBAGENT_CATALOG_VERSION = 0;
 const sessionIdSchema = z.string();
 const oneShotCatalogSchema = z.object({
@@ -22,9 +22,11 @@ const continuableCatalogSchema = z.object({
     mode: z.literal('continuable'),
     label: z.string(),
 }).strict();
+const externalCatalogSchema = oneShotCatalogSchema.extend({ version: z.literal(2), mode: z.literal('external') });
 const unknownCatalogSchema = oneShotCatalogSchema.extend({ version: z.literal(1), mode: z.literal('unknown') });
 const eventDataSchema = z.union([
     oneShotCatalogSchema,
+    externalCatalogSchema,
     continuableCatalogSchema,
     unknownCatalogSchema,
 ]);
@@ -33,6 +35,10 @@ const viewSchema = z.array(z.union([
         id: sessionIdSchema,
         createdAt: oneShotCatalogSchema.shape.childCreatedAt,
     }),
+    externalCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
+        id: sessionIdSchema,
+        createdAt: externalCatalogSchema.shape.childCreatedAt,
+    }),
     continuableCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
         id: sessionIdSchema,
         createdAt: continuableCatalogSchema.shape.childCreatedAt,
@@ -54,19 +60,8 @@ const stateSchema = z.object({
 function subagentCatalogEntries(state) {
     const entries = [];
     for (const data of iterateChunkedList(state.head)) {
-        entries.push(data.mode !== 'continuable'
-            ? {
-                id: data.childId,
-                createdAt: data.childCreatedAt,
-                mode: data.mode,
-                ...data.label === undefined ? {} : { label: data.label },
-            }
-            : {
-                id: data.childId,
-                createdAt: data.childCreatedAt,
-                mode: data.mode,
-                label: data.label,
-            });
+        const { version: _version, childId, childCreatedAt, ...descriptor } = data;
+        entries.push({ id: childId, createdAt: childCreatedAt, ...descriptor });
     }
     return entries;
 }
@@ -80,7 +75,7 @@ export const subagentCatalogProjectionDefinition = {
             return state;
         return { ...state, head: appendChunkedList(state.head, eventDataSchema.parse(event.data)) };
     },
-    stateVersion: 3,
+    stateVersion: 6,
     wire: { viewSchema, view: subagentCatalogEntries },
 };
 /**
@@ -90,20 +85,29 @@ export const subagentCatalogProjectionDefinition = {
  * @param descriptor - mode-discriminated creation label frozen with the child.
  */
 export function establishCatalogChild(parent, child, descriptor) {
-    parent.append('subagent/catalog', descriptor.mode === 'one-shot'
-        ? {
-            version: SUBAGENT_CATALOG_VERSION,
-            childId: child.id,
-            childCreatedAt: child.createdAt,
-            mode: descriptor.mode,
-            ...descriptor.label === undefined ? {} : { label: descriptor.label },
-        }
-        : {
-            version: SUBAGENT_CATALOG_VERSION,
-            childId: child.id,
-            childCreatedAt: child.createdAt,
-            mode: descriptor.mode,
-            label: descriptor.label,
-        });
+    parent.append('subagent/catalog', {
+        version: SUBAGENT_CATALOG_VERSION,
+        childId: child.id,
+        childCreatedAt: child.createdAt,
+        mode: descriptor.mode,
+        label: descriptor.label,
+    });
+}
+/** Catalog payload version emitted by external execution creation. */
+const EXTERNAL_SUBAGENT_CATALOG_VERSION = 2;
+/**
+ * Record an external execution without a local child Session.
+ * @param parent - durable direct parent receiving the discovery fact.
+ * @param childId - identity returned by the external provider.
+ * @param label - display label assigned by the caller.
+ */
+export function establishExternalCatalogChild(parent, childId, label) {
+    parent.append('subagent/catalog', {
+        version: EXTERNAL_SUBAGENT_CATALOG_VERSION,
+        childId,
+        childCreatedAt: Date.now(),
+        mode: 'external',
+        label,
+    });
 }
 //# sourceMappingURL=catalog.js.map

package/lib/types/child-agent.d.ts

@@ -1,9 +1,7 @@
 /**
  * Shared in-process child composition: the delegation-depth budget, the
  * durable session metadata, the resolved child `AgentOptions`, the delegated
- * policy seed, and the scoped setup a child agent needs. Both the one-shot
- * provider driver and the continuation manager compose children this way, so
- * depth accounting, lineage stamping, and delegation policy have one home.
+ * policy seed, and the scoped setup used by local activations.
  *
  * @module @deepseek-ai/dsh-subagent/child-agent
  */

package/lib/types/child-agent.js

@@ -1,9 +1,7 @@
 /**
  * Shared in-process child composition: the delegation-depth budget, the
  * durable session metadata, the resolved child `AgentOptions`, the delegated
- * policy seed, and the scoped setup a child agent needs. Both the one-shot
- * provider driver and the continuation manager compose children this way, so
- * depth accounting, lineage stamping, and delegation policy have one home.
+ * policy seed, and the scoped setup used by local activations.
  *
  * @module @deepseek-ai/dsh-subagent/child-agent
  */

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

@@ -7,8 +7,8 @@ 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. */
+import type { SubagentResult } from './types.ts';
+/** Durable attribution for one model-authored message between Agents. */
 export interface AgentMessageSource {
     readonly kind: 'agent-message';
     /** A message another agent addressed to this one (`relay` context form). */
@@ -56,7 +56,8 @@ export declare function withContinuableReturnGuidance(parentId: SessionId, promp
  * Build the runtime-owned settlement notice from the child's nonempty closing text.
  * @param childId - durable child session id named in the notice.
  * @param terminal - recorded terminal state for the settled Activation.
+ * @param continuable - whether the child can accept another task.
  * @returns the durable user-message representation delivered to the parent.
  */
-export declare function createSettlementMessage(childId: SessionId, terminal: ActivationTerminal): ReturnType<typeof createUserMessage>;
+export declare function createSettlementMessage(childId: SessionId, terminal: SubagentResult, continuable?: boolean): ReturnType<typeof createUserMessage>;
 //# sourceMappingURL=continuation-messages.d.ts.map

package/lib/types/continuation-messages.js

@@ -52,13 +52,16 @@ export function withContinuableReturnGuidance(parentId, prompt) {
  * 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.
+ * @param continuable - whether the child accepts a later message.
  * @returns the model-facing opening line of the settlement notice.
  */
-function settlementSummary(childId, stopReason) {
+function settlementSummary(childId, stopReason, continuable) {
     const subject = `Background subagent ${childId}`;
     switch (stopReason) {
         case 'completed':
-            return `${subject} finished and will do no further work unless you send it more.`;
+            return continuable
+                ? `${subject} finished and will do no further work unless you send it more.`
+                : `${subject} finished. It cannot receive follow-up messages.`;
         case 'aborted':
             return `${subject} was stopped before it finished.`;
         case 'max-tokens':
@@ -80,20 +83,25 @@ function settlementSummary(childId, stopReason) {
  * Build the runtime-owned settlement notice from the child's nonempty closing text.
  * @param childId - durable child session id named in the notice.
  * @param terminal - recorded terminal state for the settled Activation.
+ * @param continuable - whether the child can accept another task.
  * @returns the durable user-message representation delivered to the parent.
  */
-export function createSettlementMessage(childId, terminal) {
-    const summary = settlementSummary(childId, terminal.stopReason);
+export function createSettlementMessage(childId, terminal, continuable = true) {
+    const summary = settlementSummary(childId, terminal.stopReason, continuable);
     // Parent providers receive this notice as a user message and may reject
     // nontext assistant blocks. Keep this conversion local so SDK/UI consumers
     // retain the complete child output.
-    const closingText = (terminal.output ?? []).flatMap(block => block.type === 'text' && block.text.length > 0 ? [block] : []);
+    const closingText = terminal.output.flatMap(block => block.type === 'text' && block.text.length > 0 ? [block] : []);
     return createUserMessage({
         content: [
             { type: 'text', text: summary },
             ...closingText.length === 0
                 ? [{ type: 'text', text: 'It left no closing message.' }]
                 : [{ type: 'text', text: 'Its closing message:' }, ...closingText],
+            ...terminal.structured !== undefined
+                ? [{ type: 'text', text: `Structured result: ${JSON.stringify(terminal.structured)}` }] : [],
+            ...terminal.diagnostic !== undefined
+                ? [{ type: 'text', text: terminal.diagnostic }] : [],
         ],
         source: {
             kind: 'subagent-settled',

package/lib/types/control-types.d.ts

@@ -30,6 +30,11 @@ export type SubagentCatalogRow = {
     readonly mode: 'one-shot';
     /** Optional durable creation label from the parent catalog. */
     readonly label?: string;
+} | {
+    /** An external execution without a local child Session. */
+    readonly mode: 'external';
+    /** Optional durable creation label from the parent catalog. */
+    readonly label?: string;
 } | {
     /** A resumable conversation. */
     readonly mode: 'continuable';
@@ -67,6 +72,8 @@ export type SubagentAddress = {
 } | {
     readonly mode: 'unknown';
 });
+/** One Agent inbox destination, as the prompt request selects it. */
+export type SubagentDelivery = SubagentPromptRequest['delivery'];
 /** One human message addressed to a continuable direct child. */
 export interface SubagentPromptRequest {
     /** Identity persisted on the accepted message, minted before the call. */

package/lib/types/descriptor.d.ts

@@ -1,9 +1,9 @@
 /**
  * The durable subagent-child descriptor: the versioned, model-hidden
  * `subagent/descriptor` session event that identifies every session-backed
- * subagent and records whether it is one-shot or continuable. Continuable
- * descriptors additionally preserve the declared composition required for
- * cold resume. Providers append it turn-enclosed in the child's initial turn.
+ * subagent, including historical one-shot records. The manager appends each
+ * continuable child's descriptor inside its initial turn, preserving the
+ * declared composition required for cold resume.
  *
  * The descriptor deliberately snapshots explicit fields rather than the
  * merge-extensible `AgentOptions` object: an unrelated extension value cannot
@@ -27,8 +27,8 @@ declare module '@deepseek-ai/dsh-session/types' {
     interface SessionEventMap {
         /**
          * Durable identity and lifecycle mode of a session-backed subagent child,
-         * appended once by the establishing provider inside the child's initial
-         * turn, before its first request. Continuable records also carry their
+         * appended once inside the child's initial turn, before its first
+         * request. Continuable records also carry their
          * resumable composition. Log-only: it carries no `surfaceOp`, never enters
          * model history, and survives compaction.
          */
@@ -79,47 +79,8 @@ export interface ContinuableSubagentDescriptorData extends SubagentDescriptorBas
 }
 /** The supported durable subagent identity and optional continuation composition. */
 export type SubagentDescriptorData = OneShotSubagentDescriptorData | ContinuableSubagentDescriptorData;
-/** Fields shared by descriptor snapshot inputs. */
-interface SubagentDescriptorInputBase {
-    /** Whether the child is a terminal one-shot run or a resumable conversation. */
-    readonly mode: 'one-shot' | 'continuable';
-    /** The `ctx.subagents` provider name that will establish the child. */
-    readonly provider: string;
-}
-/** Input for a one-shot child's durable identity. */
-export interface OneShotSubagentDescriptorInput extends SubagentDescriptorInputBase {
-    readonly mode: 'one-shot';
-    /** Optional initial delegation `description` used as the durable creation label. */
-    readonly label?: string;
-}
-/** Input for a continuable child's durable identity and resumable composition. */
-export interface ContinuableSubagentDescriptorInput extends SubagentDescriptorInputBase {
-    readonly mode: 'continuable';
-    /** Initial delegation `description` used for durable enumeration. */
-    readonly label: string;
-    /** Requested child `agentOptions.provider`. */
-    readonly agentProvider?: string;
-    /** Requested child `agentOptions.model`. */
-    readonly agentModel?: string;
-    /** Requested child `agentOptions.reasoningEffort`. */
-    readonly agentReasoningEffort?: ReasoningEffortId;
-    /** Requested per-child persona. */
-    readonly persona?: string;
-    /** Requested child tool scoping. */
-    readonly toolFilter?: ToolRestriction;
-}
-/** Inputs {@link snapshotSubagentDescriptor} validates and detaches. */
-export type SubagentDescriptorInput = OneShotSubagentDescriptorInput | ContinuableSubagentDescriptorInput;
-/**
- * Validate and detach descriptor inputs into the durable payload, before any
- * Task or provider work begins — the same detached lossless-JSON boundary the
- * session log itself enforces, applied early so a synchronous validation
- * failure rejects the tool call without creating a Task.
- * @param input - the caller-collected composition fields.
- * @returns the versioned, detached descriptor payload.
- * @throws when a field is not losslessly JSON-serializable.
- */
-export declare function snapshotSubagentDescriptor(input: OneShotSubagentDescriptorInput): OneShotSubagentDescriptorData;
+/** Continuable composition fields before the snapshot stamps their format version. */
+export type ContinuableSubagentDescriptorInput = Omit<ContinuableSubagentDescriptorData, 'version'>;
 /**
  * Validate and detach a continuable descriptor input.
  * @param input - the caller-collected continuable composition fields.

package/lib/types/descriptor.js

@@ -1,9 +1,9 @@
 /**
  * The durable subagent-child descriptor: the versioned, model-hidden
  * `subagent/descriptor` session event that identifies every session-backed
- * subagent and records whether it is one-shot or continuable. Continuable
- * descriptors additionally preserve the declared composition required for
- * cold resume. Providers append it turn-enclosed in the child's initial turn.
+ * subagent, including historical one-shot records. The manager appends each
+ * continuable child's descriptor inside its initial turn, preserving the
+ * declared composition required for cold resume.
  *
  * The descriptor deliberately snapshots explicit fields rather than the
  * merge-extensible `AgentOptions` object: an unrelated extension value cannot
@@ -147,25 +147,24 @@ function parseSubagentDescriptor(value) {
         ...toolFilter !== undefined ? { toolFilter } : {},
     };
 }
+/**
+ * Validate and detach a continuable descriptor input.
+ * @param input - the caller-collected continuable composition fields.
+ * @returns the versioned, detached continuable descriptor payload.
+ * @throws when a field is not losslessly JSON-serializable.
+ */
 export function snapshotSubagentDescriptor(input) {
-    const candidate = input.mode === 'one-shot'
-        ? {
-            version: SUBAGENT_DESCRIPTOR_VERSION,
-            mode: input.mode,
-            provider: input.provider,
-            ...input.label !== undefined ? { label: input.label } : {},
-        }
-        : {
-            version: SUBAGENT_DESCRIPTOR_VERSION,
-            mode: input.mode,
-            provider: input.provider,
-            label: input.label,
-            ...input.agentProvider !== undefined ? { agentProvider: input.agentProvider } : {},
-            ...input.agentModel !== undefined ? { agentModel: input.agentModel } : {},
-            ...input.agentReasoningEffort !== undefined ? { agentReasoningEffort: input.agentReasoningEffort } : {},
-            ...input.persona !== undefined ? { persona: input.persona } : {},
-            ...input.toolFilter !== undefined ? { toolFilter: input.toolFilter } : {},
-        };
+    const candidate = {
+        version: SUBAGENT_DESCRIPTOR_VERSION,
+        mode: input.mode,
+        provider: input.provider,
+        label: input.label,
+        ...input.agentProvider !== undefined ? { agentProvider: input.agentProvider } : {},
+        ...input.agentModel !== undefined ? { agentModel: input.agentModel } : {},
+        ...input.agentReasoningEffort !== undefined ? { agentReasoningEffort: input.agentReasoningEffort } : {},
+        ...input.persona !== undefined ? { persona: input.persona } : {},
+        ...input.toolFilter !== undefined ? { toolFilter: input.toolFilter } : {},
+    };
     const snapshot = snapshotJsonValue(candidate);
     if (snapshot === undefined) {
         throw new Error('subagent descriptor is not losslessly JSON-serializable');

package/lib/types/index.d.ts

@@ -11,15 +11,14 @@
  * (`@deepseek-ai/dsh-subagent-spawn-in-process`, `-fork`, `-acp`) and the model-facing
  * consumer (`@deepseek-ai/dsh-tool-subagent`) are separate packages.
  *
- * Public operations express caller intent: `start` returns one published owned
- * one-shot run, `startContinuable` establishes a durable continuable child, and
- * `sendMessage` steers between adjacent Agents without exposing whether a child
- * is resident. Continuable children never become a {@link SubagentRun}: the
- * continuation manager holds their `AgentHandle` directly and orders every turn
- * through the child's own inbox, so providers contribute only the detached
- * creation spec and see no handle, turn, or teardown. Direct-child
- * discovery reads the parent catalog; descendant discovery recursively reads
- * those child catalogs. Neither read requires the continuation runtime.
+ * `startActivation` establishes every child under the activation manager, which
+ * owns execution, result delivery, and resource release. Local providers seed
+ * resumable Agents; external providers return a single execution handle.
+ * `sendMessage` steers between adjacent local Agents without exposing
+ * whether a child is resident. Discovery combines real child Sessions with
+ * parent-owned records for external executions.
+ * Direct discovery reads parent catalogs; descendants recursively read reachable
+ * child catalogs. External entries are leaves without local Sessions.
  *
  * Same-process providers are trusted typed collaborators. Requests, provider
  * descriptors, results, and lifecycle payloads are borrowed immutable values;
@@ -37,7 +36,7 @@ import type { Agent } from '@deepseek-ai/dsh-agent';
 import type { SessionId } from '@deepseek-ai/dsh-session';
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import type { SubagentInterruptReceipt, SubagentPromptReceipt, SubagentPromptRequest } from './control-types.ts';
-import type { ContinuableStart, ContinuableStartSpec, SubagentInterruptAuthority, SubagentProvider, SubagentRun, SubagentRunEndInfo, SubagentRunInfo, SubagentSendMessageOptions, SubagentStartRequest } from './types.ts';
+import type { SubagentActivation, SubagentActivationSpec, SubagentInterruptAuthority, SubagentProvider, SubagentRunEndInfo, SubagentRunInfo, SubagentSendMessageOptions } from './types.ts';
 import type { SubagentDescendantListEntry } from './list-children.ts';
 import type { SubagentCatalogEntry } from './projection-types.ts';
 import { deliverSubagentPrompt } from './internal.ts';
@@ -45,12 +44,11 @@ export type {} from './catalog.ts';
 export * from './out-of-process.ts';
 export { AssistantOutputFold, finalAssistantOutput } from './assistant-output.ts';
 export { SubagentRunId } from './types.ts';
-export type { ContinuableCreateRequest, ContinuableCreateSpec, ContinuableStart, ContinuableStartSpec, ResolvedSubagentStartRequest, SubagentCapabilities, SubagentInterruptAuthority, SubagentProvider, SubagentResult, SubagentRun, SubagentSendMessageOptions, SubagentStartRequest, SubagentStopReason, SubagentStopReasonMap, } from './types.ts';
+export type { ContinuableCreateRequest, ContinuableCreateSpec, SubagentCapabilities, SubagentActivation, SubagentActivationSpec, SubagentInterruptAuthority, SubagentProvider, SubagentResult, SubagentRun, SubagentSendMessageOptions, SubagentStartRequest, ResolvedSubagentStartRequest, SubagentStopReason, SubagentStopReasonMap, } from './types.ts';
 export { foldSubagentDescriptor, snapshotSubagentDescriptor, SUBAGENT_DESCRIPTOR_VERSION, } from './descriptor.ts';
-export type { ContinuableSubagentDescriptorData, ContinuableSubagentDescriptorInput, OneShotSubagentDescriptorData, OneShotSubagentDescriptorInput, SubagentDescriptorData, SubagentDescriptorInput, } from './descriptor.ts';
-export type { SubagentCatalogEntry } from './projection-types.ts';
+export type { ContinuableSubagentDescriptorData, ContinuableSubagentDescriptorInput, OneShotSubagentDescriptorData, SubagentDescriptorData, } from './descriptor.ts';
+export { STRUCTURED_OUTPUT_TOOL } from './structured.ts';
 export { SubagentError } from './error.ts';
-export { settleRun } from './run-settlement.ts';
 export { assertSubagentMaxDepth, delegationDepthOf } from './depth.ts';
 export { appendDelegatedPolicyOverrides, applyChildComposition, captureDelegatedPolicyOverrides, childSessionMeta, parentAgentOptionsForDelegation, resolveChildAgentOptions, resolveChildDepth, SubagentDepthError, } from './child-agent.ts';
 export type { ChildComposition, DelegatedPolicyOverrides } from './child-agent.ts';
@@ -58,7 +56,7 @@ export type { AgentMessageSource, SubagentSettledMessageSource } from './continu
 export type * from './control-types.ts';
 export type { SubagentDescendantListEntry } from './list-children.ts';
 export type { SubagentRunEndInfo, SubagentRunInfo } from './types.ts';
-export type { SubagentIdentityProjection, SubagentTimingProjection } from './projection-types.ts';
+export type { SubagentCatalogEntry, SubagentIdentityProjection, SubagentTimingProjection } from './projection-types.ts';
 declare module '@deepseek-ai/cordis' {
     interface Context {
         subagents: SubagentRuntime;
@@ -103,7 +101,7 @@ export interface Config {
     /** Default delegation depth for tools without an explicit limit; defaults to 1. */
     maxDepth: Volatile<number>;
 }
-/** Named provider registry with one-shot runs, durable discovery, and continuable-child operations. */
+/** Named provider registry with managed activations, durable discovery, and local child messaging. */
 export declare class SubagentRuntime extends TypertRemoteService {
     private config;
     static Config: z<Schemastery.ObjectS<NoInfer<{
@@ -113,8 +111,9 @@ export declare class SubagentRuntime extends TypertRemoteService {
         maxDepth: z<number, number, "volatile-defined">;
         maxActiveSubagents: z<number, number, "volatile-defined">;
     }>>, "plain">;
+    static inject: string[];
     private providers;
-    private continuations;
+    private manager;
     /**
      * The contained lifecycle-edge publisher. Built here because scoped dispatch
      * keys its carrier by this exact service instance, whose own context filter
@@ -129,15 +128,28 @@ export declare class SubagentRuntime extends TypertRemoteService {
      */
     resolveMaxDepth(configured?: number | 'provider-managed'): number | undefined;
     /**
-     * Establish one durable continuable child and deliver its initial prompt.
-     * Resolves when the child's inbox accepts that prompt, without waiting for the
-     * turn to start or for the message to reach the Session log; any earlier
-     * failure rejects with no ids and rolls back the child entirely.
-     * @param spec - provider, delegation request, and caller cancellation.
-     * @returns the durable child id and the accepted prompt's message id.
-     * @throws when continuation services are unavailable or materialization fails.
+     * Start a local child under its reserved identity.
+     * @param spec - local task, reserved child id, and result recipient.
+     * @returns activation with its accepted initial message id.
      */
-    startContinuable(spec: ContinuableStartSpec): Promise<ContinuableStart>;
+    startActivation(spec: SubagentActivationSpec & {
+        readonly childId: SessionId;
+    }): Promise<SubagentActivation & {
+        readonly messageId: MessageId;
+    }>;
+    /**
+     * Start a local or external child.
+     * @param spec - task, backend, and result recipient.
+     * @returns activation with a message id only for local children.
+     */
+    startActivation(spec: SubagentActivationSpec): Promise<SubagentActivation>;
+    /**
+     * Join progressing descendants without cancelling them. Idle descendants whose
+     * inboxes require a later wake stay resident and do not delay host completion.
+     * @param parent - the exact parent whose descendant work is observed.
+     * @returns whether work was joined; hosts recheck parent idle after true.
+     */
+    waitForChildren(parent: Agent): Promise<boolean>;
     /**
      * Steer one model-authored message to the sender's direct parent or direct
      * continuable child. A running target admits it at the nearest step boundary;
@@ -167,13 +179,13 @@ export declare class SubagentRuntime extends TypertRemoteService {
      */
     private [deliverSubagentPrompt];
     /**
-     * Interrupt one live continuable child's current turn under a human parent
+     * Interrupt one live child's current execution under a human parent
      * address or an exact live ancestor Agent. Fire-and-return: the cancel
      * signal is issued before this returns, but the target may keep running
      * until it observes the signal. Unclaimed pending inbox work, the Activation,
      * and published descendants are preserved; claimed work is not requeued.
-     * Once the interrupted driver is idle, a waking send resumes the parked FIFO
-     * queue. An absent target — including a one-shot or unknown id —
+     * Once the interrupted Agent is idle, a waking send resumes the parked FIFO
+     * queue. External backends stop their single execution. An absent target
      * is an accepted no-op, as is a manager-less composition, which cannot own a
      * live Activation.
      * @param targetSessionId - the durable child session id to interrupt.
@@ -183,27 +195,27 @@ export declare class SubagentRuntime extends TypertRemoteService {
      */
     interrupt(targetSessionId: SessionId, authority: SubagentInterruptAuthority): void;
     /**
-     * Close continuable admission below exact live parent Agents, stop only their
+     * Close subagent admission below exact live parent Agents, stop only their
      * visible descendant Activations synchronously, then await admitted scoped
      * materializations and release those forests child-first. The scoped cutoff
      * lasts until each exact parent leaves the registry; unrelated parent trees
      * remain live.
      * @param parents - exact host-owned parent Agents entering teardown.
-     * @returns once every retained descendant Activation released its `AgentHandle`.
+     * @returns once every retained descendant activation released its execution handle.
      * @throws an aggregate error after all branches settle when any failed.
      */
-    drainContinuableDescendants(parents: readonly Agent[]): Promise<void>;
+    drainDescendants(parents: readonly Agent[]): Promise<void>;
     /**
-     * Release selected resident continuable direct children of one exact live
+     * Release selected resident direct children of one exact live
      * parent. Other children of the same parent remain admitted and resident.
      * Absent targets and a manager-less composition are accepted no-ops.
      * @param parent - exact live direct parent authorizing the selected release.
      * @param childIds - durable direct-child ids to release when resident.
-     * @returns once every selected Activation released its `AgentHandle`.
+     * @returns once every selected activation released its execution handle.
      * @throws {SubagentError} `UNAUTHORIZED` when a resident target belongs to a
      *   different parent or the supplied parent identity is stale.
      */
-    drainContinuableChildren(parent: Agent, childIds: readonly SessionId[]): Promise<void>;
+    drainChildren(parent: Agent, childIds: readonly SessionId[]): Promise<void>;
     /**
      * Read the parent's durable direct-child catalog without loading or resuming an Agent.
      * The service owns and releases the live-preferred Session observation.
@@ -217,7 +229,8 @@ export declare class SubagentRuntime extends TypertRemoteService {
     /**
      * Recursively list reachable parent catalogs in stable pre-order, preserving
      * each catalog's event order. Each row carries its catalog parent and depth;
-     * one-shot and unknown-mode children remain traversal nodes. Unknown modes
+     * external children are leaves; one-shot and unknown-mode children remain
+     * traversal nodes. Unknown modes
      * produce unsupported diagnostics. Unreadable child catalogs produce corrupt
      * or unavailable diagnostics and stop only that branch. Root read failures,
      * missing services or projections, and cancellation reject the whole listing.
@@ -267,7 +280,8 @@ export declare class SubagentRuntime extends TypertRemoteService {
     /**
      * Register a provider under its name. Registration is effect-scoped and HMR
      * safe; removing a provider blocks new starts but does not revoke runs that
-     * were already returned to their holders.
+     * were already returned to their holders. Providers without either execution
+     * method are rejected with UNSUPPORTED_CAPABILITY before registration.
      * @param provider - the trusted provider implementation.
      * @returns the exact Cordis effect disposer.
      */
@@ -283,19 +297,6 @@ export declare class SubagentRuntime extends TypertRemoteService {
      * @returns the registered names.
      */
     list(): string[];
-    /**
-     * Establish a published child on the named provider. Capability and semantic
-     * checks run before delegation. Provider ownership lasts until its promise
-     * fulfills; a rejection therefore has no run for the caller to dispose and
-     * emits no run lifecycle events. Post-publication turn and infrastructure
-     * failures settle through the returned run.
-     * A catalog append failure disposes the run and handles its result rejection;
-     * the caller receives the catalog error even if disposal also fails.
-     * @param name - the provider to use.
-     * @param request - child label, prompt, parent, signal, and optional capabilities.
-     * @returns the published holder-owned run.
-     */
-    start(name: string, request: SubagentStartRequest): Promise<SubagentRun>;
     /**
      * Resolve one provider's detached continuable-creation contribution. Method
      * presence on the provider IS the capability, so a provider without it is
@@ -304,8 +305,8 @@ export declare class SubagentRuntime extends TypertRemoteService {
     private prepareContinuable;
     /** Look up a provider for dispatch or fail loud. */
     private expectProvider;
-    /** Resolve the optional continuable-subagent manager or fail loud. */
-    private requireContinuations;
+    /** Resolve the subagent manager or fail loud. */
+    private requireManager;
     /**
      * Build the lifecycle observer for one continuable Activation's residency
      * epoch, so the manager publishes its edges without owning event dispatch.