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

package/lib/typert.remote-client.d.ts

@@ -0,0 +1,27 @@
+/* Generated by @deepseek-ai/dsh-typert-generator from the Host FaceModel — do not edit. */
+import type {
+  RemoteResult,
+  TypertRemoteContribution,
+} from '@deepseek-ai/dsh-typert-protocol'
+import type { SessionId } from '@deepseek-ai/dsh-session/types'
+import type { SubagentCatalog, SubagentInterruptReceipt, SubagentPromptReceipt, SubagentPromptRequest } from '@deepseek-ai/dsh-subagent/client'
+
+declare module '@deepseek-ai/dsh-typert-protocol' {
+  interface TypertRemoteNamespace$7375626167656e7473 {
+    interruptByParent: (childSessionId: SessionId, parentSessionId: SessionId, mode: 'continuable') => Promise<RemoteResult<SubagentInterruptReceipt>>
+    list: (parentSessionId: SessionId, signal?: AbortSignal) => Promise<RemoteResult<SubagentCatalog>>
+    prompt: (request: SubagentPromptRequest, signal?: AbortSignal) => Promise<RemoteResult<SubagentPromptReceipt>>
+  }
+  interface TypertRemoteMap {
+    'subagents/interruptByParent': (childSessionId: SessionId, parentSessionId: SessionId, mode: 'continuable') => Promise<RemoteResult<SubagentInterruptReceipt>>
+    'subagents/list': (parentSessionId: SessionId, signal?: AbortSignal) => Promise<RemoteResult<SubagentCatalog>>
+    'subagents/prompt': (request: SubagentPromptRequest, signal?: AbortSignal) => Promise<RemoteResult<SubagentPromptReceipt>>
+  }
+  interface TypertRemoteNamespaceMap {
+    'subagents': TypertRemoteNamespace$7375626167656e7473
+  }
+}
+
+export declare const TYPERT_REMOTE: TypertRemoteContribution
+export default TYPERT_REMOTE
+//# sourceMappingURL=typert.remote-client.d.ts.map

package/lib/typert.remote-client.js

@@ -0,0 +1,242 @@
+/* Generated by @deepseek-ai/dsh-typert-generator from the Host FaceModel — do not edit. */
+import { z } from 'zod'
+
+const ToolResultBlockRemoteCodec$schema = z.object({
+  'type': z.literal("tool-result"),
+  'toolCallId': z.intersection(z.string(), z.unknown()),
+  'content': z.array(z.union([z.object({
+  'type': z.literal("text"),
+  'text': z.string(),
+}), z.object({
+  'type': z.literal("image"),
+  'attachment': z.object({
+  'attachmentId': z.intersection(z.string(), z.unknown()),
+  'mediaType': z.union([z.literal("image/png"), z.literal("image/jpeg"), z.literal("image/webp"), z.literal("image/gif")]),
+  'bytes': z.number(),
+  'width': z.number(),
+  'height': z.number(),
+  'name': z.string().optional(),
+  'originalDimensions': z.object({
+  'width': z.number(),
+  'height': z.number(),
+}).optional(),
+}),
+}), z.object({
+  'type': z.literal("reasoning"),
+  'text': z.string(),
+}), z.object({
+  'type': z.literal("tool-call"),
+  'id': z.intersection(z.string(), z.unknown()),
+  'name': z.string(),
+  'arguments': z.string(),
+}), z.lazy(() => ToolResultBlockRemoteCodec$schema)])),
+  'isError': z.boolean().optional(),
+})
+const _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_0$schema = z.intersection(z.string(), z.unknown())
+const _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_1$schema = z.intersection(z.string(), z.unknown())
+const _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_2$schema = z.literal("continuable")
+const _deepseek_ai_dsh_subagent_subagents_interruptByParent_result$schema = z.object({
+  'accepted': z.literal(true).readonly(),
+})
+const _deepseek_ai_dsh_subagent_subagents_list_parameter_0$schema = z.intersection(z.string(), z.unknown())
+const _deepseek_ai_dsh_subagent_subagents_list_result$schema = z.object({
+  'entries': z.array(z.union([z.intersection(z.object({
+  'kind': z.literal("child").readonly(),
+  'id': z.intersection(z.string(), z.unknown()).readonly(),
+  'activity': z.union([z.literal("running"), z.literal("inactive")]).readonly(),
+  'hasChildren': z.boolean().readonly(),
+}), z.object({
+  'mode': z.literal("one-shot").readonly(),
+  'label': z.string().readonly().optional(),
+})), z.intersection(z.object({
+  'kind': z.literal("child").readonly(),
+  'id': z.intersection(z.string(), z.unknown()).readonly(),
+  'activity': z.union([z.literal("running"), z.literal("inactive")]).readonly(),
+  'hasChildren': z.boolean().readonly(),
+}), z.object({
+  'mode': z.literal("continuable").readonly(),
+  'label': z.string().readonly(),
+})), z.object({
+  'kind': z.literal("diagnostic").readonly(),
+  'id': z.intersection(z.string(), z.unknown()).readonly(),
+  'reason': z.union([z.literal("corrupt"), z.literal("unsupported"), z.literal("unavailable")]).readonly(),
+})])).readonly(),
+  'parentAvailable': z.boolean().readonly(),
+})
+const _deepseek_ai_dsh_subagent_subagents_prompt_parameter_0$schema = z.object({
+  'requestId': z.intersection(z.string(), z.unknown()).readonly(),
+  'parentSessionId': z.intersection(z.string(), z.unknown()).readonly(),
+  'childSessionId': z.intersection(z.string(), z.unknown()).readonly(),
+  'mode': z.literal("continuable").readonly(),
+  'content': z.array(z.union([z.object({
+  'type': z.literal("text"),
+  'text': z.string(),
+}), z.object({
+  'type': z.literal("image"),
+  'attachment': z.object({
+  'attachmentId': z.intersection(z.string(), z.unknown()),
+  'mediaType': z.union([z.literal("image/png"), z.literal("image/jpeg"), z.literal("image/webp"), z.literal("image/gif")]),
+  'bytes': z.number(),
+  'width': z.number(),
+  'height': z.number(),
+  'name': z.string().optional(),
+  'originalDimensions': z.object({
+  'width': z.number(),
+  'height': z.number(),
+}).optional(),
+}),
+}), z.object({
+  'type': z.literal("reasoning"),
+  'text': z.string(),
+}), z.object({
+  'type': z.literal("tool-call"),
+  'id': z.intersection(z.string(), z.unknown()),
+  'name': z.string(),
+  'arguments': z.string(),
+}), z.object({
+  'type': z.literal("tool-result"),
+  'toolCallId': z.intersection(z.string(), z.unknown()),
+  'content': z.array(z.union([z.object({
+  'type': z.literal("text"),
+  'text': z.string(),
+}), z.object({
+  'type': z.literal("image"),
+  'attachment': z.object({
+  'attachmentId': z.intersection(z.string(), z.unknown()),
+  'mediaType': z.union([z.literal("image/png"), z.literal("image/jpeg"), z.literal("image/webp"), z.literal("image/gif")]),
+  'bytes': z.number(),
+  'width': z.number(),
+  'height': z.number(),
+  'name': z.string().optional(),
+  'originalDimensions': z.object({
+  'width': z.number(),
+  'height': z.number(),
+}).optional(),
+}),
+}), z.object({
+  'type': z.literal("reasoning"),
+  'text': z.string(),
+}), z.object({
+  'type': z.literal("tool-call"),
+  'id': z.intersection(z.string(), z.unknown()),
+  'name': z.string(),
+  'arguments': z.string(),
+}), z.lazy(() => ToolResultBlockRemoteCodec$schema)])),
+  'isError': z.boolean().optional(),
+}), z.object({
+  'type': z.literal("image").readonly(),
+  'mediaType': z.union([z.literal("image/png"), z.literal("image/jpeg"), z.literal("image/webp"), z.literal("image/gif")]),
+  'data': z.string(),
+  'name': z.string().optional(),
+})])).readonly(),
+  'clientTimeZone': z.string().readonly().optional(),
+})
+const _deepseek_ai_dsh_subagent_subagents_prompt_result$schema = z.object({
+  'messageId': z.intersection(z.string(), z.unknown()).readonly(),
+})
+
+export const TYPERT_REMOTE = {
+  package: '@deepseek-ai/dsh-subagent',
+  descriptors: [
+    {
+      id: '@deepseek-ai/dsh-subagent#subagents/interruptByParent',
+      service: 'subagents',
+      namespace: 'subagents',
+      method: 'interruptByParent',
+      invocation: { kind: 'direct' },
+      parameters: [
+        {
+          name: 'childSessionId',
+          wire: 'childSessionId',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
+            schema: _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_0$schema,
+          },
+        },
+        {
+          name: 'parentSessionId',
+          wire: 'parentSessionId',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
+            schema: _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_1$schema,
+          },
+        },
+        {
+          name: 'mode',
+          wire: 'mode',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-subagent#subagents/interruptByParent:mode',
+            schema: _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_2$schema,
+          },
+        },
+      ],
+      result: {
+        mode: 'strict',
+        typeSymbol: '@deepseek-ai/dsh-subagent/client#SubagentInterruptReceipt',
+        schema: _deepseek_ai_dsh_subagent_subagents_interruptByParent_result$schema,
+      },
+      sourceLocation: {"file":"packages/subagent/subagent/src/index.ts","line":479,"column":3},
+    },
+    {
+      id: '@deepseek-ai/dsh-subagent#subagents/list',
+      service: 'subagents',
+      namespace: 'subagents',
+      method: 'list',
+      implementation: 'remoteExportList',
+      invocation: { kind: 'direct' },
+      parameters: [
+        {
+          name: 'parentSessionId',
+          wire: 'parentSessionId',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
+            schema: _deepseek_ai_dsh_subagent_subagents_list_parameter_0$schema,
+          },
+        },
+      ],
+      cancellation: { parameter: 'signal' },
+      result: {
+        mode: 'strict',
+        typeSymbol: '@deepseek-ai/dsh-subagent/client#SubagentCatalog',
+        schema: _deepseek_ai_dsh_subagent_subagents_list_result$schema,
+      },
+      sourceLocation: {"file":"packages/subagent/subagent/src/index.ts","line":406,"column":9},
+    },
+    {
+      id: '@deepseek-ai/dsh-subagent#subagents/prompt',
+      service: 'subagents',
+      namespace: 'subagents',
+      method: 'prompt',
+      invocation: { kind: 'direct' },
+      parameters: [
+        {
+          name: 'request',
+          wire: 'request',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-subagent/client#SubagentPromptRequest',
+            schema: _deepseek_ai_dsh_subagent_subagents_prompt_parameter_0$schema,
+          },
+        },
+      ],
+      cancellation: { parameter: 'signal' },
+      result: {
+        mode: 'strict',
+        typeSymbol: '@deepseek-ai/dsh-subagent/client#SubagentPromptReceipt',
+        schema: _deepseek_ai_dsh_subagent_subagents_prompt_result$schema,
+      },
+      sourceLocation: {"file":"packages/subagent/subagent/src/index.ts","line":430,"column":9},
+    },
+  ],
+}
+
+export default TYPERT_REMOTE

package/lib/types/child-agent.d.ts

@@ -30,9 +30,20 @@ export declare class SubagentDepthError extends Error {
  */
 export declare function resolveChildDepth(parent: Agent, maxDepth: number | undefined): number;
 /**
- * Resolve the child's `AgentOptions`: the parent's provider/model/maxTokens
- * route unless the request overrides it, stamped with the child's own
- * delegation depth.
+ * Resolve the parent values inherited by a child. The latest request header
+ * owns provider, model, and reasoning effort after request-time selection;
+ * creation options remain the fallback before the first request and retain
+ * the configured output-token limit.
+ * @param parent - delegating parent Agent.
+ * @returns detached Agent options for child-option merging.
+ */
+export declare function parentAgentOptionsForDelegation(parent: Agent): AgentOptions;
+/**
+ * Resolve the child's `AgentOptions`: the parent's provider/model,
+ * reasoning-effort, and maxTokens values unless the request overrides them,
+ * stamped with the child's own delegation depth. Changing the route without
+ * naming an effort clears the parent's route-owned effort so the selected
+ * model resolves its own default.
  * @param parent - the delegating parent whose route the child inherits.
  * @param requested - per-child overrides, if any.
  * @param childDepth - the resolved delegation depth to stamp.

package/lib/types/child-agent.js

@@ -40,25 +40,56 @@ export function resolveChildDepth(parent, maxDepth) {
     return childDepth;
 }
 /**
- * Resolve the child's `AgentOptions`: the parent's provider/model/maxTokens
- * route unless the request overrides it, stamped with the child's own
- * delegation depth.
+ * Resolve the parent values inherited by a child. The latest request header
+ * owns provider, model, and reasoning effort after request-time selection;
+ * creation options remain the fallback before the first request and retain
+ * the configured output-token limit.
+ * @param parent - delegating parent Agent.
+ * @returns detached Agent options for child-option merging.
+ */
+export function parentAgentOptionsForDelegation(parent) {
+    const requestConfig = parent.session.requestHeader()?.config;
+    if (requestConfig === undefined)
+        return { ...parent.options };
+    const { provider: _createdProvider, model: _createdModel, reasoningEffort: _createdReasoningEffort, ...createdOptions } = parent.options;
+    return {
+        ...createdOptions,
+        provider: requestConfig.provider,
+        model: requestConfig.model,
+        ...requestConfig.reasoningEffort === undefined
+            ? {}
+            : { reasoningEffort: requestConfig.reasoningEffort },
+    };
+}
+/**
+ * Resolve the child's `AgentOptions`: the parent's provider/model,
+ * reasoning-effort, and maxTokens values unless the request overrides them,
+ * stamped with the child's own delegation depth. Changing the route without
+ * naming an effort clears the parent's route-owned effort so the selected
+ * model resolves its own default.
  * @param parent - the delegating parent whose route the child inherits.
  * @param requested - per-child overrides, if any.
  * @param childDepth - the resolved delegation depth to stamp.
  * @returns the resolved options for `ctx.agents.create()`.
  */
 export function resolveChildAgentOptions(parent, requested, childDepth) {
-    const parentProvider = parent.options.provider;
-    const parentModel = parent.options.model;
-    const parentMaxTokens = parent.options.maxTokens;
-    return {
+    const parentOptions = parentAgentOptionsForDelegation(parent);
+    const parentProvider = parentOptions.provider;
+    const parentModel = parentOptions.model;
+    const parentReasoningEffort = parentOptions.reasoningEffort;
+    const parentMaxTokens = parentOptions.maxTokens;
+    const resolved = {
         ...parentProvider !== undefined ? { provider: parentProvider } : {},
         ...parentModel !== undefined ? { model: parentModel } : {},
+        ...parentReasoningEffort !== undefined ? { reasoningEffort: parentReasoningEffort } : {},
         ...parentMaxTokens !== undefined ? { maxTokens: parentMaxTokens } : {},
         ...requested,
         subagentDepth: childDepth,
     };
+    const routeChanged = resolved.provider !== parentProvider || resolved.model !== parentModel;
+    if (routeChanged && requested?.reasoningEffort === undefined)
+        delete resolved.reasoningEffort;
+    return resolved;
 }
 /**
  * Build the child session's durable creation metadata: the parent's workspace,
@@ -125,10 +156,17 @@ export const SUBAGENT_DELEGATION_CONTEXT = 'You are a delegated subagent: your p
  */
 export function applyChildComposition(childCtx, parent, composition) {
     childCtx.get('agentPresets')?.composeFrom(childCtx, parent.ctx);
-    // Order 120: after the sandbox:policy (110) and approval:policy (115) sentences.
-    childCtx.systemPrompt.context({ name: 'subagent:delegation', order: 120, text: SUBAGENT_DELEGATION_CONTEXT });
+    childCtx.systemPrompt.context({
+        name: 'subagent:delegation',
+        order: childCtx.systemPrompt.getContextOrder('SUBAGENT_DELEGATION'),
+        text: SUBAGENT_DELEGATION_CONTEXT,
+    });
     if (composition.persona !== undefined) {
-        childCtx.systemPrompt.section({ name: 'deployment:persona', order: 0, text: composition.persona });
+        childCtx.systemPrompt.section({
+            name: 'deployment:persona',
+            order: childCtx.systemPrompt.getSectionOrder('DEPLOYMENT_PERSONA'),
+            text: composition.persona,
+        });
     }
     if (composition.toolFilter !== undefined)
         childCtx.tools.restrict(composition.toolFilter);

package/lib/types/client.d.ts

@@ -1,7 +1,8 @@
 /**
- * Browser-safe subagent projection vocabulary.
+ * Browser-safe subagent projection and control vocabulary.
  *
  * @module @deepseek-ai/dsh-subagent/client
  */
+export type * from './control-types.ts';
 export type { SubagentIdentityProjection, SubagentTimingProjection } from './projection-types.ts';
 //# sourceMappingURL=client.d.ts.map

package/lib/types/client.js

@@ -1,5 +1,5 @@
 /**
- * Browser-safe subagent projection vocabulary.
+ * Browser-safe subagent projection and control vocabulary.
  *
  * @module @deepseek-ai/dsh-subagent/client
  */

package/lib/types/continuation.d.ts

@@ -23,7 +23,7 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
 import type { ContentBlock, MessageId, MessageSource } from '@deepseek-ai/dsh-llm';
-import { SessionId } from '@deepseek-ai/dsh-session';
+import type { SessionId } from '@deepseek-ai/dsh-session';
 import type { SubagentDescriptorData } from './descriptor.ts';
 import type { ContinuableCreateRequest, ContinuableCreateSpec, SubagentStartRequest } from './types.ts';
 import type { ActivationObserver } from './lifecycle.ts';
@@ -323,7 +323,7 @@ export declare class SubagentContinuationManager {
      */
     private stateOf;
     /**
-     * Cold-resume a persisted child: inspect and authorize its Session, fold the
+     * Cold-resume a persisted child: retain and authorize its prepared Session, fold the
      * generic descriptor, create the Activation through `ctx.agents.resume()`,
      * and submit the waiting turn. This never dispatches through a subagent
      * provider — the persisted Session already holds the initial prefix and the
@@ -449,6 +449,8 @@ export declare class SubagentContinuationManager {
     private flushFinalState;
     /** Resolve the persistence service continuable children require, or fail loud. */
     private requirePersistence;
+    /** Resolve the Session query service used for cold child observations. */
+    private requireSessionQuery;
 }
 export type { SubagentDescriptorData };
 export default SubagentContinuationManager;

package/lib/types/continuation.js

@@ -20,9 +20,61 @@
  *
  * @module @deepseek-ai/dsh-subagent
  */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { randomUUID } from 'node:crypto';
-import { boundContextSummary, createUserMessage, errorChain } from '@deepseek-ai/dsh-llm';
-import { SessionId } from '@deepseek-ai/dsh-session';
+import { brandString } from '@deepseek-ai/dsh-brand';
+import { ReasoningEffortId, boundContextSummary, createUserMessage, errorChain } from '@deepseek-ai/dsh-llm';
 import { foldSubagentDescriptor, snapshotSubagentDescriptor } from "./descriptor.js";
 import { appendDelegatedPolicyOverrides, applyChildComposition, captureDelegatedPolicyOverrides, childSessionMeta, resolveChildAgentOptions, resolveChildDepth, } from "./child-agent.js";
 import { assertSubagentMaxDepth } from "./depth.js";
@@ -156,19 +208,22 @@ export class SubagentContinuationManager {
         this.assertAdmitting(parent);
         const persistence = this.requirePersistence();
         assertSubagentMaxDepth(request.maxDepth);
-        const childId = spec.childId ?? SessionId(randomUUID());
+        const childId = spec.childId ?? brandString(randomUUID());
         this.assertChildIdAvailable(childId);
         const childDepth = resolveChildDepth(parent, request.maxDepth);
         // Snapshot before any await: invalid descriptor JSON rejects the call
         // before a child exists, and the detached value is what reaches the log.
-        const agentProvider = request.agentOptions?.provider ?? parent.options.provider;
-        const agentModel = request.agentOptions?.model ?? parent.options.model;
+        const agentOptions = resolveChildAgentOptions(parent, request.agentOptions, childDepth);
+        const agentProvider = agentOptions.provider;
+        const agentModel = agentOptions.model;
+        const agentReasoningEffort = agentOptions.reasoningEffort;
         const descriptor = snapshotSubagentDescriptor({
             mode: 'continuable',
             provider: spec.provider,
             label: spec.label,
             ...agentProvider !== undefined ? { agentProvider } : {},
             ...agentModel !== undefined ? { agentModel } : {},
+            ...agentReasoningEffort !== undefined ? { agentReasoningEffort } : {},
             ...request.persona !== undefined ? { persona: request.persona } : {},
             ...request.toolFilter !== undefined ? { toolFilter: request.toolFilter } : {},
         });
@@ -202,7 +257,7 @@ export class SubagentContinuationManager {
                 provider: spec.provider,
                 parent,
                 create: { seed, meta: childSessionMeta(parent, childDepth, lineageSeedLength), delegatedPolicies },
-                agentOptions: resolveChildAgentOptions(parent, request.agentOptions, childDepth),
+                agentOptions,
                 composition: { persona: request.persona, toolFilter: request.toolFilter },
                 signal: spec.signal,
             });
@@ -610,56 +665,71 @@ export class SubagentContinuationManager {
         return 'settled';
     }
     /**
-     * Cold-resume a persisted child: inspect and authorize its Session, fold the
+     * Cold-resume a persisted child: retain and authorize its prepared Session, fold the
      * generic descriptor, create the Activation through `ctx.agents.resume()`,
      * and submit the waiting turn. This never dispatches through a subagent
      * provider — the persisted Session already holds the initial prefix and the
      * descriptor is the whole reconstruction input.
      */
     async coldResume(parent, childId, content, options) {
-        const persistence = this.requirePersistence();
-        let loaded;
+        const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            loaded = await persistence.inspect(childId, options.signal);
-        }
-        catch (error) {
-            options.signal.throwIfAborted();
-            throw new SubagentError(`subagent "${childId}" is unavailable`, 'NOT_RESUMABLE', { cause: error });
-        }
-        options.signal.throwIfAborted();
-        this.assertAdmitting(parent);
-        // Authorize the persisted header before folding: only the durable child's
-        // exact live direct parent may continue it.
-        this.authorizeLineage(parent, childId, loaded.meta.parentSession);
-        // 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(loaded.events.slice(loaded.meta.seedLength ?? 0));
-        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');
+            const query = this.requireSessionQuery();
+            let observation;
+            try {
+                observation = await query.observeSession(childId, {
+                    signal: options.signal,
+                });
+            }
+            catch (error) {
+                options.signal.throwIfAborted();
+                throw new SubagentError(`subagent "${childId}" is unavailable`, 'NOT_RESUMABLE', { cause: error });
+            }
+            const source = __addDisposableResource(env_1, observation, false);
+            this.assertAdmitting(parent);
+            // Authorize the persisted header before folding: only the durable child's
+            // exact live direct parent may continue it.
+            this.authorizeLineage(parent, childId, source.header.parentSession);
+            // 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));
+            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');
+            }
+            let activation;
+            try {
+                activation = await this.materialize({
+                    childId,
+                    provider: descriptor.provider,
+                    parent,
+                    agentOptions: {
+                        ...descriptor.agentProvider !== undefined ? { provider: descriptor.agentProvider } : {},
+                        ...descriptor.agentModel !== undefined ? { model: descriptor.agentModel } : {},
+                        ...descriptor.agentReasoningEffort !== undefined
+                            ? { reasoningEffort: ReasoningEffortId(descriptor.agentReasoningEffort) }
+                            : {},
+                    },
+                    composition: { persona: descriptor.persona, toolFilter: descriptor.toolFilter },
+                    signal: options.signal,
+                });
+            }
+            catch (error) {
+                options.signal.throwIfAborted();
+                if (error instanceof SubagentError)
+                    throw error;
+                throw new SubagentError(`subagent "${childId}" is unavailable`, 'NOT_RESUMABLE', { cause: error });
+            }
+            return await this.submitMaterialized(activation, content, options.source, parent, options.signal);
         }
-        let activation;
-        try {
-            activation = await this.materialize({
-                childId,
-                provider: descriptor.provider,
-                parent,
-                agentOptions: {
-                    ...descriptor.agentProvider !== undefined ? { provider: descriptor.agentProvider } : {},
-                    ...descriptor.agentModel !== undefined ? { model: descriptor.agentModel } : {},
-                },
-                composition: { persona: descriptor.persona, toolFilter: descriptor.toolFilter },
-                signal: options.signal,
-            });
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
         }
-        catch (error) {
-            options.signal.throwIfAborted();
-            if (error instanceof SubagentError)
-                throw error;
-            throw new SubagentError(`subagent "${childId}" is unavailable`, 'NOT_RESUMABLE', { cause: error });
+        finally {
+            __disposeResources(env_1);
         }
-        return this.submitMaterialized(activation, content, options.source, parent, options.signal);
     }
     /**
      * Submit to a freshly materialized Activation or roll it back completely.
@@ -1146,6 +1216,14 @@ export class SubagentContinuationManager {
         }
         return persistence;
     }
+    /** Resolve the Session query service used for cold child observations. */
+    requireSessionQuery() {
+        const query = this.ctx.get('sessionQuery');
+        if (query === undefined) {
+            throw new SubagentError('continuable subagents require session query (load @deepseek-ai/dsh-session-query)', 'CONTINUATION_UNAVAILABLE');
+        }
+        return query;
+    }
 }
 export default SubagentContinuationManager;
 //# sourceMappingURL=continuation.js.map