@deepseek-ai/dsh-subagent 0.1.7-rc.1 → 0.2.0-rc.1

package/README.i18n.yaml

@@ -1,6 +1,94 @@
-# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
-# side as of the last confirmed-consistent state. Both languages carry equal authority;
-# after editing either side, bring the other along and re-record with:
+# Bilingual-pair consistency record for README.md (docs/i18n/README.md): per heading
+# section, a hash of its English and Chinese blocks outside code blocks and generated regions.
+# After editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/subagent/subagent/README.md
-README.md: adffd0edfdc55177afee0390c8d1c2f7fbee7999
-README.zh.md: 79d39ca879c8a15385e1e97c6556178b04897fca
+/:
+  en: 384d01a27a111f49
+  zh: fbadc6917c3099c9
+/deepseek-ai-dsh-subagent:
+  en: 425344cec61f5c70
+  zh: 48e8f2a2e3c1f418
+/deepseek-ai-dsh-subagent/summary:
+  en: 300242b82e87aa3e
+  zh: a4a1319487072484
+/deepseek-ai-dsh-subagent/table-of-contents:
+  en: d152484eb41ac6b4
+  zh: 09388d293f9be9cb
+/deepseek-ai-dsh-subagent/use-this-package:
+  en: 4651aec03a1d2e21
+  zh: 7b6d1d604bdb1bf1
+/deepseek-ai-dsh-subagent/use-this-package/enabling-delegation:
+  en: f66e74a5fa4e49b6
+  zh: 8c3a793cc29fcc1b
+/deepseek-ai-dsh-subagent/use-this-package/delegation-settings:
+  en: 86c982223fab1a3a
+  zh: 3d220d8ed84eab9a
+/deepseek-ai-dsh-subagent/use-this-package/continuable-capacity:
+  en: 8346a0de39204c1c
+  zh: 9dd1d926790e5e8c
+/deepseek-ai-dsh-subagent/use-this-package/one-shot-and-continuable-children:
+  en: 10d0a7e0513bf04b
+  zh: 0cf2c2d81e85d7a9
+/deepseek-ai-dsh-subagent/use-this-package/messaging-interrupting-and-discovering:
+  en: ff41ac0e770ed865
+  zh: 27dcf055badf217d
+/deepseek-ai-dsh-subagent/use-this-package/failure-and-recovery:
+  en: 782aaaf8639c211c
+  zh: e2a873eece366e74
+/deepseek-ai-dsh-subagent/understand-the-implementation:
+  en: 74d91b364b23f88d
+  zh: 19cc558105efe8df
+/deepseek-ai-dsh-subagent/understand-the-implementation/design-concept:
+  en: 26c4eb7592b77d14
+  zh: c166fb6ee1a1c7d8
+/deepseek-ai-dsh-subagent/understand-the-implementation/source-map:
+  en: d9afc0d9548afe58
+  zh: 0e11526b6c001dc6
+/deepseek-ai-dsh-subagent/understand-the-implementation/one-shot-flow:
+  en: 9439bd15ee2129c9
+  zh: 6c275cf484efa0cf
+/deepseek-ai-dsh-subagent/understand-the-implementation/continuable-flow:
+  en: 9703c868342826cc
+  zh: e300484cecf15835
+/deepseek-ai-dsh-subagent/understand-the-implementation/ownership-and-invariants:
+  en: 7384d01be46a2f0a
+  zh: 83373486ad10d6d5
+/deepseek-ai-dsh-subagent/further-exploration:
+  en: d1c1e87fc59ebfe5
+  zh: b7ec9b870b514911
+/deepseek-ai-dsh-subagent/model-experience:
+  en: 215e7ba838619b7b
+  zh: a311da3843709f90
+/deepseek-ai-dsh-subagent/model-experience/settlement-notice:
+  en: f7cec22ba9d3fb4f
+  zh: 67b1d40f9b136f71
+/deepseek-ai-dsh-subagent/model-experience/settlement-notice/what-the-model-sees:
+  en: 44ba290ef9896de9
+  zh: 21d207c31228c0ce
+/deepseek-ai-dsh-subagent/model-experience/settlement-notice/token-effect:
+  en: 45dc428c61f606f5
+  zh: 7e9a2587e98c8ca6
+/deepseek-ai-dsh-subagent/model-experience/settlement-notice/kv-cache-effect:
+  en: d6b1d618083da79b
+  zh: 9a28942b7d53c382
+/deepseek-ai-dsh-subagent/model-experience/child-delegation-scope-statement:
+  en: dc8544657916e194
+  zh: b0feff0764b5d903
+/deepseek-ai-dsh-subagent/model-experience/child-delegation-scope-statement/what-the-model-sees:
+  en: 61906b6a7b656eeb
+  zh: 2fa94349714efc9f
+/deepseek-ai-dsh-subagent/model-experience/child-delegation-scope-statement/what-the-model-sees/the-delegation-scope-statement:
+  en: 960e4abc8393bcd1
+  zh: e125aa2bab1570d0
+/deepseek-ai-dsh-subagent/model-experience/child-delegation-scope-statement/token-effect:
+  en: 4e0b922b186dc2a9
+  zh: 7453563417c5b9a2
+/deepseek-ai-dsh-subagent/model-experience/child-delegation-scope-statement/kv-cache-effect:
+  en: 59e848fca82a46fb
+  zh: fcd6a8a2bb58609f
+/deepseek-ai-dsh-subagent/known-limitations-and-deferred-work:
+  en: b2182809471f0780
+  zh: cfab217025442ae8
+/deepseek-ai-dsh-subagent/known-limitations-and-deferred-work/dev-note:
+  en: 25cc0909348666bb
+  zh: 95517f12de100049

package/README.md

@@ -60,7 +60,7 @@ One-shot children run once and settle with a single result, plus an optional str
 
 ### Messaging, interrupting, and discovering
 
-Every exact live Agent can use `sendMessage()` with a direct continuable child; a resident continuable child can also use it with its direct parent. A working target receives the Agent message through Steer at its nearest step; an idle target starts a turn, and only a direct child can be cold-resumed. The parent can also interrupt a running descendant or list its children at any time. A browser continuation prompt independently selects Queue or Steer and may carry image parts: the Host admits and persists each image batch through the attachment store before the child inbox accepts the message, and refuses delivery when the child's declared model does not accept image input. Direct-child discovery reads the parent-owned `subagentCatalog` projection. `listChildren(parentSessionId, signal?)` owns a live-preferred Session observation and returns the catalog asynchronously without reading child logs. It forwards cancellation and releases the observation after materialization. Materialization preserves parent event order in O(D) time for D facts. Complete descendant discovery retains the Session corpus and child identity projection; neither path loads or resumes a child Agent.
+Every exact live Agent can use `sendMessage()` with a direct continuable child; a resident continuable child can also use it with its direct parent. A working target receives the Agent message through Steer at its nearest step; an idle target starts a turn, and only a direct child can be cold-resumed. The parent can also interrupt a running descendant or list its children at any time. A browser continuation prompt independently selects Queue or Steer and may carry image parts: the Host admits and persists each image batch through the attachment store before the child inbox accepts the message, and refuses delivery when the child's declared model does not accept image input. Direct-child discovery reads the parent-owned `subagentCatalog` projection. `listChildren(parentSessionId, signal?)` owns a live-preferred Session observation and returns the catalog asynchronously without reading child logs. It forwards cancellation and releases the observation after materialization. Materialization preserves parent event order in O(D) time for D facts. Descendant discovery recursively reads those child catalogs in parent event order, observing each reachable Session once. It skips branches whose catalogs cannot be read and returns diagnostics for them; neither path loads or resumes a child Agent.
 
 ### Failure and recovery
 
@@ -97,7 +97,7 @@ This section explains how the service is built and where the observable behavior
 | [`src/descriptor.ts`](src/descriptor.ts) | Versioned `subagent/descriptor` session-event vocabulary |
 | [`src/catalog.ts`](src/catalog.ts) | Parent-owned `subagent/catalog` event and chunked host projection |
 | [`src/child-agent.ts`](src/child-agent.ts) | Child composition, delegated policy, depth helpers |
-| [`src/list-children.ts`](src/list-children.ts) | Direct parent-catalog reads and complete descendant-corpus reads |
+| [`src/list-children.ts`](src/list-children.ts) | Direct and recursive parent-catalog reads |
 | [`src/control.ts`](src/control.ts) | Browser control request validation and stable failure codes |
 | [`src/control-types.ts`](src/control-types.ts) | Client-safe catalog row, control requests, receipts, and failures |
 | [`src/archive-admission.ts`](src/archive-admission.ts) | The `subagent` family of the Workspace registry's archive admission: running descendants and their parent-cause cancel |
@@ -184,6 +184,7 @@ Prefix-stable within a child: the statement never changes during the child's lif
 
 These limits define when the seam is a poor fit or needs special operational care. They are current package constraints, not a general delegation comparison or a task backlog.
 
+- **Descendant reads are sequential** — each reachable catalog, including one-shot children, takes one observation. A cold Session without a valid prepared observation requires a full-log read; large cold trees can accumulate storage latency.
 - **ACP children remain one-shot and are not trace-enumerable** — an ACP run has no local child session in the parent's session corpus, and remote providers need an Activation ownership contract before they can support continuable children.
 - **Adjacent model messaging only** — `sendMessage()` requires an exact live sender; every sender may target a direct continuable child, while only a sender with a resident continuable Activation may target its direct parent. Browser prompts use a separate human Queue-or-Steer control path.
 - **A direct parent must remain live for child-to-parent delivery** — the service has no durable parent mailbox; a missing parent rejects the message instead of accepting work it cannot wake.

package/README.zh.md

@@ -44,7 +44,7 @@ kind: "package-reference"
 
 ### 委派设置
 
-**插件 → Subagent** 页面的限制部分编辑 Host 的 `subagent` 设置分节。用户值覆盖本插件的组合配置；恢复默认会删除用户覆盖。`maxDepth` 默认为 `1`，在委派工具自身未配置深度时提供默认值。工具显式指定的深度（包括 `provider-managed`）优先。深度 `0` 禁止继承此设置的工具委派；深度 `1` 只允许直接子代理。修改在下一次委派时生效。直接调用服务的调用方仍自行提供可选的请求深度。
+**插件 → 子智能体**页面的限制部分编辑 Host 的 `subagent` 设置分节。用户值覆盖本插件的组合配置；恢复默认会删除用户覆盖。`maxDepth` 默认为 `1`，在委派工具自身未配置深度时提供默认值。工具显式指定的深度（包括 `provider-managed`）优先。深度 `0` 禁止继承此设置的工具委派；深度 `1` 只允许直接子代理。修改在下一次委派时生效。直接调用服务的调用方仍自行提供可选的请求深度。
 
 ### 可续接子代理容量
 
@@ -60,7 +60,7 @@ kind: "package-reference"
 
 ### 消息、中断与发现
 
-每个确切在线 Agent 都可以对直接可继续 child 使用 `sendMessage()`；驻留的可继续 child 还可以对自己的直接 parent 使用它。正在工作的目标通过 Steer 在最近 step 接收 Agent 消息；空闲目标启动轮次，且只有直接 child 可以冷恢复。parent 也可以随时中断正在运行的后代或列举自己的子级。浏览器发出的继续执行 prompt 会独立选择 Queue 或 Steer，并且可以携带图片部分：Host 先通过附件存储完成整批图片的准入与持久化，子级 inbox 才接受这条消息；当子级声明的模型不接受图片输入时拒绝投递。 直接子级发现读取 parent 自有的 `subagentCatalog` projection。`listChildren(parentSessionId, signal?)` 持有一次优先实时来源的 Session 观察，异步返回目录，不读取子级日志。它转发取消信号，并在物化后释放观察。物化以 O(D) 时间保留 D 条事实的父日志事件顺序。完整后代发现保留 Session 语料库与子级身份 projection；两条路径都不加载或恢复子级 Agent。
+每个确切在线 Agent 都可以对直接可继续 child 使用 `sendMessage()`；驻留的可继续 child 还可以对自己的直接 parent 使用它。正在工作的目标通过 Steer 在最近 step 接收 Agent 消息；空闲目标启动轮次，且只有直接 child 可以冷恢复。parent 也可以随时中断正在运行的后代或列举自己的子级。浏览器发出的继续执行 prompt 会独立选择 Queue 或 Steer，并且可以携带图片部分：Host 先通过附件存储完成整批图片的准入与持久化，子级 inbox 才接受这条消息；当子级声明的模型不接受图片输入时拒绝投递。 直接子级发现读取 parent 自有的 `subagentCatalog` projection。`listChildren(parentSessionId, signal?)` 持有一次优先实时来源的 Session 观察，异步返回目录，不读取子级日志。它转发取消信号，并在物化后释放观察。物化以 O(D) 时间保留 D 条事实的父日志事件顺序。后代发现按父事件顺序递归读取子级目录，每个可达 Session 观察一次。无法读取目录的分支会被跳过，并返回诊断；两条路径都不加载或恢复子级 Agent。
 
 ### 失败与恢复
 
@@ -97,7 +97,7 @@ kind: "package-reference"
 | [`src/descriptor.ts`](src/descriptor.ts) | 版本化的 `subagent/descriptor` 会话事件词汇 |
 | [`src/catalog.ts`](src/catalog.ts) | parent 自有的 `subagent/catalog` 事件与分块 host projection |
 | [`src/child-agent.ts`](src/child-agent.ts) | 子级组装、委派策略、深度辅助函数 |
-| [`src/list-children.ts`](src/list-children.ts) | 直接 parent 目录读取与完整后代语料读取 |
+| [`src/list-children.ts`](src/list-children.ts) | 直接与递归的 parent 目录读取 |
 | [`src/control.ts`](src/control.ts) | 浏览器控制请求校验与稳定失败分码 |
 | [`src/control-types.ts`](src/control-types.ts) | client-safe 的目录行、控制面请求、回执与失败 |
 | [`src/archive-admission.ts`](src/archive-admission.ts) | Workspace 注册表归档准入中的 `subagent` 族：运行中的子孙及其父级取消 |
@@ -184,6 +184,7 @@ You are a delegated subagent: your permission scope was fixed when you were star
 
 这些限制说明该 seam 何时不合适，或何时需要特别的运维注意。它们是当前包约束，不是通用委派对比或任务积压。
 
+- **后代读取串行执行**——每个可达目录（包括一次性子级）都需要一次观察。冷 Session 缺少有效的 prepared 观察时需要读取完整日志；大型冷会话树可能累积存储延迟。
 - **ACP 子级仍为一次性，且无法通过追踪枚举**——ACP 运行在父级会话语料中没有本地子会话，远程提供方需要 Activation 所有权约定才能支持可继续子级。
 - **仅允许相邻模型消息**——`sendMessage()` 要求确切在线 sender；每个 sender 都可以指定直接可继续 child，只有具备驻留可继续 Activation 的 sender 可以指定自己的直接 parent。浏览器提示使用独立的人类 Queue 或 Steer 控制路径。
 - **child 到 parent 的投递要求直接 parent 保持在线**——服务没有持久 parent mailbox；parent 缺失时会拒绝消息，而非接受无法唤醒的工作。

package/lib/index.js

@@ -1999,12 +1999,8 @@ var SubagentContinuationManager = class {
 //#endregion
 //#region lib/types/list-children.js
 /**
-* 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.
-*
+* Direct-child and recursive descendant discovery from parent-owned catalogs.
+* Each catalog read releases its Session observation before the next branch.
 * @module @deepseek-ai/dsh-subagent
 */
 var __addDisposableResource$1 = function(env, value, async) {
@@ -2066,12 +2062,6 @@ var __disposeResources$1 = (function(SuppressedError) {
 	return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 /**
-* Concurrent cold observations per explicit catalog listing. Current Session
-* persistence providers are local; a networked provider must promote this to
-* a validated deployment setting.
-*/
-const COLD_READ_CONCURRENCY = 4;
-/**
 * 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.
@@ -2099,241 +2089,84 @@ async function listChildren(ctx, parentSessionId, signal) {
 	}
 }
 /**
-* 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
-* 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} when listing dependencies are unavailable or the caller cancels.
+* Walk reachable parent catalogs in stable pre-order without loading Agents.
+* @see SubagentRuntime.listDescendants for failure and cancellation semantics.
+* @param ctx - context carrying the Session store and query service.
+* @param rootSessionId - parent whose catalog starts the traversal.
+* @param signal - cancellation checked around each catalog read.
+* @returns children and branch diagnostics with catalog parent and depth.
 */
 async function listDescendants(ctx, rootSessionId, signal) {
-	const listing = await prepareListing(ctx, signal);
-	const positioned = descendantCandidates(listing.corpus, rootSessionId);
-	const rows = await resolveCandidateRows(positioned.map((candidate) => candidate.record), listing, signal);
-	const entries = [];
-	positioned.forEach((position, index) => {
-		const row = rows[index];
-		if (row !== void 0) entries.push({
-			...row,
-			parentId: position.parentId,
-			depth: position.depth
-		});
-	});
-	return entries;
-}
-/** Resolve listing services once and build one live-preferred session corpus. */
-async function prepareListing(ctx, signal) {
-	const projections = ctx.get("sessionProjections");
-	if (projections === void 0) throw new SubagentError("listing subagents requires the sessionProjections registry (load @deepseek-ai/dsh-session-projection)", "SUBAGENT_CONTROL_PROJECTIONS_UNAVAILABLE");
 	const sessions = ctx.get("sessions");
 	if (sessions === void 0) throw new SubagentError("listing subagents requires the session store (load @deepseek-ai/dsh-session)", "SUBAGENT_CONTROL_SESSION_STORE_UNAVAILABLE");
-	assertListingNotCancelled(signal);
-	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 cache = ctx.get("sessionProjectionCache");
-	let records;
-	try {
-		records = await query.listSessions(signal);
-	} catch (error) {
+	const readChildren = async (id) => {
 		assertListingNotCancelled(signal);
-		throw error;
-	}
-	assertListingNotCancelled(signal);
-	const corpus = /* @__PURE__ */ new Map();
-	for (const record of records) {
-		const live = sessions.get(record.header.id);
-		corpus.set(record.header.id, {
-			header: live?.header ?? record.header,
-			live
-		});
-	}
-	const subagentParents = /* @__PURE__ */ new Set();
-	for (const record of corpus.values()) if (record.header.origin === "subagent" && record.header.parentSession !== void 0) subagentParents.add(record.header.parentSession);
-	return {
-		projections,
-		query,
-		cache,
-		corpus,
-		subagentParents
-	};
-}
-/** Resolve projection-backed rows for aligned candidates with bounded cold reads. */
-async function resolveCandidateRows(candidates, listing, signal) {
-	const { projections, query, cache, subagentParents } = listing;
-	const rows = Array.from({ length: candidates.length });
-	const coldReads = [];
-	candidates.forEach((candidate, index) => {
-		const childId = candidate.header.id;
-		if (candidate.live === void 0) {
-			coldReads.push({
-				index,
-				header: candidate.header
-			});
-			return;
-		}
-		let identity;
+		let children;
 		try {
-			identity = projections.snapshot(candidate.live, ["subagent"]).values.subagent;
-		} catch {
-			rows[index] = {
-				kind: "diagnostic",
-				id: childId,
-				reason: "corrupt"
-			};
-			return;
+			children = await listChildren(ctx, id, signal);
+		} catch (error) {
+			assertListingNotCancelled(signal);
+			throw error;
 		}
-		if (identity === void 0 || identity === null || !candidate.live.isOwnSeq(identity.seq)) return;
-		rows[index] = childRow(childId, identity, "running", subagentParents.has(childId));
-	});
-	if (coldReads.length > 0) {
-		const queue = [...coldReads];
-		await Promise.all(Array.from({ length: Math.min(COLD_READ_CONCURRENCY, queue.length) }, async () => {
-			for (let job = queue.shift(); job !== void 0; job = queue.shift()) rows[job.index] = await resolveColdIdentity(query, cache, job.header, subagentParents.has(job.header.id), signal);
-		}));
-	}
-	assertListingNotCancelled(signal);
-	return rows;
-}
-/** Build origin-classified candidates from the complete tree without recursion. */
-function descendantCandidates(corpus, rootSessionId) {
-	const children = /* @__PURE__ */ new Map();
-	for (const record of corpus.values()) {
-		const parentId = record.header.parentSession;
-		if (parentId === void 0) continue;
-		const siblings = children.get(parentId);
-		if (siblings === void 0) children.set(parentId, [record]);
-		else siblings.push(record);
-	}
-	for (const siblings of children.values()) siblings.sort(compareCorpusRecords);
-	const positioned = [];
-	const stack = (children.get(rootSessionId) ?? []).map((record) => ({
-		record,
+		assertListingNotCancelled(signal);
+		return children;
+	};
+	const stack = (await readChildren(rootSessionId)).map((entry) => ({
+		entry,
 		parentId: rootSessionId,
 		depth: 1
 	})).reverse();
 	const visited = new Set([rootSessionId]);
-	while (stack.length > 0) {
-		const position = stack.pop();
-		const id = position.record.header.id;
-		if (visited.has(id)) continue;
-		visited.add(id);
-		if (position.record.header.origin === "subagent") positioned.push(position);
-		const descendants = children.get(id) ?? [];
-		for (const record of [...descendants].reverse()) stack.push({
-			record,
-			parentId: id,
-			depth: position.depth + 1
-		});
-	}
-	return positioned;
-}
-/** Compare siblings by durable creation time, then id. */
-function compareCorpusRecords(a, b) {
-	return a.header.createdAt - b.header.createdAt || a.header.id.localeCompare(b.header.id);
-}
-/**
-* Resolve one cold candidate down the remaining ladder: an unseeded durable
-* projection-cache row, otherwise one shared Session observation. An absent or transiently failed
-* observation is one `unavailable` row retried on the next listing; an observation
-* source naming another lifecycle, and a
-* settled log the fold cannot identify — or that makes any registered unit
-* throw — are final, so they report `corrupt`.
-*/
-async function resolveColdIdentity(query, cache, header, hasChildren, signal) {
-	const env_2 = {
-		stack: [],
-		error: void 0,
-		hasError: false
-	};
-	try {
-		const childId = header.id;
-		if (cache !== void 0 && !header.isSeeded) {
-			let cached;
-			try {
-				cached = cache.cachedSnapshot(header, ["subagent"])?.values.subagent;
-			} catch {
-				cached = void 0;
-			}
-			if (cached !== void 0 && cached !== null) return childRow(childId, cached, "inactive", hasChildren);
-		}
-		assertListingNotCancelled(signal);
-		let observation;
+	const result = [];
+	for (let position = stack.pop(); position !== void 0; position = stack.pop()) {
+		const { entry, parentId, depth } = position;
+		if (visited.has(entry.id)) continue;
+		visited.add(entry.id);
+		let children;
 		try {
-			observation = await query.observeSession(childId, { ...signal === void 0 ? {} : { signal } });
+			children = await readChildren(entry.id);
 		} catch (error) {
-			assertListingNotCancelled(signal);
-			return {
+			if (error instanceof SubagentError) throw error;
+			const code = error instanceof Error && "code" in error ? error.code : void 0;
+			result.push({
 				kind: "diagnostic",
-				id: childId,
-				reason: sessionQueryCode(error) === "SESSION_QUERY_CORRUPT_SESSION" || sessionQueryCode(error) === "SESSION_QUERY_SOURCE_CONFLICT" ? "corrupt" : "unavailable"
-			};
+				id: entry.id,
+				parentId,
+				depth,
+				reason: code === "SESSION_QUERY_CORRUPT_SESSION" || code === "SESSION_QUERY_SOURCE_CONFLICT" ? "corrupt" : "unavailable"
+			});
+			continue;
 		}
-		const ownedObservation = __addDisposableResource$1(env_2, observation, false);
-		assertListingNotCancelled(signal);
-		if (!sameLifecycle(ownedObservation.header, header)) return {
-			kind: "diagnostic",
-			id: childId,
-			reason: "corrupt"
-		};
-		const identity = ownedObservation.projections?.values.subagent;
-		if (identity === void 0 || identity === null || identity.seq < ownedObservation.inheritedEventCount) return {
+		if (entry.mode === "unknown") result.push({
 			kind: "diagnostic",
-			id: childId,
-			reason: "corrupt"
-		};
-		return childRow(childId, identity, "inactive", hasChildren);
-	} catch (e_2) {
-		env_2.error = e_2;
-		env_2.hasError = true;
-	} finally {
-		__disposeResources$1(env_2);
+			id: entry.id,
+			parentId,
+			depth,
+			reason: "unsupported"
+		});
+		else {
+			const { createdAt: _createdAt, ...identity } = entry;
+			result.push({
+				...identity,
+				kind: "child",
+				parentId,
+				depth,
+				activity: sessions.get(entry.id) === void 0 ? "inactive" : "running",
+				hasChildren: children.length > 0
+			});
+		}
+		for (const child of [...children].reverse()) stack.push({
+			entry: child,
+			parentId: entry.id,
+			depth: depth + 1
+		});
 	}
+	return result;
 }
-/** Materialize one served identity as its child row. */
-function childRow(id, identity, activity, hasChildren) {
-	return identity.mode === "one-shot" ? {
-		kind: "child",
-		id,
-		mode: "one-shot",
-		...identity.label !== void 0 ? { label: identity.label } : {},
-		activity,
-		hasChildren
-	} : {
-		kind: "child",
-		id,
-		mode: "continuable",
-		label: identity.label,
-		activity,
-		hasChildren
-	};
-}
-/** Immutable header fields that distinguish one session lifecycle from another under the same id. */
-const LIFECYCLE_WITNESS_KEYS = [
-	"version",
-	"id",
-	"createdAt",
-	"cwd",
-	"parentSession",
-	"isSeeded",
-	"delegationDepth",
-	"origin",
-	"agentPreset"
-];
-/** Whether an inspected log still belongs to the enumerated lifecycle. */
-function sameLifecycle(meta, expected) {
-	return LIFECYCLE_WITNESS_KEYS.every((key) => meta[key] === expected[key]);
-}
-/** Stop a listing at its next cancellation checkpoint. */
+/** Stop the complete traversal when its caller cancels. */
 function assertListingNotCancelled(signal) {
 	if (signal?.aborted) throw new SubagentError("subagent listing was cancelled", "CANCELLED");
 }
-function sessionQueryCode(error) {
-	return error instanceof Error && "code" in error ? error.code : void 0;
-}
 //#endregion
 //#region lib/types/archive-admission.js
 /**
@@ -3139,19 +2972,19 @@ let SubagentRuntime = (() => {
 			return listChildren(this.ctx, parentSessionId, signal);
 		}
 		/**
-		* Enumerate the root's complete session-backed subagent tree in stable
-		* pre-order from one live-preferred corpus, without loading or resuming an
-		* 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 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.
+		* Recursively list reachable parent catalogs in stable pre-order, preserving
+		* each catalog's event order. Each row carries its catalog parent and depth;
+		* one-shot and unknown-mode children remain traversal nodes. Unknown modes
+		* produce unsupported diagnostics. Unreadable child catalogs produce corrupt
+		* or unavailable diagnostics and stop only that branch. Root read failures,
+		* missing services or projections, and cancellation reject the whole listing.
+		* Each catalog is observed once and released before the next read. No Agent
+		* is loaded or resumed; Sessions absent from reachable catalogs are omitted.
+		* @param rootSessionId - session whose catalog starts descendant discovery.
+		* @param signal - cancellation forwarded to and checked around each catalog read.
+		* @returns children and branch diagnostics in parent-catalog pre-order.
 		* @throws {@link SubagentError} when listing dependencies are unavailable or the caller cancels.
+		* @throws SessionQueryError when the root catalog cannot be read.
 		*/
 		listDescendants(rootSessionId, signal) {
 			return listDescendants(this.ctx, rootSessionId, signal);