@toddzheng024/dscode-bundle 0.3.0 → 0.5.0

package/vendor/subagent-core/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/vendor/subagent-core/typert.remote-client.js

@@ -0,0 +1,160 @@
+/* Generated by @deepseek-ai/dsh-typert-generator from the Host FaceModel — do not edit. */
+import { z } from 'zod'
+
+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(),
+  'delivery': z.union([z.literal("queue"), z.literal("steer")]).readonly(),
+  'content': z.array(z.union([z.object({
+  'type': z.literal("text").readonly(),
+  'text': z.string().readonly(),
+}), 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")]).readonly(),
+  'data': z.string().readonly(),
+  'name': z.string().readonly().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":480,"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":386,"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":413,"column":9},
+    },
+  ],
+}
+
+export default TYPERT_REMOTE

package/vendor/subagent-core/types/assistant-output.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Canonical selection of a child's final assistant output. Backend run results
+ * and `subagent/end.lastAssistantMessage` apply the same rule: select the last
+ * non-empty assistant message. An empty-content message records usage only
+ * when the loop appends it after a max-tokens step with no executable blocks,
+ * so it does not replace earlier output. If no non-empty message exists,
+ * select the accumulated assistant text. Selection is independent of the
+ * run's stop reason.
+ *
+ * @module @deepseek-ai/dsh-subagent/assistant-output
+ */
+import { type ContentBlock } from '@deepseek-ai/dsh-llm';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+/**
+ * Incremental fold of the selection rule, for backends that observe a child's
+ * output as it streams: session-event backends {@link push} each event, and
+ * transports without session events (ACP content chunks) {@link pushText} raw
+ * text into the same streamed fallback.
+ */
+export declare class AssistantOutputFold {
+    private message;
+    private partial;
+    /**
+     * Fold one session event: a non-empty assistant message becomes the
+     * candidate final answer, while its embedded stream and any log-only attempt
+     * extend the streamed fallback; every other event contributes nothing.
+     * @param event - the next observed session event.
+     */
+    push(event: SessionEvent): void;
+    /**
+     * Extend the streamed fallback with text observed outside session events.
+     * @param text - the next streamed text piece (an empty piece is a no-op).
+     */
+    pushText(text: string): void;
+    /**
+     * Select the final output folded so far.
+     * @returns the last non-empty assistant message, else the accumulated
+     *   streamed text, or `undefined` when the child produced neither.
+     */
+    collect(): ContentBlock[] | undefined;
+}
+/**
+ * Apply the selection rule to one complete child-owned event suffix.
+ * @param events - the child-owned events (after any seed or epoch boundary).
+ * @returns the selected output, or `undefined` when the child produced none.
+ */
+export declare function finalAssistantOutput(events: readonly SessionEvent[]): ContentBlock[] | undefined;
+//# sourceMappingURL=assistant-output.d.ts.map

package/vendor/subagent-core/types/assistant-output.js

@@ -0,0 +1,73 @@
+/**
+ * Canonical selection of a child's final assistant output. Backend run results
+ * and `subagent/end.lastAssistantMessage` apply the same rule: select the last
+ * non-empty assistant message. An empty-content message records usage only
+ * when the loop appends it after a max-tokens step with no executable blocks,
+ * so it does not replace earlier output. If no non-empty message exists,
+ * select the accumulated assistant text. Selection is independent of the
+ * run's stop reason.
+ *
+ * @module @deepseek-ai/dsh-subagent/assistant-output
+ */
+import { joinAssistantStreamText } from '@deepseek-ai/dsh-llm';
+/**
+ * Incremental fold of the selection rule, for backends that observe a child's
+ * output as it streams: session-event backends {@link push} each event, and
+ * transports without session events (ACP content chunks) {@link pushText} raw
+ * text into the same streamed fallback.
+ */
+export class AssistantOutputFold {
+    message;
+    partial = [];
+    /**
+     * Fold one session event: a non-empty assistant message becomes the
+     * candidate final answer, while its embedded stream and any log-only attempt
+     * extend the streamed fallback; every other event contributes nothing.
+     * @param event - the next observed session event.
+     */
+    push(event) {
+        if (event.type === 'assistant/message') {
+            const content = event.data.message.content;
+            if (content.length > 0)
+                this.message = content;
+        }
+        if (event.type === 'assistant/message' || event.type === 'assistant/attempt') {
+            this.pushText(joinAssistantStreamText(event.data.stream));
+        }
+    }
+    /**
+     * Extend the streamed fallback with text observed outside session events.
+     * @param text - the next streamed text piece (an empty piece is a no-op).
+     */
+    pushText(text) {
+        if (text.length > 0)
+            this.partial.push(text);
+    }
+    /**
+     * Select the final output folded so far.
+     * @returns the last non-empty assistant message, else the accumulated
+     *   streamed text, or `undefined` when the child produced neither.
+     */
+    collect() {
+        if (this.message !== undefined)
+            return this.message;
+        const text = this.partial.join('');
+        return text.length > 0 ? [{ type: 'text', text }] : undefined;
+    }
+}
+/**
+ * Apply the selection rule to one complete child-owned event suffix.
+ * @param events - the child-owned events (after any seed or epoch boundary).
+ * @returns the selected output, or `undefined` when the child produced none.
+ */
+export function finalAssistantOutput(events) {
+    // TODO: this folds the complete suffix once per run/epoch settlement. If a
+    // long continuable epoch ever profiles hot here, scan backward with early
+    // exit for the last non-empty message and fold text deltas only on the
+    // no-message fallback.
+    const fold = new AssistantOutputFold();
+    for (const event of events)
+        fold.push(event);
+    return fold.collect();
+}
+//# sourceMappingURL=assistant-output.js.map

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

@@ -0,0 +1,77 @@
+/**
+ * Parent-owned durable subagent catalog events and their chunked projection.
+ *
+ * @module @deepseek-ai/dsh-subagent/catalog
+ */
+import { z } from 'zod';
+import type { ChunkedList } from '@deepseek-ai/dsh-chunked-list';
+import type { Session, SessionEvent, SessionHeader, SessionId, SessionLogOffset } from '@deepseek-ai/dsh-session';
+import type { SubagentCatalogEntry } from './projection-types.ts';
+/** Current payload version for `subagent/catalog` events. */
+export declare const SUBAGENT_CATALOG_VERSION = 0;
+/** One complete parent-owned catalog fact. */
+export type SubagentCatalogEvent = {
+    readonly version: 0;
+    readonly childId: SessionId;
+    readonly childCreatedAt: number;
+} & ({
+    readonly mode: 'one-shot';
+    readonly label?: string;
+} | {
+    readonly mode: 'continuable';
+    readonly label: string;
+});
+declare module '@deepseek-ai/dsh-session/types' {
+    interface SessionEventMap {
+        /**
+         * A direct child's complete discovery fact.
+         * @param data - versioned parent-owned catalog entry.
+         */
+        'subagent/catalog': SubagentCatalogEvent;
+    }
+}
+/** Host fold state for one parent catalog. */
+export interface SubagentCatalogState {
+    readonly inheritedEventCount: SessionLogOffset;
+    readonly head?: ChunkedList<SubagentCatalogEvent> | undefined;
+}
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionStateMap {
+        subagentCatalog: SubagentCatalogState;
+    }
+}
+/**
+ * Materialize direct children from their parent's successful creation facts.
+ * @param state - parent catalog fold state.
+ * @returns current direct-child rows in parent catalog event order.
+ */
+declare function subagentCatalogEntries(state: SubagentCatalogState): SubagentCatalogEntry[];
+/** Parent-owned direct-child catalog projection; invalid own facts reject restoration. */
+export declare const subagentCatalogProjectionDefinition: {
+    key: "subagentCatalog";
+    stateSchema: z.ZodType<SubagentCatalogState, unknown, z.core.$ZodTypeInternals<SubagentCatalogState, unknown>>;
+    init: (_header: SessionHeader, inheritedEventCount: SessionLogOffset) => {
+        inheritedEventCount: SessionLogOffset;
+    };
+    apply: (state: NoInfer<SubagentCatalogState>, event: SessionEvent) => SubagentCatalogState;
+    stateVersion: number;
+    wire: {
+        viewSchema: z.ZodType<SubagentCatalogEntry[], unknown, z.core.$ZodTypeInternals<SubagentCatalogEntry[], unknown>>;
+        view: typeof subagentCatalogEntries;
+    };
+};
+/**
+ * Append a complete direct-child discovery fact to its parent Session.
+ * @param parent - durable direct parent receiving the discovery fact.
+ * @param child - established child's immutable Session metadata.
+ * @param descriptor - mode-discriminated creation label frozen with the child.
+ */
+export declare function establishCatalogChild(parent: Session, child: SessionHeader, descriptor: {
+    readonly mode: 'one-shot';
+    readonly label?: string;
+} | {
+    readonly mode: 'continuable';
+    readonly label: string;
+}): void;
+export {};
+//# sourceMappingURL=catalog.d.ts.map

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

@@ -0,0 +1,103 @@
+/**
+ * Parent-owned durable subagent catalog events and their chunked projection.
+ *
+ * @module @deepseek-ai/dsh-subagent/catalog
+ */
+import { z } from 'zod';
+import { appendChunkedList, chunkedListSchema, iterateChunkedList } from '@deepseek-ai/dsh-chunked-list';
+/** Current payload version for `subagent/catalog` events. */
+export const SUBAGENT_CATALOG_VERSION = 0;
+const sessionIdSchema = z.string();
+const oneShotCatalogSchema = z.object({
+    version: z.literal(SUBAGENT_CATALOG_VERSION),
+    childId: sessionIdSchema,
+    childCreatedAt: z.number().int().nonnegative(),
+    mode: z.literal('one-shot'),
+    label: z.string().optional(),
+}).strict();
+const continuableCatalogSchema = z.object({
+    version: z.literal(SUBAGENT_CATALOG_VERSION),
+    childId: sessionIdSchema,
+    childCreatedAt: z.number().int().nonnegative(),
+    mode: z.literal('continuable'),
+    label: z.string(),
+}).strict();
+const eventDataSchema = z.union([
+    oneShotCatalogSchema,
+    continuableCatalogSchema,
+]);
+const viewSchema = z.array(z.union([
+    oneShotCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
+        id: sessionIdSchema,
+        createdAt: oneShotCatalogSchema.shape.childCreatedAt,
+    }),
+    continuableCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
+        id: sessionIdSchema,
+        createdAt: continuableCatalogSchema.shape.childCreatedAt,
+    }),
+]));
+const stateSchema = z.object({
+    inheritedEventCount: z.number().int().nonnegative(),
+    head: chunkedListSchema(eventDataSchema).optional(),
+}).strict();
+/**
+ * Materialize direct children from their parent's successful creation facts.
+ * @param state - parent catalog fold state.
+ * @returns current direct-child rows in parent catalog event order.
+ */
+function subagentCatalogEntries(state) {
+    const entries = [];
+    for (const data of iterateChunkedList(state.head)) {
+        entries.push(data.mode === 'one-shot'
+            ? {
+                id: data.childId,
+                createdAt: data.childCreatedAt,
+                mode: data.mode,
+                ...data.label === undefined ? {} : { label: data.label },
+            }
+            : {
+                id: data.childId,
+                createdAt: data.childCreatedAt,
+                mode: data.mode,
+                label: data.label,
+            });
+    }
+    return entries;
+}
+/** Parent-owned direct-child catalog projection; invalid own facts reject restoration. */
+export const subagentCatalogProjectionDefinition = {
+    key: 'subagentCatalog',
+    stateSchema,
+    init: (_header, inheritedEventCount) => ({ inheritedEventCount }),
+    apply: (state, event) => {
+        if (event.type !== 'subagent/catalog' || event.seq < state.inheritedEventCount)
+            return state;
+        return { ...state, head: appendChunkedList(state.head, eventDataSchema.parse(event.data)) };
+    },
+    stateVersion: 2,
+    wire: { viewSchema, view: subagentCatalogEntries },
+};
+/**
+ * Append a complete direct-child discovery fact to its parent Session.
+ * @param parent - durable direct parent receiving the discovery fact.
+ * @param child - established child's immutable Session metadata.
+ * @param descriptor - mode-discriminated creation label frozen with the child.
+ */
+export function establishCatalogChild(parent, child, descriptor) {
+    parent.append('subagent/catalog', descriptor.mode === 'one-shot'
+        ? {
+            version: SUBAGENT_CATALOG_VERSION,
+            childId: child.id,
+            childCreatedAt: child.createdAt,
+            mode: descriptor.mode,
+            ...descriptor.label === undefined ? {} : { label: descriptor.label },
+        }
+        : {
+            version: SUBAGENT_CATALOG_VERSION,
+            childId: child.id,
+            childCreatedAt: child.createdAt,
+            mode: descriptor.mode,
+            label: descriptor.label,
+        });
+}
+//# sourceMappingURL=catalog.js.map

package/vendor/subagent-core/types/child-agent.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Shared in-process child composition: the delegation-depth budget, the
+ * durable session metadata, the resolved child `AgentOptions`, the delegated
+ * policy seed, and the scoped setup a child agent needs. Both the one-shot
+ * provider driver and the continuation manager compose children this way, so
+ * depth accounting, lineage stamping, and delegation policy have one home.
+ *
+ * @module @deepseek-ai/dsh-subagent/child-agent
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent, AgentOptions, CreateAgentOptions } from '@deepseek-ai/dsh-agent';
+import type { SandboxMode } from '@deepseek-ai/dsh-sandbox';
+import type { Session, SessionId } from '@deepseek-ai/dsh-session';
+import type { ToolRestriction } from '@deepseek-ai/dsh-tools';
+/** Thrown when starting a child would exceed the requested depth cap. */
+export declare class SubagentDepthError extends Error {
+    readonly attemptedDepth: number;
+    readonly maxDepth: number;
+    constructor(attemptedDepth: number, maxDepth: number);
+}
+/**
+ * Resolve the child's delegation depth from its parent and enforce an optional
+ * cap. The persisted parent header is the monotone floor, so a resumed parent
+ * cannot delegate as if it were top-level.
+ * @param parent - the delegating parent agent.
+ * @param maxDepth - optional absolute cap the resolved depth must not exceed.
+ * @returns the child's non-negative safe-integer depth.
+ * @throws {SubagentDepthError} when the resolved depth exceeds `maxDepth`.
+ * @throws {RangeError} when the resolved depth leaves the safe-integer range.
+ */
+export declare function resolveChildDepth(parent: Agent, maxDepth: number | undefined): number;
+/**
+ * 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.
+ * @returns the resolved options for `ctx.agents.create()`.
+ */
+export declare function resolveChildAgentOptions(parent: Agent, requested: AgentOptions | undefined, childDepth: number): AgentOptions;
+/**
+ * Build the child session's durable creation metadata: the parent's workspace,
+ * its direct lineage, coarse product origin, the recursion budget that must
+ * survive persistence, the seed boundary that separates inherited parent
+ * history from child work, and the composition the child runs under.
+ *
+ * The preset is read from the parent's LIVE scope chain rather than from its
+ * header, because a parent that switched preset while blank runs on the newer
+ * composition and its header still names the older one. Recording it is what
+ * makes a child's history reconstructable: without it a cold read of the child
+ * resolves the deployment default and rebuilds turns under a tool set the
+ * child never had.
+ * @param parent - the delegating parent agent.
+ * @param childDepth - the resolved delegation depth to persist.
+ * @param isSeeded - whether this child inherits a parent-log prefix, including an explicitly empty one.
+ * @returns the `meta` for `ctx.agents.create()`.
+ */
+export declare function childSessionMeta(parent: Agent, childDepth: number, isSeeded: boolean): NonNullable<CreateAgentOptions['meta']>;
+/** The scoped composition a child agent's creation window applies. */
+export interface ChildComposition {
+    /** Per-child persona shadowing the deployment persona. */
+    readonly persona?: string | undefined;
+    /** Per-child tool scoping. */
+    readonly toolFilter?: ToolRestriction | undefined;
+}
+/**
+ * Model-facing delegation-scope statement for every in-process child. A
+ * runtime-context contribution rather than a system-prompt section, so the
+ * deployment's system prompt stays uniform across parents and children.
+ */
+export declare const SUBAGENT_DELEGATION_CONTEXT: string;
+/**
+ * Compose one child inside its creation window: join its parent's preset,
+ * register the fixed delegation-scope statement, then apply the child's own
+ * shadowing persona section and tool restriction, all owned by the child's
+ * scope and therefore invisible to its parent and siblings. Creation and cold
+ * resume both pass through here.
+ *
+ * The join comes first and the child's own registrations second, which is the
+ * order the layering already implies — the nearest scope wins a name, and a
+ * per-child restriction intersects with everything its chain admits — but
+ * stating it here keeps the two steps from being read as independent.
+ *
+ * The join and the per-child registrations live in ONE call because a child
+ * composed without the join is exactly the defect this function exists to
+ * prevent: with every model-facing row on the agent plane, a child that joins
+ * no preset sees an empty tool registry and none of its parent's prompt
+ * sections. Taking the parent as a parameter is what makes that omission
+ * unrepresentable at the call sites.
+ * @param childCtx - the child agent's scoped creation context.
+ * @param parent - the delegating parent whose composition the child joins.
+ * @param composition - the per-child persona and tool filter to install.
+ */
+export declare function applyChildComposition(childCtx: Context, parent: Agent, composition: ChildComposition): void;
+/** Policy seeded onto a child session's log at the delegation boundary. */
+export interface DelegatedPolicyOverrides {
+    /** The parent session's explicit sandbox-mode override, or `undefined` without one. */
+    readonly sandboxMode: SandboxMode | undefined;
+    /**
+     * `'never'` whenever the approval capability is composed, `undefined`
+     * otherwise: a delegated child acts only within the sandbox scope fixed at
+     * delegation, so its asks are rejected deterministically.
+     */
+    readonly approvalPolicy: 'never' | undefined;
+}
+/**
+ * Capture the policy to seed into one delegation. Call synchronously before
+ * the child start's first await: a later parent switch belongs to the
+ * parent's future, not to this child. Only the parent session's explicit
+ * sandbox override is captured — never deployment defaults or one-shot
+ * grants — and the approval policy is pinned to `'never'` regardless of the
+ * parent's own policy.
+ * @param parent - the delegating parent agent.
+ * @returns the sandbox override (or `undefined` without one) and the approval pin.
+ */
+export declare function captureDelegatedPolicyOverrides(parent: Agent): DelegatedPolicyOverrides;
+/**
+ * Append the captured delegation policy onto the child's own log as
+ * `source: 'delegation'` events inside the unpublished creation window, so the
+ * child's effective policy is reconstructable from its log alone. Appends land
+ * after any fork seed, so fresh policy wins stale seed state; later child
+ * switches still win over these events.
+ * @param childSession - the unpublished child's session.
+ * @param overrides - the policy captured at delegation.
+ */
+export declare function appendDelegatedPolicyOverrides(childSession: Session, overrides: DelegatedPolicyOverrides): void;
+/** Identity and lineage inputs shared by every in-process child creation. */
+export interface ChildCreateInputs {
+    /** The child's reserved session id. */
+    readonly sessionId: SessionId;
+    /** The delegating parent agent. */
+    readonly parent: Agent;
+    /** The resolved delegation depth. */
+    readonly childDepth: number;
+    /** How many leading seed events came from the parent's log. */
+    readonly lineageSeedLength: number;
+}
+//# sourceMappingURL=child-agent.d.ts.map