@deepseek-ai/dsh-subagent 0.1.2-alpha.3 → 0.1.2-alpha.4

package/lib/types/continuation.js

@@ -75,11 +75,13 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 import { randomUUID } from 'node:crypto';
 import { brandString } from '@deepseek-ai/dsh-brand';
 import { ReasoningEffortId, boundContextSummary, contentHasImage, createUserMessage, errorChain } from '@deepseek-ai/dsh-llm';
+import { SessionLogOffset } from '@deepseek-ai/dsh-session';
 import { foldSubagentDescriptor, snapshotSubagentDescriptor } from "./descriptor.js";
 import { appendDelegatedPolicyOverrides, applyChildComposition, captureDelegatedPolicyOverrides, childSessionMeta, resolveChildAgentOptions, resolveChildDepth, } from "./child-agent.js";
 import { assertSubagentMaxDepth } from "./depth.js";
 import { seedDescriptorTurn } from "./descriptor-seed.js";
 import { SubagentError } from "./error.js";
+import { isAdjacentAgentSendMessageTool } from "./internal.js";
 /**
  * Read one Activation's current disposal transaction. This indirection exists
  * because TypeScript would otherwise narrow repeated reads of the mutable field
@@ -90,6 +92,39 @@ import { SubagentError } from "./error.js";
 function disposalOf(activation) {
     return activation.disposal;
 }
+/** Build durable attribution for one adjacent-Agent message. */
+function agentMessageSource(sender) {
+    return {
+        kind: 'agent-message',
+        form: 'relay',
+        senderSessionId: sender.id,
+    };
+}
+/** Build the model-visible and durable representation of one adjacent-Agent message. */
+function agentMessage(sender, content) {
+    return createUserMessage({
+        content: [
+            { type: 'text', text: `Agent ${sender.id} sent a message:` },
+            ...content,
+        ],
+        source: agentMessageSource(sender),
+    });
+}
+/** Append adjacent-Agent return guidance to a continuable child's initial task. */
+function continuableInitialPrompt(parentId, prompt) {
+    const encodedParentId = JSON.stringify(parentId);
+    return [
+        ...prompt,
+        {
+            type: 'text',
+            text: `Your parent agent id is ${encodedParentId}. Before you finish, send your result to that agent with `
+                + `send_message({ agent_id: ${encodedParentId}, message: "<self-contained result>" }). The parent shares `
+                + 'your workspace but does not automatically receive your transcript, tool output, or reasoning. Send '
+                + 'earlier messages as well when a finding changes what the parent should do next; sending a message '
+                + 'does not end your turn.',
+        },
+    ];
+}
 /**
  * One line telling a parent that a background child is finished and why, in
  * the parent's own task vocabulary.
@@ -151,7 +186,6 @@ class ChildLock {
 export class SubagentContinuationManager {
     ctx;
     host;
-    setupRegistry;
     /** Child session id → its live Activation. Process-local, never durable. */
     activations = new Map();
     /** Materializations admitted before drain, tracked through publication or rollback. */
@@ -167,10 +201,9 @@ export class SubagentContinuationManager {
      */
     closingScopes = new Map();
     draining = false;
-    constructor(ctx, host, setupRegistry) {
+    constructor(ctx, host) {
         this.ctx = ctx;
         this.host = host;
-        this.setupRegistry = setupRegistry;
         // Ordinary Cordis owner effects unwind in reverse registration order, which
         // cannot express the dynamic child graph. Register the private scope's
         // structural disposer FIRST and the drain SECOND, so reverse unwind invokes
@@ -237,7 +270,7 @@ export class SubagentContinuationManager {
         });
         spec.signal.throwIfAborted();
         this.assertAdmitting(parent);
-        const lineageSeedLength = prepared.seed?.length ?? 0;
+        const inheritedEventCount = SessionLogOffset(prepared.seed?.length ?? 0);
         const seed = seedDescriptorTurn(childId, prepared.seed, descriptor);
         const messageId = await this.locks.run(childId, async () => {
             spec.signal.throwIfAborted();
@@ -256,12 +289,19 @@ export class SubagentContinuationManager {
                 childId,
                 provider: spec.provider,
                 parent,
-                create: { seed, meta: childSessionMeta(parent, childDepth, lineageSeedLength), delegatedPolicies },
+                create: {
+                    seed,
+                    meta: childSessionMeta(parent, childDepth, prepared.seed !== undefined),
+                    inheritedEventCount,
+                    delegatedPolicies,
+                },
                 agentOptions,
                 composition: { persona: request.persona, toolFilter: request.toolFilter },
                 signal: spec.signal,
             });
-            return this.submitMaterialized(activation, request.prompt, { kind: 'user' }, parent, spec.signal);
+            return this.submitMaterialized(activation, isAdjacentAgentSendMessageTool(this.ctx.get('tools')?.get('send_message', activation.handle.agent))
+                ? continuableInitialPrompt(parent.id, request.prompt)
+                : request.prompt, { source: { kind: 'user' }, signal: spec.signal, delivery: 'queue' }, parent);
         });
         return { childId, messageId };
     }
@@ -272,23 +312,52 @@ export class SubagentContinuationManager {
         }
     }
     /**
-     * Deliver one later message to a known continuable child as its next FIFO
-     * turn. Routing depends only on Activation residency: a `running` Activation
-     * enqueues, a `waiting` one wakes the same Agent, and an absent one
-     * cold-resumes a new Activation from the persisted Session. The Agent inbox
-     * is the only queue, so every accepted message has one observable order.
-     *
-     * The caller signal owns lookup, materialization, and admission only until
-     * inbox acceptance; afterwards the accepted turn cannot be cancelled through
-     * this service.
-     * @param parent - the exact live direct parent authorizing this delivery.
-     * @param childId - the durable child session id.
-     * @param content - the user-role content to deliver.
-     * @param options - the message source fields and caller cancellation.
+     * Deliver one model-authored message to a direct continuable child or to the
+     * sender's direct parent. Both directions use Steer: a running target admits
+     * the message at its nearest step boundary, while an idle target starts a
+     * turn. A missing direct child cold-resumes through the ordinary continuation
+     * lifecycle. The caller signal owns the operation only until inbox acceptance.
+     * @param sender - exact live Agent authorizing and originating the message.
+     * @param targetId - durable direct-parent or direct-child session id.
+     * @param content - model-authored content to deliver.
+     * @param options - caller cancellation before acceptance.
      * @returns the accepted message's inbox id.
-     * @throws when parent authority, availability, or admission rejects the delivery.
+     * @throws when adjacency, availability, or admission rejects delivery.
      */
-    async followup(parent, childId, content, options) {
+    async sendMessage(sender, targetId, content, options) {
+        if (this.ctx.agents.get(sender.id) !== sender) {
+            throw new SubagentError('message delivery requires the exact live sender agent', 'UNAUTHORIZED');
+        }
+        this.assertAdmitting(sender);
+        const senderActivation = this.activations.get(sender.id);
+        if (senderActivation !== undefined
+            && senderActivation.handle.agent === sender
+            && senderActivation.parentSession === targetId) {
+            options.signal.throwIfAborted();
+            return this.sendToParent(senderActivation, sender, content);
+        }
+        if (sender.session.header.parentSession === targetId) {
+            throw new SubagentError(`agent "${sender.id}" is not a resident continuable child and cannot send to parent "${targetId}"`, 'UNAUTHORIZED');
+        }
+        return this.deliverToChild(sender, targetId, content, {
+            signal: options.signal,
+            delivery: 'steer',
+        });
+    }
+    /**
+     * Queue one human-authored prompt as a distinct direct-child turn.
+     * @param parent - exact live direct parent authorizing delivery.
+     * @param childId - durable direct-child session id.
+     * @param content - human-authored content to deliver.
+     * @param source - durable host-protocol provenance.
+     * @param signal - caller cancellation before inbox acceptance.
+     * @returns the accepted message's inbox id.
+     */
+    async queuePrompt(parent, childId, content, source, signal) {
+        return this.deliverToChild(parent, childId, content, { source, signal, delivery: 'queue' });
+    }
+    /** Route one parent-originated delivery through residency and cold resume. */
+    async deliverToChild(parent, childId, content, options) {
         this.assertAdmitting(parent);
         while (true) {
             const live = await this.locks.run(childId, async () => {
@@ -317,7 +386,7 @@ export class SubagentContinuationManager {
                         return undefined;
                     }
                 }
-                return this.submitAdmitted(activation, content, options.source, parent, options.signal);
+                return this.submitAdmitted(activation, content, options, parent);
             });
             /* v8 ignore start -- only the lost-cutoff arm above returns undefined, so only that
              * race reaches the retry below, which then cold-resumes a new Activation. */
@@ -378,68 +447,19 @@ export class SubagentContinuationManager {
             return;
         activation.handle.agent.cancel(authority.kind === 'user' ? { kind: 'user' } : { kind: 'parent' }, { keepInbox: true });
     }
-    /**
-     * Deliver explicitly selected content from one resident continuable child to
-     * its durable direct parent. Sender authorization, parent resolution, and
-     * send acceptance share one no-await span. Reporting neither concludes the
-     * child's turn nor changes its Activation lifetime.
-     * @param child - exact live reporting child; this is the authority credential.
-     * @param content - selected model-facing content.
-     * @param options - scheduling policy and pre-acceptance cancellation.
-     * @returns the stable identity of the message accepted by the parent.
-     * @throws {SubagentError} when the sender is unauthorized, the parent is not
-     *   live, or continuation admission is closing.
-     */
-    // oxlint-disable-next-line typescript/require-await -- keep rejection semantics without yielding during admission
-    async reportFrom(child, content, options) {
-        options.signal.throwIfAborted();
-        this.assertAdmitting(child);
-        const activation = this.authorizeReporter(child);
-        const parent = this.resolveReportParent(child);
-        return this.deliverReport(activation, parent, content, options.delivery);
-    }
-    /** Authorize only the exact Agent of one resident Activation. */
-    authorizeReporter(child) {
-        const activation = this.activations.get(child.id);
-        if (activation === undefined || activation.handle.agent !== child) {
-            throw new SubagentError(`agent "${child.id}" is not a live continuable subagent and cannot report`, 'UNAUTHORIZED');
-        }
-        /* v8 ignore next 6 -- only a synchronous re-entrant disposer can open this
-         * transaction between exact-agent authorization and this no-await cutoff. */
+    /** Deliver one resident continuable child's message to its live direct parent. */
+    sendToParent(activation, sender, content) {
+        /* v8 ignore next 6 -- only synchronous re-entrant teardown can open this
+         * transaction between exact-agent authorization and this no-await span. */
         if (activation.disposal !== undefined) {
-            throw new SubagentError(`subagent "${child.id}" activation is being disposed; the report was not delivered`, 'ACTIVATION_CLOSING');
+            throw new SubagentError(`subagent "${sender.id}" activation is being disposed; the message was not delivered`, 'ACTIVATION_CLOSING');
         }
-        return activation;
-    }
-    /** Resolve the reporting child's live direct parent from durable lineage. */
-    resolveReportParent(child) {
-        const parentId = child.session.header.parentSession;
-        /* v8 ignore next -- every continuation-managed child has direct-parent metadata. */
-        const parent = parentId === undefined ? undefined : this.ctx.agents.get(parentId);
+        const parent = this.ctx.agents.get(activation.parentSession);
         if (parent === undefined) {
-            throw new SubagentError('direct parent is not live; report was not delivered', 'PARENT_UNAVAILABLE');
-        }
-        return parent;
-    }
-    /** Deliver one framed report through the selected parent scheduling preset. */
-    deliverReport(activation, parent, content, delivery) {
-        const message = createUserMessage({
-            content: [
-                { type: 'text', text: `Background subagent ${activation.childId} reported:` },
-                ...content,
-            ],
-            source: {
-                kind: 'subagent-report',
-                form: 'relay',
-                senderSessionId: activation.childId,
-            },
-        });
-        if (delivery === 'next-step') {
-            this.sendWaking(parent, message, () => { this.sendReport(parent, message, delivery); });
-        }
-        else {
-            this.sendReport(parent, message, delivery);
+            throw new SubagentError('direct parent is not live; the message was not delivered', 'PARENT_UNAVAILABLE');
         }
+        const message = agentMessage(sender, content);
+        this.sendWaking(parent, message, () => { this.sendAgentMessage(parent, message); });
         return message.id;
     }
     /**
@@ -460,16 +480,13 @@ export class SubagentContinuationManager {
             send();
         }
     }
-    /** Send one report while translating only the parent's own rejection. */
-    sendReport(parent, message, delivery) {
+    /** Send one Agent message while translating only the target's own rejection. */
+    sendAgentMessage(parent, message) {
         try {
-            if (delivery === 'next-step')
-                parent.steer(message);
-            else
-                parent.inject(message);
+            parent.steer(message);
         }
         catch (error) {
-            throw new SubagentError('direct parent is not live; report was not delivered', 'PARENT_UNAVAILABLE', { cause: error });
+            throw new SubagentError('direct parent is not live; the message was not delivered', 'PARENT_UNAVAILABLE', { cause: error });
         }
     }
     /**
@@ -706,10 +723,9 @@ export class SubagentContinuationManager {
             // Fold only the child's own suffix: a fork seed replays the parent's log,
             // which may carry an ANCESTOR's descriptor when the parent is itself a
             // continuable child.
-            const descriptor = foldSubagentDescriptor(source.events.slice(source.header.seedLength ?? 0));
+            const descriptor = foldSubagentDescriptor(source.events.slice(source.inheritedEventCount));
             if (descriptor === undefined || descriptor.mode !== 'continuable') {
-                throw new SubagentError(`subagent "${childId}" has no supported continuation state and cannot be resumed; `
-                    + 'do not retry send_message with this id', 'NOT_RESUMABLE');
+                throw new SubagentError(`subagent "${childId}" has no supported continuation state and cannot be resumed; choose a different target`, 'NOT_RESUMABLE');
             }
             let activation;
             try {
@@ -734,7 +750,7 @@ export class SubagentContinuationManager {
                     throw error;
                 throw new SubagentError(`subagent "${childId}" is unavailable`, 'NOT_RESUMABLE', { cause: error });
             }
-            return await this.submitMaterialized(activation, content, options.source, parent, options.signal);
+            return await this.submitMaterialized(activation, content, options, parent);
         }
         catch (e_1) {
             env_1.error = e_1;
@@ -748,23 +764,22 @@ export class SubagentContinuationManager {
      * Submit to a freshly materialized Activation or roll it back completely.
      * @param activation - the just-published Activation to admit or release.
      * @param content - the initial or resumed message content.
-     * @param source - durable fields naming who supplied the accepted message.
+     * @param options - durable source, scheduling, and pre-acceptance cancellation.
      * @param parent - the live direct parent authorizing admission.
-     * @param signal - caller cancellation owning admission until acceptance.
      * @returns the accepted inbox message id.
      */
-    async submitMaterialized(activation, content, source, parent, signal) {
+    async submitMaterialized(activation, content, options, parent) {
         try {
             if (contentHasImage(content)) {
                 // The capability read awaits with the activation already published, so
                 // the disposal cutoff is re-checked before the submit; a drain that
                 // began during the read turns into a clean closing rejection.
-                await this.assertImageCapable(activation.handle.agent, signal);
+                await this.assertImageCapable(activation.handle.agent, options.signal);
                 if (activation.disposal !== undefined) {
                     throw new SubagentError(`subagent "${activation.childId}" is closing`, 'ACTIVATION_CLOSING');
                 }
             }
-            return this.submitAdmitted(activation, content, source, parent, signal);
+            return this.submitAdmitted(activation, content, options, parent);
         }
         catch (error) {
             /* v8 ignore next -- rollback disposal failures must not mask the
@@ -839,7 +854,6 @@ export class SubagentContinuationManager {
                 appendDelegatedPolicyOverrides(childCtx.agent.session, create.delegatedPolicies);
             }
             applyChildComposition(childCtx, parent, inputs.composition);
-            return this.setupRegistry.apply(childCtx);
         };
         const observer = this.host.observeActivation(provider, childId, parent);
         // Agent creation owns rollback before handle transfer. A rejection leaves
@@ -855,6 +869,7 @@ export class SubagentContinuationManager {
                 sessionId: childId,
                 meta: create.meta,
                 seed: create.seed,
+                inheritedEventCount: create.inheritedEventCount,
                 agentOptions: inputs.agentOptions,
                 signal: inputs.signal,
                 setup,
@@ -962,13 +977,18 @@ export class SubagentContinuationManager {
      * inbox id. Acceptance is the operation's success boundary; the manager owns
      * the Activation independently afterwards.
      */
-    submit(activation, content, source, parent) {
+    submit(activation, content, options, parent) {
         // Parent-originated delivery keeps the parent live through ownership, so
         // establish it before the message can enter the child's inbox.
         this.acquireOwnership(parent, activation.childId);
-        const message = createUserMessage({ content, source });
+        const message = options.delivery === 'steer'
+            ? agentMessage(parent, content)
+            : createUserMessage({ content, source: options.source });
         const accepted = this.admitWaking(activation, message.id, () => {
-            activation.handle.agent.followup(message);
+            if (options.delivery === 'steer')
+                activation.handle.agent.steer(message);
+            else
+                activation.handle.agent.followup(message);
         });
         // Past this point the caller has an id for this child, so its eventual
         // settlement is something the parent is owed an account of.
@@ -1003,8 +1023,8 @@ export class SubagentContinuationManager {
      * manager drain, or Activation disposal that wins before this synchronous
      * span rejects without inbox acceptance.
      */
-    submitAdmitted(activation, content, source, parent, signal) {
-        signal.throwIfAborted();
+    submitAdmitted(activation, content, options, parent) {
+        options.signal.throwIfAborted();
         this.assertAdmitting(parent);
         /* v8 ignore next 6 -- only a synchronous re-entrant disposer can change
          * this field between the caller's live check and this no-await boundary. */
@@ -1012,7 +1032,7 @@ export class SubagentContinuationManager {
             throw new SubagentError(`subagent "${activation.childId}" activation is being disposed; the message was not accepted`, 'ACTIVATION_CLOSING');
         }
         this.authorizeLineage(parent, activation.childId, activation.handle.agent.session.header.parentSession);
-        return this.submit(activation, content, source, parent);
+        return this.submit(activation, content, options, parent);
     }
     /**
      * Authorize one operation against the durable direct-parent lineage. Other

package/lib/types/descriptor-seed.d.ts

@@ -17,5 +17,5 @@ import type { SubagentDescriptorData } from './descriptor.ts';
  * @param descriptor - the snapshotted composition record to persist.
  * @returns the complete seed events, contiguous from sequence zero.
  */
-export declare function seedDescriptorTurn(childId: SessionId, seed: readonly SessionEvent[] | undefined, descriptor: SubagentDescriptorData): SessionEvent[];
+export declare function seedDescriptorTurn(childId: SessionId, seed: readonly SessionEvent[] | undefined, descriptor: SubagentDescriptorData): readonly SessionEvent[];
 //# sourceMappingURL=descriptor-seed.d.ts.map

package/lib/types/descriptor-seed.js

@@ -19,6 +19,6 @@ import { Session } from '@deepseek-ai/dsh-session';
 export function seedDescriptorTurn(childId, seed, descriptor) {
     const staged = Session.create(childId, seed);
     staged.append('subagent/descriptor', descriptor);
-    return [...staged.events];
+    return staged.snapshotEvents();
 }
 //# sourceMappingURL=descriptor-seed.js.map

package/lib/types/index.d.ts

@@ -13,8 +13,8 @@
  *
  * Public operations express caller intent: `start` returns one published owned
  * one-shot run, `startContinuable` establishes a durable continuable child, and
- * `followup` delivers later content without exposing whether the child is
- * resident. Continuable children never become a {@link SubagentRun}: the
+ * `sendMessage` steers between adjacent Agents without exposing whether a child
+ * is resident. Continuable children never become a {@link SubagentRun}: the
  * continuation manager holds their `AgentHandle` directly and orders every turn
  * through the child's own inbox, so providers contribute only the detached
  * creation spec and see no handle, turn, or teardown. Child and descendant
@@ -36,9 +36,9 @@ import type { SessionId } from '@deepseek-ai/dsh-session';
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import type { SubagentCatalog, SubagentInterruptReceipt, SubagentPromptReceipt, SubagentPromptRequest } from './control-types.ts';
 import type { SubagentProvider, SubagentRun, SubagentRunEndInfo, SubagentRunInfo, SubagentStartRequest } from './types.ts';
-import type { ContinuableStart, ContinuableStartSpec, SubagentFollowupOptions, SubagentInterruptAuthority, SubagentReportOptions } from './continuation.ts';
-import type { ContinuableSetupContribution } from './activation-setup-registry.ts';
+import type { ContinuableStart, ContinuableStartSpec, SubagentInterruptAuthority, SubagentSendMessageOptions } from './continuation.ts';
 import type { SubagentDescendantListEntry, SubagentListEntry } from './list-children.ts';
+import { queueSubagentPrompt } from './internal.ts';
 export * from './out-of-process.ts';
 export { AssistantOutputFold, finalAssistantOutput } from './assistant-output.ts';
 export { SubagentRunId } from './types.ts';
@@ -51,8 +51,7 @@ export { settleRun } from './run-settlement.ts';
 export { assertSubagentMaxDepth, delegationDepthOf } from './depth.ts';
 export { appendDelegatedPolicyOverrides, applyChildComposition, captureDelegatedPolicyOverrides, childSessionMeta, parentAgentOptionsForDelegation, resolveChildAgentOptions, resolveChildDepth, SubagentDepthError, } from './child-agent.ts';
 export type { ChildComposition, DelegatedPolicyOverrides } from './child-agent.ts';
-export type { ContinuableStart, ContinuableStartSpec, CoordinatorMessageSource, SubagentFollowupOptions, SubagentInterruptAuthority, SubagentReportDelivery, SubagentReportMessageSource, SubagentReportOptions, SubagentSettledMessageSource, } from './continuation.ts';
-export type { ContinuableSetupContribution } from './activation-setup-registry.ts';
+export type { AgentMessageSource, ContinuableStart, ContinuableStartSpec, SubagentInterruptAuthority, SubagentSendMessageOptions, SubagentSettledMessageSource, } from './continuation.ts';
 export type * from './control-types.ts';
 export type { SubagentDescendantListEntry } from './list-children.ts';
 export type { SubagentRunEndInfo, SubagentRunInfo } from './types.ts';
@@ -100,8 +99,6 @@ declare module '@deepseek-ai/cordis' {
 export declare class SubagentRuntime extends TypertRemoteService {
     private providers;
     private continuations;
-    /** Deployment contributions composed into unpublished continuable children. */
-    private readonly setupRegistry;
     /**
      * The contained lifecycle-edge publisher. Built here because scoped dispatch
      * keys its carrier by this exact service instance, whose own context filter
@@ -120,21 +117,32 @@ export declare class SubagentRuntime extends TypertRemoteService {
      */
     startContinuable(spec: ContinuableStartSpec): Promise<ContinuableStart>;
     /**
-     * Deliver one later message to a continuable child as its next FIFO turn. A
-     * resident child's Agent inbox accepts it directly (waking a `waiting`
-     * Activation), while an absent one is cold-resumed from its persisted
-     * Session. The Agent inbox is the only queue, so every accepted message has
-     * one observable order.
-     * @param parent - the exact live direct parent authorizing this delivery.
-     * @param childId - durable child session id.
-     * @param content - user-role content to deliver.
-     * @param options - the message source fields and caller cancellation, which stops the
-     *   operation only before inbox acceptance.
+     * 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, parent authority is
-     *   rejected, or the message was not admitted.
+     * @throws when continuation services are unavailable, adjacency is rejected,
+     *   or the message was not admitted.
      */
-    followup(parent: Agent, childId: SessionId, content: ContentBlock[], options: SubagentFollowupOptions): Promise<MessageId>;
+    sendMessage(sender: Agent, targetId: SessionId, content: ContentBlock[], options: SubagentSendMessageOptions): Promise<MessageId>;
+    /**
+     * Queue one host-protocol message as a distinct direct-child turn.
+     * Symbol-keyed so host adapters can preserve their own provenance 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 provenance.
+     * @param signal - caller cancellation before inbox acceptance.
+     * @returns the accepted message's inbox id.
+     */
+    private [queueSubagentPrompt];
     /**
      * Interrupt one live continuable child's current turn under a human parent
      * address or an exact live ancestor Agent. Fire-and-return: the cancel
@@ -151,27 +159,6 @@ export declare class SubagentRuntime extends TypertRemoteService {
      *   live target.
      */
     interrupt(targetSessionId: SessionId, authority: SubagentInterruptAuthority): void;
-    /**
-     * Deliver selected content from one live continuable child to its durable
-     * direct parent. The child is the authority credential; callers cannot name a
-     * recipient. Reporting does not conclude the child's turn or Activation.
-     * @param child - exact live reporting child.
-     * @param content - selected model-facing content.
-     * @param options - parent scheduling and pre-acceptance cancellation.
-     * @returns the stable identity of the parent-accepted message.
-     * @throws when continuation services are unavailable, sender authorization
-     *   fails, or the direct parent is not live.
-     */
-    reportFrom(child: Agent, content: ContentBlock[], options: SubagentReportOptions): Promise<MessageId>;
-    /**
-     * Compose one deployment capability into every continuable child's
-     * unpublished creation context on fresh creation and cold resume. Grants wait
-     * for the next Activation; removing the contribution revokes every resident
-     * installation immediately.
-     * @param contribution - synchronous child-scope installer.
-     * @returns the exact Cordis effect disposer.
-     */
-    registerContinuableSetup(contribution: ContinuableSetupContribution): () => void;
     /**
      * Close continuable admission below exact live parent Agents, stop only their
      * visible descendant Activations synchronously, then await admitted scoped