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

package/lib/index.js

@@ -30,15 +30,13 @@ 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$1.string().min(1);
 const CONTROL_ID_SCHEMAS = {
-	"subagent.list": z$1.object({ parentSessionId: SESSION_ID_SCHEMA }),
 	"subagent.prompt": z$1.object({
 		parentSessionId: SESSION_ID_SCHEMA,
 		childSessionId: SESSION_ID_SCHEMA,
@@ -63,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.
@@ -385,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";
 	}
 }
@@ -1472,47 +1438,66 @@ function foldSubagentDescriptor(events) {
 }
 const sessionIdSchema = z$1.string();
 const oneShotCatalogSchema = z$1.object({
-	version: z$1.literal(0),
+	version: z$1.union([z$1.literal(0), z$1.literal(1)]),
 	childId: sessionIdSchema,
 	childCreatedAt: z$1.number().int().nonnegative(),
 	mode: z$1.literal("one-shot"),
 	label: z$1.string().optional()
 }).strict();
 const continuableCatalogSchema = z$1.object({
-	version: z$1.literal(0),
+	version: z$1.union([z$1.literal(0), z$1.literal(1)]),
 	childId: sessionIdSchema,
 	childCreatedAt: z$1.number().int().nonnegative(),
 	mode: z$1.literal("continuable"),
 	label: z$1.string()
 }).strict();
-const eventDataSchema = z$1.union([oneShotCatalogSchema, continuableCatalogSchema]);
-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
-})]));
+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,
@@ -1537,7 +1522,7 @@ const subagentCatalogProjectionDefinition = {
 			head: appendChunkedList(state.head, eventDataSchema.parse(event.data))
 		};
 	},
-	stateVersion: 2,
+	stateVersion: 3,
 	wire: {
 		viewSchema,
 		view: subagentCatalogEntries
@@ -1603,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;
@@ -1632,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;
@@ -1925,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));
@@ -1957,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. */
@@ -2014,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;
@@ -2060,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;
@@ -2096,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);
@@ -2262,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
@@ -2272,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;
 			}
@@ -2290,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",
@@ -2304,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. */
@@ -2353,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
@@ -2366,10 +2501,12 @@ const activeIntervalSchema = z$1.object({
 }).strict();
 const projectionSchema = z$1.object({
 	settledMs: z$1.number().int().nonnegative(),
-	active: activeIntervalSchema.optional()
-}).strict().transform(({ settledMs, active }) => ({
+	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.
@@ -2385,23 +2522,27 @@ const subagentTimingProjectionDefinition = {
 		settledMs: z$1.number().int().nonnegative(),
 		active: activeIntervalSchema.optional(),
 		pendingTurnStart: z$1.number().int().nonnegative().optional(),
-		descriptorSeen: z$1.boolean()
+		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 {
@@ -2423,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;
@@ -2439,10 +2581,11 @@ 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$1.discriminatedUnion("mode", [z$1.object({
 	mode: z$1.literal("one-shot"),
@@ -2717,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",
@@ -2763,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);
@@ -2835,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",
@@ -2884,11 +2984,11 @@ let SubagentRuntime = (() => {
 				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 = /* @__PURE__ */ new Map();
 		continuations;
 		/**
@@ -2899,25 +2999,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. */
@@ -2925,9 +3013,13 @@ 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);
 			});
 		}
 		/**
@@ -2937,7 +3029,10 @@ let SubagentRuntime = (() => {
 		*/
 		resolveMaxDepth(configured) {
 			if (configured === "provider-managed") return void 0;
-			return configured ?? this.settingsSource().maxDepth;
+			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.
@@ -3032,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);
@@ -3057,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