@toddzheng024/dscode-bundle 0.7.26 → 0.7.28

package/vendor/subagent-core/types/continuation-activation.js

@@ -13,6 +13,20 @@ import { appendDelegatedPolicyOverrides, applyChildComposition, } from "./child-
 import { createSettlementMessage } from "./continuation-messages.js";
 import { SubagentError } from "./error.js";
 import { SubagentInbox } from "./inbox.js";
+/** Process-local slots shared through uninterrupted continuable parent links. */
+class ActivationPool {
+    slots = new Set();
+    /** Reserve before reconstruction; the returned release also tolerates unpublished rollback. */
+    reserve(capacity) {
+        if (this.slots.size >= capacity) {
+            throw new SubagentError(`subagent limit reached (active child limit: ${capacity}); wait for an existing child to finish `
+                + 'or complete this work with the current agents', 'ACTIVATION_LIMIT_REACHED');
+        }
+        const slot = Symbol();
+        this.slots.add(slot);
+        return () => { this.slots.delete(slot); };
+    }
+}
 /** Serialize each durable child's delivery, release, and disposal. */
 export class ChildLock {
     tails = new Map();
@@ -40,8 +54,11 @@ export class ChildLock {
 export class ContinuableActivationRegistry {
     ctx;
     observeActivation;
+    maxActiveSubagents;
     /** Child session id → its live Activation. Process-local, never durable. */
     resident = new Map();
+    /** Root identities retain their pool across child settlement without retaining dead roots. */
+    rootPools = new WeakMap();
     /** Materializations admitted before drain, tracked through publication or rollback. */
     materializations = new Set();
     /** Per-child serializer shared by delivery, release, and disposal. */
@@ -61,9 +78,10 @@ export class ContinuableActivationRegistry {
      * @param ctx - context providing Agents, Sessions, and teardown ownership.
      * @param observeActivation - build the lifecycle observer for one residency epoch.
      */
-    constructor(ctx, observeActivation) {
+    constructor(ctx, observeActivation, maxActiveSubagents) {
         this.ctx = ctx;
         this.observeActivation = observeActivation;
+        this.maxActiveSubagents = maxActiveSubagents;
         // 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
@@ -305,14 +323,20 @@ export class ContinuableActivationRegistry {
      */
     materialize(inputs) {
         this.assertAdmitting(inputs.parent);
-        const settled = Promise.withResolvers();
+        inputs.signal.throwIfAborted();
         const lineage = this.liveLineage(inputs.parent);
+        const pool = this.resident.get(inputs.parent.id)?.pool ?? this.rootPool(inputs.parent);
+        const releaseSlot = pool.reserve(this.maxActiveSubagents());
+        const settled = Promise.withResolvers();
         const materialization = {
             lineage,
             settled: settled.promise,
         };
         this.materializations.add(materialization);
-        return this.materializeTracked(inputs, lineage).finally(() => {
+        return this.materializeTracked(inputs, lineage, pool, releaseSlot).catch((error) => {
+            releaseSlot();
+            throw error;
+        }).finally(() => {
             this.materializations.delete(materialization);
             settled.resolve();
         });
@@ -400,8 +424,17 @@ export class ContinuableActivationRegistry {
         }
         return undefined;
     }
+    /** Resolve a root's pool once; descendants inherit their resident parent's pool directly. */
+    rootPool(parent) {
+        let pool = this.rootPools.get(parent);
+        if (pool === undefined) {
+            pool = new ActivationPool();
+            this.rootPools.set(parent, pool);
+        }
+        return pool;
+    }
     /** Perform one tracked materialization through publication or rollback. */
-    async materializeTracked(inputs, parentLineage) {
+    async materializeTracked(inputs, parentLineage, pool, releaseSlot) {
         const { childId, provider, parent, create } = inputs;
         inputs.signal.throwIfAborted();
         const setup = (childCtx, child) => {
@@ -433,6 +466,8 @@ export class ContinuableActivationRegistry {
                 setup,
             });
         const activation = {
+            pool,
+            releaseSlot,
             childId,
             parentSession: parent.id,
             provider,
@@ -471,6 +506,7 @@ export class ContinuableActivationRegistry {
             }
             finally {
                 this.resident.delete(activation.childId);
+                activation.releaseSlot();
                 this.releaseOwnership(activation.childId);
             }
         });
@@ -622,6 +658,7 @@ export class ContinuableActivationRegistry {
                 + failures.map(item => errorChain(item)).join('; '), 'ACTIVATION_TEARDOWN_FAILED', { cause: new AggregateError(failures) });
         }
         this.resident.delete(childId);
+        activation.releaseSlot();
         this.notifySettlement(activation, activation.observer.terminal(failure));
         this.releaseOwnership(childId);
         activation.observer.settle(failure);

package/vendor/subagent-core/types/continuation-messages.d.ts

@@ -53,7 +53,7 @@ export declare function createAgentMessage(sender: Agent, content: ContentBlock[
  */
 export declare function withContinuableReturnGuidance(parentId: SessionId, prompt: ContentBlock[]): ContentBlock[];
 /**
- * Build the runtime-owned settlement notice delivered to a child's parent.
+ * Build the runtime-owned settlement notice from the child's nonempty closing text.
  * @param childId - durable child session id named in the notice.
  * @param terminal - recorded terminal state for the settled Activation.
  * @returns the durable user-message representation delivered to the parent.

package/vendor/subagent-core/types/continuation-messages.js

@@ -77,19 +77,23 @@ function settlementSummary(childId, stopReason) {
     }
 }
 /**
- * Build the runtime-owned settlement notice delivered to a child's parent.
+ * Build the runtime-owned settlement notice from the child's nonempty closing text.
  * @param childId - durable child session id named in the notice.
  * @param terminal - recorded terminal state for the settled Activation.
  * @returns the durable user-message representation delivered to the parent.
  */
 export function createSettlementMessage(childId, terminal) {
     const summary = settlementSummary(childId, terminal.stopReason);
+    // Parent providers receive this notice as a user message and may reject
+    // nontext assistant blocks. Keep this conversion local so SDK/UI consumers
+    // retain the complete child output.
+    const closingText = (terminal.output ?? []).flatMap(block => block.type === 'text' && block.text.length > 0 ? [block] : []);
     return createUserMessage({
         content: [
             { type: 'text', text: summary },
-            ...terminal.output === undefined
+            ...closingText.length === 0
                 ? [{ type: 'text', text: 'It left no closing message.' }]
-                : [{ type: 'text', text: 'Its closing message:' }, ...terminal.output],
+                : [{ type: 'text', text: 'Its closing message:' }, ...closingText],
         ],
         source: {
             kind: 'subagent-settled',

package/vendor/subagent-core/types/continuation.d.ts

@@ -35,7 +35,7 @@ export declare class SubagentContinuationManager {
     private readonly ctx;
     private readonly host;
     private readonly activations;
-    constructor(ctx: Context, host: ContinuationHost);
+    constructor(ctx: Context, host: ContinuationHost, maxActiveSubagents: () => number);
     /**
      * Start one continuable background child and resolve at initial inbox acceptance.
      * Every earlier failure disposes any created handle and rolls back Activation

package/vendor/subagent-core/types/continuation.js

@@ -86,10 +86,10 @@ export class SubagentContinuationManager {
     ctx;
     host;
     activations;
-    constructor(ctx, host) {
+    constructor(ctx, host, maxActiveSubagents) {
         this.ctx = ctx;
         this.host = host;
-        this.activations = new ContinuableActivationRegistry(ctx, (provider, childId, parent) => host.observeActivation(provider, childId, parent));
+        this.activations = new ContinuableActivationRegistry(ctx, (provider, childId, parent) => host.observeActivation(provider, childId, parent), maxActiveSubagents);
     }
     /**
      * Start one continuable background child and resolve at initial inbox acceptance.

package/vendor/subagent-core/types/control-types.d.ts

@@ -1,7 +1,6 @@
 /**
- * Client-safe subagent catalog and control vocabulary: the durable direct-child
- * row both the listing and the browser catalog answer with, plus the
- * browser-facing control surface's prompt, receipts, and failures.
+ * Client-safe complete-descendant rows and browser continuation requests,
+ * receipts, and failures.
  *
  * @module @deepseek-ai/dsh-subagent/control-types
  */
@@ -17,42 +16,35 @@ import type { SessionId } from '@deepseek-ai/dsh-session/types';
  * rather than imported.
  */
 export type SubagentPromptRequestId = Branded<'session-request-id'>;
-/**
- * One durable direct-child row, ordered by header `createdAt` with ties broken
- * on id. Only a candidate whose durable header has `origin: 'subagent'` is
- * interpreted. A served `subagent` projection value produces a `child`; a
- * settled candidate whose fold served no identity produces a `diagnostic`; a
- * running candidate without one is omitted — its descriptor may not be
- * appended yet (the creation window). Diagnostics relay the projection fold's
- * outcome or a failed read, never a per-child event scan, and never expose
- * model-hidden descriptor content.
- */
-export type SubagentListEntry = {
-    readonly kind: 'child';
+/** Shared child fields for complete-descendant listing. */
+export type SubagentCatalogRow = {
     /** The durable child session id, stable across Activations. */
     readonly id: SessionId;
     /**
-     * Whether the child is live at the moment its reader sampled it: the
-     * durable listing reads the Session store (`running` means the logical
-     * record is resident, `inactive` that it exists only in persistence),
-     * while the browser catalog re-samples the child's Agent driver. Neither
-     * encodes a durable outcome, and a continuable child may still reject
-     * delivery as an ownership conflict.
+     * Whether complete-descendant listing observed a resident Session. This
+     * does not encode a durable outcome or guarantee continuation delivery.
      */
     readonly activity: 'running' | 'inactive';
-    /** Whether a direct descendant has durable `origin: 'subagent'`. */
-    readonly hasChildren: boolean;
 } & ({
     /** A terminal one-shot child. */
     readonly mode: 'one-shot';
-    /** Optional durable creation label from the child's descriptor. */
+    /** Optional durable creation label from the owning catalog or child descriptor. */
     readonly label?: string;
 } | {
     /** A resumable conversation. */
     readonly mode: 'continuable';
-    /** Durable creation label from the child's descriptor. */
+    /** Durable creation label from the owning catalog or child descriptor. */
     readonly label: string;
-}) | {
+});
+/**
+ * One complete-descendant row. Enumeration may also return diagnostics for
+ * child identity observations from the complete Session corpus.
+ */
+export type SubagentListEntry = SubagentCatalogRow & {
+    readonly kind: 'child';
+    /** Whether complete-corpus enumeration observed a direct child. */
+    readonly hasChildren: boolean;
+} | {
     readonly kind: 'diagnostic';
     /** The candidate's session id. */
     readonly id: SessionId;
@@ -68,12 +60,7 @@ export type SubagentListEntry = {
      */
     readonly reason: 'corrupt' | 'unsupported' | 'unavailable';
 };
-/** Complete direct-child catalog plus the delivery-time parent availability hint. */
-export interface SubagentCatalog {
-    readonly entries: readonly SubagentListEntry[];
-    readonly parentAvailable: boolean;
-}
-/** Durable parent/child address that selects subagent transport in the client. */
+/** Durable parent/child browsing address; unknown mode is resolved when child history is read. */
 export type SubagentAddress = {
     readonly parentSessionId: SessionId;
     readonly childSessionId: SessionId;
@@ -81,6 +68,8 @@ export type SubagentAddress = {
     readonly mode: 'one-shot';
 } | {
     readonly mode: 'continuable';
+} | {
+    readonly mode: 'unknown';
 });
 /** One human message addressed to a continuable direct child. */
 export interface SubagentPromptRequest {
@@ -110,9 +99,15 @@ export interface SubagentInterruptReceipt {
     readonly accepted: true;
 }
 /**
- * Failure details the control surface answers with. Catalog reads, prompts,
- * and interrupts share this vocabulary with the Client Remote result.
+ * Failure details the control surface answers with. Prompts and interrupts
+ * share these failures with the Client Remote result.
  */
+declare module '@deepseek-ai/dsh-workspace/types' {
+    interface SessionActivityKindMap {
+        /** A subagent session delegated from this session (at any depth) is inside a turn. */
+        subagent: true;
+    }
+}
 declare module '@deepseek-ai/dsh-typert-protocol' {
     interface RemoteErrorDetailsMap {
         /** A browser-supplied zone is neither UTC nor a canonical IANA name. */
@@ -139,8 +134,6 @@ declare module '@deepseek-ai/dsh-typert-protocol' {
         'subagent/delivery-unavailable': {
             readonly childSessionId: SessionId;
         };
-        /** The deployment mounts no session-projection registry. */
-        'subagent/projections-unavailable': {};
     }
 }
 //# sourceMappingURL=control-types.d.ts.map

package/vendor/subagent-core/types/control-types.js

@@ -1,7 +1,6 @@
 /**
- * Client-safe subagent catalog and control vocabulary: the durable direct-child
- * row both the listing and the browser catalog answer with, plus the
- * browser-facing control surface's prompt, receipts, and failures.
+ * Client-safe complete-descendant rows and browser continuation requests,
+ * receipts, and failures.
  *
  * @module @deepseek-ai/dsh-subagent/control-types
  */

package/vendor/subagent-core/types/control.d.ts

@@ -1,18 +1,12 @@
 /**
- * Browser-facing subagent control assembly: the catalog view sampled against
- * the live Agent registry, one browser zone's validation, and the stable
- * failure codes the Remote surface answers with.
+ * Browser-facing subagent prompt and interrupt request validation plus the
+ * stable prompt failure codes returned by the Remote surface.
  *
  * @module @deepseek-ai/dsh-subagent
  */
-import type { Context } from '@deepseek-ai/cordis';
 import type { SessionId } from '@deepseek-ai/dsh-session';
 import { z } from 'zod';
-import type { SubagentCatalog, SubagentListEntry } from './control-types.ts';
 declare const CONTROL_ID_SCHEMAS: {
-    readonly 'subagent.list': z.ZodObject<{
-        parentSessionId: z.ZodString;
-    }, z.core.$strip>;
     readonly 'subagent.prompt': z.ZodObject<{
         parentSessionId: z.ZodString;
         childSessionId: z.ZodString;
@@ -36,26 +30,6 @@ declare const CONTROL_ID_SCHEMAS: {
  * @throws {RemoteError} `gateway/bad-request` with the original Zod issues.
  */
 export declare function validateControlRequest(method: keyof typeof CONTROL_ID_SCHEMAS, payload: unknown): void;
-/**
- * Project one durable listing onto the catalog view, replacing each row's
- * store-derived activity with the live Agent driver's status and reporting
- * whether the exact parent Agent is live. Without an Agent registry no driver
- * runs at all, so every row is inactive and the parent is unavailable.
- * @param ctx - Host context that may carry the Agent registry.
- * @param parentSessionId - the listed parent.
- * @param entries - the durable direct-child listing.
- * @returns the catalog view answered to one browser.
- */
-export declare function catalogView(ctx: Context, parentSessionId: SessionId, entries: readonly SubagentListEntry[]): SubagentCatalog;
-/**
- * Refuse one catalog read while preserving cancellation and a missing
- * projections registry as distinct failures.
- * @param error - the thrown value.
- * @param signal - the caller's cancellation.
- * @returns Never — the refusal is thrown.
- * @throws {RemoteError} always.
- */
-export declare function rejectCatalogRead(error: unknown, signal: AbortSignal): never;
 /**
  * Refuse one continuation prompt without exposing provider detail: admission
  * failures the caller can act on keep their own code, everything else is

package/vendor/subagent-core/types/control.js

@@ -1,7 +1,6 @@
 /**
- * Browser-facing subagent control assembly: the catalog view sampled against
- * the live Agent registry, one browser zone's validation, and the stable
- * failure codes the Remote surface answers with.
+ * Browser-facing subagent prompt and interrupt request validation plus the
+ * stable prompt failure codes returned by the Remote surface.
  *
  * @module @deepseek-ai/dsh-subagent
  */
@@ -11,7 +10,6 @@ import { z } from 'zod';
 import { SubagentError } from "./error.js";
 const SESSION_ID_SCHEMA = z.string().min(1);
 const CONTROL_ID_SCHEMAS = {
-    'subagent.list': z.object({ parentSessionId: SESSION_ID_SCHEMA }),
     'subagent.prompt': z.object({
         parentSessionId: SESSION_ID_SCHEMA,
         childSessionId: SESSION_ID_SCHEMA,
@@ -37,42 +35,6 @@ export function validateControlRequest(method, payload) {
         throw new RemoteError('gateway/bad-request', `invalid payload for ${method}`, { issues: parsed.error.issues });
     }
 }
-/**
- * Project one durable listing onto the catalog view, replacing each row's
- * store-derived activity with the live Agent driver's status and reporting
- * whether the exact parent Agent is live. Without an Agent registry no driver
- * runs at all, so every row is inactive and the parent is unavailable.
- * @param ctx - Host context that may carry the Agent registry.
- * @param parentSessionId - the listed parent.
- * @param entries - the durable direct-child listing.
- * @returns the catalog view answered to one browser.
- */
-export function catalogView(ctx, parentSessionId, entries) {
-    const agents = ctx.get('agents');
-    return {
-        entries: entries.map((entry) => entry.kind === 'child'
-            ? { ...entry, activity: agents?.get(entry.id)?.status === 'running' ? 'running' : 'inactive' }
-            : entry),
-        parentAvailable: agents?.get(parentSessionId) !== undefined,
-    };
-}
-/**
- * Refuse one catalog read while preserving cancellation and a missing
- * projections registry as distinct failures.
- * @param error - the thrown value.
- * @param signal - the caller's cancellation.
- * @returns Never — the refusal is thrown.
- * @throws {RemoteError} always.
- */
-export function rejectCatalogRead(error, signal) {
-    if (isCancellation(error, signal)) {
-        throw new RemoteError('gateway/cancelled', 'subagent catalog read was cancelled', {}, { cause: error });
-    }
-    if (error instanceof SubagentError && error.code === 'SUBAGENT_CONTROL_PROJECTIONS_UNAVAILABLE') {
-        throw new RemoteError('subagent/projections-unavailable', 'subagent catalog is unavailable: this deployment does not mount the sessionProjections registry (load @deepseek-ai/dsh-session-projection)', {}, { cause: error });
-    }
-    throw new RemoteError('gateway/internal', 'subagent catalog read failed', {}, { cause: error });
-}
 /**
  * Refuse one continuation prompt without exposing provider detail: admission
  * failures the caller can act on keep their own code, everything else is
@@ -100,6 +62,7 @@ export function rejectPrompt(error, childSessionId, signal) {
                 throw new RemoteError('subagent/unauthorized', 'subagent does not belong to this parent', { childSessionId }, { cause: error });
             case 'DRAINING':
             case 'ACTIVATION_CLOSING':
+            case 'ACTIVATION_LIMIT_REACHED':
             case 'CONTINUATION_UNAVAILABLE':
             case 'PERSISTENCE_UNAVAILABLE':
                 throw new RemoteError('subagent/delivery-unavailable', 'subagent follow-up is temporarily unavailable', { childSessionId }, { cause: error });

package/vendor/subagent-core/types/index.d.ts

@@ -17,9 +17,9 @@
  * 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
- * discovery read the live session store and optional session persistence
- * directly and do not require that continuation runtime.
+ * creation spec and see no handle, turn, or teardown. Direct-child
+ * discovery uses the parent catalog; descendant discovery uses the Session
+ * corpus. Neither read requires the continuation runtime.
  *
  * Same-process providers are trusted typed collaborators. Requests, provider
  * descriptors, results, and lifecycle payloads are borrowed immutable values;
@@ -28,15 +28,18 @@
  *
  * @module @deepseek-ai/dsh-subagent
  */
+import type { Volatile } from '@deepseek-ai/cordis';
 import { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
 import type { Scoped } from '@deepseek-ai/dsh-scope';
 import type { ContentBlock, MessageId } from '@deepseek-ai/dsh-llm';
 import type { Agent } from '@deepseek-ai/dsh-agent';
 import type { SessionId } from '@deepseek-ai/dsh-session';
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
-import type { SubagentCatalog, SubagentInterruptReceipt, SubagentPromptReceipt, SubagentPromptRequest } from './control-types.ts';
+import type { SubagentInterruptReceipt, SubagentPromptReceipt, SubagentPromptRequest } from './control-types.ts';
 import type { ContinuableStart, ContinuableStartSpec, SubagentInterruptAuthority, SubagentProvider, SubagentRun, SubagentRunEndInfo, SubagentRunInfo, SubagentSendMessageOptions, SubagentStartRequest } from './types.ts';
-import type { SubagentDescendantListEntry, SubagentListEntry } from './list-children.ts';
+import type { SubagentDescendantListEntry } from './list-children.ts';
+import type { SubagentCatalogEntry } from './projection-types.ts';
 import { deliverSubagentPrompt } from './internal.ts';
 export type {} from './catalog.ts';
 export * from './out-of-process.ts';
@@ -45,6 +48,7 @@ export { SubagentRunId } from './types.ts';
 export type { ContinuableCreateRequest, ContinuableCreateSpec, ContinuableStart, ContinuableStartSpec, ResolvedSubagentStartRequest, SubagentCapabilities, SubagentInterruptAuthority, SubagentProvider, SubagentResult, SubagentRun, SubagentSendMessageOptions, SubagentStartRequest, SubagentStopReason, SubagentStopReasonMap, } from './types.ts';
 export { foldSubagentDescriptor, snapshotSubagentDescriptor, SUBAGENT_DESCRIPTOR_VERSION, } from './descriptor.ts';
 export type { ContinuableSubagentDescriptorData, ContinuableSubagentDescriptorInput, OneShotSubagentDescriptorData, OneShotSubagentDescriptorInput, SubagentDescriptorData, SubagentDescriptorInput, } from './descriptor.ts';
+export type { SubagentCatalogEntry } from './projection-types.ts';
 export { SubagentError } from './error.ts';
 export { settleRun } from './run-settlement.ts';
 export { assertSubagentMaxDepth, delegationDepthOf } from './depth.ts';
@@ -94,8 +98,23 @@ declare module '@deepseek-ai/cordis' {
         'subagent/end'(this: Scoped<SubagentRuntime>, info: SubagentRunEndInfo): void;
     }
 }
+/** Host configuration for continuable subagent capacity. */
+export interface Config {
+    /** Maximum live children sharing uninterrupted continuable parent links; defaults to 8. */
+    maxActiveSubagents: Volatile<number>;
+    /** Default delegation depth for tools without an explicit limit; defaults to 1. */
+    maxDepth: Volatile<number>;
+}
 /** Named provider registry with one-shot runs, durable discovery, and continuable-child operations. */
 export declare class SubagentRuntime extends TypertRemoteService {
+    private config;
+    static Config: z<Schemastery.ObjectS<NoInfer<{
+        maxDepth: z<number, number, "volatile-defined">;
+        maxActiveSubagents: z<number, number, "volatile-defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        maxDepth: z<number, number, "volatile-defined">;
+        maxActiveSubagents: z<number, number, "volatile-defined">;
+    }>>, "plain">;
     private providers;
     private continuations;
     /**
@@ -104,7 +123,13 @@ export declare class SubagentRuntime extends TypertRemoteService {
      * composes into the carrier.
      */
     private readonly emitLifecycle;
-    constructor(ctx: Context);
+    constructor(ctx: Context, config: Config);
+    /**
+     * 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?: number | 'provider-managed'): number | undefined;
     /**
      * Establish one durable continuable child and deliver its initial prompt.
      * Resolves when the child's inbox accepts that prompt, without waiting for the
@@ -132,12 +157,12 @@ export declare class SubagentRuntime extends TypertRemoteService {
     sendMessage(sender: Agent, targetId: SessionId, content: ContentBlock[], options: SubagentSendMessageOptions): Promise<MessageId>;
     /**
      * Deliver one host-protocol message to a direct continuable child.
-     * Symbol-keyed so host adapters can preserve their own provenance without
+     * 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 provenance.
+     * @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.
@@ -182,53 +207,31 @@ export declare class SubagentRuntime extends TypertRemoteService {
      */
     drainContinuableChildren(parent: Agent, childIds: readonly SessionId[]): Promise<void>;
     /**
-     * Enumerate the parent's direct session-backed subagents without loading or
-     * resuming an Agent. The Session query service supplies one live-preferred
-     * corpus and shared point observations; the projection cache supplies
-     * immutable descriptor hits without opening cold logs. The registered
-     * `subagent` projection remains the sole mode/label classifier.
-     *
-     * Every query receives `signal`, and the listing rechecks cancellation
-     * around each await. Read rejections that settle
-     * after an abort become a stable `SubagentError` with code `CANCELLED`.
-     * @param parentSessionId - parent session whose direct children are listed.
-     * @param signal - caller-owned cancellation forwarded to Session queries
-     *   and observed around every read await.
-     * @returns children and per-child diagnostics ordered by `createdAt`, then id.
-     * @throws {@link SubagentError} when the projection registry or the session
-     *   store is not mounted, or the caller cancels the listing.
+     * 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: SessionId, signal?: AbortSignal): Promise<SubagentListEntry[]>;
+    listChildren(parentSessionId: SessionId, signal?: AbortSignal): Promise<SubagentCatalogEntry[]>;
     /**
      * Enumerate the root's complete session-backed subagent tree in stable
      * pre-order from one live-preferred corpus, without loading or resuming an
      * Agent. Ordinary sessions and one-shot children remain traversal nodes so
      * continuable descendants below them are discovered; each returned entry
      * adds its durable `parentId` and root-relative `depth`. Identity resolution,
-     * diagnostics, optional persistence, and cancellation follow the same
-     * projection-backed contract as {@link listChildren}.
+     * diagnostics, optional persistence, and cancellation use the registered
+     * child identity projection and complete Session corpus.
      * @param rootSessionId - session whose complete descendant tree is listed.
      * @param signal - caller-owned cancellation forwarded to persistence reads
      *   and observed around every read await.
      * @returns children and per-candidate diagnostics with tree position, in
      *   stable pre-order.
-     * @throws {@link SubagentError} under the same conditions as {@link listChildren}.
+     * @throws {@link SubagentError} when listing dependencies are unavailable or the caller cancels.
      */
     listDescendants(rootSessionId: SessionId, signal?: AbortSignal): Promise<SubagentDescendantListEntry[]>;
-    /**
-     * Remote face of {@link listChildren} for one browser: the durable listing
-     * plus live Agent activity and the delivery-time parent availability hint.
-     * Parent availability is a hint; {@link prompt} performs the authoritative
-     * check. Named apart from the provider-name {@link list}, which owns the
-     * member.
-     * @param parentSessionId - parent session whose direct children are listed.
-     * @param signal - carrier cancellation forwarded to Session queries.
-     * @returns the catalog view for that parent.
-     * @throws {RemoteError} `gateway/bad-request` for an empty parent id,
-     *   `gateway/cancelled` for an aborted read, `subagent/projections-unavailable` when
-     *   the deployment has no projection registry, otherwise `gateway/internal`.
-     */
-    remoteExportList(parentSessionId: SessionId, signal: AbortSignal): Promise<SubagentCatalog>;
     /**
      * Deliver one browser-authored message to a continuable child through the
      * exact live direct parent, retaining the caller-minted request identity and
@@ -238,6 +241,7 @@ export declare class SubagentRuntime extends TypertRemoteService {
      * 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.