@deepseek-ai/dsh-subagent 0.1.6-alpha.2 → 0.1.7-alpha.2

package/lib/types/index.js

@@ -1,33 +1,3 @@
-/**
- * Service Definition for the subagent capability seam (`ctx.subagents`): a named-provider registry plus a
- * capability-validating asynchronous start API. Providers establish a
- * child before returning its run, so fulfillment is the single publication and
- * ownership-transfer boundary.
- *
- * Multiple providers coexist: each registers under a unique name and callers
- * select one by name.
- *
- * This package owns the Service Definition role of the capability seam. Service Providers
- * (`@deepseek-ai/dsh-subagent-spawn-in-process`, `-fork`, `-acp`) and the model-facing
- * consumer (`@deepseek-ai/dsh-tool-subagent`) are separate packages.
- *
- * Public operations express caller intent: `start` returns one published owned
- * one-shot run, `startContinuable` establishes a durable continuable child, and
- * `sendMessage` steers between adjacent Agents without exposing whether a child
- * is resident. Continuable children never become a {@link SubagentRun}: the
- * continuation manager holds their `AgentHandle` directly and orders every turn
- * through the child's own inbox, so providers contribute only the detached
- * creation spec and see no handle, turn, or teardown. Child and descendant
- * discovery read the live session store and optional session persistence
- * directly and do not require that continuation runtime.
- *
- * Same-process providers are trusted typed collaborators. Requests, provider
- * descriptors, results, and lifecycle payloads are borrowed immutable values;
- * serialization and hostile-input validation belong at real process, worker,
- * persistence, and model boundaries.
- *
- * @module @deepseek-ai/dsh-subagent
- */
 var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
     var useValue = arguments.length > 2;
     for (var i = 0; i < initializers.length; i++) {
@@ -67,12 +37,13 @@ import { scopeTarget } from '@deepseek-ai/dsh-scope';
 import { assertObjectJsonSchema } from '@deepseek-ai/dsh-tools';
 import { canonicalClientTimeZone } from '@deepseek-ai/dsh-util-time';
 import { Remote, RemoteError, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
-import { catalogView, rejectCatalogRead, rejectPrompt, validateControlRequest, } from "./control.js";
+import { rejectPrompt, validateControlRequest, } from "./control.js";
 import { SubagentError } from "./error.js";
 import { assertSubagentMaxDepth } from "./depth.js";
 import { createActivationObserver, createLifecycleEmitter, observeRun } from "./lifecycle.js";
 import SubagentContinuationManager from "./continuation.js";
 import { listChildren as listSubagentChildren, listDescendants as listSubagentDescendants } from "./list-children.js";
+import { installSubagentArchiveAdmission } from "./archive-admission.js";
 import { snapshotSubagentDescriptor } from "./descriptor.js";
 import { subagentIdentityProjectionDefinition, subagentTimingProjectionDefinition } from "./projection.js";
 import { establishCatalogChild, subagentCatalogProjectionDefinition } from "./catalog.js";
@@ -89,25 +60,22 @@ export { appendDelegatedPolicyOverrides, applyChildComposition, captureDelegated
 let SubagentRuntime = (() => {
     let _classSuper = TypertRemoteService;
     let _instanceExtraInitializers = [];
-    let _remoteExportList_decorators;
     let _prompt_decorators;
     let _interruptByParent_decorators;
     return class SubagentRuntime extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _remoteExportList_decorators = [Remote('list')];
             _prompt_decorators = [Remote('prompt')];
             _interruptByParent_decorators = [Remote('interruptByParent')];
-            __esDecorate(this, null, _remoteExportList_decorators, { kind: "method", name: "remoteExportList", static: false, private: false, access: { has: obj => "remoteExportList" in obj, get: obj => obj.remoteExportList }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _prompt_decorators, { kind: "method", name: "prompt", static: false, private: false, access: { has: obj => "prompt" in obj, get: obj => obj.prompt }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _interruptByParent_decorators, { kind: "method", name: "interruptByParent", static: false, private: false, access: { has: obj => "interruptByParent" in obj, get: obj => obj.interruptByParent }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
+        config = __runInitializers(this, _instanceExtraInitializers);
         static Config = z.object({
-            maxDepth: z.number().step(1).min(0).max(Number.MAX_SAFE_INTEGER).default(1),
-            maxActiveSubagents: z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER).default(8),
+            maxDepth: z.number().step(1).min(0).max(Number.MAX_SAFE_INTEGER).default(1).volatile(),
+            maxActiveSubagents: z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER).default(8).volatile(),
         });
-        settingsSource = __runInitializers(this, _instanceExtraInitializers);
         providers = new Map();
         continuations;
         /**
@@ -118,21 +86,13 @@ let SubagentRuntime = (() => {
         emitLifecycle;
         constructor(ctx, config) {
             super(ctx, 'subagents');
-            assertSubagentMaxDepth(config.maxDepth);
-            this.settingsSource = () => config;
-            ctx.inject(['settings'], (settingsCtx) => {
-                settingsCtx.settings.installSection(ctx, 'subagent', SubagentRuntime.Config, config, {
-                    validate: (value) => { assertSubagentMaxDepth(value.maxDepth); },
-                    setSource: (source) => { this.settingsSource = source; },
-                    onChange: () => { },
-                });
-            });
+            this.config = config;
             this.emitLifecycle = createLifecycleEmitter(this.ctx, parent => scopeTarget(this, parent));
             ctx.inject(['agents'], (childCtx) => {
                 const manager = new SubagentContinuationManager(childCtx, {
                     prepareContinuable: (name, request) => this.prepareContinuable(name, request),
                     observeActivation: (provider, childId, parent) => this.observeActivation(provider, childId, parent),
-                }, () => this.settingsSource().maxActiveSubagents);
+                }, () => this.config.maxActiveSubagents.get());
                 this.continuations = manager;
                 childCtx.effect(() => () => {
                     /* v8 ignore else -- one injected binding owns the slot until its fiber disposes. */
@@ -141,10 +101,14 @@ let SubagentRuntime = (() => {
                 }, 'subagents.continuationBinding()');
             });
             ctx.inject(['sessionProjections'], (projectionCtx) => {
-                projectionCtx.sessionProjections.register(subagentCatalogProjectionDefinition);
-                projectionCtx.sessionProjections.register(subagentTimingProjectionDefinition);
-                projectionCtx.sessionProjections.register(subagentIdentityProjectionDefinition);
+                const projections = projectionCtx.sessionProjections;
+                projections.register(subagentCatalogProjectionDefinition);
+                projections.register(subagentTimingProjectionDefinition);
+                projections.register(subagentIdentityProjectionDefinition);
             });
+            // Archive admission: this runtime is the owner that knows which live
+            // children descend from a Session and how a parent stops them.
+            ctx.inject(['agents'], (agentsCtx) => { installSubagentArchiveAdmission(agentsCtx); });
         }
         /**
          * Resolve a delegation tool's depth policy against the current user setting.
@@ -154,7 +118,11 @@ let SubagentRuntime = (() => {
         resolveMaxDepth(configured) {
             if (configured === 'provider-managed')
                 return undefined;
-            return configured ?? this.settingsSource().maxDepth;
+            if (configured !== undefined)
+                return configured;
+            const depth = this.config.maxDepth.get();
+            assertSubagentMaxDepth(depth);
+            return depth;
         }
         /**
          * Establish one durable continuable child and deliver its initial prompt.
@@ -254,21 +222,13 @@ let SubagentRuntime = (() => {
             await manager.drainChildren(parent, childIds);
         }
         /**
-         * Enumerate the parent's direct session-backed subagents without loading or
-         * resuming an Agent. The Session query service supplies one live-preferred
-         * corpus and shared point observations; the projection cache supplies
-         * immutable descriptor hits without opening cold logs. The registered
-         * `subagent` projection remains the sole mode/label classifier.
-         *
-         * Every query receives `signal`, and the listing rechecks cancellation
-         * around each await. Read rejections that settle
-         * after an abort become a stable `SubagentError` with code `CANCELLED`.
-         * @param parentSessionId - parent session whose direct children are listed.
-         * @param signal - caller-owned cancellation forwarded to Session queries
-         *   and observed around every read await.
-         * @returns children and per-child diagnostics ordered by `createdAt`, then id.
-         * @throws {@link SubagentError} when the projection registry or the session
-         *   store is not mounted, or the caller cancels the listing.
+         * Read the parent's durable direct-child catalog without loading or resuming an Agent.
+         * The service owns and releases the live-preferred Session observation.
+         * @param parentSessionId - parent whose direct children are requested.
+         * @param signal - cancellation forwarded to the Session query.
+         * @returns catalog children in parent event order.
+         * @throws {@link SubagentError} when query or catalog projection is unavailable.
+         * @throws SessionQueryError when the parent cannot be read or the query is cancelled.
          */
         listChildren(parentSessionId, signal) {
             return listSubagentChildren(this.ctx, parentSessionId, signal);
@@ -279,40 +239,18 @@ let SubagentRuntime = (() => {
          * Agent. Ordinary sessions and one-shot children remain traversal nodes so
          * continuable descendants below them are discovered; each returned entry
          * adds its durable `parentId` and root-relative `depth`. Identity resolution,
-         * diagnostics, optional persistence, and cancellation follow the same
-         * projection-backed contract as {@link listChildren}.
+         * diagnostics, optional persistence, and cancellation use the registered
+         * child identity projection and complete Session corpus.
          * @param rootSessionId - session whose complete descendant tree is listed.
          * @param signal - caller-owned cancellation forwarded to persistence reads
          *   and observed around every read await.
          * @returns children and per-candidate diagnostics with tree position, in
          *   stable pre-order.
-         * @throws {@link SubagentError} under the same conditions as {@link listChildren}.
+         * @throws {@link SubagentError} when listing dependencies are unavailable or the caller cancels.
          */
         listDescendants(rootSessionId, signal) {
             return listSubagentDescendants(this.ctx, rootSessionId, signal);
         }
-        /**
-         * Remote face of {@link listChildren} for one browser: the durable listing
-         * plus live Agent activity and the delivery-time parent availability hint.
-         * Parent availability is a hint; {@link prompt} performs the authoritative
-         * check. Named apart from the provider-name {@link list}, which owns the
-         * member.
-         * @param parentSessionId - parent session whose direct children are listed.
-         * @param signal - carrier cancellation forwarded to Session queries.
-         * @returns the catalog view for that parent.
-         * @throws {RemoteError} `gateway/bad-request` for an empty parent id,
-         *   `gateway/cancelled` for an aborted read, `subagent/projections-unavailable` when
-         *   the deployment has no projection registry, otherwise `gateway/internal`.
-         */
-        async remoteExportList(parentSessionId, signal) {
-            validateControlRequest('subagent.list', { parentSessionId });
-            try {
-                return catalogView(this.ctx, parentSessionId, await this.listChildren(parentSessionId, signal));
-            }
-            catch (error) {
-                return rejectCatalogRead(error, signal);
-            }
-        }
         /**
          * Deliver one browser-authored message to a continuable child through the
          * exact live direct parent, retaining the caller-minted request identity and

package/lib/types/lifecycle.d.ts

@@ -26,7 +26,7 @@ export interface ActivationTerminal {
     /** Why this epoch's last ordinary turn ended, or `error` when teardown failed. */
     readonly stopReason: SubagentResult['stopReason'];
     /** The epoch's final assistant content, absent when it produced none or failed. */
-    readonly output?: ContentBlock[];
+    readonly output?: readonly ContentBlock[];
 }
 /**
  * Lifecycle observer for one Activation's residency epoch, so continuable

package/lib/types/lifecycle.js

@@ -160,9 +160,10 @@ function epochStopReason(events) {
         case undefined:
         case 'completed':
             return droppedUnrun ? 'aborted' : 'completed';
-        /* v8 ignore next 3 -- `TurnEndReason` is merge-extensible, so this arm needs a
-         * backend that adds a variant; treating an unnameable reason as success would
-         * report failed work as completed. */
+        /* v8 ignore next 4 -- `forked` appears only in constructor seed history, while
+         * this function reads an epoch-owned suffix. `TurnEndReason` is merge-extensible,
+         * so a backend-added variant cannot be listed; treating an unnameable reason as
+         * success would report failed work as completed. */
         default:
             return 'error';
     }

package/lib/types/list-children.d.ts

@@ -1,24 +1,16 @@
 /**
- * Read-only enumeration of durable subagent children and descendant trees
- * through the Session query service. Candidates come from one live-preferred
- * corpus; each child's mode/label is the registered `subagent` projection
- * unit's value, resolved
- * down a three-rung ladder: the registry's watermark cache for a live child,
- * an unseeded durable projection-cache row, and one shared Session observation
- * otherwise. A seeded header deliberately lacks its exact inherited cut, so
- * it takes the body-bearing observation path before classifying an identity.
- * The projection fold is the single classification
- * authority — this module parses no descriptor
- * itself. Absent persistence, enumeration is live-only: a cold child is
- * unreachable for resume anyway, so its absence is capability absence, not an
- * error. The module owns no catalog state and does not consult Activation,
- * Agent-registry, continuation-manager, or provider state.
+ * Direct-child discovery from a parent-owned `subagent/catalog` projection,
+ * plus complete descendant-tree enumeration from the Session corpus. A direct
+ * listing owns one parent observation and reads no child log. Descendant
+ * enumeration retains the complete corpus and the child identity projection
+ * because ordinary Sessions and one-shot children remain traversal nodes.
  *
  * @module @deepseek-ai/dsh-subagent
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { SessionId } from '@deepseek-ai/dsh-session';
 import type { SubagentListEntry } from './control-types.ts';
+import type { SubagentCatalogEntry } from './projection-types.ts';
 export type { SubagentListEntry } from './control-types.ts';
 /**
  * One entry of a descendant listing: the interpreted subagent facts plus its
@@ -32,34 +24,25 @@ export type SubagentDescendantListEntry = SubagentListEntry & {
     readonly depth: number;
 };
 /**
- * Enumerate one parent's origin-classified direct children from the
- * live-preferred merge of `ctx.sessions` and optional session persistence,
- * serving each identity from the `subagent` projection unit: the registry's
- * watermark snapshot for a live child; for a cold one, a durable
- * projection-cache read for an unseeded lifecycle, else one bounded-concurrency
- * shared Session observation carrying the exact inherited cut.
- * @see SubagentRuntime.listChildren for the public cancellation and failure contract.
- * @param ctx - context carrying the session store, the projection registry,
- *   optional persistence, and the optional projection cache.
- * @param parentSessionId - parent session whose direct children are listed.
- * @param signal - caller-owned cancellation observed around every persistence read.
- * @returns children and per-child diagnostics ordered by `createdAt`, then id.
- * @throws {@link SubagentError} when the projection registry or the session
- *   store is not mounted, or the caller cancels the listing.
+ * Read one parent's durable catalog through a live-preferred Session observation.
+ * @param ctx - context carrying the Session query service.
+ * @param parentSessionId - parent whose direct children are requested.
+ * @param signal - cancellation forwarded to the Session observation.
+ * @returns direct-child rows in parent catalog event order.
+ * @throws {@link SubagentError} when query or catalog projection is unavailable.
  */
-export declare function listChildren(ctx: Context, parentSessionId: SessionId, signal?: AbortSignal): Promise<SubagentListEntry[]>;
+export declare function listChildren(ctx: Context, parentSessionId: SessionId, signal?: AbortSignal): Promise<SubagentCatalogEntry[]>;
 /**
  * Enumerate every session-backed subagent below one root in stable pre-order.
  * Ordinary sessions and one-shot children remain traversal nodes, so a
  * continuable child below either is still discovered. Classification uses the
- * same projection-backed runtime as {@link listChildren}; no Agent is loaded or
- * resumed.
+ * registered child identity projection; no Agent is loaded or resumed.
  * @see SubagentRuntime.listDescendants for the public cancellation and failure contract.
  * @param ctx - context carrying the session store, projection registry, and optional persistence/cache.
  * @param rootSessionId - session whose complete descendant tree is listed.
  * @param signal - caller-owned cancellation observed around every persistence read.
  * @returns interpreted subagents with durable direct-parent and root-relative depth.
- * @throws {@link SubagentError} under the same conditions as {@link listChildren}.
+ * @throws {@link SubagentError} when listing dependencies are unavailable or the caller cancels.
  */
 export declare function listDescendants(ctx: Context, rootSessionId: SessionId, signal?: AbortSignal): Promise<SubagentDescendantListEntry[]>;
 //# sourceMappingURL=list-children.d.ts.map

package/lib/types/list-children.js

@@ -1,18 +1,9 @@
 /**
- * Read-only enumeration of durable subagent children and descendant trees
- * through the Session query service. Candidates come from one live-preferred
- * corpus; each child's mode/label is the registered `subagent` projection
- * unit's value, resolved
- * down a three-rung ladder: the registry's watermark cache for a live child,
- * an unseeded durable projection-cache row, and one shared Session observation
- * otherwise. A seeded header deliberately lacks its exact inherited cut, so
- * it takes the body-bearing observation path before classifying an identity.
- * The projection fold is the single classification
- * authority — this module parses no descriptor
- * itself. Absent persistence, enumeration is live-only: a cold child is
- * unreachable for resume anyway, so its absence is capability absence, not an
- * error. The module owns no catalog state and does not consult Activation,
- * Agent-registry, continuation-manager, or provider state.
+ * Direct-child discovery from a parent-owned `subagent/catalog` projection,
+ * plus complete descendant-tree enumeration from the Session corpus. A direct
+ * listing owns one parent observation and reads no child log. Descendant
+ * enumeration retains the complete corpus and the child identity projection
+ * because ordinary Sessions and one-shot children remain traversal nodes.
  *
  * @module @deepseek-ai/dsh-subagent
  */
@@ -68,7 +59,6 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { SessionLogOffset } from '@deepseek-ai/dsh-session';
 import { SubagentError } from "./error.js";
 /**
  * Concurrent cold observations per explicit catalog listing. Current Session
@@ -77,42 +67,48 @@ import { SubagentError } from "./error.js";
  */
 const COLD_READ_CONCURRENCY = 4;
 /**
- * Enumerate one parent's origin-classified direct children from the
- * live-preferred merge of `ctx.sessions` and optional session persistence,
- * serving each identity from the `subagent` projection unit: the registry's
- * watermark snapshot for a live child; for a cold one, a durable
- * projection-cache read for an unseeded lifecycle, else one bounded-concurrency
- * shared Session observation carrying the exact inherited cut.
- * @see SubagentRuntime.listChildren for the public cancellation and failure contract.
- * @param ctx - context carrying the session store, the projection registry,
- *   optional persistence, and the optional projection cache.
- * @param parentSessionId - parent session whose direct children are listed.
- * @param signal - caller-owned cancellation observed around every persistence read.
- * @returns children and per-child diagnostics ordered by `createdAt`, then id.
- * @throws {@link SubagentError} when the projection registry or the session
- *   store is not mounted, or the caller cancels the listing.
+ * Read one parent's durable catalog through a live-preferred Session observation.
+ * @param ctx - context carrying the Session query service.
+ * @param parentSessionId - parent whose direct children are requested.
+ * @param signal - cancellation forwarded to the Session observation.
+ * @returns direct-child rows in parent catalog event order.
+ * @throws {@link SubagentError} when query or catalog projection is unavailable.
  */
 export async function listChildren(ctx, parentSessionId, signal) {
-    const listing = await prepareListing(ctx, signal);
-    const candidates = [...listing.corpus.values()]
-        .filter(record => record.header.parentSession === parentSessionId
-        && record.header.origin === 'subagent')
-        .sort(compareCorpusRecords);
-    const rows = await resolveCandidateRows(candidates, listing, signal);
-    return rows.filter((row) => row !== undefined);
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const query = ctx.get('sessionQuery');
+        if (query === undefined) {
+            throw new SubagentError('listing subagents requires the sessionQuery service (load @deepseek-ai/dsh-session-query)', 'SUBAGENT_CONTROL_QUERY_UNAVAILABLE');
+        }
+        const parent = __addDisposableResource(env_1, await query.observeSession(parentSessionId, {
+            ...signal === undefined ? {} : { signal },
+        }), false);
+        const entries = parent.projections?.values.subagentCatalog;
+        if (entries === undefined) {
+            throw new SubagentError('listing subagents requires the registered subagentCatalog projection', 'SUBAGENT_CONTROL_PROJECTIONS_UNAVAILABLE');
+        }
+        return entries;
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
 }
 /**
  * Enumerate every session-backed subagent below one root in stable pre-order.
  * Ordinary sessions and one-shot children remain traversal nodes, so a
  * continuable child below either is still discovered. Classification uses the
- * same projection-backed runtime as {@link listChildren}; no Agent is loaded or
- * resumed.
+ * registered child identity projection; no Agent is loaded or resumed.
  * @see SubagentRuntime.listDescendants for the public cancellation and failure contract.
  * @param ctx - context carrying the session store, projection registry, and optional persistence/cache.
  * @param rootSessionId - session whose complete descendant tree is listed.
  * @param signal - caller-owned cancellation observed around every persistence read.
  * @returns interpreted subagents with durable direct-parent and root-relative depth.
- * @throws {@link SubagentError} under the same conditions as {@link listChildren}.
+ * @throws {@link SubagentError} when listing dependencies are unavailable or the caller cancels.
  */
 export async function listDescendants(ctx, rootSessionId, signal) {
     const listing = await prepareListing(ctx, signal);
@@ -271,17 +267,17 @@ function compareCorpusRecords(a, b) {
  * throw — are final, so they report `corrupt`.
  */
 async function resolveColdIdentity(query, cache, header, hasChildren, signal) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
+    const env_2 = { stack: [], error: void 0, hasError: false };
     try {
         const childId = header.id;
         // A header deliberately exposes only whether a fork cut exists, not its
-        // integer. An unseeded lifecycle has the exact cut 0 and may use the cache;
-        // a seeded lifecycle must read the body before an identity seq can be
-        // classified as inherited or owned.
+        // integer. An unseeded lifecycle has the exact cut 0, so its cached
+        // descriptor is owned at every valid seq; a seeded lifecycle must read the
+        // body before an identity seq can be classified as inherited or owned.
         if (cache !== undefined && !header.isSeeded) {
             let cached;
             try {
-                cached = cache.cachedSnapshot(header, SessionLogOffset(0), ['subagent'])?.values.subagent;
+                cached = cache.cachedSnapshot(header, ['subagent'])?.values.subagent;
             }
             catch {
                 // Unlike the preparation fold below, a throwing cache read renders no
@@ -317,7 +313,7 @@ async function resolveColdIdentity(query, cache, header, hasChildren, signal) {
                     : 'unavailable',
             };
         }
-        const ownedObservation = __addDisposableResource(env_1, observation, false);
+        const ownedObservation = __addDisposableResource(env_2, observation, false);
         assertListingNotCancelled(signal);
         // A session id names a slot, not a lifecycle: a child deleted and
         // re-published under another owner between the enumeration and this read
@@ -332,12 +328,12 @@ async function resolveColdIdentity(query, cache, header, hasChildren, signal) {
         }
         return childRow(childId, identity, 'inactive', hasChildren);
     }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
     }
     finally {
-        __disposeResources(env_1);
+        __disposeResources(env_2);
     }
 }
 /** Materialize one served identity as its child row. */

package/lib/types/out-of-process.d.ts

@@ -68,7 +68,7 @@ export interface RunResultSettlement {
     /** The turn attempt (typically racing local cancellation); returns the terminal result. */
     attempt: () => Promise<SubagentResult>;
     /** Snapshot the provider exposes when cancellation or failure wins settlement. */
-    collectOutput: () => ContentBlock[];
+    collectOutput: () => readonly ContentBlock[];
     /** Snapshot safe provider-authored detail when a failure wins settlement. */
     collectDiagnostic?: (() => string | undefined) | undefined;
     /** Whether local cancellation settled before the attempt's outcome is observed. */

package/lib/types/projection-types.d.ts

@@ -14,6 +14,9 @@ export type SubagentCatalogEntry = {
 } | {
     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 {
@@ -26,6 +29,11 @@ export interface SubagentTimingProjection {
         /** Latest event time folded into this projection cut. */
         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;
 }
 /**
  * Durable identity of one descriptor-backed subagent session: lifecycle mode
@@ -57,7 +65,7 @@ declare module '@deepseek-ai/dsh-session-projection/types' {
     interface SessionProjectionMap {
         /** Direct children in parent catalog event order, excluding fork-inherited facts. */
         subagentCatalog: SubagentCatalogEntry[];
-        /** Active-turn duration for a descriptor-backed subagent session. */
+        /** Active-turn duration and latest closed-turn completion for a descriptor-backed subagent session. */
         subagentTiming: SubagentTimingProjection;
         /**
          * Identity of a descriptor-backed subagent session. `null` ⟺ no valid

package/lib/types/projection.d.ts

@@ -20,6 +20,8 @@ export interface TimingState {
     pendingTurnStart?: number | undefined;
     /** Whether the fold has crossed a descriptor in this logical log. */
     descriptorSeen: boolean;
+    /** Whether the latest closed post-descriptor turn completed normally; absent while a turn is open or before one closes. */
+    lastTurnCompleted?: boolean | undefined;
 }
 declare module '@deepseek-ai/dsh-session-projection/types' {
     interface SessionProjectionStateMap {
@@ -52,10 +54,13 @@ export declare const subagentTimingProjectionDefinition: {
         } | undefined;
         /** Whether the fold has crossed a descriptor in this logical log. */
         descriptorSeen: boolean;
+        /** Whether the latest closed post-descriptor turn completed normally; absent while a turn is open or before one closes. */
+        lastTurnCompleted?: boolean | undefined;
     };
     wire: {
         viewSchema: z.ZodType<SubagentTimingProjection, unknown, z.core.$ZodTypeInternals<SubagentTimingProjection, unknown>>;
         view: (state: NoInfer<TimingState>) => {
+            lastTurnCompleted?: boolean;
             active?: {
                 since: number;
                 through: number;

package/lib/types/projection.js

@@ -14,15 +14,18 @@ const activeIntervalSchema = z.object({
 const projectionSchema = z.object({
     settledMs: z.number().int().nonnegative(),
     active: activeIntervalSchema.optional(),
-}).strict().transform(({ settledMs, active }) => ({
+    lastTurnCompleted: z.boolean().optional(),
+}).strict().transform(({ settledMs, active, lastTurnCompleted }) => ({
     settledMs,
     ...active === undefined ? {} : { active },
+    ...lastTurnCompleted === undefined ? {} : { lastTurnCompleted },
 }));
 const timingStateSchema = 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.
@@ -38,9 +41,10 @@ export const subagentTimingProjectionDefinition = {
     init: () => ({ descriptorSeen: false, settledMs: 0 }),
     apply: (state, event) => {
         if (event.type === 'turn/start') {
+            const { lastTurnCompleted: _closed, ...openState } = state;
             return state.descriptorSeen
-                ? { ...state, active: { since: event.time, through: event.time } }
-                : { ...state, pendingTurnStart: event.time };
+                ? { ...openState, active: { since: event.time, through: event.time } }
+                : { ...openState, pendingTurnStart: event.time };
         }
         if (event.type === 'subagent/descriptor') {
             const activeSince = state.active?.since ?? state.pendingTurnStart;
@@ -65,6 +69,7 @@ export const subagentTimingProjectionDefinition = {
             return {
                 ...rest,
                 settledMs: state.settledMs + Math.max(0, event.time - active.since),
+                lastTurnCompleted: event.data.reason.kind === 'completed',
             };
         }
         if (state.active === undefined)
@@ -76,9 +81,10 @@ export const subagentTimingProjectionDefinition = {
         view: state => ({
             settledMs: state.settledMs,
             ...(state.active === undefined ? {} : { active: state.active }),
+            ...(state.lastTurnCompleted === undefined ? {} : { lastTurnCompleted: state.lastTurnCompleted }),
         }),
     },
-    stateVersion: 2,
+    stateVersion: 3,
 };
 // The cast bridges only the optional-label arm: Zod's optional output
 // includes explicit `undefined`, which exactOptionalPropertyTypes excludes

package/lib/types/run-settlement.js

@@ -30,7 +30,7 @@ function failureDetail(result) {
 function runOutcome(result) {
     switch (result.stopReason) {
         case 'completed':
-            return { status: 'completed', output: finalText(result.output) };
+            return { status: 'completed', result: finalText(result.output) };
         case 'aborted':
             return result.diagnostic === undefined
                 ? { status: 'killed' }

package/lib/types/types.d.ts

@@ -106,7 +106,7 @@ export interface SubagentRunEndInfo {
      * {@link SubagentResult.output}; absent on infrastructure rejection or when
      * the child produced none.
      */
-    readonly lastAssistantMessage?: ContentBlock[];
+    readonly lastAssistantMessage?: readonly ContentBlock[];
 }
 /**
  * Which START-TIME features a provider supports. Checked by the service before delegating to
@@ -260,7 +260,7 @@ export interface SubagentResult {
      * are skipped. Without a non-empty message, the output is its accumulated
      * assistant text stream, or `[]` when the child produced neither.
      */
-    readonly output: ContentBlock[];
+    readonly output: readonly ContentBlock[];
     /**
      * The structured result after a requested `outputSchema` was successfully
      * satisfied. Requesting a schema does not guarantee presence: a provider can