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

package/src/vendor/dsh-subagent/out-of-process.ts

@@ -10,22 +10,17 @@
  * @module @deepseek-ai/dsh-subagent/out-of-process
  */
 
-import { accessSync, constants, statSync } from "node:fs";
-import { isAbsolute } from "node:path";
-import type { ContentBlock } from "@deepseek-ai/dsh-llm";
-import type {
-  SubagentCapabilities,
-  SubagentResult,
-  SubagentRun,
-  SubagentStopReason,
-} from "./types.ts";
+import { accessSync, constants, statSync } from 'node:fs'
+import { isAbsolute } from 'node:path'
+import type { ContentBlock } from '@deepseek-ai/dsh-llm'
+import type { SubagentCapabilities, SubagentResult, SubagentRun, SubagentStopReason } from './types.ts'
 
 /** Maximum UTF-8 size of {@link SubagentResult.diagnostic}. */
-const MAX_SUBAGENT_DIAGNOSTIC_BYTES = 4_096;
+const MAX_SUBAGENT_DIAGNOSTIC_BYTES = 4_096
 
-const DIAGNOSTIC_TRUNCATION_SUFFIX = "\n[diagnostic truncated]";
-const utf8Encoder = new TextEncoder();
-const utf8Decoder = new TextDecoder();
+const DIAGNOSTIC_TRUNCATION_SUFFIX = '\n[diagnostic truncated]'
+const utf8Encoder = new TextEncoder()
+const utf8Decoder = new TextDecoder()
 
 /**
  * Limit provider-authored failure detail without splitting a UTF-8 sequence.
@@ -33,22 +28,23 @@ const utf8Decoder = new TextDecoder();
  * @returns the original text, or a visibly truncated value within the limit.
  */
 function limitSubagentDiagnostic(diagnostic: string): string {
-  const bytes = utf8Encoder.encode(diagnostic);
-  if (bytes.byteLength <= MAX_SUBAGENT_DIAGNOSTIC_BYTES) return diagnostic;
+  const bytes = utf8Encoder.encode(diagnostic)
+  if (bytes.byteLength <= MAX_SUBAGENT_DIAGNOSTIC_BYTES) return diagnostic
 
-  const suffixBytes = utf8Encoder.encode(DIAGNOSTIC_TRUNCATION_SUFFIX).byteLength;
-  let prefixBytes = MAX_SUBAGENT_DIAGNOSTIC_BYTES - suffixBytes;
+  const suffixBytes = utf8Encoder.encode(DIAGNOSTIC_TRUNCATION_SUFFIX).byteLength
+  let prefixBytes = MAX_SUBAGENT_DIAGNOSTIC_BYTES - suffixBytes
   while (((bytes[prefixBytes] as number) & 0b1100_0000) === 0b1000_0000) {
-    prefixBytes -= 1;
+    prefixBytes -= 1
   }
-  return utf8Decoder.decode(bytes.subarray(0, prefixBytes)) + DIAGNOSTIC_TRUNCATION_SUFFIX;
+  return utf8Decoder.decode(bytes.subarray(0, prefixBytes))
+    + DIAGNOSTIC_TRUNCATION_SUFFIX
 }
 
 /** Enforce the byte limit on a provider-returned diagnostic. */
 function normalizeSubagentDiagnostic(result: SubagentResult): SubagentResult {
   return result.diagnostic === undefined
     ? result
-    : { ...result, diagnostic: limitSubagentDiagnostic(result.diagnostic) };
+    : { ...result, diagnostic: limitSubagentDiagnostic(result.diagnostic) }
 }
 
 /**
@@ -62,7 +58,7 @@ export const NO_START_CAPABILITIES: SubagentCapabilities = Object.freeze({
   agentPreset: false,
   outputSchema: false,
   depthLimit: false,
-});
+})
 
 /**
  * Assert a configured timing bound is a positive finite number (it bounds a
@@ -73,7 +69,7 @@ export const NO_START_CAPABILITIES: SubagentCapabilities = Object.freeze({
  */
 export function assertPositiveFinite(prefix: string, name: string, value: number): void {
   if (!Number.isFinite(value) || value <= 0) {
-    throw new Error(`${prefix}: ${name} must be a positive finite number`);
+    throw new Error(`${prefix}: ${name} must be a positive finite number`)
   }
 }
 
@@ -84,14 +80,14 @@ export function assertPositiveFinite(prefix: string, name: string, value: number
  */
 function isEnterableDirectory(path: string): boolean {
   try {
-    if (!statSync(path).isDirectory()) return false;
-    accessSync(path, constants.X_OK);
-    return true;
+    if (!statSync(path).isDirectory()) return false
+    accessSync(path, constants.X_OK)
+    return true
   } catch {
     // statSync/accessSync throw only filesystem access errors here
     // (ENOENT/EACCES/ENOTDIR/…), and every one of them means the path cannot
     // serve as the child's cwd.
-    return false;
+    return false
   }
 }
 
@@ -107,12 +103,12 @@ function isEnterableDirectory(path: string): boolean {
  */
 export function assertUsableCwd(prefix: string, label: string, cwd: string): string {
   if (!isAbsolute(cwd)) {
-    throw new Error(`${prefix}: ${label} must be an absolute path: ${cwd}`);
+    throw new Error(`${prefix}: ${label} must be an absolute path: ${cwd}`)
   }
   if (!isEnterableDirectory(cwd)) {
-    throw new Error(`${prefix}: ${label} is not an accessible directory: ${cwd}`);
+    throw new Error(`${prefix}: ${label} is not an accessible directory: ${cwd}`)
   }
-  return cwd;
+  return cwd
 }
 
 /** Normalize an unknown thrown value to an Error (the catch binding is `unknown`). */
@@ -121,25 +117,25 @@ function toError(value: unknown): Error {
   // `Error`s; the `String(value)` arm is a defensive fallback for a non-Error
   // throw the typed surfaces cannot produce.
   /* v8 ignore next */
-  return value instanceof Error ? value : new Error(String(value));
+  return value instanceof Error ? value : new Error(String(value))
 }
 
 /** Inputs to {@link settleRunResult}. */
 export interface RunResultSettlement {
   /** The turn attempt (typically racing local cancellation); returns the terminal result. */
-  attempt: () => Promise<SubagentResult>;
+  attempt: () => Promise<SubagentResult>
   /** Snapshot the provider exposes when cancellation or failure wins settlement. */
-  collectOutput: () => readonly ContentBlock[];
+  collectOutput: () => readonly ContentBlock[]
   /** Snapshot safe provider-authored detail when a failure wins settlement. */
-  collectDiagnostic?: (() => string | undefined) | undefined;
+  collectDiagnostic?: (() => string | undefined) | undefined
   /** Whether local cancellation settled before the attempt's outcome is observed. */
-  cancelled: () => boolean;
+  cancelled: () => boolean
   /** Diagnostic sink for a failure flattened to a stop reason; a throw from it is contained. */
-  onError?: ((error: Error, stopReason: SubagentStopReason) => void) | undefined;
+  onError?: ((error: Error, stopReason: SubagentStopReason) => void) | undefined
   /** The request's cancellation signal (the listener is removed at settlement). */
-  signal: AbortSignal;
+  signal: AbortSignal
   /** The abort listener registered on {@link signal} at start. */
-  onAbort: () => void;
+  onAbort: () => void
 }
 
 /**
@@ -154,45 +150,47 @@ export interface RunResultSettlement {
  */
 export async function settleRunResult(parts: RunResultSettlement): Promise<SubagentResult> {
   try {
-    const result = await parts.attempt();
+    const result = await parts.attempt()
     return parts.cancelled()
-      ? { output: parts.collectOutput(), stopReason: "aborted" }
-      : normalizeSubagentDiagnostic(result);
+      ? { output: parts.collectOutput(), stopReason: 'aborted' }
+      : normalizeSubagentDiagnostic(result)
   } catch (error: unknown) {
     // Cover a rejection already queued when cancellation arrives.
-    if (parts.cancelled()) return { output: parts.collectOutput(), stopReason: "aborted" };
+    if (parts.cancelled()) return { output: parts.collectOutput(), stopReason: 'aborted' }
     // Flatten post-publication transport failures while preserving diagnostics.
     try {
-      parts.onError?.(toError(error), "error");
+      parts.onError?.(toError(error), 'error')
     } catch {
       // The diagnostic sink cannot reject the run result.
     }
-    const collected = parts.collectDiagnostic?.();
-    const diagnostic = collected === undefined ? undefined : limitSubagentDiagnostic(collected);
+    const collected = parts.collectDiagnostic?.()
+    const diagnostic = collected === undefined
+      ? undefined
+      : limitSubagentDiagnostic(collected)
     return {
       output: parts.collectOutput(),
-      ...(diagnostic === undefined ? {} : { diagnostic }),
-      stopReason: "error",
-    };
+      ...diagnostic === undefined ? {} : { diagnostic },
+      stopReason: 'error',
+    }
   } finally {
-    parts.signal.removeEventListener("abort", parts.onAbort);
+    parts.signal.removeEventListener('abort', parts.onAbort)
   }
 }
 
 /** Inputs to {@link subprocessRunHandle}. */
 export interface SubprocessRunHandleParts {
   /** The parent-scoped run id. */
-  id: SubagentRun["id"];
+  id: SubagentRun['id']
   /** The flattened, never-rejecting result (the seam contract). */
-  result: Promise<SubagentResult>;
+  result: Promise<SubagentResult>
   /** The request's cancellation signal (the listener is removed on dispose). */
-  signal: AbortSignal;
+  signal: AbortSignal
   /** The abort listener registered on {@link signal} at start. */
-  onAbort: () => void;
+  onAbort: () => void
   /** Settle local cancellation so {@link result} resolves without the child. */
-  requestCancel: () => void;
+  requestCancel: () => void
   /** Tear the child process down to quiescence (backend-owned ladder). */
-  teardown: () => Promise<void>;
+  teardown: () => Promise<void>
 }
 
 /**
@@ -204,16 +202,16 @@ export interface SubprocessRunHandleParts {
  * @returns the external run handle.
  */
 export function subprocessRunHandle(parts: SubprocessRunHandleParts): SubagentRun {
-  let disposal: Promise<void> | undefined;
+  let disposal: Promise<void> | undefined
   return {
     id: parts.id,
     result: parts.result,
     dispose(): Promise<void> {
-      if (disposal !== undefined) return disposal;
-      parts.signal.removeEventListener("abort", parts.onAbort);
-      parts.requestCancel();
-      disposal = parts.teardown();
-      return disposal;
+      if (disposal !== undefined) return disposal
+      parts.signal.removeEventListener('abort', parts.onAbort)
+      parts.requestCancel()
+      disposal = parts.teardown()
+      return disposal
     },
-  };
+  }
 }

package/src/vendor/dsh-subagent/projection-types.ts

@@ -4,35 +4,37 @@
  * @module @deepseek-ai/dsh-subagent/projection-types
  */
 
-import type { SessionId, SessionSeq } from "@deepseek-ai/dsh-session/types";
+import type { SessionId, SessionSeq } from '@deepseek-ai/dsh-session/types'
 
 /** One current direct-child discovery row materialized from parent facts. */
-export type SubagentCatalogEntry = {
-  readonly id: SessionId;
-  readonly createdAt: number;
-} & (
-  | { readonly mode: "one-shot"; readonly label?: string }
-  | { readonly mode: "external"; readonly label?: string }
-  | { readonly mode: "continuable"; readonly label: string }
-  | { readonly mode: "unknown"; readonly label?: string }
-);
+export type SubagentCatalogEntry =
+  & {
+    readonly id: SessionId
+    readonly createdAt: number
+  }
+  & (
+    | { readonly mode: 'one-shot'; readonly label?: string }
+    | { readonly mode: 'external'; readonly label?: string }
+    | { readonly mode: 'continuable'; readonly label: string }
+    | { readonly mode: 'unknown'; readonly label?: string }
+  )
 
 /** Durable active-turn timing for one descriptor-backed child session. */
 export interface SubagentTimingProjection {
   /** Milliseconds accumulated across completed turns after the child's own descriptor. */
-  settledMs: number;
+  settledMs: number
   /** Same-cut bounds of the currently open turn, when one has not reached `turn/end`. */
   active?: {
     /** Start of the open turn. */
-    since: number;
+    since: number
     /** Latest event time folded into this projection cut. */
-    through: number;
-  };
+    through: number
+  }
   /**
    * Whether the latest closed turn after the child's own descriptor completed
    * normally; absent while a turn is open or before one closes.
    */
-  lastTurnCompleted?: boolean;
+  lastTurnCompleted?: boolean
 }
 
 /**
@@ -43,33 +45,33 @@ export interface SubagentTimingProjection {
  */
 export type SubagentIdentityProjection =
   | {
-      /** A terminal one-shot child. */
-      mode: "one-shot";
-      /** Optional durable creation label from the child's descriptor. */
-      label?: string;
-      /**
-       * Seq of the `subagent/descriptor` event this identity was folded from.
-       * `session.isOwnSeq(seq)` proves the identity comes from the child's
-       * OWN log suffix — where a descriptor is immutable once appended — and
-       * not from a fork seed's replayed ancestor descriptor.
-       */
-      seq: SessionSeq;
-    }
+    /** A terminal one-shot child. */
+    mode: 'one-shot'
+    /** Optional durable creation label from the child's descriptor. */
+    label?: string
+    /**
+     * Seq of the `subagent/descriptor` event this identity was folded from.
+     * `session.isOwnSeq(seq)` proves the identity comes from the child's
+     * OWN log suffix — where a descriptor is immutable once appended — and
+     * not from a fork seed's replayed ancestor descriptor.
+     */
+    seq: SessionSeq
+  }
   | {
-      /** A resumable conversation. */
-      mode: "continuable";
-      /** Durable creation label from the child's descriptor. */
-      label: string;
-      /** Seq of the folded descriptor event; see the one-shot arm for the own-suffix proof. */
-      seq: SessionSeq;
-    };
+    /** A resumable conversation. */
+    mode: 'continuable'
+    /** Durable creation label from the child's descriptor. */
+    label: string
+    /** Seq of the folded descriptor event; see the one-shot arm for the own-suffix proof. */
+    seq: SessionSeq
+  }
 
-declare module "@deepseek-ai/dsh-session-projection/types" {
+declare module '@deepseek-ai/dsh-session-projection/types' {
   interface SessionProjectionMap {
     /** Direct children in parent catalog event order, excluding fork-inherited facts. */
-    subagentCatalog: SubagentCatalogEntry[];
+    subagentCatalog: SubagentCatalogEntry[]
     /** Active-turn duration and latest closed-turn completion for a descriptor-backed subagent session. */
-    subagentTiming: SubagentTimingProjection;
+    subagentTiming: SubagentTimingProjection
     /**
      * Identity of a descriptor-backed subagent session. `null` ⟺ no valid
      * descriptor (missing, malformed, or unrecognized-version — deliberately
@@ -79,6 +81,6 @@ declare module "@deepseek-ai/dsh-session-projection/types" {
      * identity would survive on the receiving side. The entry itself stays
      * non-optional.
      */
-    subagent: SubagentIdentityProjection | null;
+    subagent: SubagentIdentityProjection | null
   }
 }

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

@@ -5,64 +5,50 @@
  * @module @deepseek-ai/dsh-subagent/projection
  */
 
-import { z } from "zod";
-import { SessionSeq } from "@deepseek-ai/dsh-session";
-import type { ProjectionDefinition } from "@deepseek-ai/dsh-session-projection";
-import type { SessionEvent } from "@deepseek-ai/dsh-session";
-import { foldSubagentDescriptor } from "./descriptor.ts";
-import type { SubagentDescriptorData } from "./descriptor.ts";
-import type { SubagentIdentityProjection, SubagentTimingProjection } from "./projection-types.ts";
+import { z } from 'zod'
+import { SessionSeq } from '@deepseek-ai/dsh-session'
+import type { ProjectionDefinition } from '@deepseek-ai/dsh-session-projection'
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+import { foldSubagentDescriptor } from './descriptor.ts'
+import type { SubagentDescriptorData } from './descriptor.ts'
+import type { SubagentIdentityProjection, SubagentTimingProjection } from './projection-types.ts'
 
 /** Fold state for a subagent's latest timing snapshot. */
 export interface TimingState {
   /** Milliseconds accumulated across completed post-descriptor turns. */
-  settledMs: number;
+  settledMs: number
   /** Current open interval kept paired inside the fold. */
-  active?: { since: number; through: number } | undefined;
+  active?: { since: number; through: number } | undefined
   /** Latest pre-descriptor turn start, promoted when the child's own descriptor arrives. */
-  pendingTurnStart?: number | undefined;
+  pendingTurnStart?: number | undefined
   /** Whether the fold has crossed a descriptor in this logical log. */
-  descriptorSeen: boolean;
+  descriptorSeen: boolean
   /** Whether the latest closed post-descriptor turn completed normally; absent while a turn is open or before one closes. */
-  lastTurnCompleted?: boolean | undefined;
+  lastTurnCompleted?: boolean | undefined
 }
 
-const activeIntervalSchema = z
-  .object({
-    since: z.number().int().nonnegative(),
-    through: z.number().int().nonnegative(),
-  })
-  .strict();
+const activeIntervalSchema = z.object({
+  since: z.number().int().nonnegative(),
+  through: z.number().int().nonnegative(),
+}).strict()
 
-const projectionSchema: z.ZodType<SubagentTimingProjection> = z
-  .object({
-    settledMs: z.number().int().nonnegative(),
-    active: activeIntervalSchema.optional(),
-    lastTurnCompleted: z.boolean().optional(),
-  })
-  .strict()
-  .transform(({ settledMs, active, lastTurnCompleted }) => ({
-    settledMs,
-    ...(active === undefined ? {} : { active }),
-    ...(lastTurnCompleted === undefined ? {} : { lastTurnCompleted }),
-  }));
+const projectionSchema: z.ZodType<SubagentTimingProjection> = z.object({
+  settledMs: z.number().int().nonnegative(),
+  active: activeIntervalSchema.optional(),
+  lastTurnCompleted: z.boolean().optional(),
+}).strict().transform(({ settledMs, active, lastTurnCompleted }) => ({
+  settledMs,
+  ...active === undefined ? {} : { active },
+  ...lastTurnCompleted === undefined ? {} : { lastTurnCompleted },
+}))
 
-const timingStateSchema: z.ZodType<TimingState> = z
-  .object({
-    settledMs: z.number().int().nonnegative(),
-    active: activeIntervalSchema.optional(),
-    pendingTurnStart: z.number().int().nonnegative().optional(),
-    descriptorSeen: z.boolean(),
-    lastTurnCompleted: z.boolean().optional(),
-  })
-  .strict();
-
-declare module "@deepseek-ai/dsh-session-projection/types" {
-  interface SessionProjectionStateMap {
-    subagentTiming: TimingState;
-    subagent: IdentityState;
-  }
-}
+const timingStateSchema: z.ZodType<TimingState> = z.object({
+  settledMs: z.number().int().nonnegative(),
+  active: activeIntervalSchema.optional(),
+  pendingTurnStart: z.number().int().nonnegative().optional(),
+  descriptorSeen: z.boolean(),
+  lastTurnCompleted: z.boolean().optional(),
+}).strict()
 
 /**
  * Fold turn boundaries around the child's own durable descriptor.
@@ -73,59 +59,57 @@ declare module "@deepseek-ai/dsh-session-projection/types" {
  * the final reset the child's authoritative timing origin.
  */
 export const subagentTimingProjectionDefinition = {
-  key: "subagentTiming",
+  key: 'subagentTiming',
   stateSchema: timingStateSchema,
   init: () => ({ descriptorSeen: false, settledMs: 0 }),
   apply: (state, event) => {
-    if (event.type === "turn/start") {
-      const { lastTurnCompleted: _closed, ...openState } = state;
+    if (event.type === 'turn/start') {
+      const { lastTurnCompleted: _closed, ...openState } = state
       return state.descriptorSeen
         ? { ...openState, active: { since: event.time, through: event.time } }
-        : { ...openState, pendingTurnStart: event.time };
+        : { ...openState, pendingTurnStart: event.time }
     }
-    if (event.type === "subagent/descriptor") {
-      const activeSince = state.active?.since ?? state.pendingTurnStart;
+    if (event.type === 'subagent/descriptor') {
+      const activeSince = state.active?.since ?? state.pendingTurnStart
       return {
         descriptorSeen: true,
         settledMs: 0,
         ...(activeSince === undefined
           ? {}
           : { active: { since: activeSince, through: event.time } }),
-      };
+      }
     }
-    if (event.type === "turn/end") {
+    if (event.type === 'turn/end') {
       if (!state.descriptorSeen) {
-        if (state.pendingTurnStart === undefined) return state;
-        const { pendingTurnStart: _closed, ...next } = state;
-        return next;
+        if (state.pendingTurnStart === undefined) return state
+        const { pendingTurnStart: _closed, ...next } = state
+        return next
       }
-      if (state.active === undefined) return state;
-      const { active, ...rest } = state;
+      if (state.active === undefined) return state
+      const { active, ...rest } = state
       return {
         ...rest,
         settledMs: state.settledMs + Math.max(0, event.time - active.since),
-        lastTurnCompleted: event.data.reason.kind === "completed",
-      };
+        lastTurnCompleted: event.data.reason.kind === 'completed',
+      }
     }
-    if (state.active === undefined) return state;
-    return { ...state, active: { ...state.active, through: event.time } };
+    if (state.active === undefined) return state
+    return { ...state, active: { ...state.active, through: event.time } }
   },
   wire: {
     viewSchema: projectionSchema,
-    view: (state) => ({
+    view: state => ({
       settledMs: state.settledMs,
       ...(state.active === undefined ? {} : { active: state.active }),
-      ...(state.lastTurnCompleted === undefined
-        ? {}
-        : { lastTurnCompleted: state.lastTurnCompleted }),
+      ...(state.lastTurnCompleted === undefined ? {} : { lastTurnCompleted: state.lastTurnCompleted }),
     }),
   },
   stateVersion: 3,
-} satisfies ProjectionDefinition<"subagentTiming", TimingState>;
+} satisfies ProjectionDefinition<'subagentTiming', TimingState>
 
 interface IdentityState {
   /** Identity from the last valid descriptor; absent before one, and after an invalid one. */
-  identity?: SubagentIdentityProjection | undefined;
+  identity?: SubagentIdentityProjection | undefined
 }
 
 // The cast bridges only the optional-label arm: Zod's optional output
@@ -133,49 +117,43 @@ interface IdentityState {
 // from the public interface. The no-value state itself is the serializable
 // `null` arm — never `undefined` — so every registry read and push frame
 // survives JSON.stringify losslessly.
-const identityValueSchema = z.discriminatedUnion("mode", [
-  z
-    .object({
-      mode: z.literal("one-shot"),
-      label: z.string().optional(),
-      seq: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).transform(SessionSeq),
-    })
-    .strict(),
-  z
-    .object({
-      mode: z.literal("continuable"),
-      label: z.string(),
-      seq: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).transform(SessionSeq),
-    })
-    .strict(),
-]) as unknown as z.ZodType<SubagentIdentityProjection>;
+const identityValueSchema = z.discriminatedUnion('mode', [
+  z.object({
+    mode: z.literal('one-shot'),
+    label: z.string().optional(),
+    seq: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).transform(SessionSeq),
+  }).strict(),
+  z.object({
+    mode: z.literal('continuable'),
+    label: z.string(),
+    seq: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).transform(SessionSeq),
+  }).strict(),
+]) as unknown as z.ZodType<SubagentIdentityProjection>
 
-const identitySchema = identityValueSchema.nullable();
+const identitySchema = identityValueSchema.nullable()
 
-const identityStateSchema: z.ZodType<IdentityState> = z
-  .object({
-    identity: identityValueSchema.optional(),
-  })
-  .strict();
+const identityStateSchema: z.ZodType<IdentityState> = z.object({
+  identity: identityValueSchema.optional(),
+}).strict()
 
 /** Interpret one `subagent/descriptor` event's identity; no value when the payload cannot be trusted. */
 function descriptorIdentity(event: SessionEvent): SubagentIdentityProjection | undefined {
-  let descriptor: SubagentDescriptorData | undefined;
+  let descriptor: SubagentDescriptorData | undefined
   try {
-    descriptor = foldSubagentDescriptor([event]);
+    descriptor = foldSubagentDescriptor([event])
   } catch {
     // Only a malformed current-version payload throws in descriptor parsing;
     // a projection fold must never throw, so damage folds to no value.
-    descriptor = undefined;
+    descriptor = undefined
   }
-  if (descriptor === undefined) return undefined;
-  return descriptor.mode === "one-shot"
+  if (descriptor === undefined) return undefined
+  return descriptor.mode === 'one-shot'
     ? {
-        mode: "one-shot",
-        ...(descriptor.label !== undefined ? { label: descriptor.label } : {}),
-        seq: event.seq,
-      }
-    : { mode: "continuable", label: descriptor.label, seq: event.seq };
+      mode: 'one-shot',
+      ...descriptor.label !== undefined ? { label: descriptor.label } : {},
+      seq: event.seq,
+    }
+    : { mode: 'continuable', label: descriptor.label, seq: event.seq }
 }
 
 /**
@@ -190,16 +168,16 @@ function descriptorIdentity(event: SessionEvent): SubagentIdentityProjection | u
  * `null` ⟺ no valid descriptor, with the causes deliberately undistinguished.
  */
 export const subagentIdentityProjectionDefinition = {
-  key: "subagent",
+  key: 'subagent',
   stateSchema: identityStateSchema,
   init: () => ({}),
   apply: (state, event) => {
-    if (event.type !== "subagent/descriptor") return state;
-    const identity = descriptorIdentity(event);
-    return identity === undefined ? {} : { identity };
+    if (event.type !== 'subagent/descriptor') return state
+    const identity = descriptorIdentity(event)
+    return identity === undefined ? {} : { identity }
   },
-  wire: { viewSchema: identitySchema, view: (state) => state.identity ?? null },
+  wire: { viewSchema: identitySchema, view: state => state.identity ?? null },
   // Bumped when the identity gained its `seq` field: an older checkpoint row
   // would replay into a value the schema rejects, so it must refold instead.
   stateVersion: 2,
-} satisfies ProjectionDefinition<"subagent", IdentityState>;
+} satisfies ProjectionDefinition<'subagent', IdentityState>