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

package/lib/types/index.js

@@ -41,13 +41,11 @@ import { Remote, RemoteError, TypertRemoteService, principalOf } from '@deepseek
 import { rejectPrompt, validateControlRequest, } from "./control.js";
 import { SubagentError } from "./error.js";
 import { assertSubagentMaxDepth } from "./depth.js";
-import { createActivationObserver, createLifecycleEmitter } from "./lifecycle.js";
+import { 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 { listDescendants as listSubagentDescendants } from "./list-children.js";
 import { subagentIdentityProjectionDefinition, subagentTimingProjectionDefinition } from "./projection.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";
@@ -61,14 +59,14 @@ let SubagentRuntime = (() => {
     let _classSuper = TypertRemoteService;
     let _instanceExtraInitializers = [];
     let _prompt_decorators;
-    let _interruptByParent_decorators;
+    let _interruptByUser_decorators;
     return class SubagentRuntime extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _prompt_decorators = [Remote('prompt')];
-            _interruptByParent_decorators = [Remote('interruptByParent')];
+            _prompt_decorators = [Remote({ name: 'prompt', resources: { session: request => request.childSessionId } })];
+            _interruptByUser_decorators = [Remote({ name: 'interruptByUser', resources: { session: childSessionId => childSessionId } })];
             __esDecorate(this, null, _prompt_decorators, { kind: "method", name: "prompt", static: false, private: false, access: { has: obj => "prompt" in obj, get: obj => obj.prompt }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _interruptByParent_decorators, { kind: "method", name: "interruptByParent", static: false, private: false, access: { has: obj => "interruptByParent" in obj, get: obj => obj.interruptByParent }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _interruptByUser_decorators, { kind: "method", name: "interruptByUser", static: false, private: false, access: { has: obj => "interruptByUser" in obj, get: obj => obj.interruptByUser }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         config = __runInitializers(this, _instanceExtraInitializers);
@@ -90,14 +88,18 @@ let SubagentRuntime = (() => {
             super(ctx, 'subagents');
             this.config = config;
             this.emitLifecycle = createLifecycleEmitter(this.ctx, parent => scopeTarget(this, parent));
+        }
+        async [Service.init]() {
+            const ctx = this.ctx;
+            await ctx.sessionProjections.register(subagentCatalogProjectionDefinition);
+            await ctx.sessionProjections.register(subagentTimingProjectionDefinition);
+            const identityProjection = await ctx.sessionProjections.register(subagentIdentityProjectionDefinition);
+            if (ctx.fiber.uid === null)
+                return;
             ctx.inject(['agents'], (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),
+                    identityOf: session => identityProjection.stateOf(session).identity,
+                    emitLifecycle: this.emitLifecycle,
                 }, () => this.config.maxActiveSubagents.get(), () => this.config.delegatedApproval.get());
                 this.manager = manager;
                 childCtx.effect(() => () => {
@@ -106,15 +108,6 @@ let SubagentRuntime = (() => {
                         this.manager = undefined;
                 }, 'subagents.managerBinding()');
             });
-            // Archive admission: this runtime is the owner that knows which live
-            // children descend from a Session and how a parent stops them.
-            ctx.inject(['agents'], (agentsCtx) => { installSubagentArchiveAdmission(agentsCtx); });
-        }
-        async [Service.init]() {
-            const { sessionProjections } = this.ctx;
-            await sessionProjections.register(subagentCatalogProjectionDefinition);
-            await sessionProjections.register(subagentTimingProjectionDefinition);
-            await sessionProjections.register(subagentIdentityProjectionDefinition);
         }
         /**
          * Resolve a delegation tool's depth policy against the current user setting.
@@ -135,70 +128,72 @@ let SubagentRuntime = (() => {
          * @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.
+         * @throws PROVIDER_CHANGED if the selected provider is removed or replaced before dispatch.
          */
         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 });
+            assertSubagentMaxDepth(spec.maxDepth);
+            this.assertCapabilities(provider, spec);
             const manager = this.requireManager();
-            if (this.ctx.get('agents')?.get(spec.request.parent.id) !== spec.request.parent) {
+            if (this.ctx.get('agents')?.get(spec.parent.id) !== spec.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);
+            if (spec.outputSchema !== undefined)
+                assertObjectJsonSchema(spec.outputSchema);
+            const prepare = provider.prepareContinuable?.bind(provider);
+            if (prepare !== undefined) {
+                return manager.startLocal(spec, (request) => {
+                    this.assertProviderCurrent(provider);
+                    return prepare(request);
+                });
+            }
+            // oxlint-disable-next-line typescript/no-non-null-assertion -- registerProvider requires start when prepareContinuable is absent.
+            const start = provider.start.bind(provider);
+            return manager.startExternal(spec, (request) => {
+                this.assertProviderCurrent(provider);
+                return start(request);
+            });
         }
         /**
-         * 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.
+         * Resolve the root shared by an Agent and its other agents in its subagent tree.
+         * @param caller - exact live Agent whose subagent ancestry selects the tree.
+         * @returns the live root; ordinary Session forks lead independent trees.
+         * @throws when the caller or its runtime owner is unavailable.
          */
-        async waitForChildren(parent) {
-            return this.manager?.waitForChildren(parent) ?? false;
+        rootOf(caller) {
+            return this.requireManager().rootOf(caller);
         }
         /**
-         * 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;
-         * an idle target starts a turn, and an absent direct child cold-resumes from
-         * persistence. The service derives durable sender attribution from the exact
-         * live sender. Caller cancellation stops only pre-acceptance work.
-         * @param sender - exact live Agent authorizing and originating the message.
-         * @param targetId - durable direct-parent or direct-child session id.
+         * Join progressing subagent tree work for its root. Idle members with parked input
+         * stay resident without delaying host completion. Ordinary members return false.
+         * @param root - exact live subagent tree root whose member work is awaited.
+         * @returns whether work was joined; hosts recheck root idle after true.
+         */
+        async waitForTreeWork(root) {
+            return this.manager?.waitForTreeWork(root) ?? false;
+        }
+        /**
+         * Steer one model-authored message to another member of the same subagent tree.
+         * A running target receives it at its next step; an idle target starts a turn.
+         * A cold target resumes under its runtime subagent tree root without restoring
+         * its creation ancestors. Sender identity is rechecked before inbox acceptance; cancellation
+         * stops only pre-acceptance work and never retracts an accepted message.
+         * @param sender - exact live root or resident continuable Agent originating the message.
+         * @param targetId - another root or continuable member's durable Session id.
          * @param content - model-authored content to deliver.
          * @param options - caller cancellation before inbox acceptance.
          * @returns the accepted message's inbox id.
-         * @throws when continuation services are unavailable, adjacency is rejected,
-         *   or the message was not admitted.
+         * @throws when the target is outside the tree, cannot resume, or rejects input.
          */
         async sendMessage(sender, targetId, content, options) {
             return this.requireManager().sendMessage(sender, targetId, content, options);
         }
         /**
-         * Deliver one host-protocol message to a direct continuable child.
-         * Symbol-keyed so host adapters can preserve their own source descriptors without
-         * widening the public Service Definition or impersonating an Agent sender.
-         * @param parent - exact live direct parent authorizing delivery.
-         * @param childId - durable direct-child session id.
-         * @param content - host-authored content to deliver.
-         * @param source - durable host-protocol source descriptor.
-         * @param signal - caller cancellation before inbox acceptance.
-         * @param delivery - Queue as a distinct turn or Steer at the nearest step.
-         * @returns the accepted message's inbox id.
-         */
-        [deliverSubagentPrompt](parent, childId, content, source, signal, delivery) {
-            return delivery === 'steer'
-                ? this.requireManager().steerPrompt(parent, childId, content, source, signal)
-                : this.requireManager().queuePrompt(parent, childId, content, source, signal);
-        }
-        /**
-         * Interrupt one live child's current execution under a human parent
-         * address or an exact live ancestor Agent. Fire-and-return: the cancel
+         * Interrupt one live child's current execution under a trusted user
+         * operation 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.
@@ -207,7 +202,7 @@ let SubagentRuntime = (() => {
          * 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.
-         * @param authority - the human parent address or exact live ancestor Agent.
+         * @param authority - a trusted user operation or exact live ancestor Agent.
          * @throws {SubagentError} `UNAUTHORIZED` when the authority does not own the
          *   live target.
          */
@@ -215,13 +210,11 @@ let SubagentRuntime = (() => {
             this.manager?.interrupt(targetSessionId, authority);
         }
         /**
-         * 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 execution handle.
+         * Close admission and stop all instances in the selected subagent trees, then await
+         * pending startup and cleanup. Ordinary members are ignored. The cutoff lasts
+         * until each exact root leaves the registry; unrelated subagent trees remain live.
+         * @param parents - exact live subagent tree roots entering teardown.
+         * @returns once all admitted startup and member cleanup have settled.
          * @throws an aggregate error after all branches settle when any failed.
          */
         async drainDescendants(parents) {
@@ -231,34 +224,6 @@ let SubagentRuntime = (() => {
                 return;
             await manager.drainDescendants(parents);
         }
-        /**
-         * 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 execution handle.
-         * @throws {SubagentError} `UNAUTHORIZED` when a resident target belongs to a
-         *   different parent or the supplied parent identity is stale.
-         */
-        async drainChildren(parent, childIds) {
-            const manager = this.manager;
-            if (manager === undefined)
-                return;
-            await manager.drainChildren(parent, childIds);
-        }
-        /**
-         * Read the parent's durable direct-child catalog without loading or resuming an Agent.
-         * The service owns and releases the live-preferred Session observation.
-         * @param parentSessionId - parent whose direct children are requested.
-         * @param signal - cancellation forwarded to the Session query.
-         * @returns catalog children in parent event order.
-         * @throws {@link SubagentError} when query or catalog projection is unavailable.
-         * @throws SessionQueryError when the parent cannot be read or the query is cancelled.
-         */
-        listChildren(parentSessionId, signal) {
-            return listSubagentChildren(this.ctx, parentSessionId, signal);
-        }
         /**
          * Recursively list reachable parent catalogs in stable pre-order, preserving
          * each catalog's event order. Each row carries its catalog parent and depth;
@@ -279,8 +244,8 @@ let SubagentRuntime = (() => {
             return listSubagentDescendants(this.ctx, rootSessionId, signal);
         }
         /**
-         * Deliver one browser-authored message to a continuable child through the
-         * exact live direct parent, retaining the caller-minted request identity and
+         * Deliver one browser-authored message to a continuable child through its
+         * live subagent tree root, retaining the caller-minted request identity and
          * validated browser zone on the accepted message. Success identifies the
          * message the child's inbox accepted; later execution is independent of this
          * call. Queue delivery targets a later turn; steer delivery targets the
@@ -288,16 +253,17 @@ let SubagentRuntime = (() => {
          * Image parts are admitted and persisted through the attachment store
          * before delivery, and the child's model must accept image input.
          * Cold resume at capacity rejects with `subagent/delivery-unavailable`.
-         * @param request - durable address, delivery, minted identity, content, and optional browser zone.
+         * Access is checked on the target Session before attachment admission or restoration.
+         * @param request - target id, delivery, minted identity, content, and optional browser zone.
          * @param signal - carrier cancellation, owning the call until inbox acceptance.
          * @returns the accepted message's inbox identity.
          * @throws {RemoteError} `gateway/bad-request`, `subagent/attachment-invalid`,
-         *   `subagent/invalid-time-zone`, `subagent/parent-unavailable`,
+         *   `subagent/invalid-time-zone`,
          *   `subagent/not-resumable`, `subagent/unauthorized`,
          *   `subagent/delivery-unavailable`, `gateway/cancelled`, or `gateway/internal`.
          */
         async prompt(request, signal) {
-            const { parentSessionId, childSessionId, clientTimeZone, delivery } = request;
+            const { childSessionId, clientTimeZone, delivery } = request;
             validateControlRequest('subagent.prompt', request);
             const canonicalTimeZone = clientTimeZone === undefined
                 ? undefined
@@ -305,10 +271,6 @@ let SubagentRuntime = (() => {
             if (clientTimeZone !== undefined && canonicalTimeZone === undefined) {
                 throw new RemoteError('subagent/invalid-time-zone', 'clientTimeZone must be UTC or a valid IANA Area/Location name', { value: clientTimeZone });
             }
-            const parent = this.ctx.get('agents')?.get(parentSessionId);
-            if (parent === undefined) {
-                throw new RemoteError('subagent/parent-unavailable', `parent session "${parentSessionId}" is not live`, { parentSessionId });
-            }
             const principal = principalOf(this.ctx.invocation);
             const source = {
                 kind: 'user',
@@ -330,7 +292,7 @@ let SubagentRuntime = (() => {
                     content = await attachments.admitPromptContent(request.content);
                 }
                 return {
-                    messageId: await this[deliverSubagentPrompt](parent, childSessionId, content, source, signal, delivery),
+                    messageId: await this.requireManager().deliverPrompt(childSessionId, content, { source, signal, delivery }),
                 };
             }
             catch (error) {
@@ -338,28 +300,20 @@ let SubagentRuntime = (() => {
             }
         }
         /**
-         * Remote face of {@link interrupt} under one durable parent address. No
-         * catalog, history, persistence, or parent Agent lookup runs: the core
-         * primitive alone authorizes the address against the live Activation, which
-         * is what keeps a live child interruptible while its parent Agent is offline.
+         * Remote face of {@link interrupt}, authorized on the target Session by the Gateway.
+         * No catalog, history, persistence, or parent Agent lookup runs.
          * Absent, idle, and already-completed targets are accepted no-ops there.
          * @param childSessionId - durable child session id to interrupt.
-         * @param parentSessionId - durable direct parent whose authority is claimed.
-         * @param mode - required continuable-address discriminator.
          * @returns acknowledgement that the cancel signal was admitted, not that the target is quiescent.
          * @throws {RemoteError} `gateway/bad-request` for an empty id,
-         *   `subagent/unauthorized` when the address does not own the live target,
          *   otherwise `gateway/internal`.
          */
-        interruptByParent(childSessionId, parentSessionId, mode) {
-            validateControlRequest('subagent.interrupt', { childSessionId, parentSessionId, mode });
+        interruptByUser(childSessionId) {
+            validateControlRequest('subagent.interrupt', { childSessionId });
             try {
-                this.interrupt(childSessionId, { kind: 'user', parentSessionId });
+                this.interrupt(childSessionId, { kind: 'user' });
             }
             catch (error) {
-                if (error instanceof SubagentError && error.code === 'UNAUTHORIZED') {
-                    throw new RemoteError('subagent/unauthorized', 'subagent does not belong to this parent', { childSessionId }, { cause: error });
-                }
                 throw new RemoteError('gateway/internal', 'subagent interrupt failed', {}, { cause: error });
             }
             return { accepted: true };
@@ -400,21 +354,11 @@ let SubagentRuntime = (() => {
         getProvider(name) {
             return this.providers.get(name);
         }
-        /**
-         * List registered provider names in insertion order.
-         * @returns the registered names.
-         */
-        list() {
-            return [...this.providers.keys()];
-        }
-        /**
-         * Resolve one provider's detached continuable-creation contribution. Method
-         * presence on the provider IS the capability, so a provider without it is
-         * rejected before the manager reserves any child resources.
-         */
-        async prepareContinuable(name, request) {
-            const provider = this.expectProvider(name);
-            return provider.prepareContinuable(request);
+        /** A pending start must use the exact provider whose capabilities were checked. */
+        assertProviderCurrent(provider) {
+            if (this.providers.get(provider.name) !== provider) {
+                throw new SubagentError(`subagent provider "${provider.name}" changed during startup; retry the delegation`, 'PROVIDER_CHANGED');
+            }
         }
         /** Look up a provider for dispatch or fail loud. */
         expectProvider(name) {
@@ -431,13 +375,6 @@ let SubagentRuntime = (() => {
             }
             return this.manager;
         }
-        /**
-         * Build the lifecycle observer for one continuable Activation's residency
-         * epoch, so the manager publishes its edges without owning event dispatch.
-         */
-        observeActivation(provider, childId, parent) {
-            return createActivationObserver(this.emitLifecycle, provider, childId, parent);
-        }
         /** Reject the first requested capability that the provider lacks. */
         assertCapabilities(provider, request) {
             if (request.agentPreset !== undefined && (!provider.capabilities.agentPreset || provider.inheritsParentContext)) {

package/lib/types/lifecycle.d.ts

@@ -1,39 +1,19 @@
 /**
- * Lifecycle-edge publication for managed subagent activations.
+ * Contained lifecycle notifications for subagents.
  *
- * Public event payloads live in `./types.ts`; the package-private observer
- * retains only the identity shared by each start/end pair.
+ * The service owns scoped dispatch and listener containment; the manager
+ * supplies event payloads from each activation.
  *
  * @module @deepseek-ai/dsh-subagent/lifecycle
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
-import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
 import type { SubagentResult, SubagentRunEndInfo, SubagentRunInfo } from './types.ts';
 /**
- * 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 local Agent, or undefined for an external execution.
-     */
-    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 result - the captured result, with teardown failures applied.
-     */
-    settle(result: SubagentResult): void;
-}
-/**
- * Publish one lifecycle edge with per-listener exception containment. Run edges
- * carry the delegating parent that keys scoped dispatch; provider removal has no
- * parent carrier and reaches listeners unscoped.
+ * Publish one notification with per-listener exception containment. Run edges
+ * carry the subagent tree root that keys scoped dispatch. Provider removal
+ * reaches all scopes.
  *
  * The service owns this closure because scoped dispatch keys its carrier by the
  * exact service instance, whose own context filter composes into the carrier;
@@ -50,19 +30,10 @@ export type LifecycleEmitter = {
  * returned promise is logged without starving peer listeners, changing the run,
  * or — for provider removal, which fires from a disposer — breaking teardown.
  * @param ctx - the service's own context, owning dispatch and the logger.
- * @param carrier - resolve the scoped dispatch carrier for one delegating parent.
- * @returns the emitter both observers and the provider registry publish through.
+ * @param carrier - resolve the scoped dispatch carrier for one subagent tree root.
+ * @returns the emitter the manager and provider registry publish through.
  */
 export declare function createLifecycleEmitter(ctx: Context, carrier: (parent: Agent) => object): LifecycleEmitter;
-/**
- * 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.
- * @param parent - the exact live direct parent keying scoped dispatch.
- * @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:

package/lib/types/lifecycle.js

@@ -1,22 +1,20 @@
 /**
- * Lifecycle-edge publication for managed subagent activations.
+ * Contained lifecycle notifications for subagents.
  *
- * Public event payloads live in `./types.ts`; the package-private observer
- * retains only the identity shared by each start/end pair.
+ * The service owns scoped dispatch and listener containment; the manager
+ * supplies event payloads from each activation.
  *
  * @module @deepseek-ai/dsh-subagent/lifecycle
  */
-import { randomUUID } from 'node:crypto';
 import { foldConsumedWork } from '@deepseek-ai/dsh-agent';
-import { SubagentRunId } from "./types.js";
 /**
  * Build the contained lifecycle emitter this seam publishes every edge through.
  * Every listener is independently contained: a synchronous throw or a rejected
  * returned promise is logged without starving peer listeners, changing the run,
  * or — for provider removal, which fires from a disposer — breaking teardown.
  * @param ctx - the service's own context, owning dispatch and the logger.
- * @param carrier - resolve the scoped dispatch carrier for one delegating parent.
- * @returns the emitter both observers and the provider registry publish through.
+ * @param carrier - resolve the scoped dispatch carrier for one subagent tree root.
+ * @returns the emitter the manager and provider registry publish through.
  */
 export function createLifecycleEmitter(ctx, carrier) {
     return (name, info, parent) => {
@@ -36,30 +34,6 @@ export function createLifecycleEmitter(ctx, carrier) {
         }
     };
 }
-/**
- * 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.
- * @param parent - the exact live direct parent keying scoped dispatch.
- * @returns the observer whose edges this epoch publishes.
- */
-export function createActivationObserver(emit, provider, childId, parent) {
-    const identity = { runId: SubagentRunId(randomUUID()), provider, id: childId, local: false };
-    return {
-        start: (child) => {
-            identity.local = child !== undefined;
-            emit('subagent/start', identity, parent);
-        },
-        settle: ({ stopReason, output }) => {
-            emit('subagent/end', {
-                ...identity,
-                stopReason,
-                ...output.length === 0 ? {} : { lastAssistantMessage: output },
-            }, parent);
-        },
-    };
-}
 /**
  * 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: