@qlzt/dsh-subagent 0.0.0-stage → 0.2.1-alpha.3

package/lib/types/index.js

@@ -0,0 +1,455 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import z from '@deepseek-ai/schemastery';
+import { scopeTarget } from '@qlzt/dsh-scope';
+import { assertObjectJsonSchema } from '@qlzt/dsh-tools';
+import { canonicalClientTimeZone } from '@qlzt/dsh-util-time';
+import { Remote, RemoteError, TypertRemoteService } from '@qlzt/dsh-typert-protocol';
+import { rejectPrompt, validateControlRequest, } from "./control.js";
+import { SubagentError } from "./error.js";
+import { assertSubagentMaxDepth } from "./depth.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 { 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";
+export { foldSubagentDescriptor, snapshotSubagentDescriptor, SUBAGENT_DESCRIPTOR_VERSION, } from "./descriptor.js";
+export { STRUCTURED_OUTPUT_TOOL } from "./structured.js";
+export { SubagentError } from "./error.js";
+export { assertSubagentMaxDepth, delegationDepthOf } from "./depth.js";
+export { appendDelegatedPolicyOverrides, applyChildComposition, captureDelegatedPolicyOverrides, childSessionMeta, parentAgentOptionsForDelegation, resolveChildAgentOptions, resolveChildDepth, SubagentDepthError, } from "./child-agent.js";
+/** Named provider registry with managed activations, durable discovery, and local child messaging. */
+let SubagentRuntime = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _prompt_decorators;
+    let _interruptByParent_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')];
+            __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);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        config = __runInitializers(this, _instanceExtraInitializers);
+        static Config = z.object({
+            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();
+        manager;
+        /**
+         * The contained lifecycle-edge publisher. Built here because scoped dispatch
+         * keys its carrier by this exact service instance, whose own context filter
+         * composes into the carrier.
+         */
+        emitLifecycle;
+        constructor(ctx, config) {
+            super(ctx, 'subagents');
+            this.config = config;
+            this.emitLifecycle = createLifecycleEmitter(this.ctx, parent => scopeTarget(this, parent));
+            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),
+                }, () => this.config.maxActiveSubagents.get());
+                this.manager = manager;
+                childCtx.effect(() => () => {
+                    /* v8 ignore else -- one injected binding owns the slot until its fiber disposes. */
+                    if (this.manager === manager)
+                        this.manager = undefined;
+                }, 'subagents.managerBinding()');
+            });
+            ctx.inject(['sessionProjections'], (projectionCtx) => {
+                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.
+            ctx.inject(['agents'], (agentsCtx) => { installSubagentArchiveAdmission(agentsCtx); });
+        }
+        /**
+         * Resolve a delegation tool's depth policy against the current user setting.
+         * @param configured - Explicit tool limit, or provider-managed for external delegation.
+         * @returns The numeric limit, or undefined when the provider owns depth enforcement.
+         */
+        resolveMaxDepth(configured) {
+            if (configured === 'provider-managed')
+                return undefined;
+            if (configured !== undefined)
+                return configured;
+            const depth = this.config.maxDepth.get();
+            assertSubagentMaxDepth(depth);
+            return depth;
+        }
+        /**
+         * 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 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
+         * 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.
+         * @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.
+         */
+        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
+         * 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 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.
+         * @param authority - the human parent address or exact live ancestor Agent.
+         * @throws {SubagentError} `UNAUTHORIZED` when the authority does not own the
+         *   live target.
+         */
+        interrupt(targetSessionId, authority) {
+            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.
+         * @throws an aggregate error after all branches settle when any failed.
+         */
+        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 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;
+         * 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.
+         * Each catalog is observed once and released before the next read. No Agent
+         * is loaded or resumed; Sessions absent from reachable catalogs are omitted.
+         * @param rootSessionId - session whose catalog starts descendant discovery.
+         * @param signal - cancellation forwarded to and checked around each catalog read.
+         * @returns children and branch diagnostics in parent-catalog pre-order.
+         * @throws {@link SubagentError} when listing dependencies are unavailable or the caller cancels.
+         * @throws SessionQueryError when the root catalog cannot be read.
+         */
+        listDescendants(rootSessionId, signal) {
+            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
+         * 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
+         * nearest step and retains the Agent loop's best-effort fallback semantics.
+         * 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.
+         * @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/not-resumable`, `subagent/unauthorized`,
+         *   `subagent/delivery-unavailable`, `gateway/cancelled`, or `gateway/internal`.
+         */
+        async prompt(request, signal) {
+            const { parentSessionId, childSessionId, clientTimeZone, delivery } = request;
+            validateControlRequest('subagent.prompt', request);
+            const canonicalTimeZone = clientTimeZone === undefined
+                ? undefined
+                : canonicalClientTimeZone(clientTimeZone);
+            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 source = {
+                kind: 'user',
+                rpcId: request.requestId,
+                ...(canonicalTimeZone === undefined ? {} : { clientTimeZone: canonicalTimeZone }),
+            };
+            try {
+                // Admission precedes delivery: image parts become durable references
+                // here, so the child inbox only ever accepts Host-persisted attachments.
+                let content;
+                if (request.content.every((part) => part.type === 'text')) {
+                    content = request.content.map(part => ({ type: 'text', text: part.text }));
+                }
+                else {
+                    const attachments = this.ctx.get('attachments');
+                    if (attachments === undefined)
+                        throw new Error('subagent image prompt requires an attachment store');
+                    content = await attachments.admitPromptContent(request.content);
+                }
+                return {
+                    messageId: await this[deliverSubagentPrompt](parent, childSessionId, content, source, signal, delivery),
+                };
+            }
+            catch (error) {
+                return rejectPrompt(error, childSessionId, signal);
+            }
+        }
+        /**
+         * 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.
+         * 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 });
+            try {
+                this.interrupt(childSessionId, { kind: 'user', parentSessionId });
+            }
+            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 };
+        }
+        /**
+         * 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. 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)) {
+                    throw new SubagentError(`a subagent provider named "${name}" is already registered`, 'DUPLICATE_PROVIDER');
+                }
+                this.providers.set(name, provider);
+                yield () => {
+                    this.providers.delete(name);
+                    this.emitLifecycle('subagent/provider-removed', name);
+                };
+                // A throwing added-listener unwinds the yielded rollback, matching the
+                // repository's fail-loud registration semantics.
+                this.ctx.emit('subagent/provider-added', provider);
+            }.bind(this), 'subagents.registerProvider()');
+        }
+        /**
+         * Look up a provider by name.
+         * @param name - the provider name.
+         * @returns the provider, or undefined when absent.
+         */
+        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);
+        }
+        /** Look up a provider for dispatch or fail loud. */
+        expectProvider(name) {
+            const provider = this.providers.get(name);
+            if (provider === undefined) {
+                throw new SubagentError(`no subagent provider registered for "${name}"`, 'NO_PROVIDER');
+            }
+            return provider;
+        }
+        /** 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.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) {
+            const needs = [
+                { when: request.agentOptions !== undefined, cap: 'agentOptions' },
+                { when: request.outputSchema !== undefined, cap: 'outputSchema' },
+                { when: request.maxDepth !== undefined, cap: 'depthLimit' },
+                { when: request.toolFilter !== undefined, cap: 'toolFilter' },
+                { when: request.persona !== undefined, cap: 'persona' },
+            ];
+            for (const { when, cap } of needs) {
+                if (when && !provider.capabilities[cap]) {
+                    throw new SubagentError(`subagent provider "${provider.name}" does not support the "${cap}" capability`, 'UNSUPPORTED_CAPABILITY');
+                }
+            }
+        }
+    };
+})();
+export { SubagentRuntime };
+export default SubagentRuntime;
+//# sourceMappingURL=index.js.map

package/lib/types/internal.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Continuation integration markers and host adapters outside the public
+ * Service Definition and model-facing Agent messaging contract.
+ * @module @qlzt/dsh-subagent/internal
+ */
+import type { Agent } from '@qlzt/dsh-agent';
+import type { ContentBlock, MessageId, MessageSource } from '@qlzt/dsh-llm';
+import type { SessionId } from '@qlzt/dsh-session';
+import type { ToolDefinition } from '@qlzt/dsh-tools';
+import type SubagentRuntime from './index.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;
+/**
+ * Mark the standard adjacent-Agent messaging tool without changing its model-visible schema.
+ * @param definition - the standard `send_message` definition.
+ * @returns the same definition with its internal identity installed.
+ */
+export declare function markAdjacentAgentSendMessageTool(definition: ToolDefinition): ToolDefinition;
+/**
+ * Test whether one visible definition is the standard adjacent-Agent messaging tool.
+ * @param definition - the scope-resolved `send_message` candidate.
+ * @returns whether the definition carries the internal standard-tool identity.
+ */
+export declare function isAdjacentAgentSendMessageTool(definition: ToolDefinition | undefined): boolean;
+/**
+ * Process-stable symbol-keyed host delivery shared by the bundled runtime
+ * entry and this unbundled internal subpath.
+ * @internal
+ */
+export declare const deliverSubagentPrompt: unique symbol;
+/** Runtime face required by the host-only prompt adapters. */
+export interface HostPromptDeliverer {
+    [deliverSubagentPrompt](parent: Agent, childId: SessionId, content: ContentBlock[], source: MessageSource, signal: AbortSignal, delivery: SubagentDelivery): Promise<MessageId>;
+}
+/**
+ * Queue one host-protocol message without exposing another Service operation.
+ * @param runtime - subagent runtime owning continuation residency.
+ * @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.
+ * @returns the accepted message's inbox id.
+ */
+export declare function queueHostSubagentPrompt(runtime: SubagentRuntime, parent: Agent, childId: SessionId, content: ContentBlock[], source: MessageSource, signal: AbortSignal): Promise<MessageId>;
+/**
+ * Steer one host-protocol message without exposing another Service operation.
+ * @param runtime - subagent runtime owning continuation residency.
+ * @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.
+ * @returns the accepted message's inbox id.
+ */
+export declare function steerHostSubagentPrompt(runtime: SubagentRuntime, parent: Agent, childId: SessionId, content: ContentBlock[], source: MessageSource, signal: AbortSignal): Promise<MessageId>;
+//# sourceMappingURL=internal.d.ts.map

package/lib/types/internal.js

@@ -0,0 +1,58 @@
+/**
+ * Continuation integration markers and host adapters outside the public
+ * Service Definition and model-facing Agent messaging contract.
+ * @module @qlzt/dsh-subagent/internal
+ */
+/** Process-stable identity carried only by the standard adjacent-Agent messaging tool. */
+export const adjacentAgentSendMessageTool = Symbol.for('dsh.subagent.adjacentAgentSendMessageTool');
+/**
+ * Mark the standard adjacent-Agent messaging tool without changing its model-visible schema.
+ * @param definition - the standard `send_message` definition.
+ * @returns the same definition with its internal identity installed.
+ */
+export function markAdjacentAgentSendMessageTool(definition) {
+    Object.defineProperty(definition, adjacentAgentSendMessageTool, { value: true });
+    return definition;
+}
+/**
+ * Test whether one visible definition is the standard adjacent-Agent messaging tool.
+ * @param definition - the scope-resolved `send_message` candidate.
+ * @returns whether the definition carries the internal standard-tool identity.
+ */
+export function isAdjacentAgentSendMessageTool(definition) {
+    return definition !== undefined
+        && definition[adjacentAgentSendMessageTool] === true;
+}
+/**
+ * Process-stable symbol-keyed host delivery shared by the bundled runtime
+ * entry and this unbundled internal subpath.
+ * @internal
+ */
+export const deliverSubagentPrompt = Symbol.for('dsh.subagent.deliverPrompt');
+/**
+ * Queue one host-protocol message without exposing another Service operation.
+ * @param runtime - subagent runtime owning continuation residency.
+ * @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.
+ * @returns the accepted message's inbox id.
+ */
+export function queueHostSubagentPrompt(runtime, parent, childId, content, source, signal) {
+    return runtime[deliverSubagentPrompt](parent, childId, content, source, signal, 'queue');
+}
+/**
+ * Steer one host-protocol message without exposing another Service operation.
+ * @param runtime - subagent runtime owning continuation residency.
+ * @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.
+ * @returns the accepted message's inbox id.
+ */
+export function steerHostSubagentPrompt(runtime, parent, childId, content, source, signal) {
+    return runtime[deliverSubagentPrompt](parent, childId, content, source, signal, 'steer');
+}
+//# sourceMappingURL=internal.js.map

package/lib/types/lifecycle.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Lifecycle-edge publication for managed subagent activations.
+ *
+ * Public event payloads live in `./types.ts`; the package-private observer
+ * retains only the identity shared by each start/end pair.
+ *
+ * @module @qlzt/dsh-subagent/lifecycle
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@qlzt/dsh-agent';
+import type { SessionEvent, SessionId } from '@qlzt/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.
+ *
+ * The service owns this closure because scoped dispatch keys its carrier by the
+ * exact service instance, whose own context filter composes into the carrier;
+ * a narrowed stand-in would silently change scope filtering.
+ */
+export type LifecycleEmitter = {
+    (name: 'subagent/start', info: SubagentRunInfo, parent: Agent): void;
+    (name: 'subagent/end', info: SubagentRunEndInfo, parent: Agent): void;
+    (name: 'subagent/provider-removed', info: string): void;
+};
+/**
+ * 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.
+ */
+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:
+ * 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