@xrn1997/dsh-session-delete 0.4.0 → 0.6.0

package/lib/index.js

@@ -12,53 +12,98 @@ import { homedir } from "node:os";
 * 信封 {ok:true,value} / {ok:false,error:{code,message,details?}} 也是两半的共同契约。
 */
 /**
-* 插件专属前缀。
+* 插件专属前缀（九段相对它命名）。
 *
-* 为什么必须带插件名：宿主 web server 的 `register({kind:'prefix', path})` 对**重复的 (kind, path)
-* 直接抛错**（`dsh-host-webserver` 原文 `webserver: duplicate ${route.kind} route "${route.path}"`），
-* 撞了就是整棵插件树 boot 失败——所以这条路径是与生态的硬边界，不是显示好不好看的问题。
+* 为什么必须带插件名：宿主 `connection.fetch.register` 对**重复的精确路径**直接抛错
+* （`connection: exact Fetch route "…" is already registered`），撞了就是整棵插件树 boot 失败——
+* 所以这条路径是与生态的硬边界，不是显示好不好看的问题。
 */
 const SESSION_DELETE_API_PREFIX = "/dsh-session-delete-api";
-/** 九个段名（相对前缀）。写动作统一走一段 `/apply`：一次 HTTP 带一组 id、逐条回结果；
+/**
+* 唯一的取数基础路径：宿主 `/api` + 插件前缀。九段 exact Fetch 路由、客户端探测与附件 URL
+* 都从它起；`SESSION_DELETE_API_PREFIX` 只作为段名的相对前缀与错误原文。
+*/
+const OFFICIAL_SESSION_DELETE_API_PREFIX = `/api${SESSION_DELETE_API_PREFIX}`;
+/** 九个段名（相对前缀）。**每项 `{ path, method }` 两键**：某段用什么方法也是线上形状的一部分
+*  （ADR-0003），家就在这一张表——路由记录（`src/api/route-table.ts`）逐行投影（`ROUTES.x.method`），
+*  浏览器半的 GET 段同样投影、写段把 `ROUTES.x.method` 交给 `src/client/remote.ts` 的 `post()`，
+*  两半都不逐段手写一份。
+*  写动作统一走一段 `/apply`：一次 HTTP 带一组 id、逐条回结果；
 *  单条就是长度为 1 的批量，仓里不留第二条执行路径。
-*  - `GET /list`：对账并读清单（`session-trash/` 里的目录是准）。
-*  - `GET /ping`：最便宜的在/不在（不碰清册、不碰盘、不进链），供客户端探测。
-*  - `POST /detail`：单条详情（用 POST 表达一个读，判据在 `src/api/route-table.ts`）。
-*  - `POST /apply`：批量执行一个动作（`delete` / `restore` / `purge` / `count` / `orphan-clean`），逐条回 `ApplyOutcome`。
-*  - `POST /empty`：清空回收站（聚合回执，不按条回）。
-*  - `GET /orphans`：无主子会话的扫描报告（纯读）。清理是 `/apply` 的第五个动作，
+*  - `list`：对账并读清单（`session-trash/` 里的目录是准）。
+*  - `ping`：最便宜的在/不在（不碰清册、不碰盘、不进链），供客户端探测。
+*  - `detail`：单条详情（用 POST 表达一个读，判据在 `src/api/route-table.ts` 的 detail 行）。
+*  - `apply`：批量执行一个动作（`delete` / `restore` / `purge` / `count` / `orphan-clean`），逐条回 `ApplyOutcome`。
+*  - `empty`：清空回收站（聚合回执，不按条回）。
+*  - `orphans`：无主子会话的扫描报告（纯读）。清理是 `/apply` 的第五个动作，
 *    这一段只负责"有多少、在哪、多大"。
-*  - `GET /attachment`：附件原始字节（全仓唯一的二进制响应段；失败仍回 JSON 信封）。
-*  - `GET /attachment-orphans`：无引用图片对象的扫描报告（纯读；数量/字节 + 供预览的对象清单）。
-*  - `POST /attachment-clean`：清掉报告那一刻无引用的图片对象（聚合回执 `AttachmentCleanupWire`）。 */
+*  - `attachment`：附件原始字节（全仓唯一的二进制响应段；失败仍回 JSON 信封）。
+*  - `attachmentOrphans`：无引用图片对象的扫描报告（纯读；数量/字节 + 供预览的对象清单）。
+*  - `attachmentClean`：清掉报告那一刻无引用的图片对象（聚合回执 `AttachmentCleanupWire`）。 */
 const ROUTES = {
-	list: "/list",
+	list: {
+		path: "/list",
+		method: "GET"
+	},
 	/** 通道的"在不在"专用：没有入参、没有副作用、没有磁盘读。 */
-	ping: "/ping",
+	ping: {
+		path: "/ping",
+		method: "GET"
+	},
 	/** 单条详情（读回收站目录里那条会话自己的日志）。 */
-	detail: "/detail",
+	detail: {
+		path: "/detail",
+		method: "POST"
+	},
 	/** 一组 id 上的同一个动作；删除确认框那句「含 N 个子会话」也走这里（`action: 'count'`，纯读语义）。 */
-	apply: "/apply",
+	apply: {
+		path: "/apply",
+		method: "POST"
+	},
 	/** 清空回收站。 */
-	empty: "/empty",
+	empty: {
+		path: "/empty",
+		method: "POST"
+	},
 	/** 纯读：扫描回收站之外的无主子会话（父已不在语料/清册）。 */
-	orphans: "/orphans",
+	orphans: {
+		path: "/orphans",
+		method: "GET"
+	},
 	/** 附件字节（图片/普通文件）：全仓唯一的二进制响应段，读的是宿主附件库。 */
-	attachment: "/attachment",
+	attachment: {
+		path: "/attachment",
+		method: "GET"
+	},
 	/** 纯读：扫全部引用源与附件库 `objects`，报无引用图片的数量、字节与预览清单。 */
-	attachmentOrphans: "/attachment-orphans",
+	attachmentOrphans: {
+		path: "/attachment-orphans",
+		method: "GET"
+	},
 	/** 聚合清理：只删 `objects` 下无引用的图片，回 `AttachmentCleanupWire`。 */
-	attachmentClean: "/attachment-clean"
+	attachmentClean: {
+		path: "/attachment-clean",
+		method: "POST"
+	}
 };
 /** 请求参数名：浏览器半发、Node 半读，同名同义（`empty` 没有入参）。
 *  附件段是 **query 参数**（GET 二进制响应，没有请求体）。 */
 const PARAMS = {
 	entryId: "entryId",
+	/** `/detail` 的分页游标：只取这个块序号之前的块。缺省 = 从尾部取。 */
+	before: "before",
 	action: "action",
 	ids: "ids",
 	attachmentId: "id",
 	attachmentKind: "kind",
-	attachmentName: "name"
+	attachmentName: "name",
+	/** 图片引用的媒体类型 / 宽高：只给宿主 `attachments.readImage` 做引用校验，不参与路径拼接。 */
+	attachmentMediaType: "mediaType",
+	/** 字节数：图片支与文件支都带——它是宿主读面的引用一部分，并先过 `maxAttachmentBytes` 闸
+	*  （别为一张已知超限的图让宿主整份读出来）。 */
+	attachmentBytes: "bytes",
+	attachmentWidth: "width",
+	attachmentHeight: "height"
 };
 /**
 * 进程内判别「这已经是一次失败」——**按标记位认，不按 `instanceof`**（跨 realm / 跨 bundle 都不成立）。
@@ -113,6 +158,50 @@ function verbCodeOf(error) {
 /** 回收站目录名（相对宿主数据根）。Node 半拼路径，浏览器半在页脚念它——同一个字面量。 */
 const TRASH_DIR_NAME = "session-trash";
 //#endregion
+//#region src/verbs/errors.ts
+/** 失败的**结构与措辞**。码本身、码的前缀读法与动词词表都住在 `shared/wire.ts`（ADR-0003）：
+*  浏览器半也要认它们，它们属于两半共同的契约，不属于 Node 半。这里只做动词抛错与回滚措辞。 */
+function verbError(code, message, cause, details) {
+	const e = new Error(message);
+	e.code = SESSION_DELETE_CODES[code];
+	if (cause !== void 0) e.cause = cause;
+	if (details !== void 0) e.details = details;
+	return e;
+}
+/** `trash-empty` 的原文：有具体条目就点名那个 id，拿不到时只报通用那句。 */
+function trashEmpty(entryId) {
+	return verbError("trash-empty", entryId === void 0 ? "回收站里没有这一条" : `回收站里没有这一条：${entryId}`);
+}
+/** 路由自检用的失败：带 HTTP 状态语义，**不**冒充五个动词码。 */
+function routeError(code, httpStatus, message) {
+	const e = verbError("io", message);
+	e.code = SESSION_DELETE_CODES[code];
+	e.httpStatus = httpStatus;
+	return e;
+}
+/** 一条回滚步骤失败的**标签句**：label 说的是"这一步在退什么"，原文带出**那一步抛的东西**
+*  （`Error` 取 message，其余一律 `String()`；对象带 `message` 的差异归 `map-error.messageOf` 管）。
+*  调用方不许另抄这份格式——那样 details 里的句子会随各处 catch 变形，界面上就变成"同一个失败三个说法"。 */
+function rollbackReason(label, error) {
+	return `${label}：${error instanceof Error ? error.message : String(error)}`;
+}
+/** 内层错误已经挂着的回滚失败（成员自己的就地回滚失败时会有）。组级 catch 再包一次时不能丢。 */
+function carriedRollbackFailures(error) {
+	const raw = error?.details?.rollbackFailures;
+	return Array.isArray(raw) ? raw.filter((item) => typeof item === "string") : [];
+}
+/** 原错误保留，回滚失败作为 `details.rollbackFailures` 上线；码仍按原错误的动词码，
+*  没有可继承的就落 io。**内层的回滚失败要并进来**：一个成员自己退失败、兄弟也退失败时，
+*  两份失败都得在 details 里，消息也不能出现第二个「回滚未完成」。 */
+function withRollbackFailures(error, failures) {
+	const code = verbCodeOf(error) ?? "io";
+	const carried = carriedRollbackFailures(error);
+	const merged = [.../* @__PURE__ */ new Set([...carried, ...failures])];
+	const base = error instanceof Error ? error.message : String(error);
+	const extra = failures.filter((failure) => !carried.includes(failure));
+	return verbError(code, base.includes("；回滚未完成：") ? extra.length > 0 ? `${base}；${extra.join("；")}` : base : `${base}；回滚未完成：${merged.join("；")}`, error, { rollbackFailures: merged });
+}
+//#endregion
 //#region src/remote/map-error.ts
 /** 宿主两条类型化错误 → 我们的码（本文件的两行映射）。
 *  类不可 import（跨插件值 import 是红线；且宿主包与运行中的宿主不同代）⇒ 按官方构造器写死的 `this.name` 认。
@@ -123,14 +212,21 @@ const HOST_ERROR_CODE = {
 	WorkspaceUnknownSessionError: "not-found",
 	WorkspaceActiveSessionError: "live"
 };
-/** cause 链上第一个**宿主类型化错误**本身（不只它的名字）——它自己身上的字段还要当 `details` 用。
+/** cause 链上第一个**宿主类型化错误**本身（不只它的名字）——它自己身上的字段还要当 `details` 用；
+*  码在 hasOwn 证明的同一处取回（表值恒在，编译器只认贴着取的这一份）。
 *  深度有界（链坏掉不递归下去）；查表必须 `hasOwn`：`in` 会命中 `Object.prototype` 的键。 */
 function hostErrorOf(error) {
 	let current = error;
 	for (let depth = 0; depth < 8; depth++) {
 		if (current === null || typeof current !== "object") return void 0;
 		const name = current.name;
-		if (typeof name === "string" && Object.hasOwn(HOST_ERROR_CODE, name)) return current;
+		if (typeof name === "string" && Object.hasOwn(HOST_ERROR_CODE, name)) {
+			const code = HOST_ERROR_CODE[name];
+			if (code !== void 0) return {
+				host: current,
+				code
+			};
+		}
 		current = current.cause;
 	}
 }
@@ -213,12 +309,12 @@ function toRemoteFailure(error) {
 	}
 	const fromVerb = verbCodeOf(error);
 	const host = hostErrorOf(error);
-	const own = detailsOf(error) ?? (host === void 0 ? void 0 : detailsOf(host));
+	const own = detailsOf(error) ?? (host === void 0 ? void 0 : detailsOf(host.host));
 	if (host === void 0 && fromVerb === void 0 && typeof raw === "string" && raw.includes("/")) return {
 		code: SESSION_DELETE_CODES.io,
 		message: messageOf(error)
 	};
-	const code = host !== void 0 ? HOST_ERROR_CODE[host.name] : fromVerb ?? "io";
+	const code = host !== void 0 ? host.code : fromVerb ?? "io";
 	return {
 		code: SESSION_DELETE_CODES[code],
 		message: messageOf(error),
@@ -226,629 +322,195 @@ function toRemoteFailure(error) {
 	};
 }
 //#endregion
-//#region src/verbs/errors.ts
-/** 失败的**结构与措辞**。码本身、码的前缀读法与动词词表都住在 `shared/wire.ts`（ADR-0003）：
-*  浏览器半也要认它们，它们属于两半共同的契约，不属于 Node 半。这里只做动词抛错与回滚措辞。 */
-function verbError(code, message, cause, details) {
-	const e = new Error(message);
-	e.code = SESSION_DELETE_CODES[code];
-	if (cause !== void 0) e.cause = cause;
-	if (details !== void 0) e.details = details;
-	return e;
-}
-/** `trash-empty` 的原文：有具体条目就点名那个 id，拿不到时只报通用那句。 */
-function trashEmpty(entryId) {
-	return verbError("trash-empty", entryId === void 0 ? "回收站里没有这一条" : `回收站里没有这一条：${entryId}`);
+//#region src/domain/closure.ts
+/** 会话 id 去掉 `session-` 前缀后的形状：同一个会话在两代宿主里写法不同（v3 代 id 不带前缀、
+*  现行代带），归堆、成组、去重一律按这个形状比——两边都归一，不赌调用方传的是哪一代写法。 */
+function bareSessionId(id) {
+	return id.startsWith("session-") ? id.slice(8) : id;
 }
-/** 路由自检用的失败：带 HTTP 状态语义，**不**冒充五个动词码。 */
-function routeError(code, httpStatus, message) {
-	const e = verbError("io", message);
-	e.code = SESSION_DELETE_CODES[code];
-	e.httpStatus = httpStatus;
-	return e;
+/** 一个 id 的全部可能写法，原写法在前：`session-x` → `[session-x, x]`；`x` → `[x, session-x]`。
+*  逐层问宿主时按这些写法问：宿主那支按 `header.parentSession` 原文比，不替我们归一。 */
+function sessionIdShapes(id) {
+	const bare = bareSessionId(id);
+	return [.../* @__PURE__ */ new Set([
+		id,
+		bare,
+		`session-${bare}`
+	])];
 }
-/** 一条回滚步骤失败的**标签句**：label 说的是"这一步在退什么"，原文带出**那一步抛的东西**
-*  （`Error` 取 message，其余一律 `String()`；对象带 `message` 的差异归 `map-error.messageOf` 管）。
-*  调用方不许另抄这份格式——那样 details 里的句子会随各处 catch 变形，界面上就变成"同一个失败三个说法"。 */
-function rollbackReason(label, error) {
-	return `${label}：${error instanceof Error ? error.message : String(error)}`;
+/** parent(bare) 到 children 索引上的传递闭包：深度不设上限、防环、首见去重（都按 bare 归一后比）。
+*  根的两种写法都认（内部归一次）；结果不含根自己。数据里真出现环时代价是「少数一条」，
+*  不是把清单读挂死——环本来不该出现（parentSession 是一条有向边），出现就是手工改过日志或宿主 bug。 */
+function closureOf(children, root) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set([bareSessionId(root)]);
+	let frontier = [...seen];
+	while (frontier.length > 0) {
+		const next = [];
+		for (const bare of frontier) for (const kid of children.get(bare) ?? []) {
+			const kidBare = bareSessionId(kid.sessionId);
+			if (seen.has(kidBare)) continue;
+			seen.add(kidBare);
+			out.push(kid);
+			next.push(kidBare);
+		}
+		frontier = next;
+	}
+	return out;
 }
-/** 内层错误已经挂着的回滚失败（成员自己的就地回滚失败时会有）。组级 catch 再包一次时不能丢。 */
-function carriedRollbackFailures(error) {
-	const raw = error?.details?.rollbackFailures;
-	return Array.isArray(raw) ? raw.filter((item) => typeof item === "string") : [];
+/** 同一条记录两代写法只认第一次出现（保原序）。全局去重只有这一处实现：谁要按 bare 去重，
+*  交一条列表进来，别在调用点再手写一个 seen 集合。 */
+function firstByBare(members) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const member of members) {
+		const bare = bareSessionId(member.sessionId);
+		if (seen.has(bare)) continue;
+		seen.add(bare);
+		out.push(member);
+	}
+	return out;
 }
-/** 原错误保留，回滚失败作为 `details.rollbackFailures` 上线；码仍按原错误的动词码，
-*  没有可继承的就落 io。**内层的回滚失败要并进来**：一个成员自己退失败、兄弟也退失败时，
-*  两份失败都得在 details 里，消息也不能出现第二个「回滚未完成」。 */
-function withRollbackFailures(error, failures) {
-	const code = verbCodeOf(error) ?? "io";
-	const carried = carriedRollbackFailures(error);
-	const merged = [.../* @__PURE__ */ new Set([...carried, ...failures])];
-	const base = error instanceof Error ? error.message : String(error);
-	const extra = failures.filter((failure) => !carried.includes(failure));
-	return verbError(code, base.includes("；回滚未完成：") ? extra.length > 0 ? `${base}；${extra.join("；")}` : base : `${base}；回滚未完成：${merged.join("；")}`, error, { rollbackFailures: merged });
+/**
+* 整表语料 → 根闭包组：`parentSessionId` 不在 `known` 里的那些 subagent 各自成一组。`known` 两侧都
+* 归一后再比（传原始 id 即可）。「已知父为什么排除在外」是调用方的领域判据（住
+* `src/verbs/orphan-subagents.ts` 与 `CONTEXT.md` 的「无主子会话」），这一层不替它复述。
+*
+* 组内的后代仍走 `closureOf` 那一份闭包，只是多一条跨组的 `claimed`：一条记录只归第一个认领它的根。
+* 已被前一组收走的那条，连同它整支子树都不再出现在这一组里——后代在那一组已被全部认领，所以
+* 「丢掉已认领的」与「不走进已认领的那支」交回的是同一个集合。环上的代价是「少数一条」，
+* 不是把一次扫描挂死。组序与成员序都按语料原序。
+*
+* 后代也必须是 subagent 起源：普通 fork 的 `parentSession` 只是来源记录，它不进组、也不穿过它收孩子
+* （否则从 subagent 分出去的分支会被当成孤儿永久删掉）。
+*/
+function orphanRootsOf(corpus, known) {
+	const knownBares = /* @__PURE__ */ new Set();
+	for (const id of known) knownBares.add(bareSessionId(id));
+	const children = /* @__PURE__ */ new Map();
+	for (const session of corpus) {
+		const parent = session.parentSessionId;
+		if (parent === void 0) continue;
+		if (!session.subagent) continue;
+		const key = bareSessionId(parent);
+		const list = children.get(key);
+		if (list === void 0) children.set(key, [session]);
+		else list.push(session);
+	}
+	const claimed = /* @__PURE__ */ new Set();
+	const groups = [];
+	for (const session of corpus) {
+		const parent = session.parentSessionId;
+		if (!session.subagent || parent === void 0) continue;
+		if (knownBares.has(bareSessionId(parent))) continue;
+		const rootBare = bareSessionId(session.sessionId);
+		if (claimed.has(rootBare)) continue;
+		claimed.add(rootBare);
+		const members = [session];
+		for (const descendant of closureOf(children, rootBare)) {
+			const bare = bareSessionId(descendant.sessionId);
+			if (claimed.has(bare)) continue;
+			claimed.add(bare);
+			members.push(descendant);
+		}
+		groups.push({
+			root: session,
+			parentSessionId: parent,
+			members
+		});
+	}
+	return groups;
 }
 //#endregion
-//#region src/api/request-trust.ts
-/** 桌面壳那条路（asar `/lib/main.js` 的 `forwardWebRequest`）：渲染进程从 `dsh-app://app/` 加载，
-*  转发前把 `host` / `origin` / `cookie` / `sec-fetch-site` 删掉、换上一枚宿主自己的 cookie，
-*  `Referer` 保留。判据按 `protocol` + `host` 比，**不能比 `URL.origin`**（`dsh-app:` 不是 WHATWG
-*  special scheme，`new URL('dsh-app://app/').origin` 是字符串 `"null"`）。 */
-const DESKTOP_APP_SCHEME = "dsh-app:";
-const DESKTOP_APP_HOST = "app";
-/** 回环 socket 的三种写法（IPv4 / IPv6 / IPv4-mapped IPv6）。 */
-const LOOPBACK_SOCKETS = [
-	"127.0.0.1",
-	"::1",
-	"::ffff:127.0.0.1"
-];
-function isDesktopShellUrl(value) {
-	try {
-		const url = new URL(value);
-		return url.protocol === DESKTOP_APP_SCHEME && url.host === DESKTOP_APP_HOST;
-	} catch {
-		return false;
-	}
+//#region src/trash/groups.ts
+/** 这些孩子的父。 */
+function kidsOf(rows, parentId) {
+	return rows.filter((row) => row.parentEntryId === parentId);
 }
-/** 裸 authority（`host` / `host:port`）按给定 scheme 解析；解析不了回 `undefined`。 */
-function parseAuthority(authority, scheme = "http:") {
-	try {
-		return new URL(`${scheme}//${authority}`);
-	} catch {
-		return;
+/**
+* 清单露面的一行 = 组根，按清册原序。孩子折进根那一行（宿主的客户端本来就把 `origin:"subagent"`
+* 的行整排藏了 ⇒ 我们若单列就会冒出一堆点不到的行）。
+*
+* 折不进去的那两种孩子（父行不在 / 父行自己也是孩子）**自己站出来占一行**——那正是
+* `visibleGroups` 与 `groupOf` 共用同一条判据的地方。
+*/
+function visibleGroups(rows) {
+	const byId = new Map(rows.map((row) => [row.id, row]));
+	const kidsByRoot = /* @__PURE__ */ new Map();
+	const folded = /* @__PURE__ */ new Set();
+	for (const row of rows) {
+		if (row.parentEntryId === void 0) continue;
+		const parent = byId.get(row.parentEntryId);
+		if (parent === void 0 || parent.parentEntryId !== void 0) continue;
+		folded.add(row.id);
+		const siblings = kidsByRoot.get(parent.id);
+		if (siblings === void 0) kidsByRoot.set(parent.id, [row]);
+		else siblings.push(row);
 	}
+	return rows.filter((row) => !folded.has(row.id)).map((root) => ({
+		root,
+		kids: kidsByRoot.get(root.id) ?? []
+	}));
 }
-/** 与宿主 `isLoopbackHostname` 同口径：`localhost`、`[::1]`、任意 127/8。 */
-function isLoopbackHostname(hostname) {
-	if (hostname === "localhost" || hostname === "[::1]") return true;
-	const parts = hostname.split(".");
-	return parts.length === 4 && parts[0] === "127" && parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255);
-}
-/** Host 是不是本部署的 bind 字面量：忽略端口与 `%zone`（zone 是接口选择器，不是地址文本）。 */
-function isBindAddress(hostUrl, bindHost) {
-	if (bindHost === void 0) return false;
-	const zoneAt = bindHost.indexOf("%");
-	const address = zoneAt === -1 ? bindHost : bindHost.slice(0, zoneAt);
-	const bindUrl = parseAuthority(address.includes(":") ? `[${address}]` : address);
-	return bindUrl !== void 0 && bindUrl.hostname === hostUrl.hostname;
-}
-/** 携带 authority 的头（Origin / Referer）是否与 Host 同 authority：按这个头自己的 scheme 归一
-*  默认端口（`http://x:80` 与 Host `x` 是同一个 authority）。 */
-function isSameAuthority(value, hostHeader) {
-	let url;
-	try {
-		url = new URL(value);
-	} catch {
-		return false;
-	}
-	const scheme = url.protocol === "https:" ? "https:" : url.protocol === "http:" ? "http:" : void 0;
-	if (scheme === void 0) return false;
-	const hostUrl = parseAuthority(hostHeader, scheme);
-	return hostUrl !== void 0 && url.host === hostUrl.host;
-}
-/** 头栅栏：`sec-fetch-site` / Origin / Referer 三条，任何客户端都要过。 */
-function passesHeaderFence(headers, host) {
-	if (headers["sec-fetch-site"] === "cross-site") return false;
-	const origin = headers.origin;
-	if (origin !== void 0 && !isDesktopShellUrl(origin) && !isSameAuthority(origin, host)) return false;
-	const referer = headers.referer;
-	if (referer !== void 0 && !isDesktopShellUrl(referer) && !isSameAuthority(referer, host)) return false;
-	return true;
+/**
+* 一条 id 所属的整组。三种形状，三个答案：
+* - **组根** ⇒ 它自己 + 它接住的孩子（UI 点的是父那一行，删除/恢复/彻底删除都按整组走）；
+* - **孩子**（自己记着 `parentEntryId`）⇒ **只回它自己**。清单不单独列它，只有手工/降级路径会点到这里；
+* - **清册里没有这一条 id，但还有孩子指向它**（父行已被别的路径摘掉）⇒ 那一批孩子；仍然没有 ⇒ 空数组，
+*   调用方据此报 `trash-empty` / 判"已被同批前一条带走"。
+*/
+function groupOf(rows, id) {
+	const root = rows.find((row) => row.id === id);
+	if (root !== void 0) return root.parentEntryId === void 0 ? [root, ...kidsOf(rows, id)] : [root];
+	return kidsOf(rows, id);
 }
 /**
-* 这条请求归不归本插件办。`untrusted` = 归属不对（跨源 / 重绑 / 头不成形）；`unauthenticated` =
-* 归属对但远程客户端没带宿主身份（原文会提示用 `dsh web` 打印的 URL 打开）。
+* 把一条 id 所属的**整组**从快照里摘掉，回一份新快照（组语义仍只读 `groupOf`，这一条判据不另写一遍）。
+* 「同批前一条已把这一组带走」的收缩就是它：调用方各自持有那份可变视图，本函数不记账。
+*/
+function withoutGroup(rows, id) {
+	const gone = new Set(groupOf(rows, id).map((row) => row.id));
+	return rows.filter((row) => !gone.has(row.id));
+}
+/**
+* 「这条是被**同批前一条**带走的，还是整批开始前就没有，还是仍在？」
 *
-* 远程支的两个失败裁决由端口翻译宿主的区分（401 = 缺身份、403 = 归属不对）。身份层缺席（端口报
-* `absent`）一律按归属不对处理：那时没有可换的身份，不能让原文提示用户去补一个不存在的东西。
+* 幂等语义只属于 `carried`：后来者本来就不在清册里（用户点了条幽灵 id、或对账刚摘掉它）必须照样响亮报
+* `trash-empty`，不能被"已被带走"这句话掩盖成成功。**所以判据是快照的原始形状，不是当前形状**：
+* 原始快照里认得出（它自己、或指向它的孩子任一在），而当前快照里已经空了 ⇒ 同批带走的。
 */
-function judgeRequest(req, facts) {
-	const host = req.headers.host;
-	if (host === void 0 || !passesHeaderFence(req.headers, host)) return "untrusted";
-	const hostUrl = parseAuthority(host);
-	if (hostUrl === void 0) return "untrusted";
-	if ((isLoopbackHostname(hostUrl.hostname) || isBindAddress(hostUrl, facts.bindHost)) && LOOPBACK_SOCKETS.includes(req.socket.remoteAddress ?? "")) return "allowed";
-	const verdict = facts.connection.verdictFor(req);
-	if (verdict.kind === "allowed") return "allowed";
-	return verdict.kind === "unauthenticated" ? "unauthenticated" : "untrusted";
+function claimOf(original, current, id) {
+	if (groupOf(original, id).length === 0) return { verdict: "absent" };
+	const group = groupOf(current, id);
+	return group.length === 0 ? { verdict: "carried" } : {
+		verdict: "fresh",
+		group
+	};
 }
 //#endregion
-//#region src/ports/agent-handles.ts
-const CAPTURED_AGENT_HANDLES = Symbol.for("dsh-session-delete.captured-agent-handles");
-/** 在 `ctx.agents` 上包一层 `resume` / `create`，把返回的 agent handle 的 dispose 按会话 id 记下。
-*  服务缺席时走 `ctx.inject(['agents'])` **等服务挂上再装**——live profile 的插件激活顺序可能早于
-*  `agents` 服务就绪；只在 apply 时 `get` 一次会让捕获静默缺席（真机症状：重启前在回收站的能冷恢复，
-*  刚删除的会话恢复后旧 agent 拦住 prompt）。形状不符 / 属性不可写都只是**不捕获**，不影响插件激活。
+//#region src/verbs/batch-carried.ts
+/**
+* **同批已带走集**（「已被同批前一条带走」的 id）的唯一实现（ADR-0002 的内部实现）。
 *
-*  **安装时机**：先 `get('agents')`，没装成再 `inject(['agents'])`（两者只装一次，符号表兜住）。
-*  **symbol 表**：句柄表挂在服务实例的 {@link CAPTURED_AGENT_HANDLES} 上；同一个 agents 服务上的第二次
-*  安装（`get` 与 `inject` 各一次，或第二个 `createHostPort`）看见它就直接共用，不把 wrapper 套第二层。
-*  **读回判据**：cordis 的 traceable 服务代理每次读函数都会新包一层（`get` 里的 `createShadowMethod`），
-*  所以只能看 own property descriptor 的身份；拿 `service[name]` 读回比身份是必然的假警报。
+* 两种 id 域各一个 adapter：
+* - entry 适配：restore 的条目 id，`claim` 是三态（fresh / carried / absent），组语义仍读
+*   `trash/groups.ts`；
+* - session 适配：delete 的会话 id，`claim` 只有 fresh / carried，集合由动词结果长出。
+*
+* entry 适配的三态判据读 `groups.claimOf`；session 适配没有原始清册视图，只记 `take` 过的会话 id。
+* 收缩中的当前只读视图不再外递：purge 那一半连同视图住「清册作用域」（`src/verbs/trash-scope.ts`）。
+* 两个 adapter 只各自**持有**那份视图；按组收缩的判据不抄第二遍，都读 `groups.withoutGroup`。
 */
-function captureAgentHandles(ctx) {
-	let handles = /* @__PURE__ */ new Map();
-	let installed = false;
-	const install = (candidate) => {
-		if (installed) return;
-		const service = candidate;
-		if (service === void 0 || service === null) return;
-		const existing = service[CAPTURED_AGENT_HANDLES];
-		if (existing !== void 0) {
-			handles = existing;
-			installed = true;
-			return;
+/** 恢复：原始快照认得、当前视图已经空了 ⇒ 同批前一条带走的。 */
+function createEntryCarried(original) {
+	let current = [...original];
+	return {
+		claim(id) {
+			return claimOf(original, current, id);
+		},
+		take(id) {
+			current = withoutGroup(current, id);
 		}
-		let wrappedCount = 0;
-		for (const name of ["resume", "create"]) try {
-			const original = service[name];
-			if (typeof original !== "function") continue;
-			const wrapped = function(...args) {
-				const result = Reflect.apply(original, this, args);
-				result.then((value) => {
-					const handle = value;
-					const id = handle?.agent?.id;
-					if (typeof id !== "string" || id.length === 0 || typeof handle?.dispose !== "function") return;
-					handles.set(id, async () => {
-						await handle.dispose();
-					});
-				}, () => void 0);
-				return result;
-			};
-			service[name] = wrapped;
-			if (Object.getOwnPropertyDescriptor(service, name)?.value !== wrapped) throw new Error(`agents.${name} is not writable`);
-			wrappedCount += 1;
-		} catch {}
-		if (wrappedCount === 0) return;
-		try {
-			service[CAPTURED_AGENT_HANDLES] = handles;
-		} catch {}
-		installed = true;
-	};
-	const service = ctx.get("agents");
-	if (service !== void 0 && service !== null) install(service);
-	if (!installed && typeof ctx.inject === "function") try {
-		ctx.inject(["agents"], (child) => {
-			install(child.get("agents"));
-		});
-	} catch {}
-	return { async dispose(sessionId) {
-		const dispose = handles.get(sessionId);
-		if (dispose === void 0) return;
-		try {
-			await dispose();
-		} finally {
-			handles.delete(sessionId);
-		}
-	} };
-}
-//#endregion
-//#region src/ports/host-port.ts
-/** live store 的最小方法面判据（同 `projectionCacheOf` 的手法：按方法面判，不按 constructor.name）。 */
-function liveSessionsOf(ctx) {
-	const store = ctx.get("sessions");
-	if (store === void 0 || store === null) return void 0;
-	if (typeof store.get !== "function" || typeof store.liveEntryFor !== "function") return void 0;
-	return store;
-}
-/** 官方的「这些父的孩子」那一支：`kind:'parent'` 的判据逐字是 `values.includes(record.header.parentSession ?? null)`。 */
-async function filterChildrenOf(sessionQuery, values) {
-	return sessionQuery.filterSessions([{
-		kind: "parent",
-		values: [...values].sort()
-	}]);
-}
-/**
-* 从若干根逐层向下问出后代，交回 `父（bare）→ 孩子` 的索引。
-* 用 `kind:'parent'` 而不是 traceSession：父进回收站后 traceSession 认不出目标（宿主失败码
-* `SESSION_QUERY_SESSION_NOT_FOUND`），而这里要的正是父不在宿主列表之后仍留在盘上的那批。
-* 出处：asar `dsh-session-query/lib/index.js` 的 `filterSessions`。一层一次宿主调用，问空即停；
-* `seen` 防环；没有 `header.id` 的记录整条跳过（无法作为身份继续下问）。
-*/
-async function descendantsByParent(sessionQuery, roots) {
-	const children = /* @__PURE__ */ new Map();
-	const seen = new Set(roots.map(bareSessionId));
-	let frontier = [...seen];
-	while (frontier.length > 0) {
-		const values = [];
-		for (const bare of frontier) for (const shape of sessionIdShapes(bare)) if (!values.includes(shape)) values.push(shape);
-		const next = [];
-		for (const record of await filterChildrenOf(sessionQuery, values)) {
-			const id = record.header?.id;
-			const parent = record.header?.parentSession;
-			if (typeof id !== "string" || id.length === 0) continue;
-			if (typeof parent !== "string" || parent.length === 0) continue;
-			const bare = bareSessionId(id);
-			if (seen.has(bare)) continue;
-			seen.add(bare);
-			const cwd = record.header?.cwd;
-			const descendant = {
-				id,
-				bare,
-				projectDir: cwd === void 0 ? NO_CWD_PROJECT_DIR : projectKey(cwd)
-			};
-			const parentBare = bareSessionId(parent);
-			const siblings = children.get(parentBare);
-			if (siblings === void 0) children.set(parentBare, [descendant]);
-			else siblings.push(descendant);
-			next.push(bare);
-		}
-		frontier = next;
-	}
-	return children;
-}
-/** 某个根在 `descendantsByParent` 那棵树里的全部后代（深度不设上限，同一条只收一次）。 */
-function subtreeOf(children, rootBare) {
-	const out = [];
-	const seen = /* @__PURE__ */ new Set([rootBare]);
-	let frontier = [rootBare];
-	while (frontier.length > 0) {
-		const next = [];
-		for (const bare of frontier) for (const kid of children.get(bare) ?? []) {
-			if (seen.has(kid.bare)) continue;
-			seen.add(kid.bare);
-			out.push(kid);
-			next.push(kid.bare);
-		}
-		frontier = next;
-	}
-	return out;
-}
-function toMember(d) {
-	return {
-		sessionId: d.id,
-		projectDir: d.projectDir
-	};
-}
-/** {@link HostCorpusPort.subagentMembersOf} 的那一次 BFS。
-*  空清单在调用宿主之前就返回（不为一张空表扫全库）。 */
-async function membersFor(sessionQuery, parentIds) {
-	const wanted = [];
-	for (const id of parentIds) if (id.length > 0 && !wanted.includes(id)) wanted.push(id);
-	if (wanted.length === 0) return {};
-	const children = await descendantsByParent(sessionQuery, wanted);
-	const out = {};
-	for (const id of wanted) out[id] = subtreeOf(children, bareSessionId(id));
-	return out;
-}
-/** 无 cwd 的会话落在 `_no-cwd/`；`projectDirOf` 与回收站对账共用这个字面量。
-*  出处：asar `dsh-session-persistence-jsonl/lib/index.js` 的 `projectDir`（`if (cwd === void 0) return join(root, "_no-cwd");`）。 */
-const NO_CWD_PROJECT_DIR = "_no-cwd";
-/** 宿主 `projectKey(cwd)` 的逐字镜像：跨插件不能 import，宿主也没把它暴露成服务。
-*  出处：asar `dsh-session-persistence-jsonl/lib/index.js` 的 `projectKey`；调用链
-*  `locate` → `logPath` → `projectDir` → `projectKey`。本机实测 `D:/develop/GitHub/dsh-session-delete`
-*  → `--D-develop-GitHub-dsh-session-delete--`。`projectDirOf` 与回收站对账重建共用这一份；
-*  宿主换代先复核算法。 */
-function projectKey(cwd) {
-	let readable = "";
-	let separatorRun = false;
-	for (let i = 0; i < cwd.length; i++) {
-		const code = cwd.charCodeAt(i);
-		const ch = String.fromCharCode(code);
-		if (ch === "/" || ch === "\\" || ch === ":") {
-			if (!separatorRun) readable += "-";
-			separatorRun = true;
-		} else if (ch !== "~" && /^[A-Za-z0-9._-]$/.test(ch)) {
-			readable += ch;
-			separatorRun = false;
-		} else {
-			readable += `~${code.toString(16).toUpperCase().padStart(4, "0")}`;
-			separatorRun = false;
-		}
-	}
-	return `--${(readable.replace(/^-+/, "") || "root").slice(0, 251)}--`;
-}
-/** 投影缓存服务的最小方法面判据（按方法面判，不按 `constructor.name` 判）。 */
-function projectionCacheOf(ctx) {
-	const cache = ctx.get("sessionProjectionCache");
-	if (cache === void 0 || cache === null) return void 0;
-	if (typeof cache.cachedSnapshot !== "function" || typeof cache.cachedPredecessorTitle !== "function") return void 0;
-	return cache;
-}
-/** 宿主 `readSessionHeader` 对未知会话抛的是裸 `Error`，只认这句；真存储故障照抛，不能折成未命中。
-*  出处：asar `dsh-workspace/lib/types/index.js` 的
-*  `cannot validate session '${id}': session persistence holds no such session`。
-*  同文件有类型的近似句是 `WorkspaceUnknownSessionError`（`hold` 无 `s`），不会误伤。 */
-const NO_SUCH_SESSION = "session persistence holds no such session";
-/** 只认上面那一句；其余（含非 Error 抛出物）一律**不算未命中**。 */
-function isUnknownSession(error) {
-	return error instanceof Error && error.message.includes(NO_SUCH_SESSION);
-}
-/** 会话 id 去掉 `session-` 前缀后的形状（同一个父在两代里写法不同，见 {@link HostCorpusPort.subagentMembersOf}）。 */
-function bareSessionId(id) {
-	return id.startsWith("session-") ? id.slice(8) : id;
-}
-/** 一个 id 的全部可能写法，原写法在前：`session-x` → `[session-x, x]`；`x` → `[x, session-x]`。 */
-function sessionIdShapes(id) {
-	const bare = bareSessionId(id);
-	return [.../* @__PURE__ */ new Set([
-		id,
-		bare,
-		`session-${bare}`
-	])];
-}
-/** 宿主会话表的一次取数（`ctx.sessionController.list()` 的两种返回形状都折成数组）。
-*  服务没挂 / 形状不对 / 抛错 ⇒ 空表——**这条不替宿主兜错误**：调用方拿空表的语义都是"少发一条通告"，
-*  不是"恢复失败"。 */
-async function controllerItems(host) {
-	try {
-		const controller = host.get("sessionController");
-		if (controller === void 0 || controller === null || typeof controller.list !== "function") return [];
-		const listed = await controller.list();
-		const items = Array.isArray(listed) ? listed : listed?.items;
-		return Array.isArray(items) ? items : [];
-	} catch {
-		return [];
-	}
-}
-/** 账本里没有那个工作区时 {@link HostPort.attach} / {@link HostPort.detach} 抛的原话开头。
-*  **原话与判据同住这里**：抛它的是这个端口，认它的也是端口给的那句，调用方不许另抄一份字符串。 */
-const WORKSPACE_MISSING_MESSAGE = "workspace not found";
-/** 这次失败是不是"账本里没那个工作区"（而不是另有故障）。恢复侧靠它把两种失败分开：
-*  前者按「未分组」收，后者照旧回滚报 `io`——不给真故障静默改归属的机会。 */
-function isWorkspaceMissingError(error) {
-	return error instanceof Error && error.message.startsWith(WORKSPACE_MISSING_MESSAGE);
-}
-/** 宿主服务的真实绑定；出错原样抛，由 `toRemoteFailure` 按 name 映射。
-*  各方法调用的服务与方法见上方成员注释；错误映射表住 `src/remote/map-error.ts`。 */
-function createHostPort(ctx) {
-	const host = ctx;
-	const registry = host.workspaceRegistry;
-	const agentHandles = captureAgentHandles(host);
-	return {
-		/** 账本里记着这个会话的工作区：`registry.list()` 的实体 `sessionIds`（该 getter 已按 canonical cwd 过滤过）。 */
-		async workspaceOf(sessionId) {
-			return registry.list().find((workspace) => workspace.sessionIds.includes(sessionId))?.id;
-		},
-		/** 账本里还有这个工作区吗：`registry.get(id)` 是 `this.entities.get(id)` 的直通（同步 Map 查找），
-		*  未知 id 回 `undefined` ⇒ 这里只做一次判别，不抛。 */
-		async workspaceExists(workspaceId) {
-			return registry.get(workspaceId) !== void 0;
-		},
-		/**
-		* cwd → 宿主项目目录名；没有 cwd 落到 `_no-cwd`。
-		* 账本里没有这个会话回 `undefined`（未命中，不是故障）；真存储故障照抛。
-		* 未命中由 `delete-session.ts` 折成 `not-found`，真故障留 `io`——两者不能混。
-		*/
-		async projectDirOf(sessionId) {
-			let header;
-			try {
-				header = await registry.readSessionHeader(sessionId);
-			} catch (error) {
-				if (isUnknownSession(error)) return void 0;
-				throw error;
-			}
-			return header.cwd === void 0 ? NO_CWD_PROJECT_DIR : projectKey(header.cwd);
-		},
-		/** 标题走宿主投影缓存；尽力取，取不到返回空串，绝不因此让删除失败。 */
-		async titleOf(sessionId) {
-			try {
-				const header = await registry.readSessionHeader(sessionId);
-				const cache = projectionCacheOf(host);
-				const title = (cache?.cachedSnapshot(header, ["title"]) ?? cache?.cachedPredecessorTitle(header))?.values.title;
-				return typeof title === "string" ? title : "";
-			} catch {
-				return "";
-			}
-		},
-		/** 活跃判据走宿主 `workspace/session-activity` waterfall：空数组 = 无活动；
-		*  与宿主 archiveSession 的准入同源。 */
-		async isLive(sessionId) {
-			return (await host.waterfall("workspace/session-activity", { sessionId }, () => Promise.resolve([]))).length > 0;
-		},
-		/** registry 全局归档集（数组，`state.archivedSessionIds`）。 */
-		async isArchived(sessionId) {
-			return registry.archivedSessionIds.includes(sessionId);
-		},
-		/**
-		* 从 `ctx.sessions` 摘掉会话，并关闭捕获到的 agent handle。
-		*
-		* 会话列表 = 磁盘持久化 ∪ 内存活体，搬走文件只清掉一侧；宿主 `SessionController` 会丢掉
-		* `AgentHandle`，所以 `agent-handles.ts` 按会话 id 留住 handle，这里先 detach 再 dispose。
-		* 捕获不到 handle（插件激活前已启动，或 `ctx.agents` 形状变化）时只能摘 session，这是已知限制，
-		* 不拿归档兜底（ADR-0008）。
-		*
-		* 三态：读不到 store / 形状不符 / detach 或 dispose 抛 ⇒ `unknown`（不通告）；
-		* 内存里本来没有 ⇒ `not-live`；摘成功 ⇒ `evicted`。任何一步都不抛。
-		*/
-		async evictLive(sessionId) {
-			try {
-				const store = liveSessionsOf(host);
-				const session = store?.get(sessionId);
-				if (store === void 0) return "unknown";
-				if (session === void 0 || session === null) {
-					await agentHandles.dispose(sessionId);
-					return "not-live";
-				}
-				const entry = store.liveEntryFor(session);
-				if (entry === void 0 || entry === null || typeof entry.detach !== "function") return "unknown";
-				entry.detach();
-				await agentHandles.dispose(sessionId);
-				return "evicted";
-			} catch {
-				return "unknown";
-			}
-		},
-		/**
-		* 通告客户端这个会话没了：发宿主自己转发的 `api-session/removed`，客户端当场删行。
-		* 冷会话没有 `session/disposed`，不发这条就只能等重连。
-		* 只在宿主列表确实已不含它时调用（调用方按 {@link EvictionOutcome} 判）；不发假通告。
-		*/
-		async announceRemoved(sessionId) {
-			try {
-				host.emit("api-session/removed", sessionId);
-			} catch {}
-		},
-		/**
-		* 通告这组会话回来了：拉一次宿主会话表，按 id 逐条发 `api-session/added`。
-		* 摘要直接用宿主 `sessionController.list()` 的形状；取不到就不发。
-		* 批量只预取一次，避免按条全表扫。
-		*/
-		async announceRestored(sessionIds) {
-			if (sessionIds.length === 0) return;
-			const summaries = [];
-			for (const item of await controllerItems(host)) {
-				const sessionId = item?.sessionId;
-				if (typeof sessionId === "string") summaries.push({
-					sessionId,
-					summary: item
-				});
-			}
-			for (const id of sessionIds) {
-				const summary = summaries.find((item) => item.sessionId === id)?.summary;
-				if (summary === void 0) continue;
-				try {
-					host.emit("api-session/added", JSON.parse(JSON.stringify(summary)));
-				} catch {}
-			}
-		},
-		/** 官方 `unarchiveSession(sessionId)`：未归档是幂等 no-op。 */
-		async unarchive(sessionId) {
-			await registry.unarchiveSession(sessionId);
-		},
-		/** 摘账本：实体方法 `detachSession`（顶层没有）；未知工作区**响亮失败**，不静默当成功。 */
-		async detach(sessionId, workspaceId) {
-			const workspace = registry.get(workspaceId);
-			if (workspace === void 0) throw new Error(`${WORKSPACE_MISSING_MESSAGE} (detach): ${workspaceId}`);
-			await workspace.detachSession(sessionId);
-		},
-		/** 挂账本：实体方法 `attachSession`（顶层没有）。 */
-		async attach(sessionId, workspaceId) {
-			const workspace = registry.get(workspaceId);
-			if (workspace === void 0) throw new Error(`${WORKSPACE_MISSING_MESSAGE} (attach): ${workspaceId}`);
-			await workspace.attachSession(sessionId);
-		},
-		/** 确保归档：官方 `archiveSession(sessionId)`。归档是 registry **全局**的，与工作区账目无关
-		*  （JSDoc 原文 "its workspace accounting — or lack of one — is irrelevant"），所以 `workspaceId` 不用
-		*  ——未分组的会话没有工作区可传，签名里它是可选的。
-		*  不带 `stopActivity` ⇒ 有活动即抛 `WorkspaceActiveSessionError`（→ `sessiondelete/live`，src/shared/wire.ts）。 */
-		async archive(sessionId) {
-			await registry.archiveSession(sessionId);
-		},
-		async listSessions() {
-			const sessionQuery = host.get("sessionQuery");
-			if (typeof sessionQuery?.listSessions !== "function") return { available: false };
-			const records = await sessionQuery.listSessions();
-			const out = [];
-			for (const record of records) {
-				const id = record.header?.id;
-				if (typeof id !== "string" || id === "") continue;
-				const parent = record.header?.parentSession;
-				const cwd = record.header?.cwd;
-				out.push({
-					sessionId: id,
-					...typeof parent === "string" && parent !== "" ? { parentSessionId: parent } : {},
-					projectDir: cwd === void 0 ? NO_CWD_PROJECT_DIR : projectKey(cwd),
-					subagent: record.header?.origin === "subagent"
-				});
-			}
-			return {
-				available: true,
-				value: out
-			};
-		},
-		/**
-		* 官方 `sessionQuery.filterSessions([{kind:'parent', values}])`，不自扫 `~/.dsh/sessions`。
-		* 数传递闭包（孩子与孙代），不是直接孩子；`session-` 前缀两边都去掉再比，
-		* 按调用方给的写法回键。`sessionQuery` 缺席或方法缺失 ⇒ `{available:false}`，
-		* 不拿空表冒充“没有后代”；服务在场时空入参零宿主调用。
-		*/
-		async subagentMembersOf(parentIds) {
-			const sessionQuery = host.get("sessionQuery");
-			if (typeof sessionQuery?.filterSessions !== "function") return { available: false };
-			const members = await membersFor(sessionQuery, parentIds);
-			return {
-				available: true,
-				value: Object.fromEntries(Object.entries(members).map(([id, list]) => [id, list.map(toMember)]))
-			};
-		}
-	};
-}
-//#endregion
-//#region src/trash/groups.ts
-/** 这些孩子的父。 */
-function kidsOf(rows, parentId) {
-	return rows.filter((row) => row.parentEntryId === parentId);
-}
-/**
-* 清单露面的一行 = 组根，按清册原序。孩子折进根那一行（宿主的客户端本来就把 `origin:"subagent"`
-* 的行整排藏了 ⇒ 我们若单列就会冒出一堆点不到的行）。
-*
-* 折不进去的那两种孩子（父行不在 / 父行自己也是孩子）**自己站出来占一行**——那正是
-* `visibleGroups` 与 `groupOf` 共用同一条判据的地方。
-*/
-function visibleGroups(rows) {
-	const byId = new Map(rows.map((row) => [row.id, row]));
-	const kidsByRoot = /* @__PURE__ */ new Map();
-	const folded = /* @__PURE__ */ new Set();
-	for (const row of rows) {
-		if (row.parentEntryId === void 0) continue;
-		const parent = byId.get(row.parentEntryId);
-		if (parent === void 0 || parent.parentEntryId !== void 0) continue;
-		folded.add(row.id);
-		const siblings = kidsByRoot.get(parent.id);
-		if (siblings === void 0) kidsByRoot.set(parent.id, [row]);
-		else siblings.push(row);
-	}
-	return rows.filter((row) => !folded.has(row.id)).map((root) => ({
-		root,
-		kids: kidsByRoot.get(root.id) ?? []
-	}));
-}
-/**
-* 一条 id 所属的整组。三种形状，三个答案：
-* - **组根** ⇒ 它自己 + 它接住的孩子（UI 点的是父那一行，删除/恢复/彻底删除都按整组走）；
-* - **孩子**（自己记着 `parentEntryId`）⇒ **只回它自己**。清单不单独列它，只有手工/降级路径会点到这里；
-* - **清册里没有这一条 id，但还有孩子指向它**（父行已被别的路径摘掉）⇒ 那一批孩子；仍然没有 ⇒ 空数组，
-*   调用方据此报 `trash-empty` / 判"已被同批前一条带走"。
-*/
-function groupOf(rows, id) {
-	const root = rows.find((row) => row.id === id);
-	if (root !== void 0) return root.parentEntryId === void 0 ? [root, ...kidsOf(rows, id)] : [root];
-	return kidsOf(rows, id);
-}
-/**
-* 「这条是被**同批前一条**带走的，还是整批开始前就没有，还是仍在？」
-*
-* 幂等语义只属于 `carried`：后来者本来就不在清册里（用户点了条幽灵 id、或对账刚摘掉它）必须照样响亮报
-* `trash-empty`，不能被"已被带走"这句话掩盖成成功。**所以判据是快照的原始形状，不是当前形状**：
-* 原始快照里认得出（它自己、或指向它的孩子任一在），而当前快照里已经空了 ⇒ 同批带走的。
-*/
-function claimOf(original, current, id) {
-	if (groupOf(original, id).length === 0) return { verdict: "absent" };
-	const group = groupOf(current, id);
-	return group.length === 0 ? { verdict: "carried" } : {
-		verdict: "fresh",
-		group
-	};
-}
-//#endregion
-//#region src/verbs/batch-carried.ts
-/**
-* **同批已带走集**（「已被同批前一条带走」的 id）的唯一实现（ADR-0002 的内部实现）。
-*
-* 两种 id 域各一个 adapter：
-* - entry 适配：restore / purge 的条目 id，`claim` 是三态（fresh / carried / absent），组语义仍读
-*   `trash/groups.ts`；
-* - session 适配：delete 的会话 id，`claim` 只有 fresh / carried，集合由动词结果长出。
-*
-* entry 适配的三态判据读 `groups.claimOf`；session 适配没有原始清册视图，只记 `take` 过的会话 id。
-* 当前只读视图（`rows`）只挂在 entry 域上：只有 purge 要它——盘上后代要按清册里还在的 id 排除。
-*/
-/** 恢复 / 彻底删除：原始快照认得、当前视图已经空了 ⇒ 同批前一条带走的。 */
-function createEntryCarried(original) {
-	let current = [...original];
-	return {
-		claim(id) {
-			return claimOf(original, current, id);
-		},
-		take(id) {
-			const gone = new Set(groupOf(current, id).map((row) => row.id));
-			if (gone.size === 0) return;
-			current = current.filter((row) => !gone.has(row.id));
-		},
-		rows: () => current
 	};
 }
 /** 删除：会话 id 域；`take` 只收这次真的搬走的成员（父 + 盘上的孩子）。 */
@@ -884,6 +546,22 @@ const REQUIRED_ENTRY_FIELDS = {
 	title: "string",
 	sizeBytes: "number"
 };
+/** 清册行 → 线上清册行形状。**显式字面量、不用 `...row`**：线上多一格必填时这里编译不过。
+*  只搬清册里真有的事实、不带任何只读数；`/list` 的 `toWire` 与详情的子会话摘要共用这一份
+*  （否则同一条清册行会有两份会漂移的投影）。 */
+function entryWire(row) {
+	return {
+		id: row.id,
+		sessionId: row.sessionId,
+		projectDir: row.projectDir,
+		workspaceId: row.workspaceId,
+		wasArchived: row.wasArchived,
+		deletedAt: row.deletedAt,
+		title: row.title,
+		sizeBytes: row.sizeBytes,
+		...row.parentEntryId === void 0 ? {} : { parentEntryId: row.parentEntryId }
+	};
+}
 const pad = (n, w = 2) => String(n).padStart(w, "0");
 function makeEntryId(deletedAt, sessionDirName) {
 	const d = new Date(deletedAt);
@@ -896,6 +574,7 @@ function parseEntryId(id) {
 	const m = ENTRY_ID_RE.exec(id);
 	if (!m) throw new Error(`bad entry id: ${id}`);
 	const [, y, mo, d, h, mi, s, sessionDirName] = m;
+	if (y === void 0 || mo === void 0 || d === void 0 || h === void 0 || mi === void 0 || s === void 0 || sessionDirName === void 0) throw new Error(`bad entry id: ${id}`);
 	return {
 		deletedAt: Date.UTC(+y, +mo - 1, +d, +h, +mi, +s),
 		sessionDirName
@@ -1021,7 +700,9 @@ async function assertNoLive(host, sessionIds) {
 }
 //#endregion
 //#region src/verbs/member-presence.ts
-/** 本仓的在场能力实现：端口形状住 `src/ports/presence-port.ts`，这里只做三态与真值表。
+/** 本仓的在场能力实现，也是**全仓唯一的盖章处**：端口形状住 `src/ports/presence-port.ts`，这里只做
+*  三态与真值表。品牌字段是类型层的（unique symbol 不导出、没有运行时值），所以只有这一处显式断言
+*  能把三件方法盖成 `PresenceCapability`——手拼同样的三件满足不了那个面（`tests/deps.test.ts` 钉住）。
 *  `announceRestored` 直接交宿主那一手：能力面与宿主面同名同签名，再包一层只会多一个转调。 */
 function createMemberPresence(host) {
 	return {
@@ -1289,7 +970,11 @@ function isMagicAt(raw, at) {
 	return MAGIC.every((byte, i) => raw[at + i] === byte);
 }
 function readUint24LE(raw, at) {
-	return raw[at] | raw[at + 1] << 8 | raw[at + 2] << 16;
+	const b0 = raw[at];
+	const b1 = raw[at + 1];
+	const b2 = raw[at + 2];
+	if (b0 === void 0 || b1 === void 0 || b2 === void 0) return void 0;
+	return b0 | b1 << 8 | b2 << 16;
 }
 /** 块体之后有没有那 4 字节尾巴：只有"跳过它之后仍是帧头或到 EOF"才认。 */
 function withFrameTail(raw, at) {
@@ -1319,7 +1004,7 @@ function frameRanges(raw) {
 		for (;;) {
 			const blockHeader = readUint24LE(raw, cursor);
 			cursor += BLOCK_HEADER_BYTES;
-			if (cursor > raw.length) throw new Error(`zstd 块头越界：帧起于 ${at}，读到偏移 ${cursor}（文件长 ${raw.length}）`);
+			if (blockHeader === void 0 || cursor > raw.length) throw new Error(`zstd 块头越界：帧起于 ${at}，读到偏移 ${cursor}（文件长 ${raw.length}）`);
 			const blockType = blockHeader >> BLOCK_TYPE_SHIFT & 3;
 			const blockSize = blockHeader >> BLOCK_SIZE_SHIFT & BLOCK_SIZE_MASK;
 			if (blockType === BLOCK_RESERVED) throw new Error(`zstd 保留块类型：帧起于 ${at}，偏移 ${cursor - BLOCK_HEADER_BYTES} 的块头 type=3（规范 Reserved，对面解不开）`);
@@ -1420,7 +1105,7 @@ function walkSessionLog(raw, onRecord) {
 		try {
 			plain = zlib.zstdDecompressSync(raw.subarray(start, end));
 		} catch (error) {
-			throw new Error(`回收站日志第 ${stats.frames} 帧解压失败：${String(error)}`);
+			throw new Error(`回收站日志第 ${stats.frames} 帧解压失败：${String(error)}`, { cause: error });
 		}
 		const merged = carry.length === 0 ? plain : Buffer.concat([carry, plain]);
 		const cut = merged.lastIndexOf(NEWLINE);
@@ -1464,8 +1149,14 @@ function readSessionHeader(raw) {
 * ② 只要剩余引用源读不出来，就整体跳过（fail closed）——宁可留孤儿，不许删共享。
 *    引用源"读不出来"包括：目录/文件读失败、目录非空却没有规范 zstd 日志（明文/陌生布局）、
 *    JSON 超出扫描上限、日志有坏行或尾巴被截断。
+*    宿主的内核写锁 `session.lock` 例外：它不是会话内容，恒为 0 字节时既不算读不懂、也不算
+*    "目录里有东西"；非空才回落到上面的 fail closed（判据见 `imageIdsOfDir`）。
 */
 const ATTACHMENT_ID = /^sha256:[0-9a-f]{64}$/u;
+/** 合法附件 ID：形状是 `sha256:` + 64 位小写十六进制。
+*  谓词必须收成**模板字面量形状**而不是 `string`：`attachmentPathOf` 里 `!isAttachmentId(id)` 的
+*  假支若按「是 string」取反会被 TS 收成 `never`（参数本来就是 string），插值就成了 never 读数。
+*  这里判的仍是同一条正则，谓词只是把「形状」写进类型面。 */
 function isAttachmentId(value) {
 	return typeof value === "string" && ATTACHMENT_ID.test(value);
 }
@@ -1543,8 +1234,15 @@ function scanImageIdsInLog(raw) {
 }
 /** 宿主写日志时的临时名：`session.vN.jsonl.zstd.<hash>.tmp`（内容写完后才 rename 成规范名）。 */
 const TEMP_LOG_NAME = /^session(?:\.v[1-9][0-9]*)?\.jsonl(?:\.zstd)?\.[0-9a-f]+\.tmp$/u;
+/**
+* 宿主的内核写锁：宿主以写方式打开它即截断、**从不写入内容**、释放也从不删除（POSIX 上是
+* `flock(2)` 的目标，Windows 上没有这个文件）——所以每个已实体化的会话目录、以及跟着搬进
+* 回收站的条目里，它都与日志常态并存。锁只表达"谁在写"，不承载会话记录。
+*/
+const LOCK_NAME = "session.lock";
 /** 规范日志之外允许并存的两类文件：更老一代的规范日志（新代包含旧代）与 0 字节临时日志（没有消息）。
-*  其余任何文件都可能是规范日志没覆盖到的引用（例如写入中的非空临时日志），一律按不可读处理。 */
+*  其余任何文件都可能是规范日志没覆盖到的引用（例如写入中的非空临时日志），一律按不可读处理。
+*  宿主的 `session.lock` 到不了这里——它在 `imageIdsOfDir` 挑名单时就按"不是会话内容"剥掉了。 */
 async function unreadableExtraFile(deps, dir, names) {
 	for (const name of names) {
 		if (isCanonicalSessionLogName(name)) continue;
@@ -1559,12 +1257,27 @@ async function unreadableExtraFile(deps, dir, names) {
 *  同样按不可读处理（宁可留下对象等维护卡兜底，不冒"没引用"）。
 *  **规范日志旁的文件也要过关**：老一代规范日志可以并存（新代包含旧代）；0 字节临时日志是
 *  写盘未完成的空产物，也没有引用。非空临时日志、明文日志或其他任何文件仍按不可读处理（fail closed）。
+*  **宿主的内核写锁不是会话内容**：0 字节的锁在判目录形状之前先剥掉——不然每个已实体化的会话目录
+*  （含搬进回收站的条目）都会被读成"读不懂"，整份引用扫描在真机上恒跳过；没有日志的锁目录因此与
+*  空目录同判。非空的锁说明我们对这个文件的理解失效（宿主不会往里写字节），仍按不可读处理。
 */
 async function imageIdsOfDir(deps, dir) {
 	if (!await deps.fs.exists(dir)) return { ids: /* @__PURE__ */ new Set() };
 	let names;
 	try {
 		names = await deps.fs.listFiles(dir);
+		const withoutLock = [];
+		for (const name of names) {
+			if (name !== LOCK_NAME) {
+				withoutLock.push(name);
+				continue;
+			}
+			if ((await deps.fs.statFile(`${dir}/${name}`)).size > 0) return {
+				ids: /* @__PURE__ */ new Set(),
+				unreadable: `${dir}: 锁文件 ${name} 非空，无法确认里面没有引用`
+			};
+		}
+		names = withoutLock;
 	} catch (error) {
 		return {
 			ids: /* @__PURE__ */ new Set(),
@@ -1634,8 +1347,6 @@ async function imageIdsOfDir(deps, dir) {
 		};
 	}
 }
-/** 单个 JSON 引用源的扫描上限；超过就记成不可读（fail closed），**不许当作"没有引用"跳过**。 */
-const MAX_JSON_REF_BYTES = 10485760;
 /** 读全部剩余引用源；任何一处读不出都记进 `unreadable`。 */
 async function collectRemainingImageRefs(deps, input) {
 	const exclude = new Set(input.excludeDirs);
@@ -1658,6 +1369,7 @@ async function collectRemainingImageRefs(deps, input) {
 	if (await deps.fs.exists(trashRoot)) for (const name of await deps.fs.listDirs(trashRoot)) await visit(`${trashRoot}/${name}`);
 	const scanJson = async (root) => {
 		if (!await deps.fs.exists(root)) return;
+		const maxJsonRefBytes = deps.config.maxJsonRefBytes;
 		const stack = [root];
 		const seen = /* @__PURE__ */ new Set();
 		while (stack.length > 0) {
@@ -1671,8 +1383,8 @@ async function collectRemainingImageRefs(deps, input) {
 					if (!name.endsWith(".json")) continue;
 					const file = `${dir}/${name}`;
 					const stat = await deps.fs.statFile(file);
-					if (stat.size > MAX_JSON_REF_BYTES) {
-						unreadable.push(`${file}: JSON 引用源 ${stat.size} 字节超过扫描上限 ${MAX_JSON_REF_BYTES} 字节，未扫描`);
+					if (stat.size > maxJsonRefBytes) {
+						unreadable.push(`${file}: JSON 引用源 ${stat.size} 字节超过扫描上限 ${maxJsonRefBytes} 字节，未扫描`);
 						continue;
 					}
 					const text = (await deps.fs.readFile(file)).toString("utf8");
@@ -1878,7 +1590,11 @@ async function cleanOrphanImageAttachments(deps) {
 //#region src/verbs/permanent-removal.ts
 /**
 * 永久删除的测量、计划与执行：先记录目录/字节/账本归属，再按计划动盘。
-* 计划函数只读；活体准入在计划阶段、任何写之前完成。
+* 计划函数只读；活体准入在计划阶段、任何写之前完成，执行器动第一笔写前再查一次。
+*
+* 测量与补账本归属**分家**：`/list` 的只读计划只吃 {@link measureMembers}（零账本读，不再为每个
+* 盘上后代问一次 `workspaceOf`，`/list` 的失败面不再含账本归属读）；`workspaceOf` 只有
+* purge / orphan-clean 的删除计划（{@link planMemberRemovals}）才付——executor 摘账本要用它。
 */
 /** `exists → sizeOfDir` 的唯一一条度量口径（成员目录与回收站目录共用）：先问在不在，再量字节；
 *  ENOENT 是唯一一种当"不在"的失败，别的错误照旧响亮。别再在调用点各写一遍这段 try/catch。
@@ -1916,18 +1632,32 @@ async function measureMemberDir(deps, member) {
 		bytes: probe.bytes
 	} : void 0;
 }
-/** 把一组成员折成"删之前要记下的计划"；目录不在的成员跳过（记录与盘不一致是那条成员自己的事）。
-*  `purge` 的盘上后代、`orphan-clean` 的整组与 `/list` 的盘上残留都走这一处，别再各写一遍
-*  measure + workspaceOf。 */
-async function planMemberRemovals(deps, members) {
-	const plans = [];
+/** 只测量（目录 + 实测字节）：`/list` 的只读计划只吃这一支，零账本读。目录不在的成员跳过
+*  （记录与盘不一致是那条成员自己的事）。为什么不顺手把归属也问了：`/list` 投影只用字节与条数，
+*  那一格立刻被丢弃——每开一次回收站为它付 N 次宿主调用，还把账本归属读拉进 `/list` 的失败面。 */
+async function measureMembers(deps, members) {
+	const out = [];
 	for (const member of members) {
 		const measured = await measureMemberDir(deps, member);
 		if (measured === void 0) continue;
-		const workspaceId = await deps.host.workspaceOf(member.sessionId);
-		plans.push({
+		out.push({
 			sessionId: member.sessionId,
-			...measured,
+			projectDir: member.projectDir,
+			...measured
+		});
+	}
+	return out;
+}
+/** 把一组成员折成"删之前要记下的计划"：{@link measureMembers} 的测量之外**逐成员补账本归属**
+*  （`workspaceOf`）——executor 摘账本要用。`/list` 不走这里（它只吃 measureMembers，零账本读）。 */
+async function planMemberRemovals(deps, members) {
+	const plans = [];
+	for (const measured of await measureMembers(deps, members)) {
+		const workspaceId = await deps.host.workspaceOf(measured.sessionId);
+		plans.push({
+			sessionId: measured.sessionId,
+			dir: measured.dir,
+			bytes: measured.bytes,
 			...workspaceId === void 0 ? {} : { workspaceId }
 		});
 	}
@@ -1947,7 +1677,7 @@ async function measureTrashRow(deps, entry) {
 /**
 * 盘上后代的选择判据（`/list` 与 purge 的删除计划共用这一份）：`subagentMembersOf` 一次问全部父，
 * 再按 `bareSessionId` **排除全部清册 id**（跟着父进来的孩子不按盘上残留再算一遍），同一个 bare id 只认
-* **遍历顺序里第一次**出现的那条（同一个会话在两代宿主里的写法不同）。
+* **遍历顺序里第一次**出现的那条（同一个会话在两代宿主里的写法不同；去重口径住 `src/domain/closure.ts` 的 `firstByBare`）。
 *
 * 语料看不见（`available: false`）⇒ 每个根都按空成员收：`/list` 与 purge 只许静默降级，
 * 盘上残留留给 `GET /orphans` 兜底。
@@ -1962,32 +1692,41 @@ async function measureTrashRow(deps, entry) {
 async function selectStrandedMembers(host, manifest, parentIds) {
 	const manifestIds = new Set(manifest.map((row) => bareSessionId(row.sessionId)));
 	const read = await host.subagentMembersOf(parentIds);
-	const seen = /* @__PURE__ */ new Set();
-	return parentIds.map((parentId) => {
-		const wanted = [];
-		if (!read.available) return wanted;
+	if (!read.available) return parentIds.map(() => []);
+	const flat = [];
+	parentIds.forEach((parentId, groupIndex) => {
 		for (const member of read.value[parentId] ?? []) {
-			const bare = bareSessionId(member.sessionId);
-			if (manifestIds.has(bare) || seen.has(bare)) continue;
-			seen.add(bare);
-			wanted.push(member);
+			if (manifestIds.has(bareSessionId(member.sessionId))) continue;
+			flat.push({
+				sessionId: member.sessionId,
+				projectDir: member.projectDir,
+				member,
+				groupIndex
+			});
 		}
-		return wanted;
 	});
+	const out = parentIds.map(() => []);
+	for (const entry of firstByBare(flat)) {
+		const bucket = out[entry.groupIndex];
+		if (bucket === void 0) throw verbError("io", `子会话分组越界：${entry.member.sessionId}`);
+		bucket.push(entry.member);
+	}
+	return out;
 }
 /**
 * `/list` 的只读计划：一行 = 一组。释放量与 purge 用同一条口径——回收站目录与成员目录**现测**，
 * 不用清册里记的 `sizeBytes`（那是删除那一刻的事实，盘上早就变了）。
 *
 * 盘上后代经 `selectStrandedMembers` 选出（排除全部清册 id、bare id 全局只算一次）；目录不在的成员
-* 不进 `members`（与 `planMemberRemovals` 同口径）。
+* 不进 `members`（与 purge 计划同口径）。成员只吃 {@link measureMembers}：**零账本读**——不再为每个
+* 盘上后代问一次 `workspaceOf`，`/list` 的失败面不再含账本归属读（归属只有 purge 摘账本才付）。
 */
 async function planVisibleTrash(deps, rows, groups) {
 	const candidates = await selectStrandedMembers(deps.host, rows, groups.map((group) => group.root.sessionId));
 	return await Promise.all(groups.map(async ({ root, kids }, index) => {
 		const rootRow = await measureTrashRow(deps, root);
 		const kidRows = await Promise.all(kids.map((kid) => measureTrashRow(deps, kid)));
-		const members = await planMemberRemovals(deps, candidates[index] ?? []);
+		const members = await measureMembers(deps, candidates[index] ?? []);
 		const subagentBytes = kidRows.reduce((total, row) => total + row.bytes, 0);
 		const strandedBytes = members.reduce((total, member) => total + member.bytes, 0);
 		return {
@@ -2007,7 +1746,8 @@ function totalBytes(items) {
 }
 /**
 * purge 的删除计划：`targets` 由调用方按组语义（`trash/groups.ts`）选好，这里只量、只筛、只查活体。
-* **计划函数就是执行前的闸**——调用方拿到计划才允许写，所以准入必须发生在任何写之前。
+* **计划函数是执行前的第一道闸**——调用方拿到计划才允许写；计划与第一笔写之间的窗口由
+* `executeRemoval` 在首笔写前复查（见该函数头注）。
 *
 * - `trash` 按 targets 原序逐个实测（目录缺席的行 `present:false` / 0 字节，但清册行仍要摘）。
 * - 盘上后代经 `selectStrandedMembers` 选出（一次问全部 targets、排除全部清册 id、bare id 全局只计划一次）。
@@ -2016,7 +1756,7 @@ function totalBytes(items) {
 * - `attachments` 由被删目录（targets + 这些成员）里的图片引用与全部剩余引用源算独占；共享的保留、
 *   剩余引用源读不出就整体跳过（判据住 `trash/attachments.ts`，这里只接线）。
 * - 活体准入在量目录与任何写之前逐个查 targets 与**全部枚举到的**盘上后代；任一在跑就整条拒绝、
-*   零副作用。没有跳过它的开关——计划就是执行前的闸（ADR-0006）。
+*   零副作用。没有跳过它的开关；执行器首笔写前还会用计划里的 `unarchive` 名单复查（ADR-0027）。
 * - `sessionQuery` 缺席时端口回 `{ available: false }` ⇒ members 为空、不抛（盘上残留留给 `GET /orphans` 兜底）。
 */
 async function planTrashRemoval(deps, rows, targets) {
@@ -2059,8 +1799,15 @@ async function planOrphanRemoval(deps, members) {
 	};
 }
 /**
-* 按计划执行一次永久删除：只写、不再量、不再判活体（计划就是执行前的闸）。回执的字节念计划
-* （`plan.bytes`），执行期不再累加一遍。
+* 按计划执行一次永久删除：不再量。回执的字节念计划（`plan.bytes`），执行期不再累加一遍。
+*
+* **计划 + 执行器、准入查两遍**（ADR-0027）：计划期准入证明计划成立时没有会话在跑；执行器首笔写前
+* 再用同一份名单复查，补上附件扫描撑开的窗口。
+*
+* 计划期准入与第一笔写之间还隔着附件引用的全 home 扫描（`planImageAttachmentRemoval`），大 home
+* 上那是秒级窗口——期间用户 resume 一个会话，它的目录随后仍会被删。所以动任何写之前用计划里同一份
+* 会话名单**再查一次活体**（只读、廉价）；这一查失败仍然零写入。名单取 `plan.unarchive`：
+* 它覆盖所有会被删目录的会话（回收站行与盘上成员），目录已不在的成员没有可删的东西。
 *
 * 顺序：整批摘归档集 → 摘有账本的成员的账本 → 逐条回收站行
 * （在才删目录 → 摘清册行 → 通告成员离场）→ 逐条盘上成员（删目录 → 通告成员离场）→ 逐条附件对象。
@@ -2077,6 +1824,7 @@ async function planOrphanRemoval(deps, members) {
 * 通告只经 `member-presence`（摘活体三态 + `api-session/removed`），不在这里另写一份。
 */
 async function executeRemoval(deps, plan) {
+	await assertNoLive(deps.host, plan.unarchive);
 	const presence = deps.presence;
 	let removed = 0;
 	/** 删到这一刻已经腾出的**进度**：只喂 `orphan` 的部分回执；成功回执念计划的合计（`plan.bytes`）。 */
@@ -2123,7 +1871,7 @@ async function executeRemoval(deps, plan) {
 		try {
 			await deps.ledger.remove(row.entry.id);
 		} catch (error) {
-			fail("删除回收站目录失败", error, row.entry.sessionId);
+			fail("摘除回收站条目失败", error, row.entry.sessionId);
 		}
 		removed += 1;
 		await presence.memberGone(row.entry.sessionId);
@@ -2158,47 +1906,14 @@ async function executeRemoval(deps, plan) {
 * 彻底删除（组语义见 `src/trash/groups.ts`），把它的根当孤儿删掉就是**替用户做了一个没人点过的决定**。孤儿只
 * 有一种来路：父被彻底删掉了（或被手工从盘上清掉了），清册里再也没有这一行。
 *
-* 根按**传递闭包**收全部后代（与 `HostCorpusPort.subagentMembersOf` 同一口径：孩子与孙代都算，深度不设上限），
-* 同一条记录只归一组（`claimed`）——数据里真出现环时结果是"少数一条"，不是把一个会话删两遍。
+* 根按**传递闭包**收全部 subagent 后代（与 `HostCorpusPort.subagentMembersOf` 同一实现：闭包核心住
+* `src/domain/closure.ts` 的 `orphanRootsOf`，孩子与孙代都算，深度不设上限；普通 fork 不是成员、
+* 也不穿过它收后代），同一条记录只归一组
+* （`claimed`）——数据里真出现环时结果是"少数一条"，不是把一个会话删两遍。
 * 归堆与去重**两边都去 `session-` 前缀**：同一个父在两代宿主里写法不同（见 `bareSessionId` 的来历）。
 */
 function orphanGroupsOf(corpus, trashSessionIds) {
-	const known = /* @__PURE__ */ new Set();
-	for (const session of corpus) known.add(bareSessionId(session.sessionId));
-	for (const id of trashSessionIds) known.add(bareSessionId(id));
-	const children = /* @__PURE__ */ new Map();
-	for (const session of corpus) {
-		const parent = session.parentSessionId;
-		if (parent === void 0) continue;
-		const key = bareSessionId(parent);
-		const list = children.get(key);
-		if (list === void 0) children.set(key, [session]);
-		else list.push(session);
-	}
-	const claimed = /* @__PURE__ */ new Set();
-	const groups = [];
-	for (const session of corpus) {
-		const parent = session.parentSessionId;
-		if (!session.subagent || parent === void 0) continue;
-		if (known.has(bareSessionId(parent))) continue;
-		if (claimed.has(bareSessionId(session.sessionId))) continue;
-		const members = [];
-		const queue = [session];
-		for (let i = 0; i < queue.length; i += 1) {
-			const current = queue[i];
-			const id = bareSessionId(current.sessionId);
-			if (claimed.has(id)) continue;
-			claimed.add(id);
-			members.push(current);
-			for (const child of children.get(id) ?? []) queue.push(child);
-		}
-		groups.push({
-			root: session,
-			parentSessionId: parent,
-			members
-		});
-	}
-	return groups;
+	return orphanRootsOf(corpus, [...corpus.map((session) => session.sessionId), ...trashSessionIds]);
 }
 /** **本函数是纯扫描，不对账、不写清册行**（`/orphans` 声明为 pure，一次扫描不能顺手写行）。
 *  清册行由调用方选好再交进来：`/orphans` 交 `read.rows()`（raw 索引），`orphan-clean` 交
@@ -2207,12 +1922,17 @@ function orphanGroupsOf(corpus, trashSessionIds) {
 *
 *  `listSessions()` 回 `{ available: false }` 时**必须抛**：那是宿主的会话语料服务没挂，不是"这个家没有孤儿"。
 *  拿缺席当空语料 ⇒ 报告说"零条孤儿"、界面上一句"没有要清理的"，而盘上真有几百 MB——那是假话，
-*  所以这里按 `io` 响亮失败（AGENTS.md：`available: false` 意味着服务缺席，扫描方不许冒充读数）。 */
-async function loadOrphanGroups(deps, trash) {
+*  所以这里按 `io` 响亮失败（AGENTS.md：`available: false` 意味着服务缺席，扫描方不许冒充读数）。
+*
+*  `roots` 只收请求点名的那几组、**在量字节之前过滤**：`/orphans` 不传（报告全部），
+*  `orphan-clean` 传这次的根——否则点一组会把整个家所有孤儿的树都递归量一遍。 */
+async function loadOrphanGroups(deps, trash, roots) {
 	const read = await deps.host.listSessions();
 	if (!read.available) throw verbError("io", "无主子会话扫描需要宿主的 sessionQuery.listSessions");
 	const corpus = read.value;
-	const groups = orphanGroupsOf(corpus, trash.map((entry) => entry.sessionId));
+	const all = orphanGroupsOf(corpus, trash.map((entry) => entry.sessionId));
+	const wanted = roots === void 0 ? void 0 : new Set(roots.map((root) => bareSessionId(root)));
+	const groups = wanted === void 0 ? all : all.filter((group) => wanted.has(bareSessionId(group.root.sessionId)));
 	const out = [];
 	for (const group of groups) {
 		const members = [];
@@ -2224,8 +1944,10 @@ async function loadOrphanGroups(deps, trash) {
 				bytes: measured?.bytes ?? 0
 			});
 		}
+		const root = members[0];
+		if (root === void 0) throw verbError("io", `无主子会话组没有成员（父 ${group.parentSessionId}）`);
 		out.push({
-			root: members[0],
+			root,
 			parentSessionId: group.parentSessionId,
 			members
 		});
@@ -2260,49 +1982,401 @@ function reportOrphans(groups) {
 		})).sort((a, b) => b.bytes - a.bytes)
 	};
 }
-/**
-* 清一组：`planOrphanRemoval`（只读计划，整组 live 准入在一切写之前）→ `executeRemoval`（只写）。
-* 量目录、摘归档集与账本、删目录与成员通告的顺序和失败形状都住 `verbs/permanent-removal.ts`；
-* 这里只把这一组接上去，别在这再长出一段手写步骤（purge 走的是同一条路）。
-*
-* 顺序与删除那一半是**对偶**的，但不是照抄：
-* - 删除那一半不再用归档藏会话（ADR-0008）：它摘账本、搬目录，最后才摘活体。这里目录是**删掉**
-*   不是搬走，藏不藏都不影响可见性 ⇒ 归档集反而**在写之前整批摘掉**：失败时目录还在，下一次还能重试，
-*   不会留下"会话没了但还在归档集里挂着"的幽灵 id。
-* - `unarchive` 对未归档的会话是官方幂等 no-op（`registry.unarchiveSession`），所以这里不需要那次
-*   `wasArchived` 读——这里没有"还原到删除前"的义务。
-* - 摘账本只在账本真记着它时做（`workspaceOf` 未命中 = 本来就是「未分组」，不是故障）。
-* - 独占图片的剩余引用源由附件域自己扫：活动会话 + 全部 session-trash + storages/cache。
-*/
-async function cleanOrphanGroup(deps, group) {
-	return await executeRemoval(deps, await planOrphanRemoval(deps, group.members));
+/**
+* 清一组：`planOrphanRemoval`（只读计划，整组 live 准入在一切写之前）→ `executeRemoval`（只写）。
+* 量目录、摘归档集与账本、删目录与成员通告的顺序和失败形状都住 `verbs/permanent-removal.ts`；
+* 这里只把这一组接上去，别在这再长出一段手写步骤（purge 走的是同一条路）。
+*
+* 顺序与删除那一半是**对偶**的，但不是照抄：
+* - 删除那一半不再用归档藏会话（ADR-0008）：它摘账本、搬目录，最后才摘活体。这里目录是**删掉**
+*   不是搬走，藏不藏都不影响可见性 ⇒ 归档集反而**在写之前整批摘掉**：失败时目录还在，下一次还能重试，
+*   不会留下"会话没了但还在归档集里挂着"的幽灵 id。
+* - `unarchive` 对未归档的会话是官方幂等 no-op（`registry.unarchiveSession`），所以这里不需要那次
+*   `wasArchived` 读——这里没有"还原到删除前"的义务。
+* - 摘账本只在账本真记着它时做（`workspaceOf` 未命中 = 本来就是「未分组」，不是故障）。
+* - 独占图片的剩余引用源由附件域自己扫：活动会话 + 全部 session-trash + storages/cache。
+*/
+async function cleanOrphanGroup(deps, group) {
+	return await executeRemoval(deps, await planOrphanRemoval(deps, group.members));
+}
+//#endregion
+//#region src/ports/agent-handles.ts
+const CAPTURED_AGENT_HANDLES = Symbol.for("dsh-session-delete.captured-agent-handles");
+/** 在 `ctx.agents` 上包一层 `resume` / `create`，把返回的 agent handle 的 dispose 按会话 id 记下。
+*  服务缺席时走 `ctx.inject(['agents'])` **等服务挂上再装**——live profile 的插件激活顺序可能早于
+*  `agents` 服务就绪；只在 apply 时 `get` 一次会让捕获静默缺席（真机症状：重启前在回收站的能冷恢复，
+*  刚删除的会话恢复后旧 agent 拦住 prompt）。形状不符 / 属性不可写都只是**不捕获**，不影响插件激活。
+*
+*  **安装时机**：先 `get('agents')`，没装成再 `inject(['agents'])`（两者只装一次，符号表兜住）。
+*  **symbol 表**：句柄表挂在服务实例的 {@link CAPTURED_AGENT_HANDLES} 上；同一个 agents 服务上的第二次
+*  安装（`get` 与 `inject` 各一次，或第二个 `createHostPort`）看见它就直接共用，不把 wrapper 套第二层。
+*  **读回判据**：cordis 的 traceable 服务代理每次读函数都会新包一层（`get` 里的 `createShadowMethod`），
+*  所以只能看 own property descriptor 的身份；拿 `service[name]` 读回比身份是必然的假警报。
+*/
+function captureAgentHandles(ctx) {
+	let handles = /* @__PURE__ */ new Map();
+	let installed = false;
+	const install = (candidate) => {
+		if (installed) return;
+		const service = candidate;
+		if (service === void 0 || service === null) return;
+		const existing = service[CAPTURED_AGENT_HANDLES];
+		if (existing !== void 0) {
+			handles = existing;
+			installed = true;
+			return;
+		}
+		let wrappedCount = 0;
+		for (const name of ["resume", "create"]) try {
+			const original = service[name];
+			if (typeof original !== "function") continue;
+			const wrapped = function(...args) {
+				const result = Reflect.apply(original, this, args);
+				result.then((value) => {
+					const handle = value;
+					const id = handle?.agent?.id;
+					const dispose = handle?.dispose;
+					if (typeof id !== "string" || id.length === 0 || typeof dispose !== "function") return;
+					handles.set(id, async () => {
+						await dispose.call(handle);
+					});
+				}, () => void 0);
+				return result;
+			};
+			service[name] = wrapped;
+			if (Object.getOwnPropertyDescriptor(service, name)?.value !== wrapped) throw new Error(`agents.${name} is not writable`);
+			wrappedCount += 1;
+		} catch {}
+		if (wrappedCount === 0) return;
+		try {
+			service[CAPTURED_AGENT_HANDLES] = handles;
+		} catch {}
+		installed = true;
+	};
+	const service = ctx.get("agents");
+	if (service !== void 0 && service !== null) install(service);
+	if (!installed && typeof ctx.inject === "function") try {
+		ctx.inject(["agents"], (child) => {
+			install(child.get("agents"));
+		});
+	} catch {}
+	return { async dispose(sessionId) {
+		const dispose = handles.get(sessionId);
+		if (dispose === void 0) return;
+		try {
+			await dispose();
+		} finally {
+			handles.delete(sessionId);
+		}
+	} };
+}
+//#endregion
+//#region src/ports/host-port.ts
+/** live store 的最小方法面判据（同 `projectionCacheOf` 的手法：按方法面判，不按 constructor.name）。 */
+function liveSessionsOf(ctx) {
+	const store = ctx.get("sessions");
+	if (store === void 0 || store === null) return void 0;
+	if (typeof store.get !== "function" || typeof store.liveEntryFor !== "function") return void 0;
+	return store;
+}
+/** 官方的「这些父的孩子」那一支：`kind:'parent'` 的判据逐字是 `values.includes(record.header.parentSession ?? null)`。
+*  它只按 `parentSession` 原样匹配，**不是**子会话分类器：旧宿主（≤0.2.1-rc.5）的普通 fork 也写
+*  `parentSession`，0.2.2-alpha.2 起才不写。子会话的判据是 `origin` 的 subagent 标记（宿主归档闸、归档
+*  准入、持久化找子日志三处一致），所以调用方必须再按 origin 筛一遍。 */
+async function filterChildrenOf(sessionQuery, values) {
+	return sessionQuery.filterSessions([{
+		kind: "parent",
+		values: [...values].sort()
+	}]);
+}
+/**
+* 从若干根逐层向下问出后代，交回 `父（bare）→ 孩子` 的索引。
+* 用 `kind:'parent'` 而不是 traceSession：父进回收站后 traceSession 认不出目标（宿主失败码
+* `SESSION_QUERY_SESSION_NOT_FOUND`），而这里要的正是父不在宿主列表之后仍留在盘上的那批。
+* 出处：asar `dsh-session-query/lib/index.js` 的 `filterSessions`。一层一次宿主调用，问空即停；
+* `seen` 防环；没有 `header.id` 的记录整条跳过（无法作为身份继续下问）。
+*/
+async function descendantsByParent(sessionQuery, roots) {
+	const children = /* @__PURE__ */ new Map();
+	const seen = new Set(roots.map(bareSessionId));
+	let frontier = [...seen];
+	while (frontier.length > 0) {
+		const values = [];
+		for (const bare of frontier) for (const shape of sessionIdShapes(bare)) if (!values.includes(shape)) values.push(shape);
+		const next = [];
+		for (const record of await filterChildrenOf(sessionQuery, values)) {
+			const id = record.header?.id;
+			const parent = record.header?.parentSession;
+			if (typeof id !== "string" || id.length === 0) continue;
+			if (typeof parent !== "string" || parent.length === 0) continue;
+			if (record.header?.origin !== "subagent") continue;
+			const bare = bareSessionId(id);
+			if (seen.has(bare)) continue;
+			seen.add(bare);
+			const cwd = record.header.cwd;
+			const descendant = {
+				sessionId: id,
+				projectDir: cwd === void 0 ? NO_CWD_PROJECT_DIR : projectKey(cwd)
+			};
+			const parentBare = bareSessionId(parent);
+			const siblings = children.get(parentBare);
+			if (siblings === void 0) children.set(parentBare, [descendant]);
+			else siblings.push(descendant);
+			next.push(bare);
+		}
+		frontier = next;
+	}
+	return children;
+}
+/** {@link HostCorpusPort.subagentMembersOf} 的那一次 BFS：这里只负责问宿主，某个根的后代闭包
+*  由纯部件的 `closureOf` 在交回的索引上收（深度不设上限、防环、首见去重都在那一处）。
+*  空清单在调用宿主之前就返回（不为一张空表扫全库）。 */
+async function membersFor(sessionQuery, parentIds) {
+	const wanted = [];
+	for (const id of parentIds) if (id.length > 0 && !wanted.includes(id)) wanted.push(id);
+	if (wanted.length === 0) return {};
+	const children = await descendantsByParent(sessionQuery, wanted);
+	const out = {};
+	for (const id of wanted) out[id] = closureOf(children, id);
+	return out;
+}
+/** 无 cwd 的会话落在 `_no-cwd/`；`projectDirOf` 与回收站对账共用这个字面量。
+*  出处：asar `dsh-session-persistence-jsonl/lib/index.js` 的 `projectDir`（`if (cwd === void 0) return join(root, "_no-cwd");`）。 */
+const NO_CWD_PROJECT_DIR = "_no-cwd";
+/** 宿主 `projectKey(cwd)` 的逐字镜像：跨插件不能 import，宿主也没把它暴露成服务。
+*  出处：asar `dsh-session-persistence-jsonl/lib/index.js` 的 `projectKey`；调用链
+*  `locate` → `logPath` → `projectDir` → `projectKey`。本机实测 `D:/develop/GitHub/dsh-session-delete`
+*  → `--D-develop-GitHub-dsh-session-delete--`。`projectDirOf` 与回收站对账重建共用这一份；
+*  宿主换代先复核算法。 */
+function projectKey(cwd) {
+	let readable = "";
+	let separatorRun = false;
+	for (let i = 0; i < cwd.length; i++) {
+		const code = cwd.charCodeAt(i);
+		const ch = String.fromCharCode(code);
+		if (ch === "/" || ch === "\\" || ch === ":") {
+			if (!separatorRun) readable += "-";
+			separatorRun = true;
+		} else if (ch !== "~" && /^[A-Za-z0-9._-]$/.test(ch)) {
+			readable += ch;
+			separatorRun = false;
+		} else {
+			readable += `~${code.toString(16).toUpperCase().padStart(4, "0")}`;
+			separatorRun = false;
+		}
+	}
+	return `--${(readable.replace(/^-+/, "") || "root").slice(0, 251)}--`;
+}
+/** 投影缓存服务的最小方法面判据（按方法面判，不按 `constructor.name` 判）。 */
+function projectionCacheOf(ctx) {
+	const cache = ctx.get("sessionProjectionCache");
+	if (cache === void 0 || cache === null) return void 0;
+	if (typeof cache.cachedSnapshot !== "function" || typeof cache.cachedPredecessorTitle !== "function") return void 0;
+	return cache;
+}
+/** 宿主 `readSessionHeader` 对未知会话抛的是裸 `Error`，只认这句；真存储故障照抛，不能折成未命中。
+*  出处：asar `dsh-workspace/lib/types/index.js` 的
+*  `cannot validate session '${id}': session persistence holds no such session`。
+*  同文件有类型的近似句是 `WorkspaceUnknownSessionError`（`hold` 无 `s`），不会误伤。 */
+const NO_SUCH_SESSION = "session persistence holds no such session";
+/** 只认上面那一句；其余（含非 Error 抛出物）一律**不算未命中**。 */
+function isUnknownSession(error) {
+	return error instanceof Error && error.message.includes(NO_SUCH_SESSION);
+}
+/** 宿主会话表的一次取数（`ctx.sessionController.list()` 的两种返回形状都折成数组）。
+*  服务没挂 / 形状不对 / 抛错 ⇒ 空表——**这条不替宿主兜错误**：调用方拿空表的语义都是"少发一条通告"，
+*  不是"恢复失败"。 */
+async function controllerItems(host) {
+	try {
+		const controller = host.get("sessionController");
+		if (controller === void 0 || controller === null || typeof controller.list !== "function") return [];
+		const listed = await controller.list();
+		const items = Array.isArray(listed) ? listed : listed?.items;
+		return Array.isArray(items) ? items.map((item) => item) : [];
+	} catch {
+		return [];
+	}
+}
+/** 账本里没有那个工作区时 {@link HostPort.attach} / {@link HostPort.detach} 抛的原话开头。
+*  **原话与判据同住这里**：抛它的是这个端口，认它的也是端口给的那句，调用方不许另抄一份字符串。 */
+const WORKSPACE_MISSING_MESSAGE = "workspace not found";
+/** 这次失败是不是"账本里没那个工作区"（而不是另有故障）。恢复侧靠它把两种失败分开：
+*  前者按「未分组」收，后者照旧回滚报 `io`——不给真故障静默改归属的机会。 */
+function isWorkspaceMissingError(error) {
+	return error instanceof Error && error.message.startsWith(WORKSPACE_MISSING_MESSAGE);
 }
-//#endregion
-//#region src/verbs/purge-trash.ts
-/**
-* 彻底删除：从回收站里**真的**抹掉一条（或整组、或整站），并连带那些"还留在盘上、没被带走"的后代。
-*
-* 与另外两个动词的关系（ADR-0002）：它的 interface 是"这一组目标 + 一份只读清册快照
-*（targets 缺席 = 清空）"；目标由 `verbs/batch-carried.ts` 按组语义算好，批量的"已被同批前一条
-* 带走"判据不在这里。`requestedId` 是唯一的例外参数，但它**不参与任何判据**：只是让
-* `trash-empty` 的原文点得出用户点的是哪一条（原文要上屏，点名承重），批量语义仍在批量层。
-*
-* **这条动词只做两件事：拿目标、把计划交给执行器**。量目录、筛盘上后代、活体准入与"先退归档集、
-* 再摘账本、最后删目录"的顺序都住 `verbs/permanent-removal.ts`——计划只读，执行器只写，计划就是
-* 执行前的闸（别在这里再长出一段手写步骤）。
-*
-* **这条动词不做回滚**：目录删掉就没有"退回去"这回事（删到一半失败时已删目录不回滚；
-* 带部分计数的 `details` 回执只属于 `orphan-clean`，purge 的 `removed` / `freedBytes` 仍只在成功回执里给）。
-* 对应地，`kind:'trash'` 的计划失败时执行器只抛那一步的 `io` 与原文、不带 details。
-*
-* 回执里的 `attachments` 原样来自执行器：独占图片在会话目录删完之后才清，附件失败只计数、不改
-* `removed` / `freedBytes`（`skipped` = 有候选或剩余引用源读不出、这一轮部分或整体没清，原因上屏）。
-*/
-function purgeTrash(deps) {
-	return async function purgeTrash(targets, rows, requestedId) {
-		const selected = targets ?? rows;
-		if (targets !== void 0 && selected.length === 0) throw trashEmpty(requestedId);
-		return await executeRemoval(deps, await planTrashRemoval(deps, rows, selected));
+/** 宿主服务的真实绑定；出错原样抛，由 `toRemoteFailure` 按 name 映射。
+*  各方法调用的服务与方法见上方成员注释；错误映射表住 `src/remote/map-error.ts`。 */
+function createHostPort(ctx) {
+	const host = ctx;
+	const registry = host.workspaceRegistry;
+	const agentHandles = captureAgentHandles(host);
+	return {
+		/** 账本里记着这个会话的工作区：`registry.list()` 的实体 `sessionIds`（该 getter 已按 canonical cwd 过滤过）。 */
+		async workspaceOf(sessionId) {
+			return registry.list().find((workspace) => workspace.sessionIds.includes(sessionId))?.id;
+		},
+		/** 账本里还有这个工作区吗：`registry.get(id)` 是 `this.entities.get(id)` 的直通（同步 Map 查找），
+		*  未知 id 回 `undefined` ⇒ 这里只做一次判别，不抛。 */
+		async workspaceExists(workspaceId) {
+			return registry.get(workspaceId) !== void 0;
+		},
+		/**
+		* cwd → 宿主项目目录名；没有 cwd 落到 `_no-cwd`。
+		* 账本里没有这个会话回 `undefined`（未命中，不是故障）；真存储故障照抛。
+		* 未命中由 `delete-session.ts` 折成 `not-found`，真故障留 `io`——两者不能混。
+		*/
+		async projectDirOf(sessionId) {
+			let header;
+			try {
+				header = await registry.readSessionHeader(sessionId);
+			} catch (error) {
+				if (isUnknownSession(error)) return void 0;
+				throw error;
+			}
+			return header.cwd === void 0 ? NO_CWD_PROJECT_DIR : projectKey(header.cwd);
+		},
+		/** 标题走宿主投影缓存；尽力取，取不到返回空串，绝不因此让删除失败。 */
+		async titleOf(sessionId) {
+			try {
+				const header = await registry.readSessionHeader(sessionId);
+				const cache = projectionCacheOf(host);
+				const title = (cache?.cachedSnapshot(header, ["title"]) ?? cache?.cachedPredecessorTitle(header))?.values.title;
+				return typeof title === "string" ? title : "";
+			} catch {
+				return "";
+			}
+		},
+		/** 活跃判据走宿主 `workspace/session-activity` waterfall：空数组 = 无活动；
+		*  与宿主 archiveSession 的准入同源。 */
+		async isLive(sessionId) {
+			return (await host.waterfall("workspace/session-activity", { sessionId }, () => Promise.resolve([]))).length > 0;
+		},
+		/** registry 全局归档集（数组，`state.archivedSessionIds`）。 */
+		async isArchived(sessionId) {
+			return registry.archivedSessionIds.includes(sessionId);
+		},
+		/**
+		* 从 `ctx.sessions` 摘掉会话，并关闭捕获到的 agent handle。
+		*
+		* 会话列表 = 磁盘持久化 ∪ 内存活体，搬走文件只清掉一侧；宿主 `SessionController` 会丢掉
+		* `AgentHandle`，所以 `agent-handles.ts` 按会话 id 留住 handle，这里先 detach 再 dispose。
+		* 捕获不到 handle（插件激活前已启动，或 `ctx.agents` 形状变化）时只能摘 session，这是已知限制，
+		* 不拿归档兜底（ADR-0008）。
+		*
+		* 三态：读不到 store / 形状不符 / detach 或 dispose 抛 ⇒ `unknown`（不通告）；
+		* 内存里本来没有 ⇒ `not-live`；摘成功 ⇒ `evicted`。任何一步都不抛。
+		*/
+		async evictLive(sessionId) {
+			try {
+				const store = liveSessionsOf(host);
+				const session = store?.get(sessionId);
+				if (store === void 0) return "unknown";
+				if (session === void 0 || session === null) {
+					await agentHandles.dispose(sessionId);
+					return "not-live";
+				}
+				const entry = store.liveEntryFor(session);
+				if (entry === void 0 || entry === null || typeof entry.detach !== "function") return "unknown";
+				entry.detach();
+				await agentHandles.dispose(sessionId);
+				return "evicted";
+			} catch {
+				return "unknown";
+			}
+		},
+		/**
+		* 通告客户端这个会话没了：发宿主自己转发的 `api-session/removed`，客户端当场删行。
+		* 冷会话没有 `session/disposed`，不发这条就只能等重连。
+		* 只在宿主列表确实已不含它时调用（调用方按 {@link EvictionOutcome} 判）；不发假通告。
+		*/
+		async announceRemoved(sessionId) {
+			try {
+				host.emit("api-session/removed", sessionId);
+			} catch {}
+		},
+		/**
+		* 通告这组会话回来了：拉一次宿主会话表，按 id 逐条发 `api-session/added`。
+		* 摘要直接用宿主 `sessionController.list()` 的形状；取不到就不发。
+		* 批量只预取一次，避免按条全表扫。
+		*/
+		async announceRestored(sessionIds) {
+			if (sessionIds.length === 0) return;
+			const summaries = [];
+			for (const item of await controllerItems(host)) {
+				const sessionId = item?.sessionId;
+				if (typeof sessionId === "string") summaries.push({
+					sessionId,
+					summary: item
+				});
+			}
+			for (const id of sessionIds) {
+				const summary = summaries.find((item) => item.sessionId === id)?.summary;
+				if (summary === void 0) continue;
+				try {
+					host.emit("api-session/added", JSON.parse(JSON.stringify(summary)));
+				} catch {}
+			}
+		},
+		/** 官方 `unarchiveSession(sessionId)`：未归档是幂等 no-op。 */
+		async unarchive(sessionId) {
+			await registry.unarchiveSession(sessionId);
+		},
+		/** 摘账本：实体方法 `detachSession`（顶层没有）；未知工作区**响亮失败**，不静默当成功。 */
+		async detach(sessionId, workspaceId) {
+			const workspace = registry.get(workspaceId);
+			if (workspace === void 0) throw new Error(`${WORKSPACE_MISSING_MESSAGE} (detach): ${workspaceId}`);
+			await workspace.detachSession(sessionId);
+		},
+		/** 挂账本：实体方法 `attachSession`（顶层没有）。 */
+		async attach(sessionId, workspaceId) {
+			const workspace = registry.get(workspaceId);
+			if (workspace === void 0) throw new Error(`${WORKSPACE_MISSING_MESSAGE} (attach): ${workspaceId}`);
+			await workspace.attachSession(sessionId);
+		},
+		/** 确保归档：官方 `archiveSession(sessionId)`。归档是 registry **全局**的，与工作区账目无关
+		*  （JSDoc 原文 "its workspace accounting — or lack of one — is irrelevant"）⇒ 没有工作区入参，
+		*  调用方也不许再传（传了就是暗示一个从不生效的作用域）。
+		*  不带 `stopActivity` ⇒ 有活动即抛 `WorkspaceActiveSessionError`（→ `sessiondelete/live`，src/shared/wire.ts）。 */
+		async archive(sessionId) {
+			await registry.archiveSession(sessionId);
+		},
+		async listSessions() {
+			const sessionQuery = host.get("sessionQuery");
+			if (typeof sessionQuery?.listSessions !== "function") return { available: false };
+			const records = await sessionQuery.listSessions();
+			const out = [];
+			for (const record of records) {
+				const id = record.header?.id;
+				if (typeof id !== "string" || id === "") continue;
+				const parent = record.header?.parentSession;
+				const cwd = record.header?.cwd;
+				out.push({
+					sessionId: id,
+					...typeof parent === "string" && parent !== "" ? { parentSessionId: parent } : {},
+					projectDir: cwd === void 0 ? NO_CWD_PROJECT_DIR : projectKey(cwd),
+					subagent: record.header?.origin === "subagent"
+				});
+			}
+			return {
+				available: true,
+				value: out
+			};
+		},
+		/**
+		* 官方 `sessionQuery.filterSessions([{kind:'parent', values}])`，不自扫 `~/.dsh/sessions`。
+		* 数传递闭包（孩子与孙代），不是直接孩子；`session-` 前缀两边都去掉再比，
+		* 按调用方给的写法回键。`sessionQuery` 缺席或方法缺失 ⇒ `{available:false}`，
+		* 不拿空表冒充“没有后代”；服务在场时空入参零宿主调用。
+		*/
+		async subagentMembersOf(parentIds) {
+			const sessionQuery = host.get("sessionQuery");
+			if (typeof sessionQuery?.filterSessions !== "function") return { available: false };
+			return {
+				available: true,
+				value: await membersFor(sessionQuery, parentIds)
+			};
+		}
 	};
 }
 //#endregion
@@ -2416,7 +2490,7 @@ async function memberRestore(deps, presence, entry) {
 			run: async () => {
 				await deps.host.unarchive(entry.sessionId);
 			},
-			undo: () => stepUndo("重新归档失败", () => deps.host.archive(entry.sessionId, workspaceId))
+			undo: () => stepUndo("重新归档失败", () => deps.host.archive(entry.sessionId))
 		}],
 		{
 			key: "manifest",
@@ -2435,6 +2509,43 @@ async function memberRestore(deps, presence, entry) {
 	}) };
 }
 //#endregion
+//#region src/verbs/trash-scope.ts
+function createTrashScope(deps, rows) {
+	const original = rows;
+	let current = [...rows];
+	/** 拿目标、把计划交给执行器：`targets` 缺席（`undefined`）= 清空。计划只读——活体准入在**一切写
+	*  之前**（任一在跑就整条拒绝、零副作用）。盘上后代按**当前视图里还在的 id** 排除（跟着父进来的
+	*  孩子不按"盘上残留"再删一遍）；`sessionQuery` 缺席时端口回 `{ available: false }` ⇒ 这次只清
+	*  清册里的那部分，盘上残留留给 `GET /orphans` 兜底（与 delete 的降级一致，不折成失败）。 */
+	async function purgeGroup(targets, requestedId) {
+		const selected = targets ?? current;
+		if (targets !== void 0 && selected.length === 0) throw trashEmpty(requestedId);
+		return await executeRemoval(deps, await planTrashRemoval(deps, current, selected));
+	}
+	/** 收缩是内部闭包、不外露：唯一的观察面是后续 `purge` / `purgeAll` / `orphanGroups` 看见的当前视图。 */
+	const take = (id) => {
+		current = withoutGroup(current, id);
+	};
+	return {
+		purge: async (id) => {
+			const claim = claimOf(original, current, id);
+			if (claim.verdict === "carried") return {
+				removed: 0,
+				freedBytes: 0
+			};
+			const stats = await purgeGroup(claim.verdict === "fresh" ? claim.group : [], id);
+			take(id);
+			return stats;
+		},
+		purgeAll: async () => {
+			const stats = await purgeGroup(void 0);
+			current = [];
+			return stats;
+		},
+		orphanGroups: (roots) => loadOrphanGroups(deps, current, roots)
+	};
+}
+//#endregion
 //#region src/verbs/batch.ts
 /**
 * 「这一批」的唯一实现（ADR-0002）：POST /apply 的落点——一组 id 上的同一个动作。
@@ -2445,7 +2556,8 @@ async function memberRestore(deps, presence, entry) {
 * - 恢复通告攒到批尾，一次 announceRestored(ids)。
 *
 * 「已被同批前一条带走」是幂等成功（delete/restore 回 null，purge 回 0），不是失败；
-* 判据在 trash/groups.ts，同批已带走集在 batch-carried.ts。
+* 判据在 trash/groups.ts，同批已带走集：delete / restore 在 batch-carried.ts，purge 的那份连同
+* 收缩视图住 trash-scope.ts（清册作用域）。
 */
 function failure(id, action, error) {
 	return {
@@ -2498,8 +2610,8 @@ async function applyDelete(deps, ids) {
 		return entry;
 	});
 }
-/** 「这条是不是被同批前一条带走了」与视图收缩都归 `batch-carried.ts`；`apply` 整批只读一次清册，
-*  动词只拿它交回的只读组与当前清册。 */
+/** restore 的「这条是不是被同批前一条带走了」与视图收缩都归 `batch-carried.ts`（purge 那一半归
+*  `trash-scope.ts`）；`apply` 整批只读一次清册，动词只拿它交回的只读组与当前清册。 */
 async function applyRestore(deps, ids) {
 	const carried = createEntryCarried(await deps.ledger.list());
 	const run = restoreSession(deps);
@@ -2516,20 +2628,12 @@ async function applyRestore(deps, ids) {
 	if (restored.length > 0) await deps.presence.announceRestored(restored);
 	return outcomes;
 }
+/** purge 的整批语义收进清册作用域：选组、收缩视图、同批带走的幂等（回 0）与 absent 的
+*  trash-empty（原文点名）都在 `scope.purge(id)` 里——这里整批只读一次清册、逐 id 只交一个 id，
+*  两份数组（算好的组 + 收缩中的视图）不再从批量层递两遍。 */
 async function applyPurge(deps, ids) {
-	const carried = createEntryCarried(await deps.ledger.list());
-	const run = purgeTrash(deps);
-	return forEachId("purge", ids, async (entryId) => {
-		const claim = carried.claim(entryId);
-		if (claim.verdict === "carried") return {
-			removed: 0,
-			freedBytes: 0
-		};
-		const group = claim.verdict === "fresh" ? claim.group : [];
-		const stats = await run(group, carried.rows(), entryId);
-		carried.take(entryId);
-		return stats;
-	});
+	const scope = createTrashScope(deps, await deps.ledger.list());
+	return forEachId("purge", ids, (entryId) => scope.purge(entryId));
 }
 /** 删除确认框那句「含 N 个子会话」：一次问完整批（`subagentMembersOf` 本来就是批量口）。
 *  宿主口缺席（`available:false`）时按 0（这里不再有"空表"这一步）；真读失败则整次调用失败，
@@ -2551,7 +2655,7 @@ async function applyCount(deps, ids) {
 * 点过的决定（那种组该跟着父恢复或彻底删除）。
 */
 async function applyOrphanClean(deps, ids) {
-	const groups = await loadOrphanGroups(deps, await deps.ledger.list());
+	const groups = await createTrashScope(deps, await deps.ledger.list()).orphanGroups(ids);
 	const byRoot = new Map(groups.map((group) => [bareSessionId(group.root.sessionId), group]));
 	return forEachId("orphan-clean", ids, async (id) => {
 		const group = byRoot.get(bareSessionId(id));
@@ -2571,38 +2675,42 @@ function applyActions(deps, action, ids) {
 //#endregion
 //#region src/trash/detail.ts
 /**
-* 回收站**单条详情**：从回收站目录里那条会话自己的日志读出元信息与正文（用例见 `tests/trash-detail.test.ts`）。
+* 回收站**单条详情**：从回收站目录里那条会话自己的日志读出元信息与正文块（用例见 `tests/trash-detail.test.ts`）。
 *
 * 三层里的策略层——编解码在 `src/log/*`，这里只回答"给谁看、给多少、算不算失败"。
 *
-* 三条硬口径，都不是口味：
+* 四条硬口径，都不是口味：
 * ① **寻址只认清册（raw 索引）**：`entryId` 先在对账之外的 raw 索引里查，目录一律由 `trashDirOf(record.id, home)` 推
 *    ⇒ 外部输入进不了文件系统寻址（不给"传个路径就读任意目录"留缝）。
-* ② **正文只认 `source.kind === "user"`**：`user/message` 里绝大多数是宿主注入的上下文
-*    （本机实测一条会话：真实提问 21 条、注入 241 条），不过滤就被淹掉；注入条数照样上线
-*    （`injectedCount`），让"为什么少了这么多条"能与页面上的数字对账。
-* ③ **两个闸是载荷闸，不是读盘闸**：每条 3 000 字符、累计 50 万字符（CJK 最坏 ≈ 1.5 MB UTF-8）。
-*    本机存量一条都触发不了（量级随盘上会话数摆动，不在这里钉数）⇒ 它们是防异常
-*    膨胀的；**不设"文件太大就拒绝"**，那种阈值只会把真读得出来的正文挡在外面。
-*
-* 计数与正文**同源过滤、各过各的闸**：`user/message` 先要求 `source.kind === 'user'`，两类都过"空文本**且**
-* 无附件"过滤；`userMessageCount` / `assistantMessageCount` 数的是通过过滤的条数，**不受载荷闸影响**。正文再受
-* 单条/累计两个闸：单条超限截断并把那一条标成 `truncated`，累计到上限后剩下的整条不再收、只累进
-* `omittedByPayloadCap`——所以计数可以大于正文条数，详情里两件事分开说。
-* 附件随消息一起收（`attachmentsInContent`），也有两个闸：每条 20、总量 200；超出的**静默丢**，
-* 不累进 `omittedByPayloadCap`——那个计数说的是"整条正文没进来"，拿它兼报少了几张附件会让两个数都对不上。
-*/
-/** 每条文字的上限（字符）。超出即截断并置 `truncated`。 */
-const PER_MESSAGE_CHAR_CAP = 3e3;
-/** 一次回信的正文总量上限（字符）。 */
-const TOTAL_CHAR_CAP = 5e5;
-/** 一条消息带多少张附件上线。 */
-const MAX_ATTACHMENTS_PER_MESSAGE = 20;
-/** 一次回信的附件总量上限。 */
-const MAX_ATTACHMENTS_TOTAL = 200;
+* ② **正文是块，不是消息**：`user/message` 按 `source.kind` 拆成 user / injection；`assistant/message.content`
+*    按 `text` / `reasoning` 拆块，附件并进相邻的文字块；`tool/call` 建工具块、`tool/result` 按 `callId` 回填；
+*    `system/message` 与 `compaction/summary` 各成一块。turn/step/job/request 这类簿记事件不进正文——它们不是
+*    "用户想看的对话"，铺进来只会把真正的提问和回复淹掉。
+* ③ **分页是游标，不是总量闸**：一次只回尾部一页，`olderCursor` 指页首；客户端把游标原样回传取更早一页。
+*    页有两道闸：块数 `pageBlocks` 与正文总量 `pageChars`（单块超字符闸仍保留一块，游标才能前进）；
+*    每块另有 `perBlockChars` 的单块闸（正文与工具参数/结果各自算），超了标 `truncated`。
+*    构建时用**有界缓冲只留当前页**，不把整条日志的正文堆在内存里；工具结果可能落在游标之后，
+*    仍会回填到页内那个调用块（别把"已完成"误报成"未完成"）。
+* ④ **计数与正文同源过滤、各过各的闸**：`userMessageCount` / `injectedCount` 只数建了块的；`assistantMessageCount`
+*    数**每一条** assistant/message（含只带 reasoning / tool-call 的）；`toolCallCount` 数每一条 tool/call。
+*    计数是整条日志的，不受分页与任何字符闸影响。
+*
+* 附件随块一起收（`attachmentsInContent`）：每块最多 20、每页最多 200；超出的**静默丢**，不另立计数——
+* "少了几张图"与"这块被截断"不是同一件事，拿一个数兼报会让两个数都对不上。
+*/
+/** 每块文字的上限（字符）。正文、工具参数、工具结果各自吃这一刀。 */
+const PER_BLOCK_CHAR_CAP = 16e3;
+/** 一页正文的总字符上限（块按日志顺序累计；单块超闸时仍保留一块）。 */
+const PAGE_CHAR_LIMIT = 5e5;
+/** 一块最多带多少张附件上线。 */
+const MAX_ATTACHMENTS_PER_BLOCK = 20;
+/** 一页最多带多少张附件上线。 */
+const MAX_ATTACHMENTS_PER_PAGE = 200;
 const DEFAULT_LIMITS = {
-	perMessageChars: PER_MESSAGE_CHAR_CAP,
-	totalChars: TOTAL_CHAR_CAP
+	perBlockChars: PER_BLOCK_CHAR_CAP,
+	pageBlocks: 30,
+	pageChars: PAGE_CHAR_LIMIT,
+	subagents: 200
 };
 /** 一条记录里那些 `content[]` 段的文字拼起来（`\n` 分隔；非 text 段一律不参与）。 */
 function textOf(content) {
@@ -2621,9 +2729,195 @@ function attachmentWires(content) {
 		...ref.kind === "image" && ref.height !== void 0 ? { height: ref.height } : {}
 	}));
 }
+/** 单块闸：超过上限就截一刀并置标记。 */
+function clip(text, cap) {
+	return text.length > cap ? {
+		text: text.slice(0, cap),
+		truncated: true
+	} : {
+		text,
+		truncated: false
+	};
+}
+/** 「这块有没有内容」的**唯一判据**：非空正文或至少一个附件。建块（`blockBody`）与出线收尾
+*  （`PageBuilder.finish` 的附件总量闸之后）都认这一支——判据写两遍就是两份会漂移的抄本，
+*  渲染侧因此不必、也不许再兜空块。 */
+function hasContent(text, attachments) {
+	return text !== "" || attachments.length > 0;
+}
+/** 一块的正文：没内容 ⇒ 这块不建；否则过单块闸截一刀。 */
+function blockBody(rawText, attachments, cap) {
+	const text = rawText.trim();
+	const kept = attachments.slice(0, MAX_ATTACHMENTS_PER_BLOCK);
+	if (!hasContent(text, kept)) return void 0;
+	const clipped = clip(text, cap);
+	return {
+		text: clipped.text,
+		truncated: clipped.truncated,
+		attachments: kept
+	};
+}
+function textBlock(kind, time, rawText, attachments, cap) {
+	const body = blockBody(rawText, attachments, cap);
+	return body === void 0 ? void 0 : {
+		kind,
+		id: "",
+		time,
+		...body
+	};
+}
+function injectionBlock(time, sourceKind, rawText, attachments, cap) {
+	const body = blockBody(rawText, attachments, cap);
+	return body === void 0 ? void 0 : {
+		kind: "injection",
+		id: "",
+		time,
+		sourceKind,
+		...body
+	};
+}
+/** 一块在页级字符闸里占多少字符：正文与工具参数/结果都算；截断标记与附件元数据不计。 */
+function blockChars(block) {
+	switch (block.kind) {
+		case "tool": return block.args.length + block.result.length;
+		case "user":
+		case "assistant":
+		case "reasoning":
+		case "injection":
+		case "system":
+		case "compaction": return block.text.length;
+		default: return unhandledChars(block);
+	}
+}
+/** 新块类型没登记字符口径时编译失败；运行时（前后半版本错配）按 0 计。 */
+function unhandledChars(block) {
+	return 0;
+}
+/**
+* 一页的有界缓冲：只留游标之前**最后** `pageBlocks` 块，且正文总量不超过 `pageChars`。
+*
+* `nextIndex` 数的是整条日志的块序（包括游标之后的块），`buffer` 只装本页。工具结果可能落在
+* 游标之后：`toolByCallId` 让它在页内那个调用块上回填。
+*
+* 配对认的是**块对象**，不是 callId 这一格：宿主重试会让同一个 callId 建出两块，按 callId 摘映射
+* 会把仍然在页内的另一块误摘成「未完成」——ADR-0026 决定 3 明令不许。所以每个 callId 挂一串页内
+* 块（按日志顺序），挤出谁就摘谁。本机回收站与 live 日志实测：callId 与结果一比一、无重复、无逆序，
+* 这一串常态只有一个元素；串与下面的配法是给非常态兜底的。
+*/
+var PageBuilder = class PageBuilder {
+	buffer = [];
+	toolByCallId = /* @__PURE__ */ new Map();
+	nextIndex = 0;
+	chars = 0;
+	/** `end` 是本页的右边界（不含）：块序号大于等于它的不入页；`Infinity` = 从尾部取。 */
+	end;
+	limit;
+	cap;
+	pageChars;
+	constructor(end, limit, cap, pageChars) {
+		this.end = end;
+		this.limit = limit;
+		this.cap = cap;
+		this.pageChars = pageChars;
+	}
+	/** 追加一块：id 用整条日志的块序号盖，页内只留最后 `limit` 块 / `pageChars` 字符。 */
+	add(block) {
+		const index = this.nextIndex++;
+		if (index >= this.end) return;
+		block.id = String(index);
+		const chars = blockChars(block);
+		this.buffer.push({
+			index,
+			block,
+			chars
+		});
+		this.chars += chars;
+		this.trim();
+		if (block.kind === "tool") this.hook(block);
+	}
+	/** 挤出页首：块数超限，或正文超字符闸（但至少留一块，游标才能前进）。 */
+	trim() {
+		while (this.buffer.length > this.limit || this.buffer.length > 1 && this.chars > this.pageChars) {
+			const evicted = this.buffer.shift();
+			if (evicted === void 0) return;
+			this.chars -= evicted.chars;
+			if (evicted.block.kind === "tool") this.unhook(evicted.block);
+		}
+	}
+	/** 没带 callId 的调用块无从配对：照常入页（界面念「未完成」），只是不进配对串。 */
+	static pairable(block) {
+		return block.callId !== "";
+	}
+	hook(block) {
+		if (!PageBuilder.pairable(block)) return;
+		const queued = this.toolByCallId.get(block.callId);
+		if (queued === void 0) this.toolByCallId.set(block.callId, [block]);
+		else queued.push(block);
+	}
+	/** 挤出页的块从它的配对串里按对象摘掉；串空了连 key 一起摘，不留空串。 */
+	unhook(block) {
+		if (!PageBuilder.pairable(block)) return;
+		const queued = this.toolByCallId.get(block.callId);
+		if (queued === void 0) return;
+		const at = queued.indexOf(block);
+		if (at < 0) return;
+		if (queued.length === 1) this.toolByCallId.delete(block.callId);
+		else queued.splice(at, 1);
+	}
+	/**
+	* `tool/result` 回填：配给这一串里**最早那还没有结果**的调用块（同一个 callId 出两块时，结果按
+	* 到达顺序配给先出的调用，两块各留一个读数）。
+	*
+	* 两种情况落不了点，都不改写已经配上结果的块：调用块在更早的页里（那一页自己走一趟时配上）；
+	* 结果条数多过页内待配的调用块（一次调用一个读数，后到的不覆盖先配上的）。口径见
+	* `tests/trash-detail.test.ts` 的工具配对那几例。
+	*
+	* 落不了点就丢，不缓存：日志按时间落盘、结果恒在它的调用之后，逆序时这条结果无家可归、块停在
+	* 未完成——为它把游标之后的结果正文留在手里，就拆掉了「只留当前页」这个内存界（ADR-0026 决定 3）。
+	*
+	* 同一 callId 的前一块已被挤出页时，结果会配给页内后一块，后一块自己的结果随之落空：宿主重试
+	* 造出的双块没有可区分的结果序，宁可配对错位也不把仍在页内的块报成「未完成」。这是非常态兜底的
+	* 代价，不另开缓存去修（那会重新把游标之后的正文留在手里）。
+	*
+	* 回填的正文也要计入页级字符闸：超了就挤页首，被挤掉的调用块会随更早一页重新走一遍日志、
+	* 在那一页里配上同一个结果，不会丢成「未完成」。
+	*/
+	result(callId, rawResult, isError, attachments) {
+		const queued = this.toolByCallId.get(callId);
+		if (queued === void 0) return;
+		const block = queued.find((candidate) => candidate.status === "unfinished");
+		if (block === void 0) return;
+		const clipped = clip(rawResult.trim(), this.cap);
+		block.result = clipped.text;
+		block.resultTruncated = clipped.truncated;
+		block.status = isError ? "error" : "ok";
+		block.attachments = attachments.slice(0, MAX_ATTACHMENTS_PER_BLOCK);
+		const entry = this.buffer.find((candidate) => candidate.block === block);
+		if (entry !== void 0) {
+			const chars = blockChars(block);
+			this.chars += chars - entry.chars;
+			entry.chars = chars;
+			this.trim();
+		}
+	}
+	finish() {
+		let used = 0;
+		for (const { block } of this.buffer) {
+			const room = Math.max(0, Math.min(block.attachments.length, MAX_ATTACHMENTS_PER_PAGE - used));
+			block.attachments = block.attachments.slice(0, room);
+			used += room;
+		}
+		const first = this.buffer[0];
+		return {
+			blocks: this.buffer.map(({ block }) => block).filter((block) => block.kind === "tool" || hasContent(block.text, block.attachments)),
+			olderCursor: first !== void 0 && first.index > 0 ? first.index : null
+		};
+	}
+};
 function readTrashDetail(deps, limits = DEFAULT_LIMITS) {
-	return async function readTrashDetail(entryId) {
-		const record = (await deps.rows()).find((e) => e.id === entryId);
+	return async function readTrashDetail(entryId, before) {
+		const all = await deps.rows();
+		const record = all.find((e) => e.id === entryId);
 		if (record === void 0) throw trashEmpty(entryId);
 		const dir = trashDirOf(record.id, deps.home);
 		if (!await deps.fs.exists(dir)) throw verbError("io", `回收站目录不在：${dir}`);
@@ -2648,42 +2942,16 @@ function readTrashDetail(deps, limits = DEFAULT_LIMITS) {
 			assistantMessageCount: 0,
 			toolCallCount: 0,
 			injectedCount: 0,
-			messages: [],
-			omittedByPayloadCap: 0
+			blocks: [],
+			olderCursor: null
 		};
 		const models = /* @__PURE__ */ new Set();
-		let usedChars = 0;
-		let usedAttachments = 0;
-		let capped = false;
-		/** 收进正文，顺带管两个闸：截到单条上限，累计到总量就停；附件另有 20/200 两道闸。 */
-		function push(role, time, text, attachments) {
-			if (capped) {
-				detail.omittedByPayloadCap += 1;
-				return;
-			}
-			const truncated = text.length > limits.perMessageChars;
-			const kept = truncated ? text.slice(0, limits.perMessageChars) : text;
-			if (usedChars + kept.length > limits.totalChars) {
-				capped = true;
-				detail.omittedByPayloadCap += 1;
-				return;
-			}
-			usedChars += kept.length;
-			const room = Math.max(0, Math.min(MAX_ATTACHMENTS_PER_MESSAGE, MAX_ATTACHMENTS_TOTAL - usedAttachments));
-			const keptAttachments = attachments.slice(0, room);
-			usedAttachments += keptAttachments.length;
-			detail.messages.push({
-				role,
-				time,
-				text: kept,
-				truncated,
-				attachments: keptAttachments
-			});
-		}
+		const page = new PageBuilder(before ?? Number.POSITIVE_INFINITY, Math.max(1, limits.pageBlocks), limits.perBlockChars, Math.max(1, limits.pageChars ?? 5e5));
 		try {
 			walkSessionLog(raw, (r) => {
 				if (typeof r.time === "number" && r.time > detail.lastActivity) detail.lastActivity = r.time;
 				const data = r.data ?? {};
+				const time = r.time ?? 0;
 				switch (r.type) {
 					case "session":
 						if (typeof r.cwd === "string") detail.cwd = r.cwd;
@@ -2695,30 +2963,95 @@ function readTrashDetail(deps, limits = DEFAULT_LIMITS) {
 					case "turn/start":
 						detail.turnCount += 1;
 						return;
-					case "tool/call":
-						detail.toolCallCount += 1;
-						return;
 					case "user/message": {
-						if ((data.source ?? {}).kind !== "user") {
-							detail.injectedCount += 1;
-							return;
-						}
+						const source = data.source ?? {};
+						const sourceKind = typeof source.kind === "string" ? source.kind : "";
 						const text = textOf(data.content);
 						const attachments = attachmentWires(data.content);
-						if (text === "" && attachments.length === 0) return;
-						detail.userMessageCount += 1;
-						push("user", r.time ?? 0, text, attachments);
+						if (sourceKind === "user") {
+							const block = textBlock("user", time, text, attachments, limits.perBlockChars);
+							if (block !== void 0) {
+								detail.userMessageCount += 1;
+								page.add(block);
+							}
+							return;
+						}
+						const block = injectionBlock(time, sourceKind, text, attachments, limits.perBlockChars);
+						if (block !== void 0) {
+							detail.injectedCount += 1;
+							page.add(block);
+						}
 						return;
 					}
 					case "assistant/message": {
+						detail.assistantMessageCount += 1;
 						const message = data.message ?? {};
 						const source = message.source ?? {};
 						if (typeof source.model === "string") models.add(source.model);
-						const text = textOf(message.content);
-						const attachments = attachmentWires(message.content);
-						if (text === "" && attachments.length === 0) return;
-						detail.assistantMessageCount += 1;
-						push("assistant", r.time ?? 0, text, attachments);
+						const parts = Array.isArray(message.content) ? message.content : [];
+						let pendingText = [];
+						let pendingAttachments = [];
+						const flush = () => {
+							const block = textBlock("assistant", time, pendingText.join("\n"), pendingAttachments, limits.perBlockChars);
+							if (block !== void 0) page.add(block);
+							pendingText = [];
+							pendingAttachments = [];
+						};
+						for (const part of parts) {
+							if (part?.type === "text" && typeof part.text === "string") {
+								pendingText.push(part.text);
+								continue;
+							}
+							if (part?.type === "reasoning" && typeof part.text === "string") {
+								flush();
+								const block = textBlock("reasoning", time, part.text, [], limits.perBlockChars);
+								if (block !== void 0) page.add(block);
+								continue;
+							}
+							if (part?.type === "image" || part?.type === "file") {
+								pendingAttachments.push(...attachmentWires([part]));
+								continue;
+							}
+						}
+						flush();
+						return;
+					}
+					case "tool/call": {
+						detail.toolCallCount += 1;
+						const callId = typeof data.callId === "string" ? data.callId : "";
+						const name = typeof data.name === "string" ? data.name : "";
+						const args = clip(typeof data.arguments === "string" ? data.arguments : "", limits.perBlockChars);
+						page.add({
+							kind: "tool",
+							id: "",
+							time,
+							callId,
+							name,
+							status: "unfinished",
+							args: args.text,
+							argsTruncated: args.truncated,
+							result: "",
+							resultTruncated: false,
+							attachments: []
+						});
+						return;
+					}
+					case "tool/result": {
+						const message = data.message ?? {};
+						const callId = typeof message.toolCallId === "string" ? message.toolCallId : "";
+						if (callId === "") return;
+						page.result(callId, textOf(message.content), message.isError === true, attachmentWires(message.content));
+						return;
+					}
+					case "system/message": {
+						const message = data.message ?? {};
+						const block = textBlock("system", time, textOf(message.content), attachmentWires(message.content), limits.perBlockChars);
+						if (block !== void 0) page.add(block);
+						return;
+					}
+					case "compaction/summary": {
+						const block = textBlock("compaction", time, textOf(data.summary), [], limits.perBlockChars);
+						if (block !== void 0) page.add(block);
 						return;
 					}
 					default: return;
@@ -2727,13 +3060,56 @@ function readTrashDetail(deps, limits = DEFAULT_LIMITS) {
 		} catch (error) {
 			throw verbError("io", error instanceof Error ? `读回收站日志失败：${error.message}` : `读回收站日志失败：${String(error)}`, error);
 		}
+		const finished = page.finish();
+		detail.blocks = finished.blocks;
+		detail.olderCursor = finished.olderCursor;
 		detail.models = [...models];
+		const kids = visibleGroups(all).find((group) => group.root.id === record.id)?.kids ?? [];
+		if (kids.length > 0) {
+			const limit = limits.subagents ?? 200;
+			detail.subagents = kids.slice(0, limit).map(entryWire);
+			if (kids.length > limit) detail.subagentsTotal = kids.length;
+		}
 		return detail;
 	};
 }
 //#endregion
+//#region src/ports/attachments-port.ts
+/** 服务在 `available()` 之后消失/形状变了：调用方可以退回直接 fs，而不是把这次读取判成 io。 */
+var AttachmentsUnavailableError = class extends Error {
+	constructor(message = "attachments service absent") {
+		super(message);
+		this.name = "AttachmentsUnavailableError";
+	}
+};
+/** 每次调用惰性解析服务：插件与 `attachments` 的激活顺序没有承诺。 */
+function createAttachmentsPort(ctx) {
+	const serviceOf = () => {
+		try {
+			const service = ctx.get("attachments");
+			if (service === void 0 || service === null) return void 0;
+			if (typeof service.readImage !== "function" || typeof service.readFileStream !== "function") return void 0;
+			return service;
+		} catch {
+			return;
+		}
+	};
+	return {
+		available: () => serviceOf() !== void 0,
+		async readImage(ref) {
+			const service = serviceOf();
+			if (service === void 0) throw new AttachmentsUnavailableError();
+			return await service.readImage(ref);
+		},
+		async *readFileStream(ref) {
+			const service = serviceOf();
+			if (service === void 0) throw new AttachmentsUnavailableError();
+			yield* service.readFileStream(ref);
+		}
+	};
+}
+//#endregion
 //#region src/api/attachment.ts
-const MAX_ATTACHMENT_BYTES = 20971520;
 const PNG_MAGIC = Buffer.from([
 	137,
 	80,
@@ -2744,6 +3120,21 @@ const PNG_MAGIC = Buffer.from([
 	26,
 	10
 ]);
+const IMAGE_MEDIA_TYPES = [
+	"image/png",
+	"image/jpeg",
+	"image/webp",
+	"image/gif"
+];
+function isImageMediaType(value) {
+	return value !== null && IMAGE_MEDIA_TYPES.includes(value);
+}
+/** 引用里的正整数字段（bytes / width / height）；缺、空、非整数、非正数都当"元数据不够"，退回直接 fs。 */
+function positiveInt(value) {
+	if (value === null || value === "") return void 0;
+	const parsed = Number(value);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
 /** 按魔数认图片类型；认不出回 `undefined`（调用方按未知字节处理，不猜）。 */
 function sniffImage(bytes) {
 	if (bytes.length >= PNG_MAGIC.length && bytes.subarray(0, PNG_MAGIC.length).equals(PNG_MAGIC)) return "image/png";
@@ -2758,62 +3149,185 @@ function sniffImage(bytes) {
 * 否则 `encodeURIComponent` 会在写头时抛）。
 */
 function safeFilename(name, fallback) {
-	const base = [...name === null || name === "" ? fallback : name].slice(0, 120).join("").replace(/[\\/:*?"<>|\u0000-\u001f\uD800-\uDFFF]/gu, "_").replace(/\.\./gu, "_");
+	const raw = name === null || name === void 0 || name === "" ? fallback : name;
+	const base = Array.from(raw).slice(0, 120).join("").replace(/[\\/:*?"<>|\u0000-\u001f\uD800-\uDFFF]/gu, "_").replace(/\.\./gu, "_");
 	return base === "" ? fallback : base;
 }
-async function readAttachmentResponse(deps, query) {
+/** 引用里的短 id：错误文案与下载名兜底共用，别让 `sha256:` 前缀的切片散在各处。 */
+function shortId(id) {
+	return id.slice(7, 19);
+}
+/** 普通文件的下载响应；图片认不出类型时也走这一支。 */
+function downloadResponse(body, filename) {
+	return {
+		body,
+		contentType: "application/octet-stream",
+		disposition: "attachment",
+		filename
+	};
+}
+/** 服务读取/校验失败按 io 上屏，不 fallback 直接 fs：宿主读 `files/.../<name>` 别名并做摘要/元数据
+*  校验，直接 fs 读 `file-objects/...` 对象；绕过会跳过宿主的校验（ADR-0035 边界）。 */
+function attachmentsIoError(id, error) {
+	throw verbError("io", `读取附件失败：${id}（${String(error)}）`, error);
+}
+/** 同一道上限：声明字节、磁盘字节、服务返回字节都从这里过。 */
+function assertWithinLimit(id, observed, maxBytes) {
+	if (observed > maxBytes) throw verbError("io", `附件超过 ${maxBytes} 字节上限：${id}（${observed} 字节）`);
+}
+/** 流式读超过上限：没有"实际总字节"，原文用 `>上限`。 */
+function streamOverflow(id, maxBytes) {
+	throw verbError("io", `附件超过 ${maxBytes} 字节上限：${id}（>${maxBytes} 字节）`);
+}
+/** 服务路径要的引用元数据；任一字段不够就回 `undefined`（调用方退回直接 fs，不拿半截 ref 去猜）。 */
+function imageServiceRef(id, query) {
+	const mediaType = query.get(PARAMS.attachmentMediaType);
+	const bytes = positiveInt(query.get(PARAMS.attachmentBytes));
+	const width = positiveInt(query.get(PARAMS.attachmentWidth));
+	const height = positiveInt(query.get(PARAMS.attachmentHeight));
+	if (!isImageMediaType(mediaType) || bytes === void 0 || width === void 0 || height === void 0) return void 0;
+	const name = query.get(PARAMS.attachmentName);
+	return {
+		attachmentId: id,
+		mediaType,
+		bytes,
+		width,
+		height,
+		...name === null || name === "" ? {} : { name }
+	};
+}
+function fileServiceRef(id, query) {
+	const bytes = positiveInt(query.get(PARAMS.attachmentBytes));
+	const name = query.get(PARAMS.attachmentName);
+	if (bytes === void 0 || name === null || name === "") return void 0;
+	return {
+		attachmentId: id,
+		name,
+		bytes
+	};
+}
+function parseServiceRef(id, kind, query) {
+	if (kind === "image") {
+		const ref = imageServiceRef(id, query);
+		return ref === void 0 ? void 0 : {
+			kind: "image",
+			ref
+		};
+	}
+	const ref = fileServiceRef(id, query);
+	return ref === void 0 ? void 0 : {
+		kind: "file",
+		ref
+	};
+}
+/** query 只解析一次：id/kind 的 400 闸与两套引用元数据都在这里收口。 */
+function parseAttachmentRequest(query) {
 	const id = query.get(PARAMS.attachmentId);
 	const kind = query.get(PARAMS.attachmentKind);
 	if (!isAttachmentId(id)) throw routeError("bad-request", 400, `附件 id 需为 sha256:<64 位小写 hex>：${String(id)}`);
 	if (kind !== "image" && kind !== "file") throw routeError("bad-request", 400, `附件 kind 只认 image / file：${String(kind)}`);
-	const path = attachmentPathOf(deps.home, kind, id);
+	const name = query.get(PARAMS.attachmentName);
+	return {
+		id,
+		kind,
+		name: name === null || name === "" ? void 0 : name,
+		serviceRef: parseServiceRef(id, kind, query)
+	};
+}
+async function readImageViaAttachments(deps, ref, maxBytes) {
+	assertWithinLimit(ref.attachmentId, ref.bytes, maxBytes);
+	let stored;
+	try {
+		stored = await deps.attachments.readImage(ref);
+	} catch (error) {
+		if (error instanceof AttachmentsUnavailableError) return void 0;
+		attachmentsIoError(ref.attachmentId, error);
+	}
+	const body = Buffer.from(stored.data);
+	assertWithinLimit(ref.attachmentId, body.length, maxBytes);
+	return {
+		body,
+		contentType: stored.ref.mediaType,
+		disposition: "inline"
+	};
+}
+/** 普通文件走宿主服务的分块读；超限在累计处停下，不把整份字节读进内存。 */
+async function readFileViaAttachments(deps, ref, maxBytes) {
+	assertWithinLimit(ref.attachmentId, ref.bytes, maxBytes);
+	const chunks = [];
+	let total = 0;
+	let tooLarge = false;
+	try {
+		for await (const chunk of deps.attachments.readFileStream(ref)) {
+			const buffer = Buffer.from(chunk);
+			total += buffer.length;
+			if (total > maxBytes) {
+				tooLarge = true;
+				break;
+			}
+			chunks.push(buffer);
+		}
+	} catch (error) {
+		if (error instanceof AttachmentsUnavailableError) return void 0;
+		attachmentsIoError(ref.attachmentId, error);
+	}
+	if (tooLarge) streamOverflow(ref.attachmentId, maxBytes);
+	return downloadResponse(Buffer.concat(chunks), safeFilename(ref.name, shortId(ref.attachmentId)));
+}
+/** 服务优先的唯一入口；`undefined` = 服务缺席 / 元数据不够 / 服务中途消失，调用方退回直接 fs。 */
+async function readViaAttachments(deps, request, maxBytes) {
+	if (request.serviceRef === void 0) return void 0;
+	if (!deps.attachments.available()) return void 0;
+	const serviceRef = request.serviceRef;
+	return serviceRef.kind === "image" ? readImageViaAttachments(deps, serviceRef.ref, maxBytes) : readFileViaAttachments(deps, serviceRef.ref, maxBytes);
+}
+/** 旧宿主 / 元数据不够：退回直接 fs（路径仍只由 id 与 kind 推导）。 */
+async function readViaFs(deps, request, maxBytes) {
+	const path = attachmentPathOf(deps.home, request.kind, request.id);
 	let size;
 	try {
 		size = (await deps.fs.statFile(path)).size;
 	} catch (error) {
-		throw verbError("io", `附件不在：${id}（${String(error)}）`, error);
+		throw verbError("io", `附件不在：${request.id}（${String(error)}）`, error);
 	}
-	if (size > MAX_ATTACHMENT_BYTES) throw verbError("io", `附件超过 ${MAX_ATTACHMENT_BYTES} 字节上限：${id}（${size} 字节）`);
+	assertWithinLimit(request.id, size, maxBytes);
 	const bytes = await deps.fs.readFile(path);
-	if (bytes.length > MAX_ATTACHMENT_BYTES) throw verbError("io", `附件超过 ${MAX_ATTACHMENT_BYTES} 字节上限：${id}（${bytes.length} 字节）`);
-	if (kind === "file") return {
-		body: bytes,
-		contentType: "application/octet-stream",
-		disposition: "attachment",
-		filename: safeFilename(query.get(PARAMS.attachmentName), id.slice(7, 19))
-	};
+	assertWithinLimit(request.id, bytes.length, maxBytes);
+	if (request.kind === "file") return downloadResponse(bytes, safeFilename(request.name, shortId(request.id)));
 	const contentType = sniffImage(bytes);
-	if (contentType === void 0) return {
-		body: bytes,
-		contentType: "application/octet-stream",
-		disposition: "attachment",
-		filename: safeFilename(query.get(PARAMS.attachmentName), `${id.slice(7, 19)}.bin`)
-	};
+	if (contentType === void 0) return downloadResponse(bytes, safeFilename(request.name, `${shortId(request.id)}.bin`));
 	return {
 		body: bytes,
 		contentType,
 		disposition: "inline"
 	};
 }
+async function readAttachmentResponse(deps, query) {
+	const request = parseAttachmentRequest(query);
+	const maxBytes = deps.config.maxAttachmentBytes;
+	const served = await readViaAttachments(deps, request, maxBytes);
+	if (served !== void 0) return served;
+	return readViaFs(deps, request, maxBytes);
+}
 //#endregion
 //#region src/api/attachment-orphans.ts
 /**
 * 孤儿附件的报告段：`GET /attachment-orphans`。
 *
 * 报告把扫描计划折成数量/字节 + 对象清单（`id`/`bytes`，供设置页预览缩略图；最多
-* `ORPHAN_PREVIEW_LIMIT` 条，清理不受预览条数限制）。扫描跳过（引用源或对象列表读不出）时
-* **报告必须失败**——回一份 0 会让界面说"没有孤儿"，而这类失败恰恰是"不知道"，不是"没有"。
+* `src/config.ts` 的 `orphanPreviewLimit`（默认 200，ADR-0037），清理不受预览条数限制）。
+* 扫描跳过（引用源或对象列表读不出）时**报告必须失败**——回一份 0 会让界面说"没有孤儿"，
+* 而这类失败恰恰是"不知道"，不是"没有"。
 * 清理是 `POST /attachment-clean`，由路由直接接到 `cleanOrphanImageAttachments`。
 */
-/** 预览清单的上限：与详情附件的载荷闸同一量级。数量与字节仍按全量报告。 */
-const ORPHAN_PREVIEW_LIMIT = 200;
 async function reportAttachmentOrphans(deps) {
 	const plan = await scanOrphanImageAttachments(deps);
 	if (plan.skipped !== void 0) throw verbError("io", plan.skipped);
+	const limit = deps.config.orphanPreviewLimit;
 	return {
 		count: plan.entries.length,
 		totalBytes: plan.bytes,
-		items: plan.entries.slice(0, ORPHAN_PREVIEW_LIMIT).map((entry) => ({
+		items: plan.entries.slice(0, limit).map((entry) => ({
 			attachmentId: entry.id,
 			bytes: entry.bytes
 		}))
@@ -2822,21 +3336,13 @@ async function reportAttachmentOrphans(deps) {
 //#endregion
 //#region src/api/trash-rows.ts
 /**
-* 清册那一行 → 线上那一行。**显式字面量、不用 `...row`**：线上形状多一个必填字段时，这里编译不过，
-* 于是"线上多了一格却没人填"不可能悄悄发生（`...row` 会把它带过去，看上去一切正常）。
+* 清册那一行 → 线上那一行。清册字段走 `entryWire` 那份显式字面量（线上形状多一个必填字段时编译不过，
+* `...row` 会把它带过去），这里只补 `/list` 的只读数。
 */
 function toWire(row, readouts) {
 	return {
-		id: row.id,
-		sessionId: row.sessionId,
-		projectDir: row.projectDir,
-		workspaceId: row.workspaceId,
-		wasArchived: row.wasArchived,
-		deletedAt: row.deletedAt,
-		title: row.title,
-		sizeBytes: row.sizeBytes,
+		...entryWire(row),
 		releaseBytes: readouts.releaseBytes,
-		...row.parentEntryId === void 0 ? {} : { parentEntryId: row.parentEntryId },
 		...readouts.subagentCount === void 0 ? {} : { subagentCount: readouts.subagentCount },
 		...readouts.subagentBytes === void 0 ? {} : { subagentBytes: readouts.subagentBytes },
 		...readouts.strandedSubagents === void 0 ? {} : { strandedSubagents: readouts.strandedSubagents },
@@ -2873,15 +3379,17 @@ async function assembleTrashRows(deps, rows) {
 //#endregion
 //#region src/api/route-table.ts
 /**
-* 路由表（ADR-0004）：段名 → { 方法, 纯度, 读面, body, 处理 }。一条记录，两个消费者。
+* 路由表（ADR-0004；deps 切片见 ADR-0032）：段名 → { 方法, 纯度, 读面, body, deps 切片, 处理 }。一条记录，两个消费者。
 *
 * 一致性要求：
 * - 该纯的判成写 ⇒ 探测/正文读/扫描被堵在串行链后；
 * - 该写的判成纯 ⇒ 写动作绕开到达序链，与对账交错；
-* - body 该读没读 ⇒ 下游拿到 null；读两遍 ⇒ 流已被消费。
+* - body 该读没读 ⇒ 下游拿到 null；读两遍 ⇒ 流已被消费；
+* - 切片声明宽了 ⇒ 危险能力（删目录 / 时钟）漏进读段的 run；窄了 ⇒ 写段的处理编译不过。
 *
 * 这张表不放 shared/wire.ts：处理函数会 import 动词与 node:fs，而浏览器半要 import wire.ts。
-* 段名与动作仍住 wire.ts；这张表只回答“怎么处理”。
+* 段名、方法与动作仍住 wire.ts（`ROUTES` 每项 `{ path, method }`，本表的 method 只投影、不写第二份字面量）；
+* 这张表只回答“怎么处理”。
 */
 /** 必填的非空字符串字段（缺、空串、类型不对都是**同一句话**：说清是哪个字段）。 */
 function requireString(body, field) {
@@ -2889,9 +3397,17 @@ function requireString(body, field) {
 	if (typeof value !== "string" || value === "") throw routeError("bad-request", 400, `请求体需带非空字符串字段 ${field}`);
 	return value;
 }
+/** `/detail` 的分页游标：缺省 = 从尾部取；给了就必须是非负整数（负数、小数、字符串都算请求不对）。 */
+function optionalCursor(body) {
+	const value = body?.[PARAMS.before];
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 0) throw routeError("bad-request", 400, `请求体字段 ${PARAMS.before} 需是非负整数`);
+	return value;
+}
 /**
-* `/apply` 的五个动作与各自的**静态纯度**。一张表两个用途：动作名单由键派生，纯度也从同一格读——
-* 新增动作必须同时给出纯度，漏了编译不过；新加一个纯读动作也不会再静默落进 `chained`。
+* `/apply` 的五个动作与各自的**静态纯度**。一张表三个用途：动作名单由键派生，纯度从同一格读，
+* 唯一识别器（`actionOf`）也只认这些键——新增动作必须同时给出纯度，漏了编译不过；
+* 新加一个纯读动作也不会再静默落进 `chained`。
 */
 const APPLY_ACTION_TABLE = {
 	delete: "chained",
@@ -2901,15 +3417,21 @@ const APPLY_ACTION_TABLE = {
 	"orphan-clean": "chained"
 };
 const APPLY_ACTIONS = Object.keys(APPLY_ACTION_TABLE);
-/** 认不认得这个动作：`/apply` 的纯度与拒否共用同一条判据，名单只有上面那一张。 */
-function isApplyAction(value) {
-	return typeof value === "string" && Object.hasOwn(APPLY_ACTION_TABLE, value);
+/**
+* `/apply` 的动作：**全仓唯一识别器**——纯度函数与动作拒否都从这里过，
+* 不各解析一遍动作。不抛：缺动作 / 不是字符串 / 不在名单，一律回 `undefined`；
+* 抛不抛、抛哪句话归 `requireAction`。
+*/
+function actionOf(body) {
+	const value = body?.[PARAMS.action];
+	if (typeof value !== "string" || !Object.hasOwn(APPLY_ACTION_TABLE, value)) return void 0;
+	return value;
 }
 /** `/apply` 的动作：认不得的一律点名拒掉，不折成"空批量"糊弄过去。 */
 function requireAction(body) {
-	const value = body?.[PARAMS.action];
-	if (!isApplyAction(value)) throw routeError("bad-request", 400, `批量动作不认识：需是 ${APPLY_ACTIONS.join(" / ")} 之一`);
-	return value;
+	const action = actionOf(body);
+	if (action === void 0) throw routeError("bad-request", 400, `批量动作不认识：需是 ${APPLY_ACTIONS.join(" / ")} 之一`);
+	return action;
 }
 /** `/apply` 的 id 组：必须是非空字符串数组（空数组不是"什么都不做"，是调用方自己没组好）。 */
 function requireIdArray(body) {
@@ -2918,81 +3440,91 @@ function requireIdArray(body) {
 	return value;
 }
 /**
-* 九个段名各一行。`Record<段名, RouteSpec>` 是闸：`wire.ts` 加了段名而这里没加，编译不过。
+* 九个段名各一行。`Record<段名, AnyRouteSpec>` 是闸：`wire.ts` 加了段名而这里没加，编译不过；
+* 每行的 `slice` 又把该行的 `run` 钉在自己那一格 deps 上（ADR-0032）。
 */
 const ROUTE_TABLE = {
-	[ROUTES.list]: {
-		method: "GET",
+	[ROUTES.list.path]: {
+		slice: "core",
+		method: ROUTES.list.method,
 		body: "none",
 		purity: "chained",
 		read: "list",
 		response: "json",
 		run: async (deps, _body, read) => assembleTrashRows(deps, await read.rows())
 	},
-	[ROUTES.ping]: {
-		method: "GET",
+	[ROUTES.ping.path]: {
+		slice: "core",
+		method: ROUTES.ping.method,
 		body: "none",
 		purity: "pure",
 		read: "none",
 		response: "json",
 		run: async () => "pong"
 	},
-	[ROUTES.attachment]: {
-		method: "GET",
+	[ROUTES.attachment.path]: {
+		slice: "attachment",
+		method: ROUTES.attachment.method,
 		body: "none",
 		purity: "pure",
 		read: "none",
 		response: "binary",
-		run: async (deps, _body, _read, query) => readAttachmentResponse(deps, query)
+		fetchGate: "same-origin",
+		run: async (deps, query) => readAttachmentResponse(deps, query)
 	},
-	[ROUTES.attachmentOrphans]: {
-		method: "GET",
+	[ROUTES.attachmentOrphans.path]: {
+		slice: "core",
+		method: ROUTES.attachmentOrphans.method,
 		body: "none",
 		purity: "pure",
 		read: "none",
 		response: "json",
 		run: async (deps) => reportAttachmentOrphans(deps)
 	},
-	[ROUTES.attachmentClean]: {
-		method: "POST",
+	[ROUTES.attachmentClean.path]: {
+		slice: "removal",
+		method: ROUTES.attachmentClean.method,
 		body: "none",
 		purity: "chained",
 		read: "none",
 		response: "json",
 		run: async (deps) => cleanOrphanImageAttachments(deps)
 	},
-	[ROUTES.orphans]: {
-		method: "GET",
+	[ROUTES.orphans.path]: {
+		slice: "core",
+		method: ROUTES.orphans.method,
 		body: "none",
 		purity: "pure",
 		read: "raw",
 		response: "json",
 		run: async (deps, _body, read) => reportOrphans(await loadOrphanGroups(deps, await read.rows()))
 	},
-	[ROUTES.apply]: {
-		method: "POST",
+	[ROUTES.apply.path]: {
+		slice: "full",
+		method: ROUTES.apply.method,
 		body: "json",
 		purity: (body) => {
-			const action = body?.[PARAMS.action];
-			return isApplyAction(action) ? APPLY_ACTION_TABLE[action] : "chained";
+			const action = actionOf(body);
+			return action === void 0 ? "chained" : APPLY_ACTION_TABLE[action];
 		},
 		read: "none",
 		response: "json",
 		run: async (deps, body) => applyActions(deps, requireAction(body), requireIdArray(body))
 	},
-	[ROUTES.empty]: {
-		method: "POST",
+	[ROUTES.empty.path]: {
+		slice: "removal",
+		method: ROUTES.empty.method,
 		body: "none",
 		purity: "chained",
 		read: "list",
 		response: "json",
 		run: async (deps, _body, read) => {
-			const rows = await read.rows();
-			return await purgeTrash(deps)(void 0, rows);
+			return await createTrashScope(deps, await read.rows()).purgeAll();
 		}
 	},
-	[ROUTES.detail]: {
-		method: "POST",
+	[ROUTES.detail.path]: {
+		slice: "core",
+		method: ROUTES.detail.method,
 		body: "json",
 		purity: "pure",
 		read: "raw",
@@ -3001,7 +3533,7 @@ const ROUTE_TABLE = {
 			fs: deps.fs,
 			rows: () => read.rows(),
 			home: deps.home
-		})(requireString(body, PARAMS.entryId))
+		})(requireString(body, PARAMS.entryId), optionalCursor(body))
 	}
 };
 /** 段名 → 那一行；不认识的段名回 `undefined`（调用方抛 404，并带出原路径）。 */
@@ -3010,92 +3542,91 @@ function routeOf(rest) {
 }
 //#endregion
 //#region src/api/dispatch.ts
-/** 请求体字节上限：这条通道只收几个 id，1MiB 是"够用且不给自己开一条内存放大器"的量级。 */
-const JSON_BODY_MAX_BYTES = 1048576;
-function writeJson(res, status, body) {
-	res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
-	res.end(JSON.stringify(body));
-}
-function writeOk(res, value) {
-	writeJson(res, 200, {
-		ok: true,
-		value
-	});
-}
 /**
-* 二进制响应（`/attachment` 专用）。四道头都是判据不是口味：
-* - `content-type` 由处理函数给（图片按魔数认，文件一律 octet-stream）；
-* - `content-length` 与字节数同源；
-* - `cache-control: private, no-store`：附件可能来自已删除会话，不许被任何中间层留下；
-* - `nosniff` + `attachment` 下载名：字节内容与类型不一致时浏览器不许改猜。
+* /dsh-session-delete-api 的分发核心：只负责路由记录的执行。
+*
+* 传输适配器只有 `src/api/connection-route.ts` 一个：九段注册到宿主 `connection.fetch.register`
+* 的 exact Fetch 路由（`Request` / `Response`），Host/Origin/浏览器认证由宿主 `/api` bridge 完成
+* （ADR-0033）。`Request` 的字节闸 / JSON 解析、`Response` 的头与失败信封都归适配器；
+* 这里只收已经解析好的请求，做查表 → 按段注入窄面 → 跑处理 → 回结果。
 *
-* **失败不走这里**：处理函数抛出的错误仍由 `writeFailure` 写 JSON 信封（图片的 `onError` 会换成
-* 占位；普通文件走 `<a download>`，没有页面内失败面）。
+* 纯度、body 声明、读面与方法仍住 `src/api/route-table.ts` 与 `src/shared/wire.ts`；这里只按判据执行。
+*
+* - 请求本身不对用 4xx（400 请求体 / 405 方法 / 404 未知路由）；操作失败回 200 + {ok:false,error}。
+*   浏览器半先解信封，再看状态。宿主 exact route 已在 handler 之前把未声明方法 / 路径回 404，
+*   所以 405 / 未知路由 404 只在适配器直调时可达（`tests/connection-route.test.ts` 钉防御分支）。
+* - `purity` 为 chained 的请求串行执行，避免读清册/动文件/写清册交错；整个进程共用一条到达序链。
 */
-function writeBinary(res, body) {
-	const headers = {
-		"content-type": body.contentType,
-		"content-length": String(body.body.length),
-		"cache-control": "private, no-store",
-		"x-content-type-options": "nosniff"
-	};
-	if (body.filename !== void 0) headers["content-disposition"] = `${body.disposition}; filename*=UTF-8''${encodeURIComponent(body.filename)}`;
-	else if (body.disposition === "attachment") headers["content-disposition"] = "attachment";
-	res.writeHead(200, headers);
-	res.end(body.body);
-}
-/** 失败信封：码与原文都来自 `toRemoteFailure`（本插件唯一的错误映射表）。
-*  **状态语义**：**请求本身不对**不再伪装成 200——请求体不对 400、方法不对 405、
-*  未知路由 404、栅栏拒 403（它们不是"一次办成的操作"，是"这条请求不归我办/你没资格办"）。
-*  **操作失败**仍回 200 + 信封。浏览器半先解信封再看状态，所以 4xx 上带的信封照样读得出原文；
-*  `code` 一律折成 `sessiondelete/io`，那三个路由标签（`bad-request` / `bad-method` / `not-found-route`）
-*  是**抛出处给读代码的人看的站点名**，不许冒充 `src/shared/wire.ts` 的五个动词码上客户端。 */
-function writeFailure(res, error, status) {
-	const carried = error?.httpStatus;
-	writeJson(res, status ?? (typeof carried === "number" ? carried : 200), {
-		ok: false,
-		error: toRemoteFailure(error)
-	});
-}
-/** 栅栏拒绝的两种原文：归属不对（跨源 / 重绑 / 头不成形）与远程客户端没带宿主身份。
-*  两者都是 403，但客户端会上屏，原文要能告诉用户下一步做什么。 */
-const UNTRUSTED_MESSAGE = "非受信来源";
-const UNAUTHENTICATED_MESSAGE = "需要宿主的 Web 身份：请用 dsh web 打印的那一行 URL 打开页面后重试";
-/** 流式读 body 并解析成 JSON 对象：空体回 `null`，超限 / 非法 JSON / 不是对象一律抛（→ 400 + 失败信封）。
-*  **请求本身不对**（400）与**那次操作读不到东西**（200 + 信封）是两件事：前者是调用方没组好请求，
-*  后者是盘上没有；把前者也写成 200，代理与日志里就再也分不出这两类。 */
-async function readJsonBody(req) {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of req) {
-		const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		size += buf.length;
-		if (size > JSON_BODY_MAX_BYTES) throw routeError("bad-request", 400, `请求体超过 ${JSON_BODY_MAX_BYTES} 字节上限`);
-		chunks.push(buf);
-	}
-	const text = Buffer.concat(chunks).toString("utf8").trim();
-	if (text === "") return null;
-	try {
-		const parsed = JSON.parse(text);
-		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw routeError("bad-request", 400, "请求体需为 JSON 对象");
-		return parsed;
-	} catch (error) {
-		if (error instanceof SyntaxError) throw routeError("bad-request", 400, `请求体不是合法 JSON：${error.message}`);
-		throw error;
-	}
-}
 function requireMethod(method, want, route) {
 	if (method !== want) throw routeError("bad-method", 405, `方法不允许：${method}（${SESSION_DELETE_API_PREFIX}${route} 需 ${want}）`);
 }
+/** 段名的 404 与方法的 405 只在这里判一次；空段名按插件前缀显示，避免 404 原文出现一个空串。 */
+function resolveRoute(method, rest) {
+	const spec = routeOf(rest);
+	if (spec === void 0) throw routeError("not-found-route", 404, `未知路由：${method} ${rest === "" ? SESSION_DELETE_API_PREFIX : rest}`);
+	requireMethod(method, spec.method, rest);
+	return spec;
+}
 function isPure(purity, body) {
 	return typeof purity === "function" ? purity(body) === "pure" : purity === "pure";
 }
-function readBodyFor(kind, req) {
-	return kind === "json" ? readJsonBody(req) : null;
+/**
+* 全量面按行收窄（ADR-0032）：组合根装出的 {@link DeleteDeps} 只交给 `/apply`；每一段只拿到
+* 自己声明的那一格（路由表的 `slice`）。收窄是**运行期事实**，不是类型投影。
+*/
+function coreOf(full) {
+	return {
+		fs: {
+			exists: (p) => full.fs.exists(p),
+			ensureDir: (p) => full.fs.ensureDir(p),
+			rename: (from, to) => full.fs.rename(from, to),
+			sizeOfDir: (p) => full.fs.sizeOfDir(p),
+			listFiles: (p) => full.fs.listFiles(p),
+			listDirs: (p) => full.fs.listDirs(p),
+			realpath: (p) => full.fs.realpath(p),
+			readFile: (p) => full.fs.readFile(p),
+			statFile: (p) => full.fs.statFile(p)
+		},
+		host: full.host,
+		ledger: full.ledger,
+		home: full.home,
+		presence: full.presence,
+		config: full.config
+	};
+}
+/** `removal` 保留删除能力，但不带会话删除的时钟；`full` 只给 `/apply`。 */
+function removalOf(full) {
+	return {
+		fs: full.fs,
+		host: full.host,
+		ledger: full.ledger,
+		home: full.home,
+		presence: full.presence,
+		config: full.config
+	};
+}
+/** 四格只建一次：收窄对象在 dispatcher 构造期固定，请求路径只做引用选择。 */
+function slicesOf(full) {
+	const core = coreOf(full);
+	return {
+		core,
+		removal: removalOf(full),
+		full,
+		attachment: {
+			...core,
+			attachments: full.attachments
+		}
+	};
+}
+/** 按行选格：`spec.slice` 与 {@link SliceDeps} 的键同域，查表结果的类型由 `S` 直接给出。 */
+function depsFor(spec, slices) {
+	return slices[spec.slice];
 }
-function createApiHandler(deps, trust) {
+/** 路由执行器：查段 → 方法闸 → 读面 → 处理；返回归一结果。组合根只建一次。 */
+function createDispatcher(deps) {
+	const slices = slicesOf(deps);
 	/**
-	* 到达序串行链（见文件头）：路由表里 `purity === 'chained'` 的请求一个跑完再放下一个。
+	* 到达序串行链：`purity === 'chained'` 的请求一个跑完再放下一个。
 	* `tail` 由构造保证**永不 reject**（每个任务自己的失败留在交回给那次请求的那个 promise 上），
 	* 所以一次失败不会卡死链。
 	*/
@@ -3105,53 +3636,272 @@ function createApiHandler(deps, trust) {
 		tail = started.then(() => void 0, () => void 0);
 		return started;
 	};
-	return async function handle(req, res) {
-		const verdict = judgeRequest(req, trust);
-		if (verdict !== "allowed") {
-			writeFailure(res, /* @__PURE__ */ new Error(verdict === "untrusted" ? UNTRUSTED_MESSAGE : UNAUTHENTICATED_MESSAGE), 403);
-			return;
+	return async function dispatch(input) {
+		const spec = resolveRoute(input.method, input.rest);
+		const kind = spec.read;
+		let rowsPromise;
+		const read = { rows() {
+			if (kind === "none") return Promise.reject(/* @__PURE__ */ new Error("route read: none"));
+			rowsPromise ??= kind === "list" ? deps.ledger.list() : deps.ledger.raw();
+			return rowsPromise;
+		} };
+		const rowDeps = depsFor(spec, slices);
+		const task = () => spec.response === "binary" ? spec.run(rowDeps, input.search) : spec.run(rowDeps, input.body, read);
+		const result = await (isPure(spec.purity, input.body) ? task() : throughChain(task));
+		if (spec.response === "binary") return {
+			kind: "binary",
+			body: result
+		};
+		return {
+			kind: "json",
+			status: 200,
+			body: {
+				ok: true,
+				value: result
+			}
+		};
+	};
+}
+//#endregion
+//#region src/api/connection-route.ts
+/**
+* 现代宿主的 exact Fetch 路由适配器：把九段注册到 `connection.fetch.register`，
+* 由宿主 `/api` bridge 做 Host/Origin/浏览器认证（ADR-0033）。
+*
+* 为什么路径必须带 `/api`：宿主 `assertFetchRoute` 用 `endpointFromPath('/api', path)` 校验，
+* 不带 `/api/` 前缀会在注册时直接抛错。`request.url` 会被 bridge 重写成 `http://dsh.internal/...`，
+* 这里只取 `pathname` / `searchParams`，不依赖外部 origin。
+*
+* 这条路由**不重复宿主的鉴权**：Host/Origin/浏览器认证在 handler 之前已经由宿主完成；只有路由记录
+* 声明了 `fetchGate` 的段（`/attachment`）再判一次同源取数（`isSameOriginFetch`）——那是字节 oracle
+* 的收口，不是身份。插件的 4xx（请求体 / 方法）与 200 操作失败信封在这里落地——`createDispatcher`
+* 只抛带 `httpStatus` 的请求错误。401/403 是宿主的纯文本响应，客户端负责映射。适配器拥有 wire 机制：
+* body 字节闸、JSON 解析、二进制头与失败信封。
+*/
+/** 请求体字节上限：这条通道只收几个 id，1MiB 是"够用且不给自己开一条内存放大器"的量级。 */
+const JSON_BODY_MAX_BYTES = 1048576;
+/** 请求体文本 → JSON 对象；空体 `null`；非对象 / 非法 JSON 抛 400。 */
+function parseJsonBody(text) {
+	const trimmed = text.trim();
+	if (trimmed === "") return null;
+	try {
+		const parsed = JSON.parse(trimmed);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw routeError("bad-request", 400, "请求体需为 JSON 对象");
+		return parsed;
+	} catch (error) {
+		if (error instanceof SyntaxError) throw routeError("bad-request", 400, `请求体不是合法 JSON：${error.message}`);
+		throw error;
+	}
+}
+/**
+* 二进制响应的四道头（`/attachment` 专用）。判据不是口味：类型由处理函数给、长度与字节同源、
+* 不许任何中间层留下已删除会话的附件、字节与声明类型不一致时浏览器不许改猜。
+*/
+function binaryHeaders(body) {
+	const headers = {
+		"content-type": body.contentType,
+		"content-length": String(body.body.length),
+		"cache-control": "private, no-store",
+		"x-content-type-options": "nosniff"
+	};
+	if (body.filename !== void 0) headers["content-disposition"] = `${body.disposition}; filename*=UTF-8''${encodeURIComponent(body.filename)}`;
+	else if (body.disposition === "attachment") headers["content-disposition"] = "attachment";
+	return headers;
+}
+/**
+* 失败的落地：码与原文都来自 `toRemoteFailure`（本插件唯一的错误映射表）。
+* 状态语义：**请求本身不对**不伪装成 200——请求体 400、方法 405、未知路由 404；
+* **操作失败**回 200 + 信封。`code` 一律折成 `sessiondelete/io`，路由站点名不冒充动词码。
+*/
+function failureResult(error, status) {
+	const carried = error?.httpStatus;
+	return {
+		kind: "json",
+		status: status ?? (typeof carried === "number" ? carried : 200),
+		body: {
+			ok: false,
+			error: toRemoteFailure(error)
 		}
+	};
+}
+/**
+* 同源取数闸（ADR-0033 边界收口）：附件字节能被任意页面当 `<img>` 渲染，而宿主 cookie 的
+* `SameSite=Strict` 按 **site** 判——同 IP 不同端口仍会带上。宿主 `/api` 只拦 `cross-site` 与
+* authority 不符的 `Origin`，这一格补在插件这一侧：
+* - `Sec-Fetch-Site` 为 `same-site` / `cross-site` ⇒ 拒；
+* - http(s) 的 `Origin` / `Referer` 与 `Host` 不同 authority ⇒ 拒（覆盖不发送 Fetch Metadata 的代次）；
+* - 桌面壳的 `dsh-app:` 来源与三头全缺的非浏览器客户端放行——桌面转发器已摘掉
+*   `host` / `origin` / `sec-fetch-site`，「摘干净」不是不可信。
+*
+* `Host` 依赖的是宿主 bridge 保留原始请求头（它只改写 `request.url`）；真机与
+* `tests/api.test.ts` 的 `node:http` 桥都钉住这一条：同源 `Referer` 能对上 `Host`。
+*/
+function isSameOriginFetch(request) {
+	const site = request.headers.get("sec-fetch-site");
+	if (site === "same-origin") return true;
+	if (site === "same-site" || site === "cross-site") return false;
+	const host = request.headers.get("host");
+	for (const name of ["origin", "referer"]) {
+		const value = request.headers.get(name);
+		if (value === null) continue;
+		let source;
 		try {
-			const url = new URL(req.url ?? "/", "http://dsh.internal");
-			if (!url.pathname.startsWith("/dsh-session-delete-api")) throw routeError("not-found-route", 404, `未知路由：${url.pathname}`);
-			const rest = url.pathname.slice(23);
-			const spec = routeOf(rest);
-			if (spec === void 0) throw routeError("not-found-route", 404, `未知路由：${req.method ?? "GET"} ${rest === "" ? SESSION_DELETE_API_PREFIX : rest}`);
-			requireMethod(req.method ?? "GET", spec.method, rest);
-			const body = await readBodyFor(spec.body, req);
-			const kind = spec.read;
-			let rowsPromise;
-			const read = { rows() {
-				if (kind === "none") return Promise.reject(/* @__PURE__ */ new Error("route read: none"));
-				rowsPromise ??= kind === "list" ? deps.ledger.list() : deps.ledger.raw();
-				return rowsPromise;
-			} };
-			const task = () => spec.run(deps, body, read, url.searchParams);
-			const result = await (isPure(spec.purity, body) ? task() : throughChain(task));
-			if (spec.response === "binary") writeBinary(res, result);
-			else writeOk(res, result);
-		} catch (error) {
-			writeFailure(res, error);
+			source = new URL(value);
+		} catch {
+			return false;
+		}
+		if (source.protocol !== "http:" && source.protocol !== "https:" && source.protocol !== "dsh-app:") return false;
+		if (source.protocol === "dsh-app:") continue;
+		if (host === null || !isSameAuthority(source, host)) return false;
+	}
+	return true;
+}
+/** 按来源的协议解析 `Host`，两侧都过 WHATWG 归一（默认端口、大小写）后比 authority。 */
+function isSameAuthority(source, host) {
+	try {
+		return new URL(`${source.protocol}//${host}`).host === source.host;
+	} catch {
+		return false;
+	}
+}
+/** 边读边数：宿主按 `requestBody: 'buffered'` 已预读整段，这里仍守插件侧的 1 MiB 逻辑闸；
+*  超限即停，不再把读到的分片拼成更大的字符串。 */
+async function readRequestJson(request) {
+	const declared = Number(request.headers.get("content-length"));
+	if (Number.isFinite(declared) && declared > 1048576) throw routeError("bad-request", 400, `请求体超过 ${JSON_BODY_MAX_BYTES} 字节上限`);
+	const stream = request.body;
+	if (stream === null) return null;
+	const reader = stream.getReader();
+	const chunks = [];
+	let size = 0;
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			size += value.byteLength;
+			if (size > 1048576) {
+				await reader.cancel();
+				throw routeError("bad-request", 400, `请求体超过 ${JSON_BODY_MAX_BYTES} 字节上限`);
+			}
+			chunks.push(value);
 		}
+	} finally {
+		reader.releaseLock();
+	}
+	return parseJsonBody(Buffer.concat(chunks).toString("utf8"));
+}
+function toResponse(result) {
+	if (result.kind === "binary") return new Response(new Uint8Array(result.body.body), {
+		status: 200,
+		headers: binaryHeaders(result.body)
+	});
+	return new Response(JSON.stringify(result.body), {
+		status: result.status,
+		headers: { "content-type": "application/json; charset=utf-8" }
+	});
+}
+/**
+* 注册九段 exact Fetch 路由。返回一个组合 disposer；调用方把它挂在自己的 effect 上。
+* `connection` 是插件的硬依赖（web UI / 桌面端都装 `client-connection`）；`fetch.register`
+* 缺席属于宿主形状漂移，直接抛——静默返回空 disposer 会让插件「在但没有入口」。
+* `dispatch` 与分发器同源。
+*/
+function registerConnectionRoutes(service, dispatch) {
+	const fetchService = service.fetch;
+	if (fetchService === void 0 || typeof fetchService.register !== "function") throw new Error("session-delete: connection.fetch.register 不可用");
+	const disposers = [];
+	const disposeAll = async () => {
+		for (const dispose of [...disposers].reverse()) try {
+			await dispose();
+		} catch {}
 	};
+	try {
+		for (const [routePath, spec] of Object.entries(ROUTE_TABLE)) {
+			const path = `${OFFICIAL_SESSION_DELETE_API_PREFIX}${routePath}`;
+			disposers.push(fetchService.register({
+				path,
+				methods: [spec.method],
+				requestBody: "buffered",
+				fetch: async (request) => {
+					if (spec.fetchGate === "same-origin" && !isSameOriginFetch(request)) return toResponse(failureResult(routeError("bad-request", 403, "附件只允许同源页面读取")));
+					try {
+						const body = spec.body === "json" ? await readRequestJson(request) : null;
+						return toResponse(await dispatch({
+							method: request.method,
+							rest: routePath,
+							search: new URL(request.url).searchParams,
+							body
+						}));
+					} catch (error) {
+						return toResponse(failureResult(error));
+					}
+				}
+			}));
+		}
+	} catch (error) {
+		for (const dispose of [...disposers].reverse()) dispose().catch(() => void 0);
+		throw error;
+	}
+	return disposeAll;
 }
 //#endregion
-//#region src/ports/connection-port.ts
-const HOST_UNAUTHENTICATED = 401;
-/** 成员抛错按「归属不对」拒绝（fail-closed）。 */
-function createConnectionPort(ctx) {
-	return { verdictFor: (req) => {
-		const service = ctx.get("connection");
-		if (service === void 0 || typeof service.requestRejection !== "function") return { kind: "absent" };
+//#region src/config.ts
+const DEFAULT_CONFIG = Object.freeze({
+	orphanPreviewLimit: 200,
+	maxAttachmentBytes: 20971520,
+	maxJsonRefBytes: 10485760
+});
+const LIMITS = {
+	orphanPreviewLimit: {
+		min: 1,
+		max: 1e4
+	},
+	maxAttachmentBytes: {
+		min: 1,
+		max: 209715200
+	},
+	maxJsonRefBytes: {
+		min: 1,
+		max: 104857600
+	}
+};
+function intField(input, key, range) {
+	const value = input[key];
+	if (value === void 0) return DEFAULT_CONFIG[key];
+	if (typeof value !== "number" || !Number.isInteger(value) || value < range.min || value > range.max) throw new Error(`配置项 ${key} 需为 ${range.min}..${range.max} 的整数`);
+	return value;
+}
+/**
+* 把 patch 里的 `config` 归一成完整配置：缺省取默认值，未知键 / 非整数 / 越界都抛。
+* 抛错会让插件激活失败（响亮），而不是悄悄用半套配置跑。
+*/
+function normalizeConfig(value) {
+	if (value === void 0 || value === null) return DEFAULT_CONFIG;
+	if (typeof value !== "object" || Array.isArray(value)) throw new Error("配置需为对象");
+	const input = value;
+	const known = new Set(Object.keys(LIMITS));
+	for (const key of Object.keys(input)) if (!known.has(key)) throw new Error(`未知配置项：${key}`);
+	return {
+		orphanPreviewLimit: intField(input, "orphanPreviewLimit", LIMITS.orphanPreviewLimit),
+		maxAttachmentBytes: intField(input, "maxAttachmentBytes", LIMITS.maxAttachmentBytes),
+		maxJsonRefBytes: intField(input, "maxJsonRefBytes", LIMITS.maxJsonRefBytes)
+	};
+}
+/**
+* 插件 Config：Cordis 接受 Standard Schema，`~standard.validate` 交回归一后的配置。
+* 宿主在激活前校验；`apply` 再归一一次（同一份事实，不会漂）。
+*/
+const Config = { "~standard": {
+	version: 1,
+	vendor: "dsh-session-delete",
+	validate(value) {
 		try {
-			const status = service.requestRejection(req);
-			if (status === void 0) return { kind: "allowed" };
-			return { kind: status === HOST_UNAUTHENTICATED ? "unauthenticated" : "untrusted" };
-		} catch {
-			return { kind: "untrusted" };
+			return { value: normalizeConfig(value) };
+		} catch (error) {
+			return { issues: [{ message: error instanceof Error ? error.message : String(error) }] };
 		}
-	} };
-}
+	}
+} };
 //#endregion
 //#region src/ports/fs-port.ts
 /** 模块级递归：端口方法**解构出来单独调**也不能靠 `this`（`{ sizeOfDir } = port` 会让方法体的
@@ -3405,8 +4155,10 @@ function domainTable(schema) {
 function defineDomain(spec) {
 	if (!UNIT_NAME_RE.test(spec.name)) throw new Error(`domain name '${spec.name}' must match ${UNIT_NAME_RE}`);
 	if (!Number.isInteger(spec.version) || spec.version < 0) throw new Error(`domain '${spec.name}' version must be a non-negative integer, got ${spec.version}`);
-	if (spec.layout !== void 0 && spec.layout !== "single" && spec.layout !== "per-record") throw new Error(`domain '${spec.name}' layout must be 'single' or 'per-record', got ${spec.layout}`);
-	if (spec.invalidRecords !== void 0 && spec.invalidRecords !== "backup-and-skip") throw new Error(`domain '${spec.name}' invalidRecords must be 'backup-and-skip' when present`);
+	const layout = spec.layout;
+	if (layout !== void 0 && layout !== "single" && layout !== "per-record") throw new Error(`domain '${spec.name}' layout must be 'single' or 'per-record', got ${layout}`);
+	const invalidRecords = spec.invalidRecords;
+	if (invalidRecords !== void 0 && invalidRecords !== "backup-and-skip") throw new Error(`domain '${spec.name}' invalidRecords must be 'backup-and-skip' when present`);
 	for (const table of Object.keys(spec.tables)) if (!UNIT_NAME_RE.test(table)) throw new Error(`domain '${spec.name}' table name '${table}' must match ${UNIT_NAME_RE}`);
 	return spec;
 }
@@ -3482,14 +4234,11 @@ const name = "@xrn1997/dsh-session-delete";
 * - `agents`：只给 handle 捕获用（`ctx.get('agents')`；缺席时 `ctx.inject(['agents'])` 等服务就绪再装）。
 *   它同样可能晚于本插件激活，写进插件 inject 只会让整个插件 pending。
 *
-* `webServer` 是**浏览器半取数通道的承载者**（那条薄线）：插件用它注册 `/dsh-session-delete-api`
-* 前缀路由，浏览器半同源 fetch 那九个段名。它是宿主 web 组成里的硬依赖（`dsh-host-webserver` 的
-* `super(ctx, "webServer")`），服务名与 `register({kind:'prefix', path, handler})` 的形状按
-* `dsh-host-webserver/lib/index.js` 与 `README.md` 原文读实，不是猜的。
-*
-* `connection` 只喂请求栅栏的远程支（`src/api/request-trust.ts` ②），按 `ctx.get` 可选读：
-* 服务缺席时插件照常激活，远程客户端 fail-closed。它不进 `inject`——写进去会让没有 web 组成的
-* profile 整个停在 pending。
+* `connection` 是浏览器半取数通道的唯一承载者：九段注册到 `connection.fetch.register` 的
+* `/api/dsh-session-delete-api/*`，Host/Origin/浏览器认证由宿主 `/api` bridge 完成（ADR-0033）。
+* 支持面是 web UI 与桌面端，二者的标准组合都装 `client-connection`；服务缺席时插件停在 pending
+* ——可见的激活失败，而不是静默地没有入口。`webServer` 不再直接使用：exact route 仍由宿主的
+* `connection` 挂在其 `/api` 前缀上，插件不需要自己碰物理服务器。
 *
 * 清册的三层各有各的家：raw 绑定 `src/trash/storage-manifest.ts`、读面（对账 + 读）`src/trash/ledger.ts`、
 * 数据根 `src/ports/home.ts`。这里只把它们接起来，任何一层都不在组合根里长判据。
@@ -3497,16 +4246,18 @@ const name = "@xrn1997/dsh-session-delete";
 const inject = [
 	"workspaceRegistry",
 	"storageDomain",
-	"webServer"
+	"connection"
 ];
 /**
-* 装配顺序：**清单 → 端口 → 在场能力 → 动词依赖 → 前缀路由**（`DeleteDeps` 把这些依赖面合成一颗）。
+* 装配顺序：**配置归一 → 清单 → 端口 → 在场能力 → 动词依赖 → 分发器 → exact Fetch 路由**
+* （`DeleteDeps` 把这些依赖面合成一颗；`config` 是归一后的只读快照）。
 *
 * 路由用 `ctx.effect` 挂、disposer 归装载它的那根 fiber：插件卸载即摘路由（`register` 返回的
-* disposer 是官方契约）。**同一进程里只注册一次**这件事由宿主把住：重复的 `(kind, path)`
-* 在 `register` 里直接抛（`webserver: duplicate prefix route "…"`），响亮失败而不是悄悄覆盖。
+* disposer 是官方契约）。**同一进程里只注册一次**这件事由宿主把住：重复的 `(path, method)`
+* 在 `connection.fetch.register` 里直接抛，响亮失败而不是悄悄覆盖。
 */
-function apply(ctx) {
+function apply(ctx, rawConfig) {
+	const config = normalizeConfig(rawConfig);
 	const fs = createFsPort();
 	const home = resolveHome();
 	const rawManifest = createHostStorageManifest(ctx);
@@ -3517,23 +4268,17 @@ function apply(ctx) {
 		ledger: createTrashLedger(rawManifest, fs, home),
 		home,
 		presence: createMemberPresence(host),
+		config,
+		attachments: createAttachmentsPort(ctx),
 		now: () => Date.now()
 	};
-	const webServer = ctx.webServer;
-	const connection = createConnectionPort(ctx);
+	const connection = ctx.get("connection");
+	if (connection === void 0) throw new Error("session-delete: connection 服务缺席");
+	const dispatch = createDispatcher(deps);
 	ctx.effect(() => {
-		const dispose = webServer.register({
-			kind: "prefix",
-			path: SESSION_DELETE_API_PREFIX,
-			handler: createApiHandler(deps, {
-				bindHost: webServer.host,
-				connection
-			})
-		});
-		return () => {
-			dispose();
-		};
-	}, "session-delete: /dsh-session-delete-api routes");
+		const dispose = registerConnectionRoutes(connection, dispatch);
+		return () => dispose();
+	}, "session-delete: /api exact Fetch routes");
 }
 //#endregion
-export { apply, inject, name };
+export { Config, apply, inject, name };