@toddzheng024/dscode-bundle 0.7.27 → 0.7.29

package/vendor/subagent-core/typert.remote-client.js

@@ -1,38 +1,18 @@
 /* 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({
+let _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_0$schema$value
+const _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_0$schema = () => (_deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_0$schema$value ??= z.intersection(z.string(), z.unknown()))
+let _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_1$schema$value
+const _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_1$schema = () => (_deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_1$schema$value ??= z.intersection(z.string(), z.unknown()))
+let _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_2$schema$value
+const _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_2$schema = () => (_deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_2$schema$value ??= z.literal("continuable"))
+let _deepseek_ai_dsh_subagent_subagents_interruptByParent_result$schema$value
+const _deepseek_ai_dsh_subagent_subagents_interruptByParent_result$schema = () => (_deepseek_ai_dsh_subagent_subagents_interruptByParent_result$schema$value ??= 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({
+}))
+let _deepseek_ai_dsh_subagent_subagents_prompt_parameter_0$schema$value
+const _deepseek_ai_dsh_subagent_subagents_prompt_parameter_0$schema = () => (_deepseek_ai_dsh_subagent_subagents_prompt_parameter_0$schema$value ??= 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(),
@@ -48,10 +28,11 @@ const _deepseek_ai_dsh_subagent_subagents_prompt_parameter_0$schema = z.object({
   'name': z.string().readonly().optional(),
 })])).readonly(),
   'clientTimeZone': z.string().readonly().optional(),
-})
-const _deepseek_ai_dsh_subagent_subagents_prompt_result$schema = z.object({
+}))
+let _deepseek_ai_dsh_subagent_subagents_prompt_result$schema$value
+const _deepseek_ai_dsh_subagent_subagents_prompt_result$schema = () => (_deepseek_ai_dsh_subagent_subagents_prompt_result$schema$value ??= z.object({
   'messageId': z.intersection(z.string(), z.unknown()).readonly(),
-})
+}))
 
 export const TYPERT_REMOTE = {
   package: '@deepseek-ai/dsh-subagent',
@@ -70,7 +51,7 @@ export const TYPERT_REMOTE = {
           codec: {
             mode: 'strict',
             typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
-            schema: _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_0$schema,
+            create: _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_0$schema,
           },
         },
         {
@@ -80,7 +61,7 @@ export const TYPERT_REMOTE = {
           codec: {
             mode: 'strict',
             typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
-            schema: _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_1$schema,
+            create: _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_1$schema,
           },
         },
         {
@@ -90,43 +71,16 @@ export const TYPERT_REMOTE = {
           codec: {
             mode: 'strict',
             typeSymbol: '@deepseek-ai/dsh-subagent#subagents/interruptByParent:mode',
-            schema: _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_2$schema,
+            create: _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,
+        create: _deepseek_ai_dsh_subagent_subagents_interruptByParent_result$schema,
       },
-      sourceLocation: {"file":"packages/subagent/subagent/src/index.ts","line":386,"column":9},
+      sourceLocation: {"file":"packages/subagent/subagent/src/index.ts","line":483,"column":3},
     },
     {
       id: '@deepseek-ai/dsh-subagent#subagents/prompt',
@@ -142,7 +96,7 @@ export const TYPERT_REMOTE = {
           codec: {
             mode: 'strict',
             typeSymbol: '@deepseek-ai/dsh-subagent/client#SubagentPromptRequest',
-            schema: _deepseek_ai_dsh_subagent_subagents_prompt_parameter_0$schema,
+            create: _deepseek_ai_dsh_subagent_subagents_prompt_parameter_0$schema,
           },
         },
       ],
@@ -150,9 +104,9 @@ export const TYPERT_REMOTE = {
       result: {
         mode: 'strict',
         typeSymbol: '@deepseek-ai/dsh-subagent/client#SubagentPromptReceipt',
-        schema: _deepseek_ai_dsh_subagent_subagents_prompt_result$schema,
+        create: _deepseek_ai_dsh_subagent_subagents_prompt_result$schema,
       },
-      sourceLocation: {"file":"packages/subagent/subagent/src/index.ts","line":413,"column":9},
+      sourceLocation: {"file":"packages/subagent/subagent/src/index.ts","line":416,"column":9},
     },
   ],
 }

package/vendor/subagent-core/types/archive-admission.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The `subagent` family of the Workspace registry's archive admission: which
+ * subagent descendants of a Session are still inside a turn, and how they
+ * stop when the Session is archived with its work.
+ *
+ * @module @deepseek-ai/dsh-subagent
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Answer `workspace/session-activity` with the running subagent descendants of
+ * the asked Session, and `workspace/session-stop` by cancelling each of them
+ * as their parent would. Both listeners live as long as `ctx`'s fiber.
+ * @param ctx - context carrying the Agent registry; the Session query service is optional and only supplies labels.
+ */
+export declare function installSubagentArchiveAdmission(ctx: Context): void;
+//# sourceMappingURL=archive-admission.d.ts.map

package/vendor/subagent-core/types/archive-admission.js

@@ -0,0 +1,151 @@
+/**
+ * The `subagent` family of the Workspace registry's archive admission: which
+ * subagent descendants of a Session are still inside a turn, and how they
+ * stop when the Session is archived with its work.
+ *
+ * @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 { foldSubagentDescriptor } from "./descriptor.js";
+/**
+ * Answer `workspace/session-activity` with the running subagent descendants of
+ * the asked Session, and `workspace/session-stop` by cancelling each of them
+ * as their parent would. Both listeners live as long as `ctx`'s fiber.
+ * @param ctx - context carrying the Agent registry; the Session query service is optional and only supplies labels.
+ */
+export function installSubagentArchiveAdmission(ctx) {
+    ctx.on('workspace/session-activity', async ({ sessionId }, next) => {
+        const running = runningDescendants(ctx, sessionId);
+        const rest = await next();
+        if (running.length === 0)
+            return rest;
+        const own = { kind: 'subagent', items: await Promise.all(running.map(child => describe(ctx, child))) };
+        return [own, ...rest];
+    });
+    ctx.on('workspace/session-stop', ({ sessionId }) => {
+        for (const child of runningDescendants(ctx, sessionId)) {
+            try {
+                child.cancel({ kind: 'parent' });
+            }
+            catch (error) {
+                // One child refusing its cancel must not keep its siblings running for an archived parent.
+                ctx.logger.warn(`subagent: cancelling "${child.id}" for an archived Session failed: ${String(error)}`);
+            }
+        }
+    });
+}
+/**
+ * Live subagent descendants inside a turn, by durable lineage: a child whose
+ * header names its parent and carries the subagent origin this package
+ * records, at any depth. A fork shares the lineage field without the origin
+ * and is an independent conversation, so it never holds its source. Lineage
+ * is read as data, so a damaged header chain that loops is visited once.
+ */
+function runningDescendants(ctx, rootId) {
+    const childrenOf = new Map();
+    for (const agent of ctx.agents.list()) {
+        const { parentSession, origin } = agent.session.header;
+        if (parentSession === undefined || origin !== 'subagent')
+            continue;
+        const siblings = childrenOf.get(parentSession) ?? [];
+        siblings.push(agent);
+        childrenOf.set(parentSession, siblings);
+    }
+    const running = [];
+    const pending = [rootId];
+    const visited = new Set();
+    while (pending.length > 0) {
+        const parentId = pending.shift();
+        if (visited.has(parentId))
+            continue;
+        visited.add(parentId);
+        for (const child of childrenOf.get(parentId) ?? []) {
+            if (child.status === 'running')
+                running.push(child);
+            pending.push(child.id);
+        }
+    }
+    return running;
+}
+/**
+ * The child's activity item: its id, plus the durable creation label its
+ * descriptor carries, read through a live Session observation. Without the
+ * Session query service, or with a descriptor that is absent or unreadable,
+ * the item names the child by id alone.
+ */
+async function describe(ctx, child) {
+    const query = ctx.get('sessionQuery');
+    if (query === undefined)
+        return { id: child.id };
+    try {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const observation = __addDisposableResource(env_1, await query.observeSession(child.id, { projectionMode: 'none' }), false);
+            const label = foldSubagentDescriptor(observation.events.slice(observation.inheritedEventCount))?.label;
+            return label === undefined ? { id: child.id } : { id: child.id, label };
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+    catch {
+        // A damaged descriptor is data damage in the child; the report still names the child.
+        return { id: child.id };
+    }
+}
+//# sourceMappingURL=archive-admission.js.map

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

@@ -37,12 +37,12 @@ export declare class AssistantOutputFold {
      * @returns the last non-empty assistant message, else the accumulated
      *   streamed text, or `undefined` when the child produced neither.
      */
-    collect(): ContentBlock[] | undefined;
+    collect(): readonly 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;
+export declare function finalAssistantOutput(events: readonly SessionEvent[]): readonly ContentBlock[] | undefined;
 //# sourceMappingURL=assistant-output.d.ts.map

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

@@ -7,24 +7,31 @@ 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. */
+/** Catalog payload version emitted by live child creation. */
 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;
-} & ({
+type KnownCatalogMode = {
     readonly mode: 'one-shot';
     readonly label?: string;
 } | {
     readonly mode: 'continuable';
     readonly label: string;
-});
+};
+/** Parent catalog v0 records known modes; v1 also retains children with unknown mode. */
+export type SubagentCatalogEvent = {
+    readonly childId: SessionId;
+    readonly childCreatedAt: number;
+} & (({
+    readonly version: 0;
+} & KnownCatalogMode) | ({
+    readonly version: 1;
+} & (KnownCatalogMode | {
+    readonly mode: 'unknown';
+    readonly label?: string;
+})));
 declare module '@deepseek-ai/dsh-session/types' {
     interface SessionEventMap {
         /**
-         * A direct child's complete discovery fact.
+         * A direct child's identity and available discovery fields.
          * @param data - versioned parent-owned catalog entry.
          */
         'subagent/catalog': SubagentCatalogEvent;
@@ -41,7 +48,7 @@ declare module '@deepseek-ai/dsh-session-projection/types' {
     }
 }
 /**
- * Materialize direct children from their parent's successful creation facts.
+ * Materialize complete and unknown-mode child identities from parent catalog events.
  * @param state - parent catalog fold state.
  * @returns current direct-child rows in parent catalog event order.
  */

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

@@ -5,26 +5,28 @@
  */
 import { z } from 'zod';
 import { appendChunkedList, chunkedListSchema, iterateChunkedList } from '@deepseek-ai/dsh-chunked-list';
-/** Current payload version for `subagent/catalog` events. */
+/** Catalog payload version emitted by live child creation. */
 export const SUBAGENT_CATALOG_VERSION = 0;
 const sessionIdSchema = z.string();
 const oneShotCatalogSchema = z.object({
-    version: z.literal(SUBAGENT_CATALOG_VERSION),
+    version: z.union([z.literal(0), z.literal(1)]),
     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),
+    version: z.union([z.literal(0), z.literal(1)]),
     childId: sessionIdSchema,
     childCreatedAt: z.number().int().nonnegative(),
     mode: z.literal('continuable'),
     label: z.string(),
 }).strict();
+const unknownCatalogSchema = oneShotCatalogSchema.extend({ version: z.literal(1), mode: z.literal('unknown') });
 const eventDataSchema = z.union([
     oneShotCatalogSchema,
     continuableCatalogSchema,
+    unknownCatalogSchema,
 ]);
 const viewSchema = z.array(z.union([
     oneShotCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
@@ -35,20 +37,24 @@ const viewSchema = z.array(z.union([
         id: sessionIdSchema,
         createdAt: continuableCatalogSchema.shape.childCreatedAt,
     }),
+    unknownCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
+        id: sessionIdSchema,
+        createdAt: unknownCatalogSchema.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.
+ * Materialize complete and unknown-mode child identities from parent catalog events.
  * @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'
+        entries.push(data.mode !== 'continuable'
             ? {
                 id: data.childId,
                 createdAt: data.childCreatedAt,
@@ -74,7 +80,7 @@ export const subagentCatalogProjectionDefinition = {
             return state;
         return { ...state, head: appendChunkedList(state.head, eventDataSchema.parse(event.data)) };
     },
-    stateVersion: 2,
+    stateVersion: 3,
     wire: { viewSchema, view: subagentCatalogEntries },
 };
 /**

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

@@ -106,6 +106,8 @@ export declare const SUBAGENT_DELEGATION_CONTEXT: string;
 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 shared-bundle preset identity when the parent currently runs in Auto or Full access. */
+    readonly permissionPreset: 'auto' | 'danger-full-access' | undefined;
     /** The parent session's explicit sandbox-mode override, or `undefined` without one. */
     readonly sandboxMode: SandboxMode | undefined;
     /**
@@ -116,12 +118,13 @@ export interface DelegatedPolicyOverrides {
     readonly approvalPolicy: 'never' | undefined;
 }
 /**
- * Capture the policy to seed into one delegation. Call synchronously before
+ * Capture the permission state 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.
+ * parent's future, not to this child. Auto and Full access identities are
+ * inherited only through the in-process DSH path so either can replace a stale
+ * same-bundle fork value. 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.
  */

package/vendor/subagent-core/types/child-agent.js

@@ -172,17 +172,20 @@ export function applyChildComposition(childCtx, parent, composition) {
         childCtx.tools.restrict(composition.toolFilter);
 }
 /**
- * Capture the policy to seed into one delegation. Call synchronously before
+ * Capture the permission state 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.
+ * parent's future, not to this child. Auto and Full access identities are
+ * inherited only through the in-process DSH path so either can replace a stale
+ * same-bundle fork value. 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 function captureDelegatedPolicyOverrides(parent) {
+    const preset = parent.ctx.get('permissionPresets')?.current(parent.session);
     return {
+        permissionPreset: preset === 'auto' || preset === 'danger-full-access' ? preset : undefined,
         sandboxMode: parent.ctx.get('sandboxPolicy')?.overrideOf(parent.session),
         approvalPolicy: parent.ctx.get('approval') === undefined ? undefined : 'never',
     };
@@ -203,5 +206,8 @@ export function appendDelegatedPolicyOverrides(childSession, overrides) {
     if (overrides.approvalPolicy !== undefined) {
         childSession.append('approval/policy', { policy: overrides.approvalPolicy, source: 'delegation' });
     }
+    if (overrides.permissionPreset !== undefined) {
+        childSession.append('permission/preset', { preset: overrides.permissionPreset });
+    }
 }
 //# sourceMappingURL=child-agent.js.map

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

@@ -18,12 +18,22 @@ import type { SubagentDescriptorData } from './descriptor.ts';
 import { SubagentInbox } from './inbox.ts';
 import type { SubagentDelivery } from './inbox.ts';
 import type { ActivationObserver } from './lifecycle.ts';
+/** Process-local slots shared through uninterrupted continuable parent links. */
+declare class ActivationPool {
+    private readonly slots;
+    /** Reserve before reconstruction; the returned release also tolerates unpublished rollback. */
+    reserve(capacity: number): () => void;
+}
 /**
  * One residency epoch for a reconstructed continuable child Agent. It directly
  * owns the published `AgentHandle`; the registry's private activation-owner
  * scope is its structural Cordis owner.
  */
 export interface Activation {
+    /** Shared capacity for this Activation and all its continuable descendants. */
+    readonly pool: ActivationPool;
+    /** Return this epoch's slot after its handle has finished disposal. */
+    readonly releaseSlot: () => void;
     /** The durable child this Activation is an epoch of. */
     readonly childId: SessionId;
     /**
@@ -104,8 +114,11 @@ export declare class ChildLock {
 export declare class ContinuableActivationRegistry {
     private readonly ctx;
     private readonly observeActivation;
+    private readonly maxActiveSubagents;
     /** Child session id → its live Activation. Process-local, never durable. */
     private readonly resident;
+    /** Root identities retain their pool across child settlement without retaining dead roots. */
+    private readonly rootPools;
     /** Materializations admitted before drain, tracked through publication or rollback. */
     private readonly materializations;
     /** Per-child serializer shared by delivery, release, and disposal. */
@@ -125,7 +138,7 @@ export declare class ContinuableActivationRegistry {
      * @param ctx - context providing Agents, Sessions, and teardown ownership.
      * @param observeActivation - build the lifecycle observer for one residency epoch.
      */
-    constructor(ctx: Context, observeActivation: (provider: string, childId: SessionId, parent: Agent) => ActivationObserver);
+    constructor(ctx: Context, observeActivation: (provider: string, childId: SessionId, parent: Agent) => ActivationObserver, maxActiveSubagents: () => number);
     /**
      * Return the live Activation for a durable child id, if resident.
      * @param childId - durable child session id to look up.
@@ -227,6 +240,8 @@ export declare class ContinuableActivationRegistry {
     private liveLineage;
     /** Return the teardown that closed continuable admission for this agent's lineage. */
     private closingTeardownFor;
+    /** Resolve a root's pool once; descendants inherit their resident parent's pool directly. */
+    private rootPool;
     /** Perform one tracked materialization through publication or rollback. */
     private materializeTracked;
     /** Release an Activation whose start edge was not published. */
@@ -248,4 +263,5 @@ export declare class ContinuableActivationRegistry {
     /** Request a best-effort final session flush before closing natural-settlement admission. */
     private flushFinalState;
 }
+export {};
 //# sourceMappingURL=continuation-activation.d.ts.map