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

package/lib/index.js

@@ -1,9 +1,10 @@
+import z from "@deepseek-ai/schemastery";
 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 { AttachmentError } from "@deepseek-ai/dsh-attachment";
-import { z } from "zod";
+import { z as z$1 } from "zod";
 import { HarnessError, ReasoningEffortId, boundContextSummary, contentHasImage, createUserMessage, errorChain, joinAssistantStreamText } from "@deepseek-ai/dsh-llm";
 import { randomUUID } from "node:crypto";
 import { foldConsumedWork } from "@deepseek-ai/dsh-agent";
@@ -29,25 +30,23 @@ var SubagentError = class extends HarnessError {
 //#endregion
 //#region lib/types/control.js
 /**
-* Browser-facing subagent control assembly: the catalog view sampled against
-* the live Agent registry, one browser zone's validation, and the stable
-* failure codes the Remote surface answers with.
+* Browser-facing subagent prompt and interrupt request validation plus the
+* stable prompt failure codes returned by the Remote surface.
 *
 * @module @deepseek-ai/dsh-subagent
 */
-const SESSION_ID_SCHEMA = z.string().min(1);
+const SESSION_ID_SCHEMA = z$1.string().min(1);
 const CONTROL_ID_SCHEMAS = {
-	"subagent.list": z.object({ parentSessionId: SESSION_ID_SCHEMA }),
-	"subagent.prompt": z.object({
+	"subagent.prompt": z$1.object({
 		parentSessionId: SESSION_ID_SCHEMA,
 		childSessionId: SESSION_ID_SCHEMA,
-		mode: z.literal("continuable"),
-		delivery: z.enum(["queue", "steer"])
+		mode: z$1.literal("continuable"),
+		delivery: z$1.enum(["queue", "steer"])
 	}),
-	"subagent.interrupt": z.object({
+	"subagent.interrupt": z$1.object({
 		parentSessionId: SESSION_ID_SCHEMA,
 		childSessionId: SESSION_ID_SCHEMA,
-		mode: z.literal("continuable")
+		mode: z$1.literal("continuable")
 	})
 };
 /**
@@ -62,39 +61,6 @@ function validateControlRequest(method, payload) {
 	if (!parsed.success) throw new RemoteError("gateway/bad-request", `invalid payload for ${method}`, { issues: parsed.error.issues });
 }
 /**
-* Project one durable listing onto the catalog view, replacing each row's
-* store-derived activity with the live Agent driver's status and reporting
-* whether the exact parent Agent is live. Without an Agent registry no driver
-* runs at all, so every row is inactive and the parent is unavailable.
-* @param ctx - Host context that may carry the Agent registry.
-* @param parentSessionId - the listed parent.
-* @param entries - the durable direct-child listing.
-* @returns the catalog view answered to one browser.
-*/
-function catalogView(ctx, parentSessionId, entries) {
-	const agents = ctx.get("agents");
-	return {
-		entries: entries.map((entry) => entry.kind === "child" ? {
-			...entry,
-			activity: agents?.get(entry.id)?.status === "running" ? "running" : "inactive"
-		} : entry),
-		parentAvailable: agents?.get(parentSessionId) !== void 0
-	};
-}
-/**
-* Refuse one catalog read while preserving cancellation and a missing
-* projections registry as distinct failures.
-* @param error - the thrown value.
-* @param signal - the caller's cancellation.
-* @returns Never — the refusal is thrown.
-* @throws {RemoteError} always.
-*/
-function rejectCatalogRead(error, signal) {
-	if (isCancellation(error, signal)) throw new RemoteError("gateway/cancelled", "subagent catalog read was cancelled", {}, { cause: error });
-	if (error instanceof SubagentError && error.code === "SUBAGENT_CONTROL_PROJECTIONS_UNAVAILABLE") throw new RemoteError("subagent/projections-unavailable", "subagent catalog is unavailable: this deployment does not mount the sessionProjections registry (load @deepseek-ai/dsh-session-projection)", {}, { cause: error });
-	throw new RemoteError("gateway/internal", "subagent catalog read failed", {}, { cause: error });
-}
-/**
 * Refuse one continuation prompt without exposing provider detail: admission
 * failures the caller can act on keep their own code, everything else is
 * internal.
@@ -113,6 +79,7 @@ function rejectPrompt(error, childSessionId, signal) {
 		case "UNAUTHORIZED": throw new RemoteError("subagent/unauthorized", "subagent does not belong to this parent", { childSessionId }, { cause: error });
 		case "DRAINING":
 		case "ACTIVATION_CLOSING":
+		case "ACTIVATION_LIMIT_REACHED":
 		case "CONTINUATION_UNAVAILABLE":
 		case "PERSISTENCE_UNAVAILABLE": throw new RemoteError("subagent/delivery-unavailable", "subagent follow-up is temporarily unavailable", { childSessionId }, { cause: error });
 		default: break;
@@ -383,9 +350,10 @@ function epochStopReason(events) {
 		case "blocked": return "refusal";
 		case void 0:
 		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";
 	}
 }
@@ -752,6 +720,19 @@ var SubagentInbox = class {
 *
 * @module @deepseek-ai/dsh-subagent/continuation-activation
 */
+/** Process-local slots shared through uninterrupted continuable parent links. */
+var ActivationPool = class {
+	slots = /* @__PURE__ */ new Set();
+	/** Reserve before reconstruction; the returned release also tolerates unpublished rollback. */
+	reserve(capacity) {
+		if (this.slots.size >= capacity) throw new SubagentError(`subagent limit reached (active child limit: ${capacity}); wait for an existing child to finish or complete this work with the current agents`, "ACTIVATION_LIMIT_REACHED");
+		const slot = Symbol();
+		this.slots.add(slot);
+		return () => {
+			this.slots.delete(slot);
+		};
+	}
+};
 /** Serialize each durable child's delivery, release, and disposal. */
 var ChildLock = class {
 	tails = /* @__PURE__ */ new Map();
@@ -775,8 +756,11 @@ var ChildLock = class {
 var ContinuableActivationRegistry = class {
 	ctx;
 	observeActivation;
+	maxActiveSubagents;
 	/** Child session id → its live Activation. Process-local, never durable. */
 	resident = /* @__PURE__ */ new Map();
+	/** Root identities retain their pool across child settlement without retaining dead roots. */
+	rootPools = /* @__PURE__ */ new WeakMap();
 	/** Materializations admitted before drain, tracked through publication or rollback. */
 	materializations = /* @__PURE__ */ new Set();
 	/** Per-child serializer shared by delivery, release, and disposal. */
@@ -796,9 +780,10 @@ var ContinuableActivationRegistry = class {
 	* @param ctx - context providing Agents, Sessions, and teardown ownership.
 	* @param observeActivation - build the lifecycle observer for one residency epoch.
 	*/
-	constructor(ctx, observeActivation) {
+	constructor(ctx, observeActivation, maxActiveSubagents) {
 		this.ctx = ctx;
 		this.observeActivation = observeActivation;
+		this.maxActiveSubagents = maxActiveSubagents;
 		const scope = ctx.plugin(function activationOwner() {});
 		this.ownerCtx = scope.ctx;
 		ctx.on("agent/disposed", ({ agent }) => {
@@ -979,14 +964,20 @@ var ContinuableActivationRegistry = class {
 	*/
 	materialize(inputs) {
 		this.assertAdmitting(inputs.parent);
-		const settled = Promise.withResolvers();
+		inputs.signal.throwIfAborted();
 		const lineage = this.liveLineage(inputs.parent);
+		const pool = this.resident.get(inputs.parent.id)?.pool ?? this.rootPool(inputs.parent);
+		const releaseSlot = pool.reserve(this.maxActiveSubagents());
+		const settled = Promise.withResolvers();
 		const materialization = {
 			lineage,
 			settled: settled.promise
 		};
 		this.materializations.add(materialization);
-		return this.materializeTracked(inputs, lineage).finally(() => {
+		return this.materializeTracked(inputs, lineage, pool, releaseSlot).catch((error) => {
+			releaseSlot();
+			throw error;
+		}).finally(() => {
 			this.materializations.delete(materialization);
 			settled.resolve();
 		});
@@ -1061,8 +1052,17 @@ var ContinuableActivationRegistry = class {
 		const lineage = this.liveLineage(agent);
 		for (const [root, members] of this.closingScopes) if (members.has(agent) || lineage.includes(root)) return root;
 	}
+	/** Resolve a root's pool once; descendants inherit their resident parent's pool directly. */
+	rootPool(parent) {
+		let pool = this.rootPools.get(parent);
+		if (pool === void 0) {
+			pool = new ActivationPool();
+			this.rootPools.set(parent, pool);
+		}
+		return pool;
+	}
 	/** Perform one tracked materialization through publication or rollback. */
-	async materializeTracked(inputs, parentLineage) {
+	async materializeTracked(inputs, parentLineage, pool, releaseSlot) {
 		const { childId, provider, parent, create } = inputs;
 		inputs.signal.throwIfAborted();
 		const setup = (childCtx, child) => {
@@ -1090,6 +1090,8 @@ var ContinuableActivationRegistry = class {
 			setup
 		});
 		const activation = {
+			pool,
+			releaseSlot,
 			childId,
 			parentSession: parent.id,
 			provider,
@@ -1128,6 +1130,7 @@ var ContinuableActivationRegistry = class {
 				await activation.handle.dispose();
 			} finally {
 				this.resident.delete(activation.childId);
+				activation.releaseSlot();
 				this.releaseOwnership(activation.childId);
 			}
 		});
@@ -1241,6 +1244,7 @@ var ContinuableActivationRegistry = class {
 		if (failures.length === 1) failure = failures[0];
 		else if (failures.length > 1) failure = new SubagentError(`subagent "${childId}" activation teardown failed at ${failures.length} boundaries: ` + failures.map((item) => errorChain(item)).join("; "), "ACTIVATION_TEARDOWN_FAILED", { cause: new AggregateError(failures) });
 		this.resident.delete(childId);
+		activation.releaseSlot();
 		this.notifySettlement(activation, activation.observer.terminal(failure));
 		this.releaseOwnership(childId);
 		activation.observer.settle(failure);
@@ -1432,49 +1436,68 @@ function foldSubagentDescriptor(events) {
 	if (event === void 0) return void 0;
 	return parseSubagentDescriptor(event.data);
 }
-const sessionIdSchema = z.string();
-const oneShotCatalogSchema = z.object({
-	version: z.literal(0),
+const sessionIdSchema = z$1.string();
+const oneShotCatalogSchema = z$1.object({
+	version: z$1.union([z$1.literal(0), z$1.literal(1)]),
 	childId: sessionIdSchema,
-	childCreatedAt: z.number().int().nonnegative(),
-	mode: z.literal("one-shot"),
-	label: z.string().optional()
+	childCreatedAt: z$1.number().int().nonnegative(),
+	mode: z$1.literal("one-shot"),
+	label: z$1.string().optional()
 }).strict();
-const continuableCatalogSchema = z.object({
-	version: z.literal(0),
+const continuableCatalogSchema = z$1.object({
+	version: z$1.union([z$1.literal(0), z$1.literal(1)]),
 	childId: sessionIdSchema,
-	childCreatedAt: z.number().int().nonnegative(),
-	mode: z.literal("continuable"),
-	label: z.string()
+	childCreatedAt: z$1.number().int().nonnegative(),
+	mode: z$1.literal("continuable"),
+	label: z$1.string()
 }).strict();
-const eventDataSchema = z.union([oneShotCatalogSchema, continuableCatalogSchema]);
-const viewSchema = z.array(z.union([oneShotCatalogSchema.omit({
-	version: true,
-	childId: true,
-	childCreatedAt: true
-}).extend({
-	id: sessionIdSchema,
-	createdAt: oneShotCatalogSchema.shape.childCreatedAt
-}), continuableCatalogSchema.omit({
-	version: true,
-	childId: true,
-	childCreatedAt: true
-}).extend({
-	id: sessionIdSchema,
-	createdAt: continuableCatalogSchema.shape.childCreatedAt
-})]));
-const stateSchema = z.object({
-	inheritedEventCount: z.number().int().nonnegative(),
+const unknownCatalogSchema = oneShotCatalogSchema.extend({
+	version: z$1.literal(1),
+	mode: z$1.literal("unknown")
+});
+const eventDataSchema = z$1.union([
+	oneShotCatalogSchema,
+	continuableCatalogSchema,
+	unknownCatalogSchema
+]);
+const viewSchema = z$1.array(z$1.union([
+	oneShotCatalogSchema.omit({
+		version: true,
+		childId: true,
+		childCreatedAt: true
+	}).extend({
+		id: sessionIdSchema,
+		createdAt: oneShotCatalogSchema.shape.childCreatedAt
+	}),
+	continuableCatalogSchema.omit({
+		version: true,
+		childId: true,
+		childCreatedAt: true
+	}).extend({
+		id: sessionIdSchema,
+		createdAt: continuableCatalogSchema.shape.childCreatedAt
+	}),
+	unknownCatalogSchema.omit({
+		version: true,
+		childId: true,
+		childCreatedAt: true
+	}).extend({
+		id: sessionIdSchema,
+		createdAt: unknownCatalogSchema.shape.childCreatedAt
+	})
+]));
+const stateSchema = z$1.object({
+	inheritedEventCount: z$1.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" ? {
+	for (const data of iterateChunkedList(state.head)) entries.push(data.mode !== "continuable" ? {
 		id: data.childId,
 		createdAt: data.childCreatedAt,
 		mode: data.mode,
@@ -1499,7 +1522,7 @@ const subagentCatalogProjectionDefinition = {
 			head: appendChunkedList(state.head, eventDataSchema.parse(event.data))
 		};
 	},
-	stateVersion: 2,
+	stateVersion: 3,
 	wire: {
 		viewSchema,
 		view: subagentCatalogEntries
@@ -1565,7 +1588,7 @@ const deliverSubagentPrompt = Symbol.for("dsh.subagent.deliverPrompt");
 *
 * @module @deepseek-ai/dsh-subagent
 */
-var __addDisposableResource$1 = function(env, value, async) {
+var __addDisposableResource$2 = 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;
@@ -1594,7 +1617,7 @@ var __addDisposableResource$1 = function(env, value, async) {
 	} else if (async) env.stack.push({ async: true });
 	return value;
 };
-var __disposeResources$1 = (function(SuppressedError) {
+var __disposeResources$2 = (function(SuppressedError) {
 	return function(env) {
 		function fail(e) {
 			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
@@ -1633,10 +1656,10 @@ var SubagentContinuationManager = class {
 	ctx;
 	host;
 	activations;
-	constructor(ctx, host) {
+	constructor(ctx, host, maxActiveSubagents) {
 		this.ctx = ctx;
 		this.host = host;
-		this.activations = new ContinuableActivationRegistry(ctx, (provider, childId, parent) => host.observeActivation(provider, childId, parent));
+		this.activations = new ContinuableActivationRegistry(ctx, (provider, childId, parent) => host.observeActivation(provider, childId, parent), maxActiveSubagents);
 	}
 	/**
 	* Start one continuable background child and resolve at initial inbox acceptance.
@@ -1887,7 +1910,7 @@ var SubagentContinuationManager = class {
 				options.signal.throwIfAborted();
 				throw new SubagentError(`subagent "${childId}" is unavailable`, "NOT_RESUMABLE", { cause: error });
 			}
-			const source = __addDisposableResource$1(env_1, observation, false);
+			const source = __addDisposableResource$2(env_1, observation, false);
 			this.activations.assertAdmitting(parent);
 			this.activations.authorizeLineage(parent, childId, source.header.parentSession);
 			const descriptor = foldSubagentDescriptor(source.events.slice(source.inheritedEventCount));
@@ -1919,7 +1942,7 @@ var SubagentContinuationManager = class {
 			env_1.error = e_1;
 			env_1.hasError = true;
 		} finally {
-			__disposeResources$1(env_1);
+			__disposeResources$2(env_1);
 		}
 	}
 	/** Admit a materialized child, commit its creation fact, and release it on failure. */
@@ -1976,24 +1999,15 @@ var SubagentContinuationManager = class {
 //#endregion
 //#region lib/types/list-children.js
 /**
-* 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
 */
-var __addDisposableResource = function(env, value, async) {
+var __addDisposableResource$1 = 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;
@@ -2022,7 +2036,7 @@ var __addDisposableResource = function(env, value, async) {
 	} else if (async) env.stack.push({ async: true });
 	return value;
 };
-var __disposeResources = (function(SuppressedError) {
+var __disposeResources$1 = (function(SuppressedError) {
 	return function(env) {
 		function fail(e) {
 			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
@@ -2058,37 +2072,43 @@ var __disposeResources = (function(SuppressedError) {
 */
 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.
 */
 async function listChildren(ctx, parentSessionId, signal) {
-	const listing = await prepareListing(ctx, signal);
-	return (await resolveCandidateRows([...listing.corpus.values()].filter((record) => record.header.parentSession === parentSessionId && record.header.origin === "subagent").sort(compareCorpusRecords), listing, signal)).filter((row) => row !== void 0);
+	const env_1 = {
+		stack: [],
+		error: void 0,
+		hasError: false
+	};
+	try {
+		const query = ctx.get("sessionQuery");
+		if (query === void 0) throw new SubagentError("listing subagents requires the sessionQuery service (load @deepseek-ai/dsh-session-query)", "SUBAGENT_CONTROL_QUERY_UNAVAILABLE");
+		const entries = __addDisposableResource$1(env_1, await query.observeSession(parentSessionId, { ...signal === void 0 ? {} : { signal } }), false).projections?.values.subagentCatalog;
+		if (entries === void 0) 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$1(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.
 */
 async function listDescendants(ctx, rootSessionId, signal) {
 	const listing = await prepareListing(ctx, signal);
@@ -2224,7 +2244,7 @@ function compareCorpusRecords(a, b) {
 * throw — are final, so they report `corrupt`.
 */
 async function resolveColdIdentity(query, cache, header, hasChildren, signal) {
-	const env_1 = {
+	const env_2 = {
 		stack: [],
 		error: void 0,
 		hasError: false
@@ -2234,7 +2254,7 @@ async function resolveColdIdentity(query, cache, header, hasChildren, signal) {
 		if (cache !== void 0 && !header.isSeeded) {
 			let cached;
 			try {
-				cached = cache.cachedSnapshot(header, SessionLogOffset(0), ["subagent"])?.values.subagent;
+				cached = cache.cachedSnapshot(header, ["subagent"])?.values.subagent;
 			} catch {
 				cached = void 0;
 			}
@@ -2252,7 +2272,7 @@ async function resolveColdIdentity(query, cache, header, hasChildren, signal) {
 				reason: sessionQueryCode(error) === "SESSION_QUERY_CORRUPT_SESSION" || sessionQueryCode(error) === "SESSION_QUERY_SOURCE_CONFLICT" ? "corrupt" : "unavailable"
 			};
 		}
-		const ownedObservation = __addDisposableResource(env_1, observation, false);
+		const ownedObservation = __addDisposableResource$1(env_2, observation, false);
 		assertListingNotCancelled(signal);
 		if (!sameLifecycle(ownedObservation.header, header)) return {
 			kind: "diagnostic",
@@ -2266,11 +2286,11 @@ async function resolveColdIdentity(query, cache, header, hasChildren, signal) {
 			reason: "corrupt"
 		};
 		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$1(env_2);
 	}
 }
 /** Materialize one served identity as its child row. */
@@ -2315,6 +2335,159 @@ function sessionQueryCode(error) {
 	return error instanceof Error && "code" in error ? error.code : void 0;
 }
 //#endregion
+//#region lib/types/archive-admission.js
+/**
+* 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 = 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,
+			dispose,
+			async
+		});
+	} else if (async) env.stack.push({ async: true });
+	return value;
+};
+var __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;
+});
+/**
+* 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.
+*/
+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;
+		return [{
+			kind: "subagent",
+			items: await Promise.all(running.map((child) => describe(ctx, child)))
+		}, ...rest];
+	});
+	ctx.on("workspace/session-stop", ({ sessionId }) => {
+		for (const child of runningDescendants(ctx, sessionId)) try {
+			child.cancel({ kind: "parent" });
+		} catch (error) {
+			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 = /* @__PURE__ */ new Map();
+	for (const agent of ctx.agents.list()) {
+		const { parentSession, origin } = agent.session.header;
+		if (parentSession === void 0 || origin !== "subagent") continue;
+		const siblings = childrenOf.get(parentSession) ?? [];
+		siblings.push(agent);
+		childrenOf.set(parentSession, siblings);
+	}
+	const running = [];
+	const pending = [rootId];
+	const visited = /* @__PURE__ */ 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 === void 0) 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 === void 0 ? { id: child.id } : {
+				id: child.id,
+				label
+			};
+		} catch (e_1) {
+			env_1.error = e_1;
+			env_1.hasError = true;
+		} finally {
+			__disposeResources(env_1);
+		}
+	} catch {
+		return { id: child.id };
+	}
+}
+//#endregion
 //#region lib/types/projection.js
 /**
 * Pure session projections for subagent identity (mode/label) and active-turn
@@ -2322,16 +2495,18 @@ function sessionQueryCode(error) {
 *
 * @module @deepseek-ai/dsh-subagent/projection
 */
-const activeIntervalSchema = z.object({
-	since: z.number().int().nonnegative(),
-	through: z.number().int().nonnegative()
+const activeIntervalSchema = z$1.object({
+	since: z$1.number().int().nonnegative(),
+	through: z$1.number().int().nonnegative()
 }).strict();
-const projectionSchema = z.object({
-	settledMs: z.number().int().nonnegative(),
-	active: activeIntervalSchema.optional()
-}).strict().transform(({ settledMs, active }) => ({
+const projectionSchema = z$1.object({
+	settledMs: z$1.number().int().nonnegative(),
+	active: activeIntervalSchema.optional(),
+	lastTurnCompleted: z$1.boolean().optional()
+}).strict().transform(({ settledMs, active, lastTurnCompleted }) => ({
 	settledMs,
-	...active === void 0 ? {} : { active }
+	...active === void 0 ? {} : { active },
+	...lastTurnCompleted === void 0 ? {} : { lastTurnCompleted }
 }));
 /**
 * Fold turn boundaries around the child's own durable descriptor.
@@ -2343,27 +2518,31 @@ const projectionSchema = z.object({
 */
 const subagentTimingProjectionDefinition = {
 	key: "subagentTiming",
-	stateSchema: z.object({
-		settledMs: z.number().int().nonnegative(),
+	stateSchema: z$1.object({
+		settledMs: z$1.number().int().nonnegative(),
 		active: activeIntervalSchema.optional(),
-		pendingTurnStart: z.number().int().nonnegative().optional(),
-		descriptorSeen: z.boolean()
+		pendingTurnStart: z$1.number().int().nonnegative().optional(),
+		descriptorSeen: z$1.boolean(),
+		lastTurnCompleted: z$1.boolean().optional()
 	}).strict(),
 	init: () => ({
 		descriptorSeen: false,
 		settledMs: 0
 	}),
 	apply: (state, event) => {
-		if (event.type === "turn/start") return state.descriptorSeen ? {
-			...state,
-			active: {
-				since: event.time,
-				through: event.time
-			}
-		} : {
-			...state,
-			pendingTurnStart: event.time
-		};
+		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
+			};
+		}
 		if (event.type === "subagent/descriptor") {
 			const activeSince = state.active?.since ?? state.pendingTurnStart;
 			return {
@@ -2385,7 +2564,8 @@ const subagentTimingProjectionDefinition = {
 			const { active, ...rest } = state;
 			return {
 				...rest,
-				settledMs: state.settledMs + Math.max(0, event.time - active.since)
+				settledMs: state.settledMs + Math.max(0, event.time - active.since),
+				lastTurnCompleted: event.data.reason.kind === "completed"
 			};
 		}
 		if (state.active === void 0) return state;
@@ -2401,22 +2581,23 @@ const subagentTimingProjectionDefinition = {
 		viewSchema: projectionSchema,
 		view: (state) => ({
 			settledMs: state.settledMs,
-			...state.active === void 0 ? {} : { active: state.active }
+			...state.active === void 0 ? {} : { active: state.active },
+			...state.lastTurnCompleted === void 0 ? {} : { lastTurnCompleted: state.lastTurnCompleted }
 		})
 	},
-	stateVersion: 2
+	stateVersion: 3
 };
-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)
+const identityValueSchema = z$1.discriminatedUnion("mode", [z$1.object({
+	mode: z$1.literal("one-shot"),
+	label: z$1.string().optional(),
+	seq: z$1.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).transform(SessionSeq)
+}).strict(), z$1.object({
+	mode: z$1.literal("continuable"),
+	label: z$1.string(),
+	seq: z$1.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).transform(SessionSeq)
 }).strict()]);
 const identitySchema = identityValueSchema.nullable();
-const identityStateSchema = z.object({ identity: identityValueSchema.optional() }).strict();
+const identityStateSchema = z$1.object({ identity: identityValueSchema.optional() }).strict();
 /** Interpret one `subagent/descriptor` event's identity; no value when the payload cannot be trusted. */
 function descriptorIdentity(event) {
 	let descriptor;
@@ -2679,7 +2860,7 @@ function runOutcome(result) {
 	switch (result.stopReason) {
 		case "completed": return {
 			status: "completed",
-			output: finalText(result.output)
+			result: finalText(result.output)
 		};
 		case "aborted": return result.diagnostic === void 0 ? { status: "killed" } : {
 			status: "failed",
@@ -2725,36 +2906,6 @@ async function settleRun(run) {
 }
 //#endregion
 //#region lib/types/index.js
-/**
-* 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 = function(thisArg, initializers, value) {
 	var useValue = arguments.length > 2;
 	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
@@ -2797,26 +2948,13 @@ var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializ
 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",
@@ -2846,7 +2984,12 @@ let SubagentRuntime = (() => {
 				value: _metadata
 			});
 		}
-		providers = (__runInitializers(this, _instanceExtraInitializers), /* @__PURE__ */ new Map());
+		config = __runInitializers(this, _instanceExtraInitializers);
+		static Config = z.object({
+			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()
+		});
+		providers = /* @__PURE__ */ new Map();
 		continuations;
 		/**
 		* The contained lifecycle-edge publisher. Built here because scoped dispatch
@@ -2854,14 +2997,15 @@ let SubagentRuntime = (() => {
 		* composes into the carrier.
 		*/
 		emitLifecycle;
-		constructor(ctx) {
+		constructor(ctx, config) {
 			super(ctx, "subagents");
+			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.config.maxActiveSubagents.get());
 				this.continuations = manager;
 				childCtx.effect(() => () => {
 					/* v8 ignore else -- one injected binding owns the slot until its fiber disposes. */
@@ -2869,10 +3013,26 @@ 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);
 			});
+			ctx.inject(["agents"], (agentsCtx) => {
+				installSubagentArchiveAdmission(agentsCtx);
+			});
+		}
+		/**
+		* Resolve a delegation tool's depth policy against the current user setting.
+		* @param configured - Explicit tool limit, or provider-managed for external delegation.
+		* @returns The numeric limit, or undefined when the provider owns depth enforcement.
+		*/
+		resolveMaxDepth(configured) {
+			if (configured === "provider-managed") return void 0;
+			if (configured !== void 0) return configured;
+			const depth = this.config.maxDepth.get();
+			assertSubagentMaxDepth(depth);
+			return depth;
 		}
 		/**
 		* Establish one durable continuable child and deliver its initial prompt.
@@ -2967,21 +3127,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 listChildren(this.ctx, parentSessionId, signal);
@@ -2992,40 +3144,19 @@ 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 listDescendants(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
 		* validated browser zone on the accepted message. Success identifies the
@@ -3034,6 +3165,7 @@ let SubagentRuntime = (() => {
 		* nearest step and retains the Agent loop's best-effort fallback semantics.
 		* Image parts are admitted and persisted through the attachment store
 		* before delivery, and the child's model must accept image input.
+		* Cold resume at capacity rejects with `subagent/delivery-unavailable`.
 		* @param request - durable address, delivery, minted identity, content, and optional browser zone.
 		* @param signal - carrier cancellation, owning the call until inbox acceptance.
 		* @returns the accepted message's inbox identity.