@morlay/dsh-subagent 0.0.10 → 0.0.11-alpha.0

package/src/vendor/dsh-subagent/catalog.ts

@@ -4,124 +4,98 @@
  * @module @deepseek-ai/dsh-subagent/catalog
  */
 
-import { z } from "zod";
-import {
-  appendChunkedList,
-  chunkedListSchema,
-  iterateChunkedList,
-} from "@deepseek-ai/dsh-chunked-list";
-import type { ChunkedList } from "@deepseek-ai/dsh-chunked-list";
+import { z } from 'zod'
+import { appendChunkedList, chunkedListSchema, iterateChunkedList } from '@deepseek-ai/dsh-chunked-list'
+import type { ChunkedList } from '@deepseek-ai/dsh-chunked-list'
 import type {
   Session,
   SessionEvent,
   SessionHeader,
   SessionId,
   SessionLogOffset,
-} from "@deepseek-ai/dsh-session";
-import type { ProjectionDefinition } from "@deepseek-ai/dsh-session-projection";
-import type { SubagentCatalogEntry } from "./projection-types.ts";
+} from '@deepseek-ai/dsh-session'
+import type { ProjectionDefinition } from '@deepseek-ai/dsh-session-projection'
+import type { SubagentCatalogEntry } from './projection-types.ts'
 
 /** Catalog payload version emitted by local child creation. */
-export const SUBAGENT_CATALOG_VERSION = 0;
+export const SUBAGENT_CATALOG_VERSION = 0
 
 type KnownCatalogMode =
-  | { readonly mode: "one-shot"; readonly label?: string }
-  | { readonly mode: "continuable"; readonly label: string };
+  | { readonly mode: 'one-shot'; readonly label?: string }
+  | { readonly mode: 'continuable'; readonly label: string }
 
 /** Parent catalog v0 records local modes, v1 adds unknown children, and v2 records external executions. */
-export type SubagentCatalogEvent = {
-  readonly childId: SessionId;
-  readonly childCreatedAt: number;
-} & (
-  | ({ readonly version: 0 } & KnownCatalogMode)
-  | ({ readonly version: 1 } & (
-      | KnownCatalogMode
-      | { readonly mode: "unknown"; readonly label?: string }
-    ))
-  | { readonly version: 2; readonly mode: "external"; readonly label?: string }
-);
+export type SubagentCatalogEvent =
+  & {
+    readonly childId: SessionId
+    readonly childCreatedAt: number
+  } & (
+    | ({ readonly version: 0 } & KnownCatalogMode)
+    | ({ readonly version: 1 } & (KnownCatalogMode | { readonly mode: 'unknown'; readonly label?: string }))
+    | { readonly version: 2; readonly mode: 'external'; readonly label?: string }
+  )
 
-declare module "@deepseek-ai/dsh-session/types" {
+declare module '@deepseek-ai/dsh-session/types' {
   interface SessionEventMap {
     /**
      * A direct child's identity and available discovery fields.
      * @param data - versioned parent-owned catalog entry.
      */
-    "subagent/catalog": SubagentCatalogEvent;
+    'subagent/catalog': SubagentCatalogEvent
   }
 }
 
 /** Host fold state for one parent catalog. */
 export interface SubagentCatalogState {
-  readonly inheritedEventCount: SessionLogOffset;
-  readonly head?: ChunkedList<SubagentCatalogEvent> | undefined;
+  readonly inheritedEventCount: SessionLogOffset
+  readonly head?: ChunkedList<SubagentCatalogEvent> | undefined
 }
 
-const sessionIdSchema = z.string() as unknown as z.ZodType<SessionId>;
-const oneShotCatalogSchema = z
-  .object({
-    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.union([z.literal(0), z.literal(1)]),
-    childId: sessionIdSchema,
-    childCreatedAt: z.number().int().nonnegative(),
-    mode: z.literal("continuable"),
-    label: z.string(),
-  })
-  .strict();
-const externalCatalogSchema = oneShotCatalogSchema.extend({
-  version: z.literal(2),
-  mode: z.literal("external"),
-});
-const unknownCatalogSchema = oneShotCatalogSchema.extend({
-  version: z.literal(1),
-  mode: z.literal("unknown"),
-});
+const sessionIdSchema = z.string() as unknown as z.ZodType<SessionId>
+const oneShotCatalogSchema = z.object({
+  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.union([z.literal(0), z.literal(1)]),
+  childId: sessionIdSchema,
+  childCreatedAt: z.number().int().nonnegative(),
+  mode: z.literal('continuable'),
+  label: z.string(),
+}).strict()
+const externalCatalogSchema = oneShotCatalogSchema.extend({ version: z.literal(2), mode: z.literal('external') })
+const unknownCatalogSchema = oneShotCatalogSchema.extend({ version: z.literal(1), mode: z.literal('unknown') })
 const eventDataSchema = z.union([
   oneShotCatalogSchema,
   externalCatalogSchema,
   continuableCatalogSchema,
   unknownCatalogSchema,
-]) as z.ZodType<SubagentCatalogEvent>;
-const viewSchema = z.array(
-  z.union([
-    oneShotCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
-      id: sessionIdSchema,
-      createdAt: oneShotCatalogSchema.shape.childCreatedAt,
-    }),
-    externalCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
-      id: sessionIdSchema,
-      createdAt: externalCatalogSchema.shape.childCreatedAt,
-    }),
-    continuableCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
-      id: sessionIdSchema,
-      createdAt: continuableCatalogSchema.shape.childCreatedAt,
-    }),
-    unknownCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
-      id: sessionIdSchema,
-      createdAt: unknownCatalogSchema.shape.childCreatedAt,
-    }),
-  ]),
-) as z.ZodType<SubagentCatalogEntry[]>;
-const stateSchema: z.ZodType<SubagentCatalogState> = z
-  .object({
-    inheritedEventCount: z.number().int().nonnegative() as unknown as z.ZodType<SessionLogOffset>,
-    head: chunkedListSchema(eventDataSchema).optional(),
-  })
-  .strict();
-
-declare module "@deepseek-ai/dsh-session-projection/types" {
-  interface SessionProjectionStateMap {
-    subagentCatalog: SubagentCatalogState;
-  }
-}
+]) as z.ZodType<SubagentCatalogEvent>
+const viewSchema = z.array(z.union([
+  oneShotCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
+    id: sessionIdSchema,
+    createdAt: oneShotCatalogSchema.shape.childCreatedAt,
+  }),
+  externalCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
+    id: sessionIdSchema,
+    createdAt: externalCatalogSchema.shape.childCreatedAt,
+  }),
+  continuableCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
+    id: sessionIdSchema,
+    createdAt: continuableCatalogSchema.shape.childCreatedAt,
+  }),
+  unknownCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
+    id: sessionIdSchema,
+    createdAt: unknownCatalogSchema.shape.childCreatedAt,
+  }),
+])) as z.ZodType<SubagentCatalogEntry[]>
+const stateSchema: z.ZodType<SubagentCatalogState> = z.object({
+  inheritedEventCount: z.number().int().nonnegative() as unknown as z.ZodType<SessionLogOffset>,
+  head: chunkedListSchema(eventDataSchema).optional(),
+}).strict()
 
 /**
  * Materialize complete and unknown-mode child identities from parent catalog events.
@@ -129,28 +103,26 @@ declare module "@deepseek-ai/dsh-session-projection/types" {
  * @returns current direct-child rows in parent catalog event order.
  */
 function subagentCatalogEntries(state: SubagentCatalogState): SubagentCatalogEntry[] {
-  const entries: SubagentCatalogEntry[] = [];
+  const entries: SubagentCatalogEntry[] = []
   for (const data of iterateChunkedList(state.head)) {
-    const { version: _version, childId, childCreatedAt, ...descriptor } = data;
-    entries.push({ id: childId, createdAt: childCreatedAt, ...descriptor });
+    const { version: _version, childId, childCreatedAt, ...descriptor } = data
+    entries.push({ id: childId, createdAt: childCreatedAt, ...descriptor })
   }
-  return entries;
+  return entries
 }
 
 /** Parent-owned direct-child catalog projection; invalid own facts reject restoration. */
 export const subagentCatalogProjectionDefinition = {
-  key: "subagentCatalog",
+  key: 'subagentCatalog',
   stateSchema,
-  init: (_header: SessionHeader, inheritedEventCount: SessionLogOffset) => ({
-    inheritedEventCount,
-  }),
+  init: (_header: SessionHeader, inheritedEventCount: SessionLogOffset) => ({ inheritedEventCount }),
   apply: (state, event: SessionEvent) => {
-    if (event.type !== "subagent/catalog" || event.seq < state.inheritedEventCount) return state;
-    return { ...state, head: appendChunkedList(state.head, eventDataSchema.parse(event.data)) };
+    if (event.type !== 'subagent/catalog' || event.seq < state.inheritedEventCount) return state
+    return { ...state, head: appendChunkedList(state.head, eventDataSchema.parse(event.data)) }
   },
   stateVersion: 6,
   wire: { viewSchema, view: subagentCatalogEntries },
-} satisfies ProjectionDefinition<"subagentCatalog", SubagentCatalogState>;
+} satisfies ProjectionDefinition<'subagentCatalog', SubagentCatalogState>
 
 /**
  * Append a complete direct-child discovery fact to its parent Session.
@@ -161,19 +133,19 @@ export const subagentCatalogProjectionDefinition = {
 export function establishCatalogChild(
   parent: Session,
   child: SessionHeader,
-  descriptor: { readonly mode: "continuable"; readonly label: string },
+  descriptor: { readonly mode: 'continuable'; readonly label: string },
 ): void {
-  parent.append("subagent/catalog", {
+  parent.append('subagent/catalog', {
     version: SUBAGENT_CATALOG_VERSION,
     childId: child.id,
     childCreatedAt: child.createdAt,
     mode: descriptor.mode,
     label: descriptor.label,
-  });
+  })
 }
 
 /** Catalog payload version emitted by external execution creation. */
-const EXTERNAL_SUBAGENT_CATALOG_VERSION = 2;
+const EXTERNAL_SUBAGENT_CATALOG_VERSION = 2
 
 /**
  * Record an external execution without a local child Session.
@@ -181,16 +153,12 @@ const EXTERNAL_SUBAGENT_CATALOG_VERSION = 2;
  * @param childId - identity returned by the external provider.
  * @param label - display label assigned by the caller.
  */
-export function establishExternalCatalogChild(
-  parent: Session,
-  childId: SessionId,
-  label: string,
-): void {
-  parent.append("subagent/catalog", {
+export function establishExternalCatalogChild(parent: Session, childId: SessionId, label: string): void {
+  parent.append('subagent/catalog', {
     version: EXTERNAL_SUBAGENT_CATALOG_VERSION,
     childId,
     childCreatedAt: Date.now(),
-    mode: "external",
+    mode: 'external',
     label,
-  });
+  })
 }

package/src/vendor/dsh-subagent/child-agent.ts

@@ -6,36 +6,33 @@
  * @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 {} from "@deepseek-ai/dsh-system-prompt";
-import type { ToolRestriction } from "@deepseek-ai/dsh-tools";
+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 {} from '@deepseek-ai/dsh-system-prompt'
+import type { ToolRestriction } from '@deepseek-ai/dsh-tools'
 // Type-only: make `ctx.get('sandboxPolicy')`, `ctx.get('approval')`, and
 // `ctx.get('permissionPresets')` resolve to their services when composed — delegation consumes them
 // opportunistically (the documented `ctx.get` pattern), never as a hard dep —
 // and merge the inherited permission session-event payloads.
-import type {} from "@deepseek-ai/dsh-sandbox-policy";
-import type {} from "@deepseek-ai/dsh-user-approval";
-import type {} from "@deepseek-ai/dsh-permission-presets";
+import type {} from '@deepseek-ai/dsh-sandbox-policy'
+import type {} from '@deepseek-ai/dsh-user-approval'
+import type {} from '@deepseek-ai/dsh-permission-presets'
 // Type-only: make `ctx.get('agentPresets')` resolve to the preset roster when
 // composed — a child inherits its parent's composition opportunistically (the
 // documented `ctx.get` pattern), never as a hard dep. A rosterless deployment
 // keeps its model-facing rows on the host plane, where the child already sees
 // them through the tool registry's global layer.
-import type {} from "@deepseek-ai/dsh-agent-preset-registry";
-import { delegationDepthOf } from "./depth.ts";
-import { SubagentError } from "./error.ts";
+import type {} from '@deepseek-ai/dsh-agent-preset-registry'
+import { delegationDepthOf } from './depth.ts'
+import { SubagentError } from './error.ts'
 
 /** Thrown when starting a child would exceed the requested depth cap. */
 export class SubagentDepthError extends Error {
-  constructor(
-    public readonly attemptedDepth: number,
-    public readonly maxDepth: number,
-  ) {
-    super(`subagent depth ${attemptedDepth} exceeds maxDepth ${maxDepth}`);
-    this.name = "SubagentDepthError";
+  constructor(public readonly attemptedDepth: number, public readonly maxDepth: number) {
+    super(`subagent depth ${attemptedDepth} exceeds maxDepth ${maxDepth}`)
+    this.name = 'SubagentDepthError'
   }
 }
 
@@ -50,14 +47,14 @@ export class SubagentDepthError extends Error {
  * @throws {RangeError} when the resolved depth leaves the safe-integer range.
  */
 export function resolveChildDepth(parent: Agent, maxDepth: number | undefined): number {
-  const childDepth = delegationDepthOf(parent) + 1;
+  const childDepth = delegationDepthOf(parent) + 1
   if (!Number.isSafeInteger(childDepth)) {
-    throw new RangeError("subagent child depth exceeds the safe-integer range");
+    throw new RangeError('subagent child depth exceeds the safe-integer range')
   }
   if (maxDepth !== undefined && childDepth > maxDepth) {
-    throw new SubagentDepthError(childDepth, maxDepth);
+    throw new SubagentDepthError(childDepth, maxDepth)
   }
-  return childDepth;
+  return childDepth
 }
 
 /**
@@ -69,22 +66,22 @@ export function resolveChildDepth(parent: Agent, maxDepth: number | undefined):
  * @returns detached Agent options for child-option merging.
  */
 export function parentAgentOptionsForDelegation(parent: Agent): AgentOptions {
-  const requestConfig = parent.session.requestHeader()?.config;
-  if (requestConfig === undefined) return { ...parent.options };
+  const requestConfig = parent.session.requestHeader()?.config
+  if (requestConfig === undefined) return { ...parent.options }
   const {
     provider: _createdProvider,
     model: _createdModel,
     reasoningEffort: _createdReasoningEffort,
     ...createdOptions
-  } = parent.options;
+  } = parent.options
   return {
     ...createdOptions,
     provider: requestConfig.provider,
     model: requestConfig.model,
-    ...(requestConfig.reasoningEffort === undefined
+    ...requestConfig.reasoningEffort === undefined
       ? {}
-      : { reasoningEffort: requestConfig.reasoningEffort }),
-  };
+      : { reasoningEffort: requestConfig.reasoningEffort },
+  }
 }
 
 /**
@@ -103,22 +100,22 @@ export function resolveChildAgentOptions(
   requested: AgentOptions | undefined,
   childDepth: number,
 ): AgentOptions {
-  const parentOptions = parentAgentOptionsForDelegation(parent);
-  const parentProvider = parentOptions.provider;
-  const parentModel = parentOptions.model;
-  const parentReasoningEffort = parentOptions.reasoningEffort;
-  const parentMaxTokens = parentOptions.maxTokens;
+  const parentOptions = parentAgentOptionsForDelegation(parent)
+  const parentProvider = parentOptions.provider
+  const parentModel = parentOptions.model
+  const parentReasoningEffort = parentOptions.reasoningEffort
+  const parentMaxTokens = parentOptions.maxTokens
   const resolved: AgentOptions = {
-    ...(parentProvider !== undefined ? { provider: parentProvider } : {}),
-    ...(parentModel !== undefined ? { model: parentModel } : {}),
-    ...(parentReasoningEffort !== undefined ? { reasoningEffort: parentReasoningEffort } : {}),
-    ...(parentMaxTokens !== undefined ? { maxTokens: parentMaxTokens } : {}),
+    ...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;
+  }
+  const routeChanged = resolved.provider !== parentProvider || resolved.model !== parentModel
+  if (routeChanged && requested?.reasoningEffort === undefined) delete resolved.reasoningEffort
+  return resolved
 }
 
 /**
@@ -140,30 +137,30 @@ export function childSessionMeta(
   childDepth: number,
   isSeeded: boolean,
   selectedPreset?: string,
-): NonNullable<CreateAgentOptions["meta"]> {
-  const parentHeader = parent.session.header;
-  const agentPreset = selectedPreset ?? parent.ctx.get("agentPresets")?.composedPreset(parent.ctx);
+): NonNullable<CreateAgentOptions['meta']> {
+  const parentHeader = parent.session.header
+  const agentPreset = selectedPreset ?? parent.ctx.get('agentPresets')?.composedPreset(parent.ctx)
   return {
-    ...(parentHeader.cwd !== undefined ? { cwd: parentHeader.cwd } : {}),
-    ...(agentPreset === undefined ? {} : { agentPreset }),
+    ...parentHeader.cwd !== undefined ? { cwd: parentHeader.cwd } : {},
+    ...agentPreset === undefined ? {} : { agentPreset },
     parentSession: parentHeader.id,
     isSeeded,
     // Navigation classification only; the descriptor remains the authority
     // for mode and continuation capability.
-    origin: "subagent",
+    origin: 'subagent',
     // Durable: the recursion budget must survive persistence and resume.
     delegationDepth: childDepth,
-  };
+  }
 }
 
 /** The scoped composition a child agent's creation window applies. */
 export interface ChildComposition {
   /** Independently mounted preset; omission shares the parent's standing generation. */
-  readonly agentPreset?: string | undefined;
+  readonly agentPreset?: string | undefined
   /** Historical descriptor persona reapplied only during cold resume. */
-  readonly persona?: string | undefined;
+  readonly persona?: string | undefined
   /** Historical descriptor tool restriction reapplied only during cold resume. */
-  readonly toolFilter?: ToolRestriction | undefined;
+  readonly toolFilter?: ToolRestriction | undefined
 }
 
 /**
@@ -171,11 +168,11 @@ export interface ChildComposition {
  * runtime-context contribution rather than a system-prompt section, so the
  * deployment's system prompt stays uniform across parents and children.
  */
-export const SUBAGENT_DELEGATION_CONTEXT =
-  "You are a delegated subagent: your permission scope was fixed when you were started and cannot be " +
-  "widened from inside this session — operations that require approval are rejected automatically. " +
-  "When the task needs access beyond that scope, do not retry the denied operation; state the " +
-  "limitation in your reply so the delegating agent can handle it.";
+export const SUBAGENT_DELEGATION_CONTEXT
+  = 'You are a delegated subagent: your permission scope was fixed when you were started and cannot be '
+    + 'widened from inside this session — operations that require approval are rejected automatically. '
+    + 'When the task needs access beyond that scope, do not retry the denied operation; state the '
+    + 'limitation in your reply so the delegating agent can handle it.'
 
 /**
  * Compose a child before publication and restore historical descriptor overrides.
@@ -192,35 +189,32 @@ export function applyChildComposition(
   composition: ChildComposition,
 ): void | Promise<void> {
   if (composition.agentPreset !== undefined) {
-    const presets = childCtx.get("agentPresets");
+    const presets = childCtx.get('agentPresets')
     if (presets === undefined) {
-      throw new SubagentError(
-        "selecting a child agent preset requires the agent-presets service",
-        "PRESET_UNAVAILABLE",
-      );
+      throw new SubagentError('selecting a child agent preset requires the agent-presets service', 'PRESET_UNAVAILABLE')
     }
     return presets.mount(childCtx, composition.agentPreset).then(() => {
-      applyChildOverrides(childCtx, composition);
-    });
+      applyChildOverrides(childCtx, composition)
+    })
   }
-  childCtx.get("agentPresets")?.composeFrom(childCtx, parent.ctx);
-  applyChildOverrides(childCtx, composition);
+  childCtx.get('agentPresets')?.composeFrom(childCtx, parent.ctx)
+  applyChildOverrides(childCtx, composition)
 }
 
 function applyChildOverrides(childCtx: Context, composition: ChildComposition): void {
   childCtx.systemPrompt.context({
-    name: "subagent:delegation",
-    order: childCtx.systemPrompt.getContextOrder("SUBAGENT_DELEGATION"),
+    name: 'subagent:delegation',
+    order: childCtx.systemPrompt.getContextOrder('SUBAGENT_DELEGATION'),
     text: SUBAGENT_DELEGATION_CONTEXT,
-  });
+  })
   if (composition.persona !== undefined) {
     childCtx.systemPrompt.section({
-      name: "deployment:persona-prefix",
-      order: childCtx.systemPrompt.getSectionOrder("DEPLOYMENT_PERSONA_PREFIX"),
+      name: 'deployment:persona-prefix',
+      order: childCtx.systemPrompt.getSectionOrder('DEPLOYMENT_PERSONA_PREFIX'),
       text: composition.persona,
-    });
+    })
   }
-  if (composition.toolFilter !== undefined) childCtx.tools.restrict(composition.toolFilter);
+  if (composition.toolFilter !== undefined) childCtx.tools.restrict(composition.toolFilter)
 }
 
 /** Policy seeded onto a child session's log at the delegation boundary. */
@@ -229,15 +223,15 @@ export interface DelegatedPolicyOverrides {
    * The parent's current preset identity when it runs in Auto or Full access;
    * the child keeps it under the pinned `never` approval policy.
    */
-  readonly permissionPreset: "auto" | "danger-full-access" | undefined;
+  readonly permissionPreset: 'auto' | 'danger-full-access' | undefined
   /** The parent session's explicit sandbox-mode override, or `undefined` without one. */
-  readonly sandboxMode: SandboxMode | undefined;
+  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;
+  readonly approvalPolicy: 'never' | undefined
 }
 
 /**
@@ -252,21 +246,21 @@ export interface DelegatedPolicyOverrides {
  * @returns the sandbox override (or `undefined` without one) and the approval pin.
  */
 export function captureDelegatedPolicyOverrides(parent: Agent): DelegatedPolicyOverrides {
-  const preset = parent.ctx.get("permissionPresets")?.current(parent.session);
+  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",
-  };
+    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',
+  }
 }
 
 /**
  * Append the captured delegation policy onto the child's own log as
- * `source: 'delegation'` events inside the unpublished creation window, so the
+ * `source: 'delegation'` events after Session announcement and before Agent registration, 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 childSession - the child's announced, writable Session.
  * @param overrides - the policy captured at delegation.
  */
 export function appendDelegatedPolicyOverrides(
@@ -274,27 +268,24 @@ export function appendDelegatedPolicyOverrides(
   overrides: DelegatedPolicyOverrides,
 ): void {
   if (overrides.sandboxMode !== undefined) {
-    childSession.append("sandbox/mode", { mode: overrides.sandboxMode, source: "delegation" });
+    childSession.append('sandbox/mode', { mode: overrides.sandboxMode, source: 'delegation' })
   }
   if (overrides.approvalPolicy !== undefined) {
-    childSession.append("approval/policy", {
-      policy: overrides.approvalPolicy,
-      source: "delegation",
-    });
+    childSession.append('approval/policy', { policy: overrides.approvalPolicy, source: 'delegation' })
   }
   if (overrides.permissionPreset !== undefined) {
-    childSession.append("permission/preset", { preset: overrides.permissionPreset });
+    childSession.append('permission/preset', { preset: overrides.permissionPreset })
   }
 }
 
 /** Identity and lineage inputs shared by every in-process child creation. */
 export interface ChildCreateInputs {
   /** The child's reserved session id. */
-  readonly sessionId: SessionId;
+  readonly sessionId: SessionId
   /** The delegating parent agent. */
-  readonly parent: Agent;
+  readonly parent: Agent
   /** The resolved delegation depth. */
-  readonly childDepth: number;
+  readonly childDepth: number
   /** How many leading seed events came from the parent's log. */
-  readonly lineageSeedLength: number;
+  readonly lineageSeedLength: number
 }