@deepseek-ai/dsh-subagent 0.1.1-rc.2 → 0.1.2-alpha.2

package/lib/types/control-types.d.ts

@@ -0,0 +1,160 @@
+/**
+ * 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.
+ *
+ * @module @deepseek-ai/dsh-subagent/control-types
+ */
+import type { EncodedImageAttachment } from '@deepseek-ai/dsh-attachment/types';
+import type { Branded } from '@deepseek-ai/dsh-brand';
+import type { MessageId } from '@deepseek-ai/dsh-llm/brand';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm/types';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+/**
+ * Client-minted identity of one browser prompt, persisted on the exact accepted
+ * message. It carries the Session Controller's `session-request-id` brand so a
+ * subagent prompt and an ordinary Session prompt share one identity
+ * vocabulary; that package depends on this one, so the brand is spelled here
+ * 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';
+    /** 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.
+     */
+    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. */
+    readonly label?: string;
+} | {
+    /** A resumable conversation. */
+    readonly mode: 'continuable';
+    /** Durable creation label from the child's descriptor. */
+    readonly label: string;
+}) | {
+    readonly kind: 'diagnostic';
+    /** The candidate's session id. */
+    readonly id: SessionId;
+    /**
+     * Why the candidate has no `child` row: `corrupt` for a settled candidate
+     * whose projection fold served no identity (a missing, malformed, or
+     * unrecognized-version descriptor — deliberately undistinguished), and
+     * for any candidate whose log makes a registered unit's fold or schema
+     * throw (deterministic data damage, contained per child); `unavailable`
+     * when the candidate's Session observation was absent or transiently
+     * unreadable (retried on the next listing). `unsupported` is never produced; it remains in the
+     * union for consumers that route on it.
+     */
+    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. */
+export type SubagentAddress = {
+    readonly parentSessionId: SessionId;
+    readonly childSessionId: SessionId;
+} & ({
+    readonly mode: 'one-shot';
+} | {
+    readonly mode: 'continuable';
+});
+/**
+ * One browser-encoded upload as the Session prompt wire carries it: the shared
+ * attachment vocabulary under the content-block tag.
+ */
+export interface EncodedImagePromptBlock extends EncodedImageAttachment {
+    readonly type: 'image';
+}
+/**
+ * One block a browser prompt may carry. The encoded upload is accepted by the
+ * wire and refused by the Host, so the Client narrows nothing: a caller that
+ * attaches an image is answered, not silently stripped.
+ */
+export type SubagentPromptContentPart = ContentBlock | EncodedImagePromptBlock;
+/** One human message addressed to a continuable direct child. */
+export interface SubagentPromptRequest {
+    /** Identity persisted on the accepted message, minted before the call. */
+    readonly requestId: SubagentPromptRequestId;
+    readonly parentSessionId: SessionId;
+    readonly childSessionId: SessionId;
+    /** Required discriminator retained from the browser control address. */
+    readonly mode: 'continuable';
+    /** Content proposed as the child's user message; images are refused. */
+    readonly content: readonly SubagentPromptContentPart[];
+    /** Optional browser zone sampled for this exact human prompt. */
+    readonly clientTimeZone?: string;
+}
+/** Inbox identity returned once the continuation accepts one human message. */
+export interface SubagentPromptReceipt {
+    readonly messageId: MessageId;
+}
+/** Uniform acknowledgement that one interrupt request was admitted. */
+export interface SubagentInterruptReceipt {
+    readonly accepted: true;
+}
+/**
+ * Failure details the control surface answers with. The catalog read, the
+ * prompt, and the interrupt produce these codes; a Client fabricates
+ * `subagent/not-resumable` and `subagent/delivery-unavailable` for a one-shot
+ * address it refuses before the call, so both planes read one vocabulary.
+ */
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface RemoteErrorDetailsMap {
+        /** A browser-supplied zone is neither UTC nor a canonical IANA name. */
+        'subagent/invalid-time-zone': {
+            readonly value: string;
+        };
+        /** No live Agent carries the addressed parent session. */
+        'subagent/parent-unavailable': {
+            readonly parentSessionId: SessionId;
+        };
+        /** The addressed child cannot take a continuation. */
+        'subagent/not-resumable': {
+            readonly childSessionId: SessionId;
+        };
+        /** The claimed parent does not own the addressed child. */
+        'subagent/unauthorized': {
+            readonly childSessionId: SessionId;
+        };
+        /**
+         * The continuation admits no attachment. `reason` names the refused plane
+         * for the caller's copy, as the Session prompt's attachment refusals do.
+         */
+        'subagent/attachment-unsupported': {
+            readonly childSessionId: SessionId;
+            readonly reason: string;
+        };
+        /** The child exists but its inbox cannot admit the message now. */
+        'subagent/delivery-unavailable': {
+            readonly childSessionId: SessionId;
+        };
+        /** The deployment mounts no session-projection registry. */
+        'subagent/projections-unavailable': {};
+    }
+}
+//# sourceMappingURL=control-types.d.ts.map

package/lib/types/control-types.js

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ *
+ * @module @deepseek-ai/dsh-subagent/control-types
+ */
+export {};
+//# sourceMappingURL=control-types.js.map

package/lib/types/control.d.ts

@@ -0,0 +1,83 @@
+/**
+ * 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.
+ *
+ * @module @deepseek-ai/dsh-subagent
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+import { z } from 'zod';
+import type { SubagentCatalog, SubagentListEntry, SubagentPromptContentPart } 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;
+        mode: z.ZodLiteral<"continuable">;
+    }, z.core.$strip>;
+    readonly 'subagent.interrupt': z.ZodObject<{
+        parentSessionId: z.ZodString;
+        childSessionId: z.ZodString;
+        mode: z.ZodLiteral<"continuable">;
+    }, z.core.$strip>;
+};
+/**
+ * Apply the subagent payload checks that are stricter than generated
+ * branded-string codecs.
+ * @param method - method name carried in the failure message.
+ * @param payload - decoded control fields to validate.
+ * @throws {RemoteError} `gateway/bad-request` with the original Zod issues.
+ */
+export declare function validateControlRequest(method: keyof typeof CONTROL_ID_SCHEMAS, payload: unknown): void;
+/**
+ * Admit the content one continuation may deliver, refusing every image.
+ *
+ * The blocks become the child's user message verbatim, and this surface admits
+ * no attachment: nothing here registers encoded bytes with the attachment
+ * service, so an image would reach the child as a reference nothing resolves.
+ * The wire accepts the encoded upload so this refusal — not a Client that
+ * strips the block — is what the caller is answered with. Other block types
+ * still cross unnarrowed.
+ * @param childSessionId - the addressed child, named by the refusal.
+ * @param content - blocks the caller asked to deliver.
+ * @returns the admitted blocks, in order, as the durable content vocabulary.
+ * @throws {RemoteError} `subagent/attachment-unsupported` when any block is an image.
+ */
+export declare function admitPromptContent(childSessionId: SessionId, content: readonly SubagentPromptContentPart[]): ContentBlock[];
+/**
+ * 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
+ * internal.
+ * @param error - the thrown value.
+ * @param childSessionId - the addressed child.
+ * @param signal - the caller's cancellation.
+ * @returns Never — the refusal is thrown.
+ * @throws {RemoteError} always.
+ */
+export declare function rejectPrompt(error: unknown, childSessionId: SessionId, signal: AbortSignal): never;
+export {};
+//# sourceMappingURL=control.d.ts.map

package/lib/types/control.js

@@ -0,0 +1,133 @@
+/**
+ * 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.
+ *
+ * @module @deepseek-ai/dsh-subagent
+ */
+import { RemoteError } from '@deepseek-ai/dsh-typert-protocol';
+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,
+        mode: z.literal('continuable'),
+    }),
+    'subagent.interrupt': z.object({
+        parentSessionId: SESSION_ID_SCHEMA,
+        childSessionId: SESSION_ID_SCHEMA,
+        mode: z.literal('continuable'),
+    }),
+};
+/**
+ * Apply the subagent payload checks that are stricter than generated
+ * branded-string codecs.
+ * @param method - method name carried in the failure message.
+ * @param payload - decoded control fields to validate.
+ * @throws {RemoteError} `gateway/bad-request` with the original Zod issues.
+ */
+export function validateControlRequest(method, payload) {
+    const parsed = CONTROL_ID_SCHEMAS[method].safeParse(payload);
+    if (!parsed.success) {
+        throw new RemoteError('gateway/bad-request', `invalid payload for ${method}`, { issues: parsed.error.issues });
+    }
+}
+/**
+ * Admit the content one continuation may deliver, refusing every image.
+ *
+ * The blocks become the child's user message verbatim, and this surface admits
+ * no attachment: nothing here registers encoded bytes with the attachment
+ * service, so an image would reach the child as a reference nothing resolves.
+ * The wire accepts the encoded upload so this refusal — not a Client that
+ * strips the block — is what the caller is answered with. Other block types
+ * still cross unnarrowed.
+ * @param childSessionId - the addressed child, named by the refusal.
+ * @param content - blocks the caller asked to deliver.
+ * @returns the admitted blocks, in order, as the durable content vocabulary.
+ * @throws {RemoteError} `subagent/attachment-unsupported` when any block is an image.
+ */
+export function admitPromptContent(childSessionId, content) {
+    const admitted = [];
+    for (const block of content) {
+        if (block.type === 'image') {
+            throw new RemoteError('subagent/attachment-unsupported', 'subagent continuation does not accept images', { childSessionId, reason: 'SUBAGENT_IMAGE_UNSUPPORTED' });
+        }
+        admitted.push(block);
+    }
+    return admitted;
+}
+/**
+ * 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
+ * internal.
+ * @param error - the thrown value.
+ * @param childSessionId - the addressed child.
+ * @param signal - the caller's cancellation.
+ * @returns Never — the refusal is thrown.
+ * @throws {RemoteError} always.
+ */
+export function rejectPrompt(error, childSessionId, signal) {
+    if (isCancellation(error, signal)) {
+        throw new RemoteError('gateway/cancelled', 'subagent prompt was cancelled', {}, { cause: error });
+    }
+    if (error instanceof SubagentError) {
+        switch (error.code) {
+            case 'NOT_RESUMABLE':
+                throw new RemoteError('subagent/not-resumable', 'subagent cannot be resumed', { childSessionId }, { cause: error });
+            case 'UNAUTHORIZED':
+                throw new RemoteError('subagent/unauthorized', 'subagent does not belong to this parent', { childSessionId }, { cause: error });
+            case 'DRAINING':
+            case 'ACTIVATION_CLOSING':
+            case 'CONTINUATION_UNAVAILABLE':
+            case 'PERSISTENCE_UNAVAILABLE':
+                throw new RemoteError('subagent/delivery-unavailable', 'subagent follow-up is temporarily unavailable', { childSessionId }, { cause: error });
+            // A code outside the admission vocabulary is not the caller's move to make.
+            default:
+                break;
+        }
+    }
+    throw new RemoteError('gateway/internal', 'subagent prompt failed', {}, { cause: error });
+}
+function isCancellation(error, signal) {
+    return signal.aborted || (error instanceof SubagentError && error.code === 'CANCELLED');
+}
+//# sourceMappingURL=control.js.map

package/lib/types/descriptor.d.ts

@@ -21,6 +21,7 @@
  * @module @deepseek-ai/dsh-subagent/descriptor
  */
 import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import type { ToolRestriction } from '@deepseek-ai/dsh-tools';
 declare module '@deepseek-ai/dsh-session/types' {
     interface SessionEventMap {
@@ -40,7 +41,7 @@ declare module '@deepseek-ai/dsh-session/types' {
  * Supporting another composition input is a deliberate version change, never
  * an implicit extra field.
  */
-export declare const SUBAGENT_DESCRIPTOR_VERSION = 2;
+export declare const SUBAGENT_DESCRIPTOR_VERSION = 3;
 /** Fields shared by every supported `subagent/descriptor` payload. */
 interface SubagentDescriptorBase {
     /** Descriptor format version ({@link SUBAGENT_DESCRIPTOR_VERSION}). */
@@ -69,6 +70,8 @@ export interface ContinuableSubagentDescriptorData extends SubagentDescriptorBas
     readonly agentProvider?: string;
     /** Resolved child `agentOptions.model`, when one was declared. */
     readonly agentModel?: string;
+    /** Resolved child `agentOptions.reasoningEffort`, when one was declared. */
+    readonly agentReasoningEffort?: ReasoningEffortId;
     /** Per-child persona that shadows the deployment persona on resume. */
     readonly persona?: string;
     /** Child tool scoping reapplied on resume. */
@@ -98,6 +101,8 @@ export interface ContinuableSubagentDescriptorInput extends SubagentDescriptorIn
     readonly agentProvider?: string;
     /** Requested child `agentOptions.model`. */
     readonly agentModel?: string;
+    /** Requested child `agentOptions.reasoningEffort`. */
+    readonly agentReasoningEffort?: ReasoningEffortId;
     /** Requested per-child persona. */
     readonly persona?: string;
     /** Requested child tool scoping. */

package/lib/types/descriptor.js

@@ -20,14 +20,14 @@
  *
  * @module @deepseek-ai/dsh-subagent/descriptor
  */
-import { snapshotJsonValue } from '@deepseek-ai/dsh-session';
+import { snapshotJsonValue } from '@deepseek-ai/dsh-util-values';
 /**
  * The current descriptor format version, stamped into every appended
  * `subagent/descriptor` event and required verbatim by {@link foldSubagentDescriptor}.
  * Supporting another composition input is a deliberate version change, never
  * an implicit extra field.
  */
-export const SUBAGENT_DESCRIPTOR_VERSION = 2;
+export const SUBAGENT_DESCRIPTOR_VERSION = 3;
 const DESCRIPTOR_BASE_KEYS = [
     'version',
     'mode',
@@ -39,6 +39,7 @@ const CONTINUABLE_DESCRIPTOR_KEYS = new Set([
     ...DESCRIPTOR_BASE_KEYS,
     'agentProvider',
     'agentModel',
+    'agentReasoningEffort',
     'persona',
     'toolFilter',
 ]);
@@ -129,6 +130,7 @@ function parseSubagentDescriptor(value) {
     }
     const agentProvider = optionalString(value, 'agentProvider');
     const agentModel = optionalString(value, 'agentModel');
+    const agentReasoningEffort = optionalString(value, 'agentReasoningEffort');
     const persona = optionalString(value, 'persona');
     const toolFilter = Object.hasOwn(value, 'toolFilter')
         ? parseToolFilter(value['toolFilter'])
@@ -140,6 +142,7 @@ function parseSubagentDescriptor(value) {
         label,
         ...agentProvider !== undefined ? { agentProvider } : {},
         ...agentModel !== undefined ? { agentModel } : {},
+        ...agentReasoningEffort !== undefined ? { agentReasoningEffort } : {},
         ...persona !== undefined ? { persona } : {},
         ...toolFilter !== undefined ? { toolFilter } : {},
     };
@@ -159,6 +162,7 @@ export function snapshotSubagentDescriptor(input) {
             label: input.label,
             ...input.agentProvider !== undefined ? { agentProvider: input.agentProvider } : {},
             ...input.agentModel !== undefined ? { agentModel: input.agentModel } : {},
+            ...input.agentReasoningEffort !== undefined ? { agentReasoningEffort: input.agentReasoningEffort } : {},
             ...input.persona !== undefined ? { persona: input.persona } : {},
             ...input.toolFilter !== undefined ? { toolFilter: input.toolFilter } : {},
         };

package/lib/types/index.d.ts

@@ -4,10 +4,8 @@
  * child before returning its run, so fulfillment is the single publication and
  * ownership-transfer boundary.
  *
- * Unlike the bash seam (one executor per context, second load throws), MULTIPLE
- * providers coexist here: each registers under a unique name and a caller picks
- * one by name. The shape mirrors the LLM adapter registry
- * (`LlmRuntime.registerAdapter`), not the single-service bash executor.
+ * Multiple providers coexist: each registers under a unique name and callers
+ * select one by name.
  *
  * This package owns the Service Definition role of the capability seam. Service Providers
  * (`@deepseek-ai/dsh-subagent-spawn-in-process`, `-fork`, `-acp`) and the model-facing
@@ -30,11 +28,13 @@
  *
  * @module @deepseek-ai/dsh-subagent
  */
-import { Context, Service } from '@deepseek-ai/cordis';
+import { Context } from '@deepseek-ai/cordis';
 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 { 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';
@@ -49,11 +49,12 @@ export { seedDescriptorTurn } from './descriptor-seed.ts';
 export { SubagentError } from './error.ts';
 export { settleRun } from './run-settlement.ts';
 export { assertSubagentMaxDepth, delegationDepthOf } from './depth.ts';
-export { appendDelegatedPolicyOverrides, applyChildComposition, captureDelegatedPolicyOverrides, childSessionMeta, resolveChildAgentOptions, resolveChildDepth, SubagentDepthError, } from './child-agent.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 { SubagentDescendantListEntry, SubagentListEntry } from './list-children.ts';
+export type * from './control-types.ts';
+export type { SubagentDescendantListEntry } from './list-children.ts';
 export type { SubagentRunEndInfo, SubagentRunInfo } from './types.ts';
 export type { SubagentIdentityProjection, SubagentTimingProjection } from './projection-types.ts';
 declare module '@deepseek-ai/cordis' {
@@ -96,7 +97,7 @@ declare module '@deepseek-ai/cordis' {
     }
 }
 /** Named provider registry with one-shot runs, durable discovery, and continuable-child operations. */
-export declare class SubagentRuntime extends Service {
+export declare class SubagentRuntime extends TypertRemoteService {
     private providers;
     private continuations;
     /** Deployment contributions composed into unpublished continuable children. */
@@ -195,27 +196,16 @@ export declare class SubagentRuntime extends Service {
     drainContinuableChildren(parent: Agent, childIds: readonly SessionId[]): Promise<void>;
     /**
      * Enumerate the parent's direct session-backed subagents without loading or
-     * resuming an Agent and without any query service: the listing merges the live
-     * session store with optional session persistence (live-preferred) and
-     * serves each child's durable mode/label from the registered `subagent`
-     * projection unit down a three-rung ladder — the registry's watermark
-     * snapshot for a live child; for a cold one, a durable projection-cache
-     * row when the optional cache serves an own-suffix identity (its `seq`
-     * gate proves the value postdates the fork seed, where a child's own
-     * descriptor is immutable once appended), else one persistence inspection
-     * folded through the registry. The
-     * projection fold is the single classification authority; per-child
-     * diagnostics relay a fold that served no identity or a failed inspection,
-     * never a list-time descriptor parse. Absent persistence, enumeration is
-     * live-only (a cold child cannot be resumed then either, so its absence is
-     * capability absence, not an error). This service consults no Agent
-     * registrations, Activations, or providers.
+     * 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 persistence read receives `signal`, and the listing rechecks
-     * cancellation around each of those awaits. Read rejections that settle
+     * 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 persistence reads
+     * @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
@@ -238,6 +228,50 @@ export declare class SubagentRuntime extends Service {
      * @throws {@link SubagentError} under the same conditions as {@link listChildren}.
      */
     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
+     * validated browser zone on the accepted message. Success identifies the
+     * message the child's FIFO inbox accepted; later execution is independent of
+     * this call.
+     * @param request - durable address, 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-unsupported`,
+     *   `subagent/invalid-time-zone`, `subagent/parent-unavailable`,
+     *   `subagent/not-resumable`, `subagent/unauthorized`,
+     *   `subagent/delivery-unavailable`, `gateway/cancelled`, or `gateway/internal`.
+     */
+    prompt(request: SubagentPromptRequest, signal: AbortSignal): Promise<SubagentPromptReceipt>;
+    /**
+     * 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: SessionId, parentSessionId: SessionId, mode: 'continuable'): SubagentInterruptReceipt;
     /**
      * 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