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

package/lib/types/index.js

@@ -40,23 +40,22 @@ import { Remote, RemoteError, TypertRemoteService } from '@deepseek-ai/dsh-typer
 import { rejectPrompt, validateControlRequest, } from "./control.js";
 import { SubagentError } from "./error.js";
 import { assertSubagentMaxDepth } from "./depth.js";
-import { createActivationObserver, createLifecycleEmitter, observeRun } from "./lifecycle.js";
-import SubagentContinuationManager from "./continuation.js";
+import { createActivationObserver, createLifecycleEmitter } from "./lifecycle.js";
+import SubagentManager from "./manager.js";
 import { listChildren as listSubagentChildren, listDescendants as listSubagentDescendants } from "./list-children.js";
 import { installSubagentArchiveAdmission } from "./archive-admission.js";
-import { snapshotSubagentDescriptor } from "./descriptor.js";
 import { subagentIdentityProjectionDefinition, subagentTimingProjectionDefinition } from "./projection.js";
-import { establishCatalogChild, subagentCatalogProjectionDefinition } from "./catalog.js";
+import { subagentCatalogProjectionDefinition } from "./catalog.js";
 import { deliverSubagentPrompt } from "./internal.js";
 export * from "./out-of-process.js";
 export { AssistantOutputFold, finalAssistantOutput } from "./assistant-output.js";
 export { SubagentRunId } from "./types.js";
 export { foldSubagentDescriptor, snapshotSubagentDescriptor, SUBAGENT_DESCRIPTOR_VERSION, } from "./descriptor.js";
+export { STRUCTURED_OUTPUT_TOOL } from "./structured.js";
 export { SubagentError } from "./error.js";
-export { settleRun } from "./run-settlement.js";
 export { assertSubagentMaxDepth, delegationDepthOf } from "./depth.js";
 export { appendDelegatedPolicyOverrides, applyChildComposition, captureDelegatedPolicyOverrides, childSessionMeta, parentAgentOptionsForDelegation, resolveChildAgentOptions, resolveChildDepth, SubagentDepthError, } from "./child-agent.js";
-/** 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. */
 let SubagentRuntime = (() => {
     let _classSuper = TypertRemoteService;
     let _instanceExtraInitializers = [];
@@ -76,8 +75,9 @@ let SubagentRuntime = (() => {
             maxDepth: z.number().step(1).min(0).max(Number.MAX_SAFE_INTEGER).default(1).volatile(),
             maxActiveSubagents: z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER).default(8).volatile(),
         });
+        static inject = ['workingDirectory'];
         providers = new Map();
-        continuations;
+        manager;
         /**
          * The contained lifecycle-edge publisher. Built here because scoped dispatch
          * keys its carrier by this exact service instance, whose own context filter
@@ -89,22 +89,25 @@ let SubagentRuntime = (() => {
             this.config = config;
             this.emitLifecycle = createLifecycleEmitter(this.ctx, parent => scopeTarget(this, parent));
             ctx.inject(['agents'], (childCtx) => {
-                const manager = new SubagentContinuationManager(childCtx, {
+                const manager = new SubagentManager(childCtx, {
+                    startExternal: (name, request) => {
+                        const provider = this.expectProvider(name);
+                        return provider.start(request);
+                    },
                     prepareContinuable: (name, request) => this.prepareContinuable(name, request),
                     observeActivation: (provider, childId, parent) => this.observeActivation(provider, childId, parent),
                 }, () => this.config.maxActiveSubagents.get());
-                this.continuations = manager;
+                this.manager = manager;
                 childCtx.effect(() => () => {
                     /* v8 ignore else -- one injected binding owns the slot until its fiber disposes. */
-                    if (this.continuations === manager)
-                        this.continuations = undefined;
-                }, 'subagents.continuationBinding()');
+                    if (this.manager === manager)
+                        this.manager = undefined;
+                }, 'subagents.managerBinding()');
             });
             ctx.inject(['sessionProjections'], (projectionCtx) => {
-                const projections = projectionCtx.sessionProjections;
-                projections.register(subagentCatalogProjectionDefinition);
-                projections.register(subagentTimingProjectionDefinition);
-                projections.register(subagentIdentityProjectionDefinition);
+                projectionCtx.sessionProjections.register(subagentCatalogProjectionDefinition);
+                projectionCtx.sessionProjections.register(subagentTimingProjectionDefinition);
+                projectionCtx.sessionProjections.register(subagentIdentityProjectionDefinition);
             });
             // Archive admission: this runtime is the owner that knows which live
             // children descend from a Session and how a parent stops them.
@@ -125,16 +128,36 @@ let SubagentRuntime = (() => {
             return depth;
         }
         /**
-         * 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.
+         * Establish a managed child with backend-specific execution capabilities.
+         * @param spec - task, backend, and result recipient.
+         * @returns identities, execution result, and exact-activation disposal. A reserved
+         * childId requires a local backend and guarantees an accepted messageId.
          */
-        async startContinuable(spec) {
-            return this.requireContinuations().startContinuable(spec);
+        async startActivation(spec) {
+            const provider = this.expectProvider(spec.provider);
+            if (spec.childId !== undefined && provider.prepareContinuable === undefined) {
+                throw new SubagentError('reserved child ids require a local backend', 'UNSUPPORTED_CAPABILITY');
+            }
+            assertSubagentMaxDepth(spec.request.maxDepth);
+            this.assertCapabilities(provider, { ...spec.request, signal: spec.signal });
+            const manager = this.requireManager();
+            if (this.ctx.get('agents')?.get(spec.request.parent.id) !== spec.request.parent) {
+                throw new SubagentError('subagent creation requires the exact live parent agent', 'UNAUTHORIZED');
+            }
+            if (spec.request.outputSchema !== undefined)
+                assertObjectJsonSchema(spec.request.outputSchema);
+            return provider.prepareContinuable === undefined
+                ? manager.startExternal(spec)
+                : manager.startLocal(spec);
+        }
+        /**
+         * 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.
+         */
+        async waitForChildren(parent) {
+            return this.manager?.waitForChildren(parent) ?? false;
         }
         /**
          * Steer one model-authored message to the sender's direct parent or direct
@@ -151,7 +174,7 @@ let SubagentRuntime = (() => {
          *   or the message was not admitted.
          */
         async sendMessage(sender, targetId, content, options) {
-            return this.requireContinuations().sendMessage(sender, targetId, content, options);
+            return this.requireManager().sendMessage(sender, targetId, content, options);
         }
         /**
          * Deliver one host-protocol message to a direct continuable child.
@@ -167,17 +190,17 @@ let SubagentRuntime = (() => {
          */
         [deliverSubagentPrompt](parent, childId, content, source, signal, delivery) {
             return delivery === 'steer'
-                ? this.requireContinuations().steerPrompt(parent, childId, content, source, signal)
-                : this.requireContinuations().queuePrompt(parent, childId, content, source, signal);
+                ? this.requireManager().steerPrompt(parent, childId, content, source, signal)
+                : this.requireManager().queuePrompt(parent, childId, content, source, signal);
         }
         /**
-         * 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.
@@ -186,37 +209,37 @@ let SubagentRuntime = (() => {
          *   live target.
          */
         interrupt(targetSessionId, authority) {
-            this.continuations?.interrupt(targetSessionId, authority);
+            this.manager?.interrupt(targetSessionId, authority);
         }
         /**
-         * 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.
          */
-        async drainContinuableDescendants(parents) {
-            const manager = this.continuations;
-            // Absent continuation services means nothing was ever materialized.
+        async drainDescendants(parents) {
+            const manager = this.manager;
+            // An absent activation manager cannot own materialized children.
             if (manager === undefined)
                 return;
             await manager.drainDescendants(parents);
         }
         /**
-         * 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.
          */
-        async drainContinuableChildren(parent, childIds) {
-            const manager = this.continuations;
+        async drainChildren(parent, childIds) {
+            const manager = this.manager;
             if (manager === undefined)
                 return;
             await manager.drainChildren(parent, childIds);
@@ -236,7 +259,8 @@ let SubagentRuntime = (() => {
         /**
          * 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.
@@ -338,12 +362,16 @@ let SubagentRuntime = (() => {
         /**
          * 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.
          */
         registerProvider(provider) {
             const name = provider.name;
+            if (provider.start === undefined && provider.prepareContinuable === undefined) {
+                throw new SubagentError(`subagent provider "${name}" must implement start or prepareContinuable`, 'UNSUPPORTED_CAPABILITY');
+            }
             // oxlint-disable-next-line typescript/no-misused-promises -- synchronous disposer
             return this.ctx.effect(function* () {
                 if (this.providers.has(name)) {
@@ -374,50 +402,6 @@ let SubagentRuntime = (() => {
         list() {
             return [...this.providers.keys()];
         }
-        /**
-         * 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.
-         */
-        async start(name, request) {
-            const provider = this.expectProvider(name);
-            this.assertCapabilities(provider, request);
-            assertSubagentMaxDepth(request.maxDepth);
-            if (request.outputSchema !== undefined)
-                assertObjectJsonSchema(request.outputSchema);
-            const descriptor = snapshotSubagentDescriptor({
-                mode: 'one-shot',
-                provider: name,
-                ...request.label !== undefined ? { label: request.label } : {},
-            });
-            const resolved = { ...request, descriptor };
-            const run = await provider.start(resolved);
-            const child = run.localAgent?.session;
-            if (child !== undefined) {
-                try {
-                    establishCatalogChild(request.parent.session, child.header, descriptor);
-                }
-                catch (error) {
-                    // No caller receives this run; the catalog error owns the failed start.
-                    void run.result.catch(() => undefined);
-                    try {
-                        await run.dispose();
-                    }
-                    catch (cleanupError) {
-                        this.ctx.logger.warn(`subagent: disposal after catalog append failure also failed: ${String(cleanupError)}`);
-                    }
-                    throw error;
-                }
-            }
-            return observeRun(this.emitLifecycle, name, request.parent, run);
-        }
         /**
          * Resolve one provider's detached continuable-creation contribution. Method
          * presence on the provider IS the capability, so a provider without it is
@@ -425,10 +409,6 @@ let SubagentRuntime = (() => {
          */
         async prepareContinuable(name, request) {
             const provider = this.expectProvider(name);
-            if (provider.prepareContinuable === undefined) {
-                throw new SubagentError(`subagent provider "${provider.name}" does not support continuable children `
-                    + '(no prepareContinuable capability)', 'UNSUPPORTED_CAPABILITY');
-            }
             return provider.prepareContinuable(request);
         }
         /** Look up a provider for dispatch or fail loud. */
@@ -439,12 +419,12 @@ let SubagentRuntime = (() => {
             }
             return provider;
         }
-        /** Resolve the optional continuable-subagent manager or fail loud. */
-        requireContinuations() {
-            if (this.continuations === undefined) {
+        /** Resolve the subagent manager or fail loud. */
+        requireManager() {
+            if (this.manager === undefined) {
                 throw new SubagentError('continuable subagents require the agents service', 'CONTINUATION_UNAVAILABLE');
             }
-            return this.continuations;
+            return this.manager;
         }
         /**
          * Build the lifecycle observer for one continuable Activation's residency

package/lib/types/internal.d.ts

@@ -8,7 +8,7 @@ import type { ContentBlock, MessageId, MessageSource } from '@deepseek-ai/dsh-ll
 import type { SessionId } from '@deepseek-ai/dsh-session';
 import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
 import type SubagentRuntime from './index.ts';
-import type { SubagentDelivery } from './inbox.ts';
+import type { SubagentDelivery } from './control-types.ts';
 /** Process-stable identity carried only by the standard adjacent-Agent messaging tool. */
 export declare const adjacentAgentSendMessageTool: unique symbol;
 /**

package/lib/types/lifecycle.d.ts

@@ -1,69 +1,34 @@
 /**
- * Lifecycle-edge publication for both subagent shapes: the contained emitter,
- * the one-shot run observer, and the continuable Activation observer.
+ * Lifecycle-edge publication for managed subagent activations.
  *
- * The public payload contracts ({@link SubagentRunInfo},
- * {@link SubagentRunEndInfo}) live in `./types.ts` with the rest of the seam's
- * consumer-facing types; this module owns only the implementation and the
- * package-private {@link ActivationObserver} the continuation manager consumes.
- * Keeping the internal control interface out of the published surface is
- * deliberate: the observer's `start`/`capture`/`settle` ordering is a contract
- * between this module and one in-package caller, not something a plugin may
- * depend on.
+ * Public event payloads live in `./types.ts`; the package-private observer
+ * retains only the identity shared by each start/end pair.
  *
  * @module @deepseek-ai/dsh-subagent/lifecycle
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
-import type { ContentBlock } from '@deepseek-ai/dsh-llm';
-import type { SessionId } from '@deepseek-ai/dsh-session';
-import type { SubagentResult, SubagentRun, SubagentRunEndInfo, SubagentRunInfo } from './types.ts';
+import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session';
+import type { SubagentResult, SubagentRunEndInfo, SubagentRunInfo } from './types.ts';
 /**
- * How one Activation's residency epoch ended, as both the terminal lifecycle
- * edge and the manager's own parent delivery report it.
- */
-export interface ActivationTerminal {
-    /** Why this epoch's last ordinary turn ended, or `error` when teardown failed. */
-    readonly stopReason: SubagentResult['stopReason'];
-    /** The epoch's final assistant content, absent when it produced none or failed. */
-    readonly output?: readonly ContentBlock[];
-}
-/**
- * Lifecycle observer for one Activation's residency epoch, so continuable
- * children emit the same start/end pair as one-shot runs. Package-private: the
+ * Lifecycle observer for one activation's residency epoch. Package-private: the
  * continuation manager is the only consumer, and its call ordering is an
  * in-package contract rather than a published extension point.
  */
 export interface ActivationObserver {
     /**
      * Publish the start edge once the epoch is resident.
-     * @param child - the resident child agent, whose log suffix bounds this epoch.
-     */
-    start(child: Agent): void;
-    /**
-     * Snapshot the child-dependent terminal facts while the child is still
-     * registered, because handle disposal unregisters it and consumers resolve it
-     * to read the child's own log and scope.
-     * @param child - the quiescent child agent about to be released.
-     */
-    capture(child: Agent): void;
-    /**
-     * Resolve the terminal facts {@link settle} will publish, without publishing
-     * them. The manager's parent delivery must run before the ownership release
-     * that lets the parent settle, which is earlier than the terminal edge; both
-     * therefore read one computation instead of restating the failure rule.
-     * @param failure - the teardown or durability failure, or `undefined` on success.
-     * @returns this epoch's stop reason and final assistant content.
+     * @param child - the resident local Agent, or undefined for an external execution.
      */
-    terminal(failure: unknown): ActivationTerminal;
+    start(child?: Agent): void;
     /**
      * Publish the terminal edge exactly once, pairing this epoch's {@link start},
      * after the disposal outcome is known. Called only for a resident epoch: a
      * failure before residency publishes no edge, because inventing one would
      * report a lifecycle the child never had.
-     * @param failure - the teardown or durability failure, or `undefined` on success.
+     * @param result - the captured result, with teardown failures applied.
      */
-    settle(failure: unknown): void;
+    settle(result: SubagentResult): void;
 }
 /**
  * Publish one lifecycle edge with per-listener exception containment. Run edges
@@ -90,19 +55,7 @@ export type LifecycleEmitter = {
  */
 export declare function createLifecycleEmitter(ctx: Context, carrier: (parent: Agent) => object): LifecycleEmitter;
 /**
- * Emit the start/end lifecycle pair for one accepted one-shot run.
- * @param emit - the contained lifecycle emitter.
- * @param provider - the provider that established the run.
- * @param parent - the delegating parent keying scoped dispatch.
- * @param run - the published run whose settlement closes the pair.
- * @returns the same run, unchanged.
- */
-export declare function observeRun(emit: LifecycleEmitter, provider: string, parent: Agent, run: SubagentRun): SubagentRun;
-/**
- * Build the observer for one continuable Activation's residency epoch. Observers
- * see the same vocabulary as a one-shot run, so a child's start and settlement
- * remain observable without exposing whether the manager materialized, woke, or
- * cold-resumed it. Creation failure before residency emits no lifecycle edge.
+ * Build the observer for one local or external activation's residency epoch. Creation failure before residency emits no lifecycle edge.
  * @param emit - the contained lifecycle emitter.
  * @param provider - the provider name recorded in the durable descriptor.
  * @param childId - the durable child session id.
@@ -110,4 +63,21 @@ export declare function observeRun(emit: LifecycleEmitter, provider: string, par
  * @returns the observer whose edges this epoch publishes.
  */
 export declare function createActivationObserver(emit: LifecycleEmitter, provider: string, childId: SessionId, parent: Agent): ActivationObserver;
+/**
+ * Why this child's epoch ended, for the terminal lifecycle edge and the
+ * manager's own parent delivery. The child's own log is authoritative:
+ * teardown succeeding says nothing about whether the model errored, hit its
+ * token ceiling, or was cancelled, so deriving the reason from disposal would
+ * report failed work as completed.
+ *
+ * {@link foldConsumedWork} supplies both halves the raw turn sequence cannot:
+ * which turn accounts for the work this epoch consumed, and whether accepted
+ * work was cancelled after it without any turn opening over it. A recorded
+ * failure still wins over a cancellation — stopping a child that had already
+ * failed does not turn its failure into a cancellation.
+ * @param events - this epoch's own event suffix.
+ * @returns its terminal stop reason; `completed` only for an epoch that both
+ *   closed cleanly and had nothing left to run.
+ */
+export declare function epochStopReason(events: readonly SessionEvent[]): SubagentResult['stopReason'];
 //# sourceMappingURL=lifecycle.d.ts.map

package/lib/types/lifecycle.js

@@ -1,22 +1,13 @@
 /**
- * Lifecycle-edge publication for both subagent shapes: the contained emitter,
- * the one-shot run observer, and the continuable Activation observer.
+ * Lifecycle-edge publication for managed subagent activations.
  *
- * The public payload contracts ({@link SubagentRunInfo},
- * {@link SubagentRunEndInfo}) live in `./types.ts` with the rest of the seam's
- * consumer-facing types; this module owns only the implementation and the
- * package-private {@link ActivationObserver} the continuation manager consumes.
- * Keeping the internal control interface out of the published surface is
- * deliberate: the observer's `start`/`capture`/`settle` ordering is a contract
- * between this module and one in-package caller, not something a plugin may
- * depend on.
+ * Public event payloads live in `./types.ts`; the package-private observer
+ * retains only the identity shared by each start/end pair.
  *
  * @module @deepseek-ai/dsh-subagent/lifecycle
  */
 import { randomUUID } from 'node:crypto';
 import { foldConsumedWork } from '@deepseek-ai/dsh-agent';
-import { SessionLogOffset } from '@deepseek-ai/dsh-session';
-import { finalAssistantOutput } from "./assistant-output.js";
 import { SubagentRunId } from "./types.js";
 /**
  * Build the contained lifecycle emitter this seam publishes every edge through.
@@ -46,40 +37,7 @@ export function createLifecycleEmitter(ctx, carrier) {
     };
 }
 /**
- * Emit the start/end lifecycle pair for one accepted one-shot run.
- * @param emit - the contained lifecycle emitter.
- * @param provider - the provider that established the run.
- * @param parent - the delegating parent keying scoped dispatch.
- * @param run - the published run whose settlement closes the pair.
- * @returns the same run, unchanged.
- */
-export function observeRun(emit, provider, parent, run) {
-    const identity = {
-        runId: SubagentRunId(randomUUID()),
-        provider,
-        id: run.id,
-        local: run.localAgent !== undefined,
-    };
-    // Attach the terminal observer before dispatching start. Promise reactions
-    // still run after this synchronous start emission, preserving start → end.
-    void run.result.then((result) => {
-        emit('subagent/end', {
-            ...identity,
-            stopReason: result.stopReason,
-            // Omit the field when no output exists, matching continuable epochs.
-            ...result.output.length === 0 ? {} : { lastAssistantMessage: result.output },
-        }, parent);
-    }, () => {
-        emit('subagent/end', { ...identity, stopReason: 'error' }, parent);
-    });
-    emit('subagent/start', identity, parent);
-    return run;
-}
-/**
- * Build the observer for one continuable Activation's residency epoch. Observers
- * see the same vocabulary as a one-shot run, so a child's start and settlement
- * remain observable without exposing whether the manager materialized, woke, or
- * cold-resumed it. Creation failure before residency emits no lifecycle edge.
+ * Build the observer for one local or external activation's residency epoch. Creation failure before residency emits no lifecycle edge.
  * @param emit - the contained lifecycle emitter.
  * @param provider - the provider name recorded in the durable descriptor.
  * @param childId - the durable child session id.
@@ -87,40 +45,17 @@ export function observeRun(emit, provider, parent, run) {
  * @returns the observer whose edges this epoch publishes.
  */
 export function createActivationObserver(emit, provider, childId, parent) {
-    const identity = { runId: SubagentRunId(randomUUID()), provider, id: childId, local: true };
-    // A cold resume replays earlier turns, so this epoch's telemetry must come
-    // from the suffix it actually produced — never the whole session, which
-    // would report a previous epoch's answer when this one opened no turn.
-    let boundary = SessionLogOffset(0);
-    // Assigned by `capture()`, which the disposal path always runs before
-    // `settle()`; a resident epoch therefore always has its facts by then.
-    let captured = { stopReason: 'completed' };
-    // Teardown failure overrides the epoch's own outcome and withholds its
-    // output: an answer this harness could not durably release is not a result.
-    const terminal = (failure) => failure === undefined
-        ? captured
-        : { stopReason: 'error' };
+    const identity = { runId: SubagentRunId(randomUUID()), provider, id: childId, local: false };
     return {
         start: (child) => {
-            boundary = child.session.seq;
+            identity.local = child !== undefined;
             emit('subagent/start', identity, parent);
         },
-        capture: (child) => {
-            // oxlint-disable-next-line typescript/no-deprecated -- Existing Session history read; migration deferred.
-            const own = child.session.snapshotEvents(boundary);
-            const output = finalAssistantOutput(own);
-            captured = {
-                stopReason: epochStopReason(own),
-                ...output === undefined ? {} : { output },
-            };
-        },
-        terminal,
-        settle: (failure) => {
-            const { stopReason, output } = terminal(failure);
+        settle: ({ stopReason, output }) => {
             emit('subagent/end', {
                 ...identity,
                 stopReason,
-                ...output === undefined ? {} : { lastAssistantMessage: output },
+                ...output.length === 0 ? {} : { lastAssistantMessage: output },
             }, parent);
         },
     };
@@ -141,7 +76,7 @@ export function createActivationObserver(emit, provider, childId, parent) {
  * @returns its terminal stop reason; `completed` only for an epoch that both
  *   closed cleanly and had nothing left to run.
  */
-function epochStopReason(events) {
+export function epochStopReason(events) {
     const { end, droppedUnrun } = foldConsumedWork(events);
     switch (end?.data.reason.kind) {
         case 'max-tokens':

package/lib/types/list-children.js

@@ -126,7 +126,7 @@ export async function listDescendants(ctx, rootSessionId, signal) {
         visited.add(entry.id);
         let children;
         try {
-            children = await readChildren(entry.id);
+            children = entry.mode === 'external' ? [] : await readChildren(entry.id);
         }
         catch (error) {
             if (error instanceof SubagentError)