@xrn1997/dsh-session-delete 0.3.0 → 0.3.1

package/lib/index.js

@@ -72,7 +72,7 @@ function isDSHRemoteError(value) {
 /** 失败码的域。与宿主官方域（`workspace/*`、`session/*`…）不重名，见本文件。 */
 const SESSION_DELETE_ERROR_DOMAIN = "sessiondelete";
 /** 五个**动词码**（本文件那张表）。`io` 是唯一兜底。 */
-const VERB_CODES$1 = [
+const VERB_CODES = [
 	"live",
 	"not-found",
 	"trash-empty",
@@ -89,6 +89,23 @@ const SESSION_DELETE_CODES = {
 	"not-found-route": "sessiondelete/not-found-route",
 	"bad-request": "sessiondelete/bad-request"
 };
+/** 失败码的前缀。读码只走下面两条，别在调用点各写一份字面量。 */
+const CODE_PREFIX = `${SESSION_DELETE_ERROR_DOMAIN}/`;
+/** `error.code` 是不是本仓的失败形状（`sessiondelete/<后缀>`）。**只认前缀**：后缀在不在册是
+*  {@link verbCodeOf} 的问题。任何要「已经是本仓的码就原样对待」的调用点都问这一句，不在调用点
+*  再写一份前缀字面量。 */
+function isSessionDeleteCodeError(error) {
+	const raw = error?.code;
+	return typeof raw === "string" && raw.startsWith(CODE_PREFIX);
+}
+/** `error.code` 折回那个动词词：前缀与后缀两件都成立才交回（后缀要在 {@link VERB_CODES} 册上）。
+*  路由自检码、别域的码、非字符串 code 一律 `undefined`。 */
+function verbCodeOf(error) {
+	const raw = error?.code;
+	if (typeof raw !== "string" || !raw.startsWith(CODE_PREFIX)) return void 0;
+	const suffix = raw.slice(CODE_PREFIX.length);
+	return VERB_CODES.includes(suffix) ? suffix : void 0;
+}
 /** 回收站目录名（相对宿主数据根）。Node 半拼路径，浏览器半在页脚念它——同一个字面量。 */
 const TRASH_DIR_NAME = "session-trash";
 //#endregion
@@ -185,7 +202,7 @@ function toRemoteFailure(error) {
 		};
 	}
 	const raw = error?.code;
-	if (typeof raw === "string" && OFFICIAL_CODE.test(raw) && !raw.startsWith(`${DOMAIN}/`)) {
+	if (typeof raw === "string" && OFFICIAL_CODE.test(raw) && !isSessionDeleteCodeError(error)) {
 		const details = detailsOf(error);
 		return {
 			code: raw,
@@ -193,8 +210,7 @@ function toRemoteFailure(error) {
 			...details === void 0 ? {} : { details }
 		};
 	}
-	const reason = typeof raw === "string" && raw.startsWith(`${DOMAIN}/`) ? raw.slice(14) : void 0;
-	const fromVerb = reason !== void 0 && VERB_CODES$1.includes(reason) ? reason : void 0;
+	const fromVerb = verbCodeOf(error);
 	const host = hostErrorOf(error);
 	const own = detailsOf(error) ?? (host === void 0 ? void 0 : detailsOf(host));
 	if (host === void 0 && fromVerb === void 0 && typeof raw === "string" && raw.includes("/")) return {
@@ -210,19 +226,8 @@ function toRemoteFailure(error) {
 }
 //#endregion
 //#region src/verbs/errors.ts
-/** 五个码 / 三个路由自检码的**家都在 `shared/wire.ts`**（ADR-0003）：浏览器半也要认它们（比如
-*  `not-found` 在界面上是中性提示而不是失败），所以它们属于两半共同的契约，不属于 Node 半。
-*  这里只转出旧名，免得调用点全改一遍。 */
-const VERB_CODES = VERB_CODES$1;
-/** `sessiondelete/` 这个前缀——拆码用它，别在下面几处各写一遍字面量。 */
-const VERB_CODE_PREFIX = `${SESSION_DELETE_ERROR_DOMAIN}/`;
-/** `error.code` 是不是本仓的动词码（`sessiondelete/<码>`）。**唯一判据**：`journalFailure` 与永久删除
-*  执行器要"已经是动词码就原样抛"时都问这一句。同文件的 `withRollbackFailures` 还要码的后缀，所以它
-*  就地 `slice` 一次——前缀仍只住 `VERB_CODE_PREFIX` 这一处，别在调用点另写一份字面量。 */
-function isVerbCodeError(error) {
-	const raw = error?.code;
-	return typeof raw === "string" && raw.startsWith(VERB_CODE_PREFIX);
-}
+/** 失败的**结构与措辞**。码本身、码的前缀读法与动词词表都住在 `shared/wire.ts`（ADR-0003）：
+*  浏览器半也要认它们，它们属于两半共同的契约，不属于 Node 半。这里只做动词抛错与回滚措辞。 */
 function verbError(code, message, cause, details) {
 	const e = new Error(message);
 	e.code = SESSION_DELETE_CODES[code];
@@ -252,9 +257,7 @@ function carriedRollbackFailures(error) {
 *  没有可继承的就落 io。**内层的回滚失败要并进来**：一个成员自己退失败、兄弟也退失败时，
 *  两份失败都得在 details 里，消息也不能出现第二个「回滚未完成」。 */
 function withRollbackFailures(error, failures) {
-	const raw = error?.code;
-	const reason = typeof raw === "string" && raw.startsWith(VERB_CODE_PREFIX) ? raw.slice(VERB_CODE_PREFIX.length) : void 0;
-	const code = reason !== void 0 && VERB_CODES.includes(reason) ? reason : "io";
+	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);
@@ -655,41 +658,26 @@ function createHostPort(ctx) {
 			} catch {}
 		},
 		/**
-		* 通告客户端"这个会话回来了"。
+		* 通告客户端"这组会话回来了"：**拉一次**宿主自己的会话列表，按 id 逐条发 `api-session/added`。
 		*
 		* 摘要**取自宿主自己的会话列表**（`ctx.sessionController.list()`），不自己造一行：客户端 `handleSessionAdded`
 		* 要的是宿主 `summaryFor` 那套形状（sessionId / updatedAt / blank / projections…），照抄宿主的那一份最可靠。
 		* 取不到（控制器缺席 / 列表里没有它 / 抛错）就**一条都不发**。
 		*
-		* **这一条单条路是删除组回滚用的**：成员已经收过 `api-session/removed`，退回 `sessions/` 之后要补一条
-		* "added"，否则客户端那一行要等到重连才回来。正常恢复走 {@link announceRestoredBatch} + 一次预取——
-		* 100 条的批量用单条路就是 100 遍全表扫，那正是 2026-10-17 那次"恢复很慢"的头号来源。
+		* **取数从 interface 收进了 implementation**：单条就是长度为 1 的批，批量恢复与删除组回滚走同一条路。
+		* 一次预取由这里保证——100 条一组的批量若按条拉表就是 100 遍全表扫，那正是 2026-10-17 那次"恢复很慢"的头号来源。
 		*/
-		async announceRestored(sessionId) {
-			const summary = (await this.restoredSummariesOf()).find((item) => item.sessionId === sessionId)?.summary;
-			if (summary === void 0) return;
-			try {
-				host.emit("api-session/added", JSON.parse(JSON.stringify(summary)));
-			} catch {}
-		},
-		/** 整批预取一次会话表（`[{ sessionId, summary }]`）：通告的路径与单条一致，**拉表从每条一次抬成整批一次**。 */
-		async restoredSummariesOf() {
-			const out = [];
+		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") out.push({
+				if (typeof sessionId === "string") summaries.push({
 					sessionId,
 					summary: item
 				});
 			}
-			return out;
-		},
-		/** 一组会话的通告（2026-10-17 批量重构）：`known` 给了就**一次都不拉表**，只按它筛。
-		*  与 {@link announceRestored} 同一判据、同一事件、同一载荷形状，只是取数由整批共享。 */
-		async announceRestoredBatch(ids, known) {
-			if (ids.length === 0) return;
-			const summaries = known ?? await this.restoredSummariesOf();
-			for (const id of ids) {
+			for (const id of sessionIds) {
 				const summary = summaries.find((item) => item.sessionId === id)?.summary;
 				if (summary === void 0) continue;
 				try {
@@ -820,14 +808,63 @@ function groupOf(rows, id) {
 	return kidsOf(rows, id);
 }
 /**
-* 「这条是被**同批前一条**带走的，还是整批开始前就没有？」
+* 「这条是被**同批前一条**带走的，还是整批开始前就没有，还是仍在？」
 *
-* 幂等语义只属于前者：后来者本来就不在清册里（用户点了条幽灵 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 的内部实现）。
+*
+* 三个动作曾各有一套机制：delete 用动词回吐的 `movedSessionIds`，restore/purge 用
+* `original / current` 两份快照 + 旧 boolean 谓词 + `shrink`。这里把判据收成 `claim(id)` + `take(id)`；
+* 两种 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
+* （因此只有 fresh / carried 两态）。这里只做 id 域适配，不另写组语义。
+* 两域的 `claim` 形状不同：entry 交 `GroupClaim`（只有 fresh 带组），session 只交 verdict；
+* 当前只读视图（`rows`）只挂在 entry 域上：只有 purge 要它——盘上后代要按清册里还在的 id 排除。
 */
-function takenByEarlierInBatch(original, current, id) {
-	return groupOf(original, id).length > 0 && groupOf(current, id).length === 0;
+/** 恢复 / 彻底删除：原始快照认得、当前视图已经空了 ⇒ 同批前一条带走的。 */
+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` 只收这次真的搬走的成员（父 + 盘上的孩子）。 */
+function createSessionCarried() {
+	const carried = /* @__PURE__ */ new Set();
+	return {
+		claim(id) {
+			return carried.has(bareSessionId(id)) ? { verdict: "carried" } : { verdict: "fresh" };
+		},
+		take(id) {
+			carried.add(bareSessionId(id));
+		}
+	};
 }
 //#endregion
 //#region src/trash/entry.ts
@@ -890,420 +927,190 @@ function trashDirOf(entryId, home) {
 	return `${home}/${TRASH_DIR_NAME}/${entryId}`;
 }
 //#endregion
-//#region src/log/zstd-frames.ts
-const MAGIC = [
-	40,
-	181,
-	47,
-	253
-];
-/** magic(4) + Frame_Header_Descriptor(1) 之后第一个字节的偏移。 */
-const AFTER_DESCRIPTOR = 5;
-const BLOCK_HEADER_BYTES = 3;
-const BLOCK_LAST = 1;
-const BLOCK_TYPE_SHIFT = 1;
-const BLOCK_SIZE_SHIFT = 3;
-const BLOCK_SIZE_MASK = 2097151;
-const BLOCK_RAW = 0;
-const BLOCK_RLE = 1;
-const BLOCK_COMRESSED = 2;
-/** 规范（RFC 8878 表 4）里 3 是 **Reserved**，不是"未压缩块"：见到就抛，别照 Raw 吞块体。 */
-const BLOCK_RESERVED = 3;
-/** descriptor 各字段的取值 → 字段字节数（zstd 帧头的两张尺寸表）。 */
-const DID_SIZES = [
-	0,
-	1,
-	2,
-	4
-];
-const FCS_SIZES_SINGLE = [
-	1,
-	2,
-	4,
-	8
-];
-const FCS_SIZES_MULTI = [
-	0,
-	2,
-	4,
-	8
-];
-/** 实测的帧尾长度（校验和位置；bit5 没置位也照样带，见文件头注）。 */
-const FRAME_TAIL_BYTES = 4;
-function isMagicAt(raw, at) {
-	return MAGIC.every((byte, i) => raw[at + i] === byte);
+//#region src/verbs/member-journal.ts
+/**
+* 一次成员移动 = 一串**自带反向动作的步骤**（ADR-0002）。
+*
+* 为什么需要它：`delete-session.ts` 的 `moveOneIn`/`undoOneIn` 与 `restore-session.ts` 的 `restoreOne`
+* （含它的反向闭包）互为镜像，各自手写了三到四段嵌套 `try/catch`：迁移前全仓 `rollbackReason(` **22 处**、
+* `withRollbackFailures(` **8 处**。那不是"回滚值得自己的候选"，而是**同一条正反动作对被写了两遍**。
+*
+* 这里独占四件事，三个动词各自只声明"这次要做哪几步、每步怎么退"：
+* ① **相反顺序**退化（最后做成的先退）；
+* ② 一步失败时把**已经做成的**那些退回去；
+* ③ 失败收集：某一步退不干净时**不让原错误独走**（`details.rollbackFailures`，见 `verbs/errors.ts`）；
+* ④ **非原子步骤**：`undoOnFailure` 让"这一步自己失败了"也跑它的反向动作（例如"取消归档"半做完了，
+*    得先把会话重新藏回去）。
+*
+* 边界：它只服务"成员在 `sessions/` 与 `session-trash/` 之间搬"这一件事。做成通用撤销框架就会吸进
+* 不属于它的知识（谁该通告、通告几次、哪些失败算成功）。
+*/
+/** 已经把某个前缀做成了的 journal——`undo()` 就退那一个前缀。 */
+function createJournal(steps) {
+	const done = [];
+	const undoAll = async (alsoFailing) => {
+		const failures = [];
+		const restored = /* @__PURE__ */ new Map();
+		const runUndo = async (step) => {
+			if (step.undo === void 0) return;
+			const result = await step.undo();
+			failures.push(...result.failures);
+			restored.set(step.key, result.restored);
+		};
+		if (alsoFailing?.undo !== void 0) await runUndo(alsoFailing);
+		for (const step of [...done].reverse()) await runUndo(step);
+		return {
+			failures,
+			restored: (key) => restored.get(key) ?? false
+		};
+	};
+	return {
+		async run() {
+			for (const step of steps) {
+				try {
+					await step.run();
+				} catch (error) {
+					const undo = await undoAll(step.undoOnFailure === true ? step : void 0);
+					const base = journalFailure(step, error);
+					throw undo.failures.length > 0 ? withRollbackFailures(base, undo.failures) : base;
+				}
+				done.push(step);
+			}
+		},
+		undo() {
+			return undoAll();
+		}
+	};
 }
-function readUint24LE(raw, at) {
-	return raw[at] | raw[at + 1] << 8 | raw[at + 2] << 16;
+/** 跑一步反向动作并把它自己的失败收成一条原因（不抛：这些失败由调用方汇总成 `rollbackFailures`）。 */
+async function attempt(label, run) {
+	try {
+		await run();
+		return [];
+	} catch (error) {
+		return [rollbackReason(label, error)];
+	}
 }
-/** 块体之后有没有那 4 字节尾巴：只有"跳过它之后仍是帧头或到 EOF"才认。 */
-function withFrameTail(raw, at) {
-	const afterTail = at + FRAME_TAIL_BYTES;
-	if (afterTail <= raw.length && (afterTail === raw.length || isMagicAt(raw, afterTail))) return afterTail;
-	return at;
+/** 一步反向动作的完整结果：主写是否回到原样 + 失败串。附属写失败只进 `failures`，不推翻 `restored`。 */
+async function stepUndo(label, run) {
+	const failures = await attempt(label, run);
+	return {
+		restored: failures.length === 0,
+		failures
+	};
 }
 /**
-* 把 `raw` 切成帧区间。
-* @throws 起始处不是 magic、或某帧算到的末位既不是下一帧帧头也不是 EOF——**一律抛**，
-*   绝不"尽力往下解"：切错帧的后果是把半截压缩体当解压输入，那时解出来的东西不可信。
+* **组级回滚**：把已经做成的成员按相反顺序退回；某一步退不干净时把失败并进原错误的
+* `details.rollbackFailures`，绝不让原错误独走（2026-10-19 `f2a7757`；那些失败句子的合并与措辞住
+* `src/verbs/errors.ts`，这里只是唯一的调用方）。删除与恢复两个按组走的动词共用这一处，
+* "相反顺序 + 失败合并"不再各写一遍。
 */
-function frameRanges(raw) {
-	const ranges = [];
-	let at = 0;
-	while (at < raw.length) {
-		if (!isMagicAt(raw, at)) throw new Error(`zstd 帧头缺席：偏移 ${at} 处不是 magic（前面第 ${ranges.length} 帧的边界算歪了？）`);
-		const descriptor = raw[at + 4];
-		if (descriptor === void 0) throw new Error(`zstd 帧头不完整：偏移 ${at} 之后不足 ${AFTER_DESCRIPTOR} 字节`);
-		const fcsFlag = descriptor & 3;
-		const singleSegment = descriptor >> 2 & 1;
-		const didFlag = descriptor >> 6 & 3;
-		let cursor = at + AFTER_DESCRIPTOR;
-		if (!singleSegment) cursor += 1;
-		cursor += DID_SIZES[didFlag];
-		cursor += (singleSegment ? FCS_SIZES_SINGLE : FCS_SIZES_MULTI)[fcsFlag];
-		for (;;) {
-			const blockHeader = readUint24LE(raw, cursor);
-			cursor += BLOCK_HEADER_BYTES;
-			if (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，对面解不开）`);
-			if (blockType === BLOCK_RAW || blockType === BLOCK_COMRESSED) cursor += blockSize;
-			else if (blockType === BLOCK_RLE) cursor += 1;
-			if (blockHeader & BLOCK_LAST) break;
-		}
-		cursor = withFrameTail(raw, cursor);
-		if (cursor !== raw.length && !isMagicAt(raw, cursor)) throw new Error(`zstd 帧边界算歪了：帧起于 ${at}，算到 ${cursor}，那里既不是下一帧帧头也不是 EOF`);
-		ranges.push({
-			start: at,
-			end: cursor
-		});
-		at = cursor;
+async function rollbackJournals(journals, error) {
+	const failures = [];
+	for (const journal of [...journals].reverse()) {
+		const undo = await journal.undo();
+		failures.push(...undo.failures);
 	}
-	return ranges;
+	if (failures.length > 0) throw withRollbackFailures(error, failures);
+	throw error;
+}
+/**
+* 这一步的失败形状：已经是动词码（`verbError` 的输出）就原样带，否则折成 `sessiondelete/io`。
+* 原文用 `String(error)` 而不是 `.message`——那 22 处既有措辞就是这么拼的（`Error: boom` 也在里面），
+* 换一种拼法会让上屏原文跟着变。
+*/
+function journalFailure(step, error) {
+	if (isSessionDeleteCodeError(error)) return error;
+	return verbError("io", `${step.label}：${String(error)}`, error);
 }
 //#endregion
-//#region src/log/session-log.ts
+//#region src/verbs/live-admission.ts
+/** 逐个问，任一在跑就抛 `live`。名单的挑选（哪些成员算这一组）归调用方，这里只按传入顺序问完。 */
+async function assertNoLive(host, sessionIds) {
+	for (const sessionId of sessionIds) if (await host.isLive(sessionId)) throw verbError("live", `会话正在运行：${sessionId}`);
+}
+//#endregion
+//#region src/verbs/member-presence.ts
+function createMemberPresence(host) {
+	return {
+		async memberGone(sessionId, facts = {}) {
+			if (facts.backInTrash === false) return;
+			if (await host.evictLive(sessionId) !== "unknown") await host.announceRemoved(sessionId);
+		},
+		async memberBack(sessionId, facts) {
+			if (!facts.diskBack || !facts.workspaceBack) return;
+			await host.announceRestored([sessionId]);
+		}
+	};
+}
 /**
-* 会话日志（`session.vN.jsonl.zstd`）的**逐帧读法**：帧边界交给 `zstd-frames.ts`，这一层只做
-* 「帧 → 明文 → 一行一条 JSON」的解码，并把每条记录原样交给回调。
+* 给一次成员移动的 journal 补上「在场那条尾巴」：run 完全成功之后离场、undo 之后按事实归位或离场。
 *
-* **策略不在这里**（哪些 `type` 算正文、截断到多少字、算不算失败）——那是 `src/trash/detail.ts` 的事。
-* 这一层只懂编解码，所以它能被单独验穿。
+* 为什么是个工厂：删除与恢复此前各手拼一个匿名 journal，形状逐字相同（`journal.run` 加上
+* `presence.memberGone`／`journal.undo` 加上 `presence.memberBack`），只差键 → 事实的映射。
+* 两处各写一遍，就是「补在哪一拍」这条顺序又有第二个家。
 *
-* 两条实测决定的口径：
-* ① **必须逐帧**：Node 的 `zstdDecompressSync` 与 `createZstdDecompress()` 都只给第一帧（见
-*    `zstd-frames.ts` 头注）；明文留在手里会一次装下整条日志（本机 125 条合计 280.7 MB），
-*    所以**一帧一帧解、解完就撒手**，内存口径是"最大那一帧的明文"（实测 8.99 MB）而不是整条。
-* ② **一行的余量跨帧带走**（2026-10-16 改，原来靠"跳过解不开的行"兜）：写作侧是一条条 append，
-*    本机实测**没有一帧切在行中间**（连最后一帧都整行收尾；绝对帧数随盘上会话数摆动，那份读数
-*    不在这里钉，来历留在 git 历史），
-*    所以旧口径当时并不丢东西；但"逐帧 `split('\n')`"一旦遇上切行就是**静默少一条记录**（半个头
-*    加半个身，两半都解不开 JSON），而少掉的那条正是页面上要跟账的正文。带上余量之后这条不变量
-*    不必再成立，顺带把**跨帧的多字节字符**也解对了——拼接在字节层做，`toString('utf8')` 只看整行。
-*    真被切断的尾巴（写一半）仍然**跳过并计数**：绝不因为一行就抛整个读数，前面几百条是真的。
-*/
-const NEWLINE = 10;
-/**
-* 宿主给每一代日志的词法（逐字取自 `@deepseek-ai/dsh-session-format@0.2.0-rc.2` 的
-* `CANONICAL_LOG_FILENAME`，剥掉压缩后缀那段由我们自己在正则里补上 `.zstd`）：
-* 裸名 `session.jsonl` 是**第 0 代**，往后是 `session.vN`；`.v0`、前导零、大写、临时名都不是规范名。
+* 边界：`memberGone` 的 `backInTrash:false` 早退与 `memberBack` 的两件齐备真值表仍归 `createMemberPresence`；
+* 这里只把事实原样递过去，不替它判断。
 */
-const CANONICAL_ZSTD_LOG = /^session(?:\.v([1-9][0-9]*))?\.jsonl\.zstd$/u;
+function withPresenceTail(presence, journal, tail) {
+	const announce = async (undo) => {
+		const fact = tail.onUndone(undo);
+		if (fact.kind === "leave") {
+			await presence.memberGone(tail.sessionId, { backInTrash: fact.backInTrash });
+			return;
+		}
+		await presence.memberBack(tail.sessionId, {
+			diskBack: fact.diskBack,
+			workspaceBack: fact.workspaceBack
+		});
+	};
+	return {
+		async run() {
+			await journal.run();
+			if (tail.onDone === "leave") await presence.memberGone(tail.sessionId);
+		},
+		async undo() {
+			const undo = await journal.undo();
+			await announce(undo);
+			return undo;
+		}
+	};
+}
+//#endregion
+//#region src/verbs/move-group.ts
 /**
-* 同一个会话目录里**可以并存多代日志**（宿主换代时把老代留在原地当历史语料，本机实测 7 个目录如此），
-* 而新代是老代的**迁移后超集**（实测：`firstTs` 与开头那条提问完全相同、记录更多、末尾更晚）
-* ⇒ 要读的是版本号最大的那一代，读旧代 = 读到一份截了尾巴的快照；把几代拼起来 = 重复计数。
+* 组级成员移动：组根先跑（拿到 `undefined`），跟随者按序跑并拿到根结果；任一失败就把**已经做成**的
+* 按相反顺序退回。
 *
-* 明文（无 `.zstd`）不在此列：本插件的读法逐帧解 zstd，明文得走另一条解码路。
+* 这里拥有顺序、整组回滚与**组根结果的交回**：根先跑，跟随者按序拿到根结果；调用方直接拿
+* 返回的根结果，不按位置索引结果数组。跟随者自己的结果不向上交回——当前调用方不需要。
+* 单成员的步骤与反向动作仍归 `member-journal.ts`；这条归属的裁决见 ADR-0002。
 */
-function pickSessionLog(names) {
-	let best;
-	let bestVersion = -1;
-	for (const name of names) {
-		const match = CANONICAL_ZSTD_LOG.exec(name);
-		if (match === null) continue;
-		const version = match[1] === void 0 ? 0 : Number(match[1]);
-		if (version > bestVersion) {
-			bestVersion = version;
-			best = name;
-		}
+async function moveGroup({ root, followers, move }) {
+	const journals = [];
+	const run = async (member, rootResult) => {
+		const prepared = await move(member, rootResult);
+		await prepared.journal.run();
+		journals.push(prepared.journal);
+		return prepared.result;
+	};
+	try {
+		const rootResult = await run(root, void 0);
+		for (const follower of followers) await run(follower, rootResult);
+		return rootResult;
+	} catch (error) {
+		return await rollbackJournals(journals, error);
 	}
-	return best;
 }
+//#endregion
+//#region src/verbs/delete-session.ts
 /**
-* 逐帧走一遍日志，每条记录交给回调。
+* 删除 = 移入回收站，**按组走**：用户点掉一条父会话时，宿主的客户端把 `origin:"subagent"` 的孩子
+* 整排藏了 ⇒ 那些目录既看不见也继续占着字节（本机实测 41 条父留了 320 个目录 / 74.6 MB）。
+* 所以这里把父在盘上的孩子一起搬进来，各自成目录、各自一行，清册用 `parentEntryId` 记它是谁的孩子。
 *
-* 回调返回 `false` = **提前停机**（后面的帧不再解——`readSessionHeader` 只要第一行）。
-* 停机后 `stats` 只是停机前那部分，别拿来做全量对账。
-*/
-function walkSessionLog(raw, onRecord) {
-	const stats = {
-		frames: 0,
-		records: 0,
-		unparsedLines: 0,
-		truncatedTailBytes: 0
-	};
-	let stopped = false;
-	const feed = (line) => {
-		if (line === "") return;
-		let parsed;
-		try {
-			parsed = JSON.parse(line);
-		} catch {
-			stats.unparsedLines += 1;
-			return;
-		}
-		stats.records += 1;
-		if (onRecord(parsed !== null && typeof parsed === "object" ? parsed : {}) === false) stopped = true;
-	};
-	/** 上一帧没闭合的那一行。**存字节不存字符**：切在多字节字符中间的帧要拼回完整才解得对。 */
-	let carry = Buffer.alloc(0);
-	for (const { start, end } of frameRanges(raw)) {
-		if (stopped) break;
-		stats.frames += 1;
-		let plain;
-		try {
-			plain = zlib.zstdDecompressSync(raw.subarray(start, end));
-		} catch (error) {
-			throw new Error(`回收站日志第 ${stats.frames} 帧解压失败：${String(error)}`);
-		}
-		const merged = carry.length === 0 ? plain : Buffer.concat([carry, plain]);
-		const cut = merged.lastIndexOf(NEWLINE);
-		if (cut === -1) {
-			carry = merged;
-			continue;
-		}
-		carry = merged.subarray(cut + 1);
-		for (const line of merged.subarray(0, cut).toString("utf8").split("\n")) {
-			feed(line);
-			if (stopped) break;
-		}
-	}
-	stats.truncatedTailBytes = carry.length;
-	if (carry.length > 0 && !stopped) feed(carry.toString("utf8"));
-	return stats;
-}
-/**
-* 日志的 **header**：格式事实是"第一行即 header"（`type: 'session'`，含 `id` 与 `cwd`，v3/v4 均如此，
-* AGENTS.md 有实测背书）——这里按 `type === 'session'` 找**第一条**这样的记录并就地停机
-* （不要求它恰是第一个可解析行：坏一行前缀不该让整条日志判不出身份）。
-* 找不到（空日志 / 全是别种记录）回 `undefined`；帧坏了照抛——那是"读不出来"，与"没有 header"是两件事。
-*/
-function readSessionHeader(raw) {
-	let header;
-	walkSessionLog(raw, (record) => {
-		if (record.type !== "session") return;
-		header = record;
-		return false;
-	});
-	return header;
-}
-//#endregion
-//#region src/trash/reconcile.ts
-/**
-* 回收站清单的**对账**：以 `session-trash/` 里的条目目录为准，把清单修回一致（CONTEXT.md 的「对账」条）。
-*
-* 手工动回收站**只需要动那一个目录**——多出来的目录在这里被重建出行、目录没了的行在这里被摘掉；
-* `~/.dsh/storages/` 那份清单从此是**内部索引**，不用手碰。
-*
-* 五条口径（都不是口味）：
-* ① **每次读清单都对账**（`GET /list` 的正文就是"对账 + 读"）：挂载、刷新、别处动过后的自动重读、
-*    客户端启动探测全走这条 ⇒ "改完目录不用再做任何事，下一次读就对了"。代价 = 每次读多一次目录枚举
-*    （本机 124 条，毫秒级）；**零漂移零写入**（快路直接返回原清单）。
-* ② **回收站根不在 ⇒ 整套跳过、一个字节都不动**：那不是"回收站空了"，是"这块地不在原处"
-*    （人为搬走、盘没挂上）——照常对账会把全部行的元数据一次判没。
-* ③ **重建行只写"文件里真有的事实"**：`id` = 目录名、`sessionId`/`cwd` 读日志 header、
-*    `projectDir` 由 `cwd` 经宿主同名算法 `projectKey` 反推、`deletedAt` 从目录名的时间戳解、
-*    `sizeBytes` 现场量。**文件侧没有副本的三件**按缺省落：`workspaceId: ''`（恢复时跳过挂账本，
-*    落在「未分组」）、`wasArchived: false`（文件侧没有归档事实；旧条目恢复走迁移支）、`title: ''`（详情有日志标题兜底）
-*    ——这是重建的固有代价，不是可以"再读读看"的东西。
-* ④ **认不出 / 读不出的目录：不动、不列**（名字不像条目、目录里没有日志、header 读不出、尺寸量不出，
-*    各跳过各的）。它是"外人放进来的东西"，不是用户动作失败：跳过即静默，绝不为它删目录或抛掉整次读数。
-* ⑤ **幂等**：再跑一遍零写入；崩在任何一步，下一次读清单接着把它修完。
-*
-* 与三个写动词的**串行化不在这里**（那是传输层的事，见 `src/api/dispatch.ts` 的到达序链）：
-* 对账与删除/恢复/彻底删除都是"读清单 + 动文件 + 写清单"的多步，交错跑会互相踩——删除刚把目录搬进
-* 回收站、行还没写上时，对账抢先把这行按目录"重建"出来，随后又被真实行覆盖成降级元数据。
-*/
-/** 目录名是不是一条条目 id（形状契约在 `entry.ts`：`<删除时刻UTC>-<原目录名>`；
-*  原目录名还必须能安全地拼回磁盘路径——带分隔符的名字仍按"外人"跳过，不让一次对账读崩）。 */
-function isEntryId(name) {
-	try {
-		return isSinglePathSegment(parseEntryId(name).sessionDirName);
-	} catch {
-		return false;
-	}
-}
-/**
-* 从一个手工放进回收站的目录重建清单行。**任一件事实拿不到就整体放弃这一条**（回 `undefined`）：
-* 半截行比"不列"更坏——恢复会照它把目录搬去一个错的地方（同 `detail.ts` 那条"半截正文"的口径）。
-*
-* `sessionId` 取日志 header 的 `id`（恢复之后宿主按日志 header 建索引，那才是会话身份）；
-* header 缺席这个字段才回落到目录名里那段原目录名。
-*/
-async function buildEntry(deps, id) {
-	const dir = trashDirOf(id, deps.home);
-	let logName;
-	try {
-		logName = pickSessionLog(await deps.fs.listFiles(dir));
-	} catch {
-		return;
-	}
-	if (logName === void 0) return void 0;
-	let raw;
-	try {
-		raw = await deps.fs.readFile(`${dir}/${logName}`);
-	} catch {
-		return;
-	}
-	let header;
-	try {
-		header = readSessionHeader(raw);
-	} catch {
-		return;
-	}
-	if (header === void 0) return void 0;
-	let sizeBytes;
-	try {
-		sizeBytes = await deps.fs.sizeOfDir(dir);
-	} catch {
-		return;
-	}
-	const { deletedAt, sessionDirName } = parseEntryId(id);
-	const cwd = typeof header.cwd === "string" ? header.cwd : "";
-	return {
-		id,
-		sessionId: typeof header.id === "string" && header.id !== "" ? header.id : sessionDirName,
-		projectDir: cwd === "" ? NO_CWD_PROJECT_DIR : projectKey(cwd),
-		workspaceId: "",
-		wasArchived: false,
-		deletedAt,
-		title: "",
-		sizeBytes
-	};
-}
-/** 对账并回清单——**返回的就是修好之后的那份**（与 `manifest.list()` 同序：最近删除在前）。 */
-async function reconcileTrash(deps) {
-	const rows = await deps.manifest.list();
-	const root = `${deps.home}/${TRASH_DIR_NAME}`;
-	if (!await deps.fs.exists(root)) return rows;
-	const dirIds = /* @__PURE__ */ new Set();
-	for (const name of await deps.fs.listDirs(root)) if (isEntryId(name)) dirIds.add(name);
-	const rowIds = new Set(rows.map((row) => row.id));
-	const drops = rows.filter((row) => !dirIds.has(row.id));
-	const rebuilds = [];
-	for (const id of dirIds) {
-		if (rowIds.has(id)) continue;
-		const entry = await buildEntry(deps, id);
-		if (entry !== void 0) rebuilds.push(entry);
-	}
-	if (drops.length === 0 && rebuilds.length === 0) return rows;
-	for (const row of drops) await deps.manifest.remove(row.id);
-	for (const entry of rebuilds) await deps.manifest.add(entry);
-	return await deps.manifest.list();
-}
-//#endregion
-//#region src/verbs/member-journal.ts
-/**
-* 一次成员移动 = 一串**自带反向动作的步骤**（ADR-0002）。
-*
-* 为什么需要它：`delete-session.ts` 的 `moveOneIn`/`undoOneIn` 与 `restore-session.ts` 的 `restoreOne`
-* （含它的反向闭包）互为镜像，各自手写了三到四段嵌套 `try/catch`：迁移前全仓 `rollbackReason(` **22 处**、
-* `withRollbackFailures(` **8 处**。那不是"回滚值得自己的候选"，而是**同一条正反动作对被写了两遍**。
-*
-* 这里独占四件事，三个动词各自只声明"这次要做哪几步、每步怎么退"：
-* ① **相反顺序**退化（最后做成的先退）；
-* ② 一步失败时把**已经做成的**那些退回去；
-* ③ 失败收集：某一步退不干净时**不让原错误独走**（`details.rollbackFailures`，见 `verbs/errors.ts`）；
-* ④ **非原子步骤**：`undoOnFailure` 让"这一步自己失败了"也跑它的反向动作（例如"取消归档"半做完了，
-*    得先把会话重新藏回去）。
-*
-* 边界：它只服务"成员在 `sessions/` 与 `session-trash/` 之间搬"这一件事。做成通用撤销框架就会吸进
-* 不属于它的知识（谁该通告、通告几次、哪些失败算成功）。
-*/
-/** 已经把某个前缀做成了的 journal——`undo()` 就退那一个前缀。 */
-function createJournal(steps) {
-	const done = [];
-	const undoAll = async (alsoFailing) => {
-		const failures = [];
-		if (alsoFailing?.undo !== void 0) failures.push(...await alsoFailing.undo());
-		for (const step of [...done].reverse()) {
-			if (step.undo === void 0) continue;
-			failures.push(...await step.undo());
-		}
-		return failures;
-	};
-	return {
-		async run() {
-			for (const step of steps) {
-				try {
-					await step.run();
-				} catch (error) {
-					const failures = await undoAll(step.undoOnFailure === true ? step : void 0);
-					const base = journalFailure(step, error);
-					throw failures.length > 0 ? withRollbackFailures(base, failures) : base;
-				}
-				done.push(step);
-			}
-		},
-		undo() {
-			return undoAll();
-		}
-	};
-}
-/** 跑一步反向动作并把它自己的失败收成一条原因（不抛：这些失败由调用方汇总成 `rollbackFailures`）。 */
-async function attempt(label, run) {
-	try {
-		await run();
-		return [];
-	} catch (error) {
-		return [rollbackReason(label, error)];
-	}
-}
-/**
-* **组级回滚**：把已经做成的成员按相反顺序退回；某一步退不干净时把失败并进原错误的
-* `details.rollbackFailures`，绝不让原错误独走（2026-10-19 `f2a7757`；那些失败句子的合并与措辞住
-* `src/verbs/errors.ts`，这里只是唯一的调用方）。删除与恢复两个按组走的动词共用这一处，
-* "相反顺序 + 失败合并"不再各写一遍。
-*/
-async function rollbackJournals(journals, error) {
-	const failures = [];
-	for (const journal of [...journals].reverse()) failures.push(...await journal.undo());
-	if (failures.length > 0) throw withRollbackFailures(error, failures);
-	throw error;
-}
-/**
-* 这一步的失败形状：已经是动词码（`verbError` 的输出）就原样带，否则折成 `sessiondelete/io`。
-* 原文用 `String(error)` 而不是 `.message`——那 22 处既有措辞就是这么拼的（`Error: boom` 也在里面），
-* 换一种拼法会让上屏原文跟着变。
-*/
-function journalFailure(step, error) {
-	if (isVerbCodeError(error)) return error;
-	return verbError("io", `${step.label}：${String(error)}`, error);
-}
-//#endregion
-//#region src/verbs/member-presence.ts
-function createMemberPresence(host) {
-	return {
-		async memberGone(sessionId, facts = {}) {
-			if (facts.backInTrash === false) return;
-			if (await host.evictLive(sessionId) !== "unknown") await host.announceRemoved(sessionId);
-		},
-		async memberBack(sessionId, facts) {
-			if (!facts.diskBack || !facts.workspaceBack) return;
-			await host.announceRestored(sessionId);
-		}
-	};
-}
-//#endregion
-//#region src/verbs/delete-session.ts
-/**
-* 删除 = 移入回收站，**按组走**：用户点掉一条父会话时，宿主的客户端把 `origin:"subagent"` 的孩子
-* 整排藏了 ⇒ 那些目录既看不见也继续占着字节（本机实测 41 条父留了 320 个目录 / 74.6 MB）。
-* 所以这里把父在盘上的孩子一起搬进来，各自成目录、各自一行，清册用 `parentEntryId` 记它是谁的孩子。
-*
-* 三段，顺序承重：
+* 三段，顺序承重（成员循环与整组回滚的实现住 `verbs/move-group.ts`）：
 * ① **先点组、先验活体**（一个字节都不写）。任一成员在跑就整组拒绝——不替用户终止正在跑的活，
 *    也绝不允许"父已经搬进回收站、孩子因为在跑而搬不动"这种半套。
 * ② **逐个搬**：每个成员是一份 `journal`（`verbs/member-journal.ts`），搬不动时 journal 自己把
@@ -1311,7 +1118,8 @@ function createMemberPresence(host) {
 * ③ **组级回滚**：某一个成员搬不动时，把**已经搬进去的**那些按相反顺序退回原处（清册行跟着摘、
 *    账本跟着挂），失败照抛——不留"半组在回收站、半组在原地"的世界。
 *
-* interface 只有**一个 id**：批量的性质不在这里（同批"已被前一条带走"的判据归 `verbs/batch.ts`）。
+* interface 只有**一个 id**：批量的性质不在这里（同批已带走集归 `verbs/batch-carried.ts`，
+* 组语义归 `trash/groups.ts`）。
 * 结果带回这次真的搬走的整组（`movedSessionIds`）——它是动词交回的内部数据，不再靠回调借用动词的手。
 */
 function deleteSession(deps) {
@@ -1321,40 +1129,32 @@ function deleteSession(deps) {
 		const kids = read.available ? read.value[sessionId] ?? [] : [];
 		const parentProjectDir = await deps.host.projectDirOf(sessionId);
 		if (parentProjectDir === void 0) throw verbError("not-found", `宿主的持久化里没有这个会话：${sessionId}`);
-		const candidates = [{
-			sessionId,
-			projectDir: parentProjectDir
-		}, ...kids.map((k) => ({
-			sessionId: k.sessionId,
-			projectDir: k.projectDir
-		}))];
-		for (const member of candidates) if (await deps.host.isLive(member.sessionId)) throw verbError("live", `会话正在运行：${member.sessionId}`);
+		await assertNoLive(deps.host, [sessionId, ...kids.map((kid) => kid.sessionId)]);
 		const parentDir = sessionDirOf(parentProjectDir, sessionId, deps.home);
 		if (!await deps.fs.exists(parentDir)) throw verbError("not-found", `会话目录不存在：${parentDir}`);
-		const members = [{
+		const parent = {
 			sessionId,
 			projectDir: parentProjectDir
-		}];
+		};
+		const members = [parent];
 		for (const kid of kids) if (await deps.fs.exists(sessionDirOf(kid.projectDir, kid.sessionId, deps.home))) members.push({
 			sessionId: kid.sessionId,
 			projectDir: kid.projectDir
 		});
 		const deletedAt = deps.now();
-		const done = [];
-		let parentEntry;
-		try {
-			for (const member of members) {
-				const isParent = member.sessionId === sessionId;
-				const move = await memberMove(deps, presence, member, deletedAt, isParent ? void 0 : parentEntry.id);
-				if (isParent) parentEntry = move.entry;
-				await move.journal.run();
-				done.push(move.journal);
-			}
-		} catch (error) {
-			await rollbackJournals(done, error);
-		}
 		return {
-			entry: parentEntry,
+			entry: await moveGroup({
+				root: parent,
+				followers: members.slice(1),
+				move: async (member, rootResult) => {
+					const parentEntryId = rootResult?.id;
+					const move = await memberMove(deps, presence, member, deletedAt, parentEntryId);
+					return {
+						journal: move.journal,
+						result: move.entry
+					};
+				}
+			}),
 			movedSessionIds: members.map((member) => member.sessionId)
 		};
 	};
@@ -1391,72 +1191,65 @@ async function memberMove(deps, presence, member, deletedAt, parentEntryId) {
 	};
 	/** 目录真的搬进回收站了吗——决定那一步的反向动作有没有东西可退。 */
 	let moved = false;
-	/** 回滚的两件写是否都真正退回原样：目录、账本。两个事实交给成员在场 module 判「归位」通告。
-	*  删除不碰归档集 ⇒ 可见性不是这次删除改过的事实，不进真值表。 */
-	let movedBack = false;
-	let workspaceBack = workspaceId === void 0;
-	const journal = createJournal([
-		{
-			label: "读取会话现场失败",
-			run: async () => {
-				entry.title = await deps.host.titleOf(sessionId);
-				entry.sizeBytes = await deps.fs.sizeOfDir(sessionDir);
-			}
-		},
-		...workspaceId === void 0 ? [] : [{
-			label: "摘账本失败",
-			run: async () => {
-				await deps.host.detach(sessionId, workspaceId);
-			},
-			undo: async () => {
-				return await attempt("账本挂回失败", async () => {
-					await deps.host.attach(sessionId, workspaceId);
-					workspaceBack = true;
-				});
-			}
-		}],
-		{
-			label: "移动会话目录失败",
-			undoOnFailure: true,
-			run: async () => {
-				await deps.fs.ensureDir(`${deps.home}/${TRASH_DIR_NAME}`);
-				await deps.fs.rename(sessionDir, trashDir);
-				moved = true;
-				try {
-					await deps.manifest.add(entry);
-				} catch (error) {
-					throw verbError("io", `登记回收站条目失败：${String(error)}`, error);
-				}
-			},
-			undo: async () => {
-				if (!moved) return [];
-				const failures = [...await attempt("目录搬回失败", async () => {
-					await deps.fs.rename(trashDir, sessionDir);
-					movedBack = true;
-				})];
-				if (failures.length === 0) failures.push(...await attempt("清册行摘除失败", () => deps.manifest.remove(entry.id)));
-				return failures;
-			}
-		}
-	]);
 	return {
 		entry,
-		journal: {
-			async run() {
-				await journal.run();
-				await presence.memberGone(sessionId);
+		journal: withPresenceTail(presence, createJournal([
+			{
+				key: "read",
+				label: "读取会话现场失败",
+				run: async () => {
+					entry.title = await deps.host.titleOf(sessionId);
+					entry.sizeBytes = await deps.fs.sizeOfDir(sessionDir);
+				}
 			},
-			/** 组级回滚：先把成员自己的步骤按相反顺序退回，再交给成员在场 module 判「三件写都回去了吗」。
-			*  这一行此前已经收过 `api-session/removed`；不发"回来了"它就会在客户端消失到重连为止。 */
-			async undo() {
-				const failures = await journal.undo();
-				await presence.memberBack(sessionId, {
-					diskBack: movedBack,
-					workspaceBack
-				});
-				return failures;
+			...workspaceId === void 0 ? [] : [{
+				key: "workspace",
+				label: "摘账本失败",
+				run: async () => {
+					await deps.host.detach(sessionId, workspaceId);
+				},
+				undo: () => stepUndo("账本挂回失败", () => deps.host.attach(sessionId, workspaceId))
+			}],
+			{
+				key: "dir",
+				label: "移动会话目录失败",
+				undoOnFailure: true,
+				run: async () => {
+					await deps.fs.ensureDir(`${deps.home}/${TRASH_DIR_NAME}`);
+					await deps.fs.rename(sessionDir, trashDir);
+					moved = true;
+					try {
+						await deps.ledger.add(entry);
+					} catch (error) {
+						throw verbError("io", `登记回收站条目失败：${String(error)}`, error);
+					}
+				},
+				undo: async () => {
+					if (!moved) return {
+						restored: true,
+						failures: []
+					};
+					const directory = await stepUndo("目录搬回失败", () => deps.fs.rename(trashDir, sessionDir));
+					const failures = [...directory.failures];
+					if (directory.restored) failures.push(...await attempt("清册行摘除失败", () => deps.ledger.remove(entry.id)));
+					return {
+						restored: directory.restored,
+						failures
+					};
+				}
 			}
-		}
+		]), {
+			sessionId,
+			onDone: "leave",
+			/** 组级回滚：先按相反顺序退步骤，再判「目录与账本两件写都回去了吗」。
+			*  这一行此前已经收过 `api-session/removed`；不发「回来了」它就会在客户端消失到重连为止。
+			*  「退没退成」由 journal 的逐步结果交出来，这里只读键，不自己累计布尔。 */
+			onUndone: (undo) => ({
+				kind: "return",
+				diskBack: undo.restored("dir"),
+				workspaceBack: workspaceId === void 0 ? true : undo.restored("workspace")
+			})
+		})
 	};
 }
 //#endregion
@@ -1593,28 +1386,24 @@ async function planVisibleTrash(deps, rows, groups) {
 		};
 	}));
 }
-/** 活体准入：逐个问，任一在跑就抛 `live`。**计划函数就是执行前的闸**——调用方拿到计划才允许写，
-*  所以这里必须发生在任何写之前（`admission:'none'` 的调用方自己承担这个风险，不进来）。 */
-async function assertNoLive(deps, sessionIds) {
-	for (const sessionId of sessionIds) if (await deps.host.isLive(sessionId)) throw verbError("live", `会话正在运行：${sessionId}`);
-}
 function totalBytes(items) {
 	return items.reduce((total, item) => total + item.bytes, 0);
 }
 /**
 * purge 的删除计划：`targets` 由调用方按组语义（`trash/groups.ts`）选好，这里只量、只筛、只查活体。
+* **计划函数就是执行前的闸**——调用方拿到计划才允许写，所以准入必须发生在任何写之前。
 *
 * - `trash` 按 targets 原序逐个实测（目录缺席的行 `present:false` / 0 字节，但清册行仍要摘）。
 * - 盘上后代经 `selectStrandedMembers` 选出（一次问全部 targets、排除全部清册 id、bare id 全局只计划一次）。
 * - `members` 只收盘上还有目录的成员（目录缺席没有可删的字节）；`unarchive` = targets + 这些成员：
 *   只摘这一次真要碰的 id。
-* - `admission:'live'` 在量目录与任何写之前逐个查 targets 与**全部枚举到的**盘上后代；
-*   任一在跑就整条拒绝，零副作用。
+* - 活体准入在量目录与任何写之前逐个查 targets 与**全部枚举到的**盘上后代；任一在跑就整条拒绝、
+*   零副作用。没有跳过它的开关——计划就是执行前的闸（ADR-0006）。
 * - `sessionQuery` 缺席时端口回 `{ available: false }` ⇒ members 为空、不抛（盘上残留留给 `GET /orphans` 兜底）。
 */
-async function planTrashRemoval(deps, rows, targets, options) {
+async function planTrashRemoval(deps, rows, targets) {
 	const candidates = (await selectStrandedMembers(deps.host, rows, targets.map((entry) => entry.sessionId))).flat();
-	if (options.admission === "live") await assertNoLive(deps, [...targets.map((entry) => entry.sessionId), ...candidates.map((member) => member.sessionId)]);
+	await assertNoLive(deps.host, [...targets.map((entry) => entry.sessionId), ...candidates.map((member) => member.sessionId)]);
 	const trash = await Promise.all(targets.map((entry) => measureTrashRow(deps, entry)));
 	const members = await planMemberRemovals(deps, candidates);
 	return {
@@ -1635,7 +1424,7 @@ async function planTrashRemoval(deps, rows, targets, options) {
 * - 回执由 `kind:'orphan'` 派生：删目录阶段失败时执行器要交回 `{removed, freedBytes, failedSessionId}`。
 */
 async function planOrphanRemoval(deps, members) {
-	await assertNoLive(deps, members.map((member) => member.sessionId));
+	await assertNoLive(deps.host, members.map((member) => member.sessionId));
 	const present = await planMemberRemovals(deps, members);
 	return {
 		kind: "orphan",
@@ -1646,7 +1435,8 @@ async function planOrphanRemoval(deps, members) {
 	};
 }
 /**
-* 按计划执行一次永久删除：只写、不再量、不再判活体（计划就是执行前的闸）。
+* 按计划执行一次永久删除：只写、不再量、不再判活体（计划就是执行前的闸）。回执的字节念计划
+* （`plan.bytes`），执行期不再累加一遍。
 *
 * 顺序（与迁移前的 purge / orphan-clean 一致）：整批摘归档集 → 摘有账本的成员的账本 → 逐条回收站行
 * （在才删目录 → 摘清册行 → 通告成员离场）→ 逐条盘上成员（删目录 → 通告成员离场）。目录删掉就没有
@@ -1662,15 +1452,16 @@ async function planOrphanRemoval(deps, members) {
 async function executeRemoval(deps, plan) {
 	const presence = createMemberPresence(deps.host);
 	let removed = 0;
-	let freedBytes = 0;
+	/** 删到这一刻已经腾出的**进度**：只喂 `orphan` 的部分回执；成功回执念计划的合计（`plan.bytes`）。 */
+	let freedSoFar = 0;
 	/** 删除途中失败的唯一出口：标签沿用旧措辞；部分回执只属于 `orphan`（由计划的 `kind` 派生）。
 	*  已经是本仓动词码的错误原样抛（与 `member-journal.ts` 的 `journalFailure` 同一条判据）——
 	*  `not-found` / `live` 之类不许在这里被折成 `io`。 */
 	const fail = (label, error, failedSessionId) => {
-		if (isVerbCodeError(error)) throw error;
+		if (isSessionDeleteCodeError(error)) throw error;
 		const details = plan.kind === "orphan" ? {
 			removed,
-			freedBytes,
+			freedBytes: freedSoFar,
 			failedSessionId
 		} : void 0;
 		throw verbError("io", `${label}：${String(error)}`, error, details);
@@ -1700,10 +1491,10 @@ async function executeRemoval(deps, plan) {
 			} catch (error) {
 				fail("删除回收站目录失败", error, row.entry.sessionId);
 			}
-			freedBytes += row.bytes;
+			freedSoFar += row.bytes;
 		}
 		try {
-			await deps.manifest.remove(row.entry.id);
+			await deps.ledger.remove(row.entry.id);
 		} catch (error) {
 			fail("删除回收站目录失败", error, row.entry.sessionId);
 		}
@@ -1718,12 +1509,12 @@ async function executeRemoval(deps, plan) {
 			fail(memberLabel, error, member.sessionId);
 		}
 		removed += 1;
-		freedBytes += member.bytes;
+		freedSoFar += member.bytes;
 		await presence.memberGone(member.sessionId);
 	}
 	return {
 		removed,
-		freedBytes
+		freedBytes: plan.bytes
 	};
 }
 //#endregion
@@ -1777,17 +1568,19 @@ function orphanGroupsOf(corpus, trashSessionIds) {
 	}
 	return groups;
 }
-/** 纯读：调用方应先走一次 `/list` 对账（面板的 refresh 就是这样）；本函数不写清单。
-*  写动作 `orphan-clean` 会自己先 reconcile，避免拿一份过期清册判"父没了"。
+/** **本函数是纯扫描，不对账、不写清册行**（`/orphans` 声明为 pure，一次扫描不能顺手写行）。清册默认读
+*   `ledger.raw()`；写路径（`orphan-clean`）可以在调它之前先 `ledger.list()` 对账，并把交回的行递进来，
+*  免得同一份索引再读一遍——否则刚被人手工搬进 `session-trash/` 的父目录还没有行，会被当成"父没了"
+*  直接删盘。
 *
 *  `listSessions()` 回 `{ available: false }` 时**必须抛**：那是宿主的会话语料服务没挂，不是"这个家没有孤儿"。
 *  拿缺席当空语料 ⇒ 报告说"零条孤儿"、界面上一句"没有要清理的"，而盘上真有几百 MB——那是假话，
 *  所以这里按 `io` 响亮失败（AGENTS.md：`available: false` 意味着服务缺席，扫描方不许冒充读数）。 */
-async function loadOrphanGroups(deps) {
+async function loadOrphanGroups(deps, trash) {
 	const read = await deps.host.listSessions();
 	if (!read.available) throw verbError("io", "无主子会话扫描需要宿主的 sessionQuery.listSessions");
 	const corpus = read.value;
-	const groups = orphanGroupsOf(corpus, (await deps.manifest.list()).map((entry) => entry.sessionId));
+	const groups = orphanGroupsOf(corpus, (trash ?? await deps.ledger.raw()).map((entry) => entry.sessionId));
 	const out = [];
 	for (const group of groups) {
 		const members = [];
@@ -1856,10 +1649,12 @@ async function cleanOrphanGroup(deps, group) {
 /**
 * 彻底删除：从回收站里**真的**抹掉一条（或整组、或整站），并连带那些"还留在盘上、没被带走"的后代。
 *
-* 与另外两个动词的关系（ADR-0002）：它的 interface 只有"一个条目 id（或缺席 = 清空）"，
-* 批量的快照与"已被同批前一条带走"的判据不在这里（归 `verbs/batch.ts`）。
+* 与另外两个动词的关系（ADR-0002）：它的 interface 是"这一组目标 + 一份只读清册快照
+*（targets 缺席 = 清空）"；目标由 `verbs/batch-carried.ts` 按组语义算好，批量的"已被同批前一条
+* 带走"判据不在这里。`requestedId` 是唯一的例外参数，但它**不参与任何判据**：只是让
+* `trash-empty` 的原文点得出用户点的是哪一条（原文要上屏，点名承重），批量语义仍在批量层。
 *
-* **这条动词只做两件事：选目标、拿计划交给执行器**。量目录、筛盘上后代、活体准入与"先退归档集、
+* **这条动词只做两件事：拿目标、把计划交给执行器**。量目录、筛盘上后代、活体准入与"先退归档集、
 * 再摘账本、最后删目录"的顺序都住 `verbs/permanent-removal.ts`——计划只读，执行器只写，计划就是
 * 执行前的闸（别在这里再长出一段手写步骤）。
 *
@@ -1868,11 +1663,10 @@ async function cleanOrphanGroup(deps, group) {
 * 对应地，`kind:'trash'` 的计划失败时执行器只抛那一步的 `io` 与原文、不带 details。
 */
 function purgeTrash(deps) {
-	return async function purgeTrash(entryId, snapshot) {
-		const all = snapshot ?? await deps.manifest.list();
-		const targets = entryId === void 0 ? all : groupOf(all, entryId);
-		if (entryId !== void 0 && targets.length === 0) throw verbError("trash-empty", `回收站里没有这一条：${entryId}`);
-		return await executeRemoval(deps, await planTrashRemoval(deps, all, targets, { admission: "live" }));
+	return async function purgeTrash(targets, rows, requestedId) {
+		const selected = targets ?? rows;
+		if (targets !== void 0 && selected.length === 0) throw verbError("trash-empty", requestedId === void 0 ? "回收站里没有这一条" : `回收站里没有这一条：${requestedId}`);
+		return await executeRemoval(deps, await planTrashRemoval(deps, rows, selected));
 	};
 }
 //#endregion
@@ -1881,7 +1675,7 @@ function purgeTrash(deps) {
 * 恢复 = 把删除那次**按原路退回**，而且按组走：当年是按组一起搬进来的（父 + 它在盘上的孩子），
 * 只回父就会在回收站里留下一堆点不到的孩子行——清单只列父行，那些行既看不见也清不掉。
 *
-* 三段与删除对称：
+* 三段与删除对称（成员循环与整组回滚的实现住 `verbs/move-group.ts`）：
 * ① **预检整组**（一个字节都不写）：每个成员的回收站目录与项目目录都得在。缺席的判据与原来一致
 *    （回收站目录不在 = `trash-empty`；原项目目录不在 = `project-missing`，且绝不静默建目录）。
 *    预检在写之前，是为了不让"父已经回到 `sessions/`、孩子因为项目目录没了而回不去"这种半组留在外面。
@@ -1891,32 +1685,31 @@ function purgeTrash(deps) {
 * ③ 中途失败时 journal 把这个成员自己退回回收站；**已经恢复完的**兄弟由整组 catch 按相反顺序一起退回。
 *
 * **通告不在这里**：一次批量只该拉一遍宿主会话表、只发一次 `api-session/added`（2026-10-17 那次
-* "恢复很慢"就是逐条发）。通告归 `verbs/batch.ts`（ADR-0002），所以这个动词的 interface 只有
-* "一个条目 id 进、回收站那一行出"，没有批量专用的开关。
+* "恢复很慢"就是逐条发）。通告归 `verbs/batch.ts`（ADR-0002），所以这个动词的 interface 是
+* "一个条目 id + 这一组进、回收站那一行出"，没有批量专用的开关。
 */
 function restoreSession(deps) {
 	const presence = createMemberPresence(deps.host);
-	return async function restoreSession(entryId, snapshot) {
-		const all = snapshot ?? await deps.manifest.list();
-		const target = all.find((e) => e.id === entryId);
-		if (!target) throw verbError("trash-empty", `回收站里没有这一条：${entryId}`);
-		const group = groupOf(all, entryId);
+	return async function restoreSession(entryId, group) {
+		const [root, ...followers] = group;
+		const target = group.find((e) => e.id === entryId);
+		if (root === void 0 || target === void 0) throw verbError("trash-empty", `回收站里没有这一条：${entryId}`);
 		for (const entry of group) {
 			const trashDir = trashDirOf(entry.id, deps.home);
 			if (!await deps.fs.exists(trashDir)) throw verbError("trash-empty", `回收站条目已不在磁盘上：${trashDir}`);
 			const projectRoot = sessionDirOf(entry.projectDir, "", deps.home).replace(/\/$/, "");
 			if (!await deps.fs.exists(`${deps.home}/sessions`) || !await deps.fs.exists(projectRoot)) throw verbError("project-missing", `原项目目录已不存在：${projectRoot}`);
 		}
-		const done = [];
-		try {
-			for (const entry of group) {
-				const move = await memberRestore(deps, presence, entry);
-				await move.journal.run();
-				done.push(move.journal);
+		await moveGroup({
+			root,
+			followers,
+			move: async (entry) => {
+				return {
+					journal: (await memberRestore(deps, presence, entry)).journal,
+					result: void 0
+				};
 			}
-		} catch (error) {
-			await rollbackJournals(done, error);
-		}
+		});
 		return target;
 	};
 }
@@ -1963,21 +1756,17 @@ async function memberRestore(deps, presence, entry) {
 	const legacyArchived = !entry.wasArchived && await deps.host.isArchived(entry.sessionId);
 	/** 真挂上了账本才记下那个 id——回滚里"摘账本"那一步只对挂过的成员存在。 */
 	let attached = false;
-	/** 组级回滚时，目录是否真的退回回收站——作为事实交给成员在场 module 判「已移除」通告。 */
-	let movedBack = false;
-	const journal = createJournal([
+	return { journal: withPresenceTail(presence, createJournal([
 		{
+			key: "dir",
 			label: "放回会话目录失败",
 			run: async () => {
 				await deps.fs.rename(trashDir, sessionDir);
 			},
-			undo: async () => {
-				const failures = await attempt("目录退回回收站失败", () => deps.fs.rename(sessionDir, trashDir));
-				if (failures.length === 0) movedBack = true;
-				return failures;
-			}
+			undo: () => stepUndo("目录退回回收站失败", () => deps.fs.rename(sessionDir, trashDir))
 		},
 		...workspaceId === void 0 ? [] : [{
+			key: "workspace",
 			label: "挂回账本失败",
 			run: async () => {
 				try {
@@ -1987,32 +1776,38 @@ async function memberRestore(deps, presence, entry) {
 					if (!isWorkspaceMissingError(error) || await deps.host.workspaceExists(workspaceId)) throw error;
 				}
 			},
-			undo: async () => attached ? attempt("摘账本失败", () => deps.host.detach(entry.sessionId, workspaceId)) : []
+			undo: async () => {
+				if (!attached) return {
+					restored: true,
+					failures: []
+				};
+				return stepUndo("摘账本失败", () => deps.host.detach(entry.sessionId, workspaceId));
+			}
 		}],
 		...!legacyArchived ? [] : [{
+			key: "archive",
 			label: "取消归档失败",
 			undoOnFailure: true,
 			run: async () => {
 				await deps.host.unarchive(entry.sessionId);
 			},
-			undo: () => attempt("重新归档失败", () => deps.host.archive(entry.sessionId, workspaceId))
+			undo: () => stepUndo("重新归档失败", () => deps.host.archive(entry.sessionId, workspaceId))
 		}],
 		{
+			key: "manifest",
 			label: "摘回收站条目失败",
 			run: async () => {
-				await deps.manifest.remove(entry.id);
+				await deps.ledger.remove(entry.id);
 			},
-			undo: () => attempt("清册行写回失败", () => deps.manifest.add(entry))
-		}
-	]);
-	return { journal: {
-		run: () => journal.run(),
-		async undo() {
-			const failures = await journal.undo();
-			await presence.memberGone(entry.sessionId, { backInTrash: movedBack });
-			return failures;
+			undo: () => stepUndo("清册行写回失败", () => deps.ledger.add(entry))
 		}
-	} };
+	]), {
+		sessionId: entry.sessionId,
+		onUndone: (undo) => ({
+			kind: "leave",
+			backInTrash: undo.restored("dir")
+		})
+	}) };
 }
 //#endregion
 //#region src/verbs/batch.ts
@@ -2025,16 +1820,18 @@ async function memberRestore(deps, presence, entry) {
 * interface 上（`onMembers` / `snapshot` / `suppressAnnounce`），于是每个动词都得知道"我是第几个、
 * 前面的兄弟带走了谁"，同一个事实还有三种机制（回调、调用方 `taken` 集合、动词就地收缩数组）。
 *
-* 这一层独占四件（每条批量语义都在这里）：
+* 这一层拥有三件（每条批量语义都在这里）：
 * ① **去重保序**：输入顺序就是界面"清单从上往下"的读感；
-* ② **清册快照**：整批只读一次"最初的样子"，用来判断"已被同批前一条带走"；
-* ③ **逐条信封**：一条失败不传染下一条，失败按 `map-error` 那张表折成 `{code,message,details?}`；
-* ④ **一批一次通告**：恢复的 `api-session/added` 攒到批尾、配一次预取的摘要表发（逐条发 = 每条一次
-*   宿主全表扫，那正是 2026-10-17 "恢复很慢"的头号来源）。
+* ② **逐条信封**：一条失败不传染下一条，失败按 `map-error` 那张表折成 `{code,message,details?}`；
+* ③ **一批一次通告**：恢复的 `api-session/added` 攒到批尾、调一次 `announceRestored(ids)`（预取与逐条
+*   发送都在 adapter 里；逐条调 = 每条一次宿主全表扫，那正是 2026-10-17 "恢复很慢"的头号来源）。
+*
+* **同批已带走集**（整批只读一次"最初的样子"）住 `src/verbs/batch-carried.ts`；这里消费它的
+* `claim` / `take`，purge 另取 entry 域的 `rows()` 作为当前只读清册。
 *
 * 「已被同批前一条带走」是**幂等成功**，不是失败：用户要的结果本来就已经达成了（`delete`/`restore`
-* 回 `null`；`purge` 回 `{removed:0,freedBytes:0}`）。判据读 `trash/groups.ts`（ADR-0001），
-* 与 `/list` 的装配、与三个动词同一条。
+* 回 `null`；`purge` 回 `{removed:0,freedBytes:0}`）。判据仍归 `trash/groups.ts`（ADR-0001，
+* 由 `batch-carried.ts` 调用），同批已带走集只决定"这一条还该不该交给动词"。
 */
 function failure(id, action, error) {
 	return {
@@ -2065,116 +1862,307 @@ function unique(ids) {
 	return out;
 }
 /**
-* 一条 id 一条结果：**这是批量唯一的形式**（单条就是长度为 1 的批量，仓里不留第二条执行路径）。
-* 动词只收一个 id、只吐一条结果；`try/catch` 在这一处，失败不传染下一条。
+* 一条 id 一条结果：**这是批量唯一的形式**（单条就是长度为 1 的批量，仓里不留第二条执行路径）。
+* 动词只收一个 id、只吐一条结果；`try/catch` 在这一处，失败不传染下一条。
+*/
+async function forEachId(action, ids, run) {
+	const outcomes = [];
+	for (const id of unique(ids)) try {
+		outcomes.push(success(id, action, await run(id)));
+	} catch (error) {
+		outcomes.push(failure(id, action, error));
+	}
+	return outcomes;
+}
+async function applyDelete(deps, ids) {
+	const run = deleteSession(deps);
+	const carried = createSessionCarried();
+	return forEachId("delete", ids, async (sessionId) => {
+		if (carried.claim(sessionId).verdict === "carried") return null;
+		const { entry, movedSessionIds } = await run(sessionId);
+		for (const movedId of movedSessionIds) carried.take(movedId);
+		return entry;
+	});
+}
+/** 「这条是不是被同批前一条带走了」与视图收缩都归 `batch-carried.ts`；`apply` 整批只读一次清册，
+*  动词只拿它交回的只读组与当前清册。 */
+async function applyRestore(deps, ids) {
+	const carried = createEntryCarried(await deps.ledger.list());
+	const run = restoreSession(deps);
+	const restored = [];
+	const outcomes = await forEachId("restore", ids, async (entryId) => {
+		const claim = carried.claim(entryId);
+		if (claim.verdict === "carried") return null;
+		const group = claim.verdict === "fresh" ? claim.group : [];
+		const entry = await run(entryId, group);
+		carried.take(entryId);
+		restored.push(...group.map((row) => row.sessionId));
+		return entry;
+	});
+	if (restored.length > 0) await deps.host.announceRestored(restored);
+	return outcomes;
+}
+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;
+	});
+}
+/** 删除确认框那句「含 N 个子会话」：一次问完整批（`subagentMembersOf` 本来就是批量口）。
+*  宿主口缺席（`available:false`）时按 0（这里不再有"空表"这一步）；真读失败则整次调用失败，
+*  浏览器半按"读不到"把整句不说。 */
+async function applyCount(deps, ids) {
+	const wanted = unique(ids);
+	const read = await deps.host.subagentMembersOf(wanted);
+	return wanted.map((id) => success(id, "count", read.available ? read.value[id]?.length ?? 0 : 0));
+}
+/**
+* 清一组无主子会话（父已被彻底删掉、孩子还留在 `sessions/` 里的那些）。id 是**根会话 id**——
+* 界面先 `GET /orphans` 拿 `roots` 再原样带回来，所以这里的 `not-found` 说的是"这句话已经过期了"
+* （父又被人放回回收站、组已被上一个请求带走，或另一处已经把目录清掉），不是"用户打错了一个 id"。
+* 根 id 两边都去 `session-` 前缀再比：报告原样回传是正常路径，外部调用带另一种写法也认。
+*
+* **这是写动作，排在到达序链上**，而且**先对账再扫**：`loadOrphanGroups` 本身只扫描、不写清册；
+* 这里先把 `ledger.list()` 对账后的行交给它——刚被人手工搬进 `session-trash/` 的那一格目录此刻可能还
+* 没有对应行，拿 raw 索引扫就会把"父还在回收站里等着"的一组当成孤儿**直接删盘**，替用户做了一个没人
+* 点过的决定（那种组该跟着父恢复或彻底删除）。
+*/
+async function applyOrphanClean(deps, ids) {
+	const groups = await loadOrphanGroups(deps, await deps.ledger.list());
+	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));
+		if (group === void 0) throw verbError("not-found", `不再是可清理的无主子会话：${id}`);
+		return await cleanOrphanGroup(deps, group);
+	});
+}
+function applyActions(deps, action, ids) {
+	switch (action) {
+		case "delete": return applyDelete(deps, ids);
+		case "restore": return applyRestore(deps, ids);
+		case "purge": return applyPurge(deps, ids);
+		case "count": return applyCount(deps, ids);
+		case "orphan-clean": return applyOrphanClean(deps, ids);
+	}
+}
+//#endregion
+//#region src/log/zstd-frames.ts
+const MAGIC = [
+	40,
+	181,
+	47,
+	253
+];
+/** magic(4) + Frame_Header_Descriptor(1) 之后第一个字节的偏移。 */
+const AFTER_DESCRIPTOR = 5;
+const BLOCK_HEADER_BYTES = 3;
+const BLOCK_LAST = 1;
+const BLOCK_TYPE_SHIFT = 1;
+const BLOCK_SIZE_SHIFT = 3;
+const BLOCK_SIZE_MASK = 2097151;
+const BLOCK_RAW = 0;
+const BLOCK_RLE = 1;
+const BLOCK_COMRESSED = 2;
+/** 规范（RFC 8878 表 4）里 3 是 **Reserved**，不是"未压缩块"：见到就抛，别照 Raw 吞块体。 */
+const BLOCK_RESERVED = 3;
+/** descriptor 各字段的取值 → 字段字节数（zstd 帧头的两张尺寸表）。 */
+const DID_SIZES = [
+	0,
+	1,
+	2,
+	4
+];
+const FCS_SIZES_SINGLE = [
+	1,
+	2,
+	4,
+	8
+];
+const FCS_SIZES_MULTI = [
+	0,
+	2,
+	4,
+	8
+];
+/** 实测的帧尾长度（校验和位置；bit5 没置位也照样带，见文件头注）。 */
+const FRAME_TAIL_BYTES = 4;
+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;
+}
+/** 块体之后有没有那 4 字节尾巴：只有"跳过它之后仍是帧头或到 EOF"才认。 */
+function withFrameTail(raw, at) {
+	const afterTail = at + FRAME_TAIL_BYTES;
+	if (afterTail <= raw.length && (afterTail === raw.length || isMagicAt(raw, afterTail))) return afterTail;
+	return at;
+}
+/**
+* 把 `raw` 切成帧区间。
+* @throws 起始处不是 magic、或某帧算到的末位既不是下一帧帧头也不是 EOF——**一律抛**，
+*   绝不"尽力往下解"：切错帧的后果是把半截压缩体当解压输入，那时解出来的东西不可信。
+*/
+function frameRanges(raw) {
+	const ranges = [];
+	let at = 0;
+	while (at < raw.length) {
+		if (!isMagicAt(raw, at)) throw new Error(`zstd 帧头缺席：偏移 ${at} 处不是 magic（前面第 ${ranges.length} 帧的边界算歪了？）`);
+		const descriptor = raw[at + 4];
+		if (descriptor === void 0) throw new Error(`zstd 帧头不完整：偏移 ${at} 之后不足 ${AFTER_DESCRIPTOR} 字节`);
+		const fcsFlag = descriptor & 3;
+		const singleSegment = descriptor >> 2 & 1;
+		const didFlag = descriptor >> 6 & 3;
+		let cursor = at + AFTER_DESCRIPTOR;
+		if (!singleSegment) cursor += 1;
+		cursor += DID_SIZES[didFlag];
+		cursor += (singleSegment ? FCS_SIZES_SINGLE : FCS_SIZES_MULTI)[fcsFlag];
+		for (;;) {
+			const blockHeader = readUint24LE(raw, cursor);
+			cursor += BLOCK_HEADER_BYTES;
+			if (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，对面解不开）`);
+			if (blockType === BLOCK_RAW || blockType === BLOCK_COMRESSED) cursor += blockSize;
+			else if (blockType === BLOCK_RLE) cursor += 1;
+			if (blockHeader & BLOCK_LAST) break;
+		}
+		cursor = withFrameTail(raw, cursor);
+		if (cursor !== raw.length && !isMagicAt(raw, cursor)) throw new Error(`zstd 帧边界算歪了：帧起于 ${at}，算到 ${cursor}，那里既不是下一帧帧头也不是 EOF`);
+		ranges.push({
+			start: at,
+			end: cursor
+		});
+		at = cursor;
+	}
+	return ranges;
+}
+//#endregion
+//#region src/log/session-log.ts
+/**
+* 会话日志（`session.vN.jsonl.zstd`）的**逐帧读法**：帧边界交给 `zstd-frames.ts`，这一层只做
+* 「帧 → 明文 → 一行一条 JSON」的解码，并把每条记录原样交给回调。
+*
+* **策略不在这里**（哪些 `type` 算正文、截断到多少字、算不算失败）——那是 `src/trash/detail.ts` 的事。
+* 这一层只懂编解码，所以它能被单独验穿。
+*
+* 两条实测决定的口径：
+* ① **必须逐帧**：Node 的 `zstdDecompressSync` 与 `createZstdDecompress()` 都只给第一帧（见
+*    `zstd-frames.ts` 头注）；明文留在手里会一次装下整条日志（本机 125 条合计 280.7 MB），
+*    所以**一帧一帧解、解完就撒手**，内存口径是"最大那一帧的明文"（实测 8.99 MB）而不是整条。
+* ② **一行的余量跨帧带走**（2026-10-16 改，原来靠"跳过解不开的行"兜）：写作侧是一条条 append，
+*    本机实测**没有一帧切在行中间**（连最后一帧都整行收尾；绝对帧数随盘上会话数摆动，那份读数
+*    不在这里钉，来历留在 git 历史），
+*    所以旧口径当时并不丢东西；但"逐帧 `split('\n')`"一旦遇上切行就是**静默少一条记录**（半个头
+*    加半个身，两半都解不开 JSON），而少掉的那条正是页面上要跟账的正文。带上余量之后这条不变量
+*    不必再成立，顺带把**跨帧的多字节字符**也解对了——拼接在字节层做，`toString('utf8')` 只看整行。
+*    真被切断的尾巴（写一半）仍然**跳过并计数**：绝不因为一行就抛整个读数，前面几百条是真的。
+*/
+const NEWLINE = 10;
+/**
+* 宿主给每一代日志的词法（逐字取自 `@deepseek-ai/dsh-session-format@0.2.0-rc.2` 的
+* `CANONICAL_LOG_FILENAME`，剥掉压缩后缀那段由我们自己在正则里补上 `.zstd`）：
+* 裸名 `session.jsonl` 是**第 0 代**，往后是 `session.vN`；`.v0`、前导零、大写、临时名都不是规范名。
 */
-async function forEachId(action, ids, run) {
-	const outcomes = [];
-	for (const id of unique(ids)) try {
-		outcomes.push(success(id, action, await run(id)));
-	} catch (error) {
-		outcomes.push(failure(id, action, error));
-	}
-	return outcomes;
-}
-/** 这一组的行从"当前快照"里摘掉（父行带走孩子后，后到的孩子 id 要认得出"已经不在了"）。 */
-function shrink(current, rows) {
-	for (const row of rows) {
-		const at = current.indexOf(row);
-		if (at >= 0) current.splice(at, 1);
+const CANONICAL_ZSTD_LOG = /^session(?:\.v([1-9][0-9]*))?\.jsonl\.zstd$/u;
+/**
+* 同一个会话目录里**可以并存多代日志**（宿主换代时把老代留在原地当历史语料，本机实测 7 个目录如此），
+* 而新代是老代的**迁移后超集**（实测：`firstTs` 与开头那条提问完全相同、记录更多、末尾更晚）
+* ⇒ 要读的是版本号最大的那一代，读旧代 = 读到一份截了尾巴的快照；把几代拼起来 = 重复计数。
+*
+* 明文（无 `.zstd`）不在此列：本插件的读法逐帧解 zstd，明文得走另一条解码路。
+*/
+function pickSessionLog(names) {
+	let best;
+	let bestVersion = -1;
+	for (const name of names) {
+		const match = CANONICAL_ZSTD_LOG.exec(name);
+		if (match === null) continue;
+		const version = match[1] === void 0 ? 0 : Number(match[1]);
+		if (version > bestVersion) {
+			bestVersion = version;
+			best = name;
+		}
 	}
-}
-async function applyDelete(deps, ids) {
-	const run = deleteSession(deps);
-	const carried = /* @__PURE__ */ new Set();
-	return forEachId("delete", ids, async (sessionId) => {
-		const root = bareSessionId(sessionId);
-		if (carried.has(root)) return null;
-		const { entry, movedSessionIds } = await run(sessionId);
-		for (const movedId of movedSessionIds) carried.add(bareSessionId(movedId));
-		return entry;
-	});
-}
-/** 「这条是不是被同批前一条带走了」：原始快照里认得出、当前快照里已经空了。
-*  **收缩归这一层**（动词只拿只读快照）——`apply` 整批只读一次清册，`takenByEarlierInBatch` 不比它多读。 */
-async function applyRestore(deps, ids) {
-	const original = await deps.manifest.list();
-	const current = [...original];
-	const run = restoreSession(deps);
-	const restored = [];
-	const outcomes = await forEachId("restore", ids, async (entryId) => {
-		if (takenByEarlierInBatch(original, current, entryId)) return null;
-		const group = groupOf(current, entryId);
-		const entry = await run(entryId, current);
-		restored.push(...group.map((row) => row.sessionId));
-		shrink(current, group);
-		return entry;
-	});
-	if (restored.length > 0) await deps.host.announceRestoredBatch(restored, await deps.host.restoredSummariesOf());
-	return outcomes;
-}
-async function applyPurge(deps, ids) {
-	const original = await deps.manifest.list();
-	const current = [...original];
-	const run = purgeTrash(deps);
-	return forEachId("purge", ids, async (entryId) => {
-		if (takenByEarlierInBatch(original, current, entryId)) return {
-			removed: 0,
-			freedBytes: 0
-		};
-		const group = groupOf(current, entryId);
-		const stats = await run(entryId, current);
-		shrink(current, group);
-		return stats;
-	});
-}
-/** 删除确认框那句「含 N 个子会话」：一次问完整批（`subagentMembersOf` 本来就是批量口）。
-*  宿主口缺席（`available:false`）时按 0（这里不再有"空表"这一步）；真读失败则整次调用失败，
-*  浏览器半按"读不到"把整句不说。 */
-async function applyCount(deps, ids) {
-	const wanted = unique(ids);
-	const read = await deps.host.subagentMembersOf(wanted);
-	return wanted.map((id) => success(id, "count", read.available ? read.value[id]?.length ?? 0 : 0));
+	return best;
 }
 /**
-* 清一组无主子会话（父已被彻底删掉、孩子还留在 `sessions/` 里的那些）。id 是**根会话 id**——
-* 界面先 `GET /orphans` 拿 `roots` 再原样带回来，所以这里的 `not-found` 说的是"这句话已经过期了"
-* （父又被人放回回收站、组已被上一个请求带走，或另一处已经把目录清掉），不是"用户打错了一个 id"。
-* 根 id 两边都去 `session-` 前缀再比：报告原样回传是正常路径，外部调用带另一种写法也认。
+* 逐帧走一遍日志，每条记录交给回调。
 *
-* **这是写动作，排在到达序链上**，而且**先对账再扫**（2026-10-19）：判"父没了"用的是清册，而刚被人
-* 手工搬进 `session-trash/` 的那一格目录此刻可能还没有对应行——不对账就会把"父还在回收站里等着"的
-* 一组当成孤儿**直接删盘**，替用户做了一个没人点过的决定（那种组该跟着父恢复或彻底删除）。
-* 对账写在动词这一侧而不是只写在路由里，为的是 `apply` 的批量入口只有一个：链上的排队与这份快照
-* 谁也别想只占一半。
+* 回调返回 `false` = **提前停机**（后面的帧不再解——`readSessionHeader` 只要第一行）。
+* 停机后 `stats` 只是停机前那部分，别拿来做全量对账。
 */
-async function applyOrphanClean(deps, ids) {
-	await reconcileTrash(deps);
-	const groups = await loadOrphanGroups(deps);
-	const byRoot = new Map(groups.map((group) => [bareSessionId(group.root.sessionId), group]));
-	const outcomes = [];
-	for (const id of unique(ids)) {
-		const group = byRoot.get(bareSessionId(id));
-		if (group === void 0) {
-			outcomes.push(failure(id, "orphan-clean", verbError("not-found", `不再是可清理的无主子会话：${id}`)));
-			continue;
+function walkSessionLog(raw, onRecord) {
+	const stats = {
+		frames: 0,
+		records: 0,
+		unparsedLines: 0,
+		truncatedTailBytes: 0
+	};
+	let stopped = false;
+	const feed = (line) => {
+		if (line === "") return;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			stats.unparsedLines += 1;
+			return;
 		}
+		stats.records += 1;
+		if (onRecord(parsed !== null && typeof parsed === "object" ? parsed : {}) === false) stopped = true;
+	};
+	/** 上一帧没闭合的那一行。**存字节不存字符**：切在多字节字符中间的帧要拼回完整才解得对。 */
+	let carry = Buffer.alloc(0);
+	for (const { start, end } of frameRanges(raw)) {
+		if (stopped) break;
+		stats.frames += 1;
+		let plain;
 		try {
-			outcomes.push(success(id, "orphan-clean", await cleanOrphanGroup(deps, group)));
+			plain = zlib.zstdDecompressSync(raw.subarray(start, end));
 		} catch (error) {
-			outcomes.push(failure(id, "orphan-clean", error));
+			throw new Error(`回收站日志第 ${stats.frames} 帧解压失败：${String(error)}`);
+		}
+		const merged = carry.length === 0 ? plain : Buffer.concat([carry, plain]);
+		const cut = merged.lastIndexOf(NEWLINE);
+		if (cut === -1) {
+			carry = merged;
+			continue;
+		}
+		carry = merged.subarray(cut + 1);
+		for (const line of merged.subarray(0, cut).toString("utf8").split("\n")) {
+			feed(line);
+			if (stopped) break;
 		}
 	}
-	return outcomes;
+	stats.truncatedTailBytes = carry.length;
+	if (carry.length > 0 && !stopped) feed(carry.toString("utf8"));
+	return stats;
 }
-function applyActions(deps, action, ids) {
-	switch (action) {
-		case "delete": return applyDelete(deps, ids);
-		case "restore": return applyRestore(deps, ids);
-		case "purge": return applyPurge(deps, ids);
-		case "count": return applyCount(deps, ids);
-		case "orphan-clean": return applyOrphanClean(deps, ids);
-	}
+/**
+* 日志的 **header**：格式事实是"第一行即 header"（`type: 'session'`，含 `id` 与 `cwd`，v3/v4 均如此，
+* AGENTS.md 有实测背书）——这里按 `type === 'session'` 找**第一条**这样的记录并就地停机
+* （不要求它恰是第一个可解析行：坏一行前缀不该让整条日志判不出身份）。
+* 找不到（空日志 / 全是别种记录）回 `undefined`；帧坏了照抛——那是"读不出来"，与"没有 header"是两件事。
+*/
+function readSessionHeader(raw) {
+	let header;
+	walkSessionLog(raw, (record) => {
+		if (record.type !== "session") return;
+		header = record;
+		return false;
+	});
+	return header;
 }
 const DEFAULT_LIMITS = {
 	perMessageChars: 3e3,
@@ -2187,7 +2175,7 @@ function textOf(content) {
 }
 function readTrashDetail(deps, limits = DEFAULT_LIMITS) {
 	return async function readTrashDetail(entryId) {
-		const record = (await deps.manifest.list()).find((e) => e.id === entryId);
+		const record = (await deps.ledger.raw()).find((e) => e.id === entryId);
 		if (record === void 0) throw verbError("trash-empty", `回收站里没有这一条：${entryId}`);
 		const dir = trashDirOf(record.id, deps.home);
 		if (!await deps.fs.exists(dir)) throw verbError("io", `回收站目录不在：${dir}`);
@@ -2388,7 +2376,7 @@ const ROUTE_TABLE = {
 		method: "GET",
 		body: "none",
 		purity: "chained",
-		run: async (deps) => assembleTrashRows(deps, await reconcileTrash(deps))
+		run: async (deps) => assembleTrashRows(deps, await deps.ledger.list())
 	},
 	[ROUTES.ping]: {
 		method: "GET",
@@ -2413,7 +2401,7 @@ const ROUTE_TABLE = {
 		body: "none",
 		purity: "chained",
 		run: async (deps) => {
-			const rows = await reconcileTrash(deps);
+			const rows = await deps.ledger.list();
 			return await purgeTrash(deps)(void 0, rows);
 		}
 	},
@@ -2653,6 +2641,125 @@ function resolveHome(env = process.env, homeDir = homedir()) {
 	return resolve(raw);
 }
 //#endregion
+//#region src/trash/reconcile.ts
+/**
+* 回收站清单的**对账**：以 `session-trash/` 里的条目目录为准，把清单修回一致（CONTEXT.md 的「对账」条）。
+*
+* 手工动回收站**只需要动那一个目录**——多出来的目录在这里被重建出行、目录没了的行在这里被摘掉；
+* `~/.dsh/storages/` 那份清单从此是**内部索引**，不用手碰。
+*
+* 五条口径（都不是口味）：
+* ① **每次真相读都对账**（`src/trash/ledger.ts` 的 `list()`；`GET /list` 的正文就是"对账 + 读"）：挂载、
+*    刷新、别处动过后的自动重读、客户端挂载后的首次列表读全走这条 ⇒ "改完目录不用再做任何事，下一次读就对了"。
+*    pure 读面（`/orphans`、`/detail`）走 `raw()`，不对账——对账会写行，必须排在到达序链上。
+*    代价 = 每次真相读多一次目录枚举（本机 124 条，毫秒级）；**零漂移零写入**（快路直接返回原清单）。
+* ② **回收站根不在 ⇒ 整套跳过、一个字节都不动**：那不是"回收站空了"，是"这块地不在原处"
+*    （人为搬走、盘没挂上）——照常对账会把全部行的元数据一次判没。
+* ③ **重建行只写"文件里真有的事实"**：`id` = 目录名、`sessionId`/`cwd` 读日志 header、
+*    `projectDir` 由 `cwd` 经宿主同名算法 `projectKey` 反推、`deletedAt` 从目录名的时间戳解、
+*    `sizeBytes` 现场量。**文件侧没有副本的三件**按缺省落：`workspaceId: ''`（恢复时跳过挂账本，
+*    落在「未分组」）、`wasArchived: false`（文件侧没有归档事实；旧条目恢复走迁移支）、`title: ''`（详情有日志标题兜底）
+*    ——这是重建的固有代价，不是可以"再读读看"的东西。
+* ④ **认不出 / 读不出的目录：不动、不列**（名字不像条目、目录里没有日志、header 读不出、尺寸量不出，
+*    各跳过各的）。它是"外人放进来的东西"，不是用户动作失败：跳过即静默，绝不为它删目录或抛掉整次读数。
+* ⑤ **幂等**：再跑一遍零写入；崩在任何一步，下一次读清单接着把它修完。
+*
+* 与三个写动词的**串行化不在这里**（那是传输层的事，见 `src/api/dispatch.ts` 的到达序链）：
+* 对账与删除/恢复/彻底删除都是"读清单 + 动文件 + 写清单"的多步，交错跑会互相踩——删除刚把目录搬进
+* 回收站、行还没写上时，对账抢先把这行按目录"重建"出来，随后又被真实行覆盖成降级元数据。
+*/
+/** 目录名是不是一条条目 id（形状契约在 `entry.ts`：`<删除时刻UTC>-<原目录名>`；
+*  原目录名还必须能安全地拼回磁盘路径——带分隔符的名字仍按"外人"跳过，不让一次对账读崩）。 */
+function isEntryId(name) {
+	try {
+		return isSinglePathSegment(parseEntryId(name).sessionDirName);
+	} catch {
+		return false;
+	}
+}
+/**
+* 从一个手工放进回收站的目录重建清单行。**任一件事实拿不到就整体放弃这一条**（回 `undefined`）：
+* 半截行比"不列"更坏——恢复会照它把目录搬去一个错的地方（同 `detail.ts` 那条"半截正文"的口径）。
+*
+* `sessionId` 取日志 header 的 `id`（恢复之后宿主按日志 header 建索引，那才是会话身份）；
+* header 缺席这个字段才回落到目录名里那段原目录名。
+*/
+async function buildEntry(deps, id) {
+	const dir = trashDirOf(id, deps.home);
+	let logName;
+	try {
+		logName = pickSessionLog(await deps.fs.listFiles(dir));
+	} catch {
+		return;
+	}
+	if (logName === void 0) return void 0;
+	let raw;
+	try {
+		raw = await deps.fs.readFile(`${dir}/${logName}`);
+	} catch {
+		return;
+	}
+	let header;
+	try {
+		header = readSessionHeader(raw);
+	} catch {
+		return;
+	}
+	if (header === void 0) return void 0;
+	let sizeBytes;
+	try {
+		sizeBytes = await deps.fs.sizeOfDir(dir);
+	} catch {
+		return;
+	}
+	const { deletedAt, sessionDirName } = parseEntryId(id);
+	const cwd = typeof header.cwd === "string" ? header.cwd : "";
+	return {
+		id,
+		sessionId: typeof header.id === "string" && header.id !== "" ? header.id : sessionDirName,
+		projectDir: cwd === "" ? NO_CWD_PROJECT_DIR : projectKey(cwd),
+		workspaceId: "",
+		wasArchived: false,
+		deletedAt,
+		title: "",
+		sizeBytes
+	};
+}
+/** 对账并回清单——**返回的就是修好之后的那份**（与 `manifest.list()` 同序：最近删除在前）。 */
+async function reconcileTrash(deps) {
+	const rows = await deps.manifest.list();
+	const root = `${deps.home}/${TRASH_DIR_NAME}`;
+	if (!await deps.fs.exists(root)) return rows;
+	const dirIds = /* @__PURE__ */ new Set();
+	for (const name of await deps.fs.listDirs(root)) if (isEntryId(name)) dirIds.add(name);
+	const rowIds = new Set(rows.map((row) => row.id));
+	const drops = rows.filter((row) => !dirIds.has(row.id));
+	const rebuilds = [];
+	for (const id of dirIds) {
+		if (rowIds.has(id)) continue;
+		const entry = await buildEntry(deps, id);
+		if (entry !== void 0) rebuilds.push(entry);
+	}
+	if (drops.length === 0 && rebuilds.length === 0) return rows;
+	for (const row of drops) await deps.manifest.remove(row.id);
+	for (const entry of rebuilds) await deps.manifest.add(entry);
+	return await deps.manifest.list();
+}
+//#endregion
+//#region src/trash/ledger.ts
+function createTrashLedger(raw, fs, home) {
+	return {
+		list: () => reconcileTrash({
+			fs,
+			manifest: raw,
+			home
+		}),
+		raw: () => raw.list(),
+		add: (entry) => raw.add(entry),
+		remove: (id) => raw.remove(id)
+	};
+}
+//#endregion
 //#region src/trash/manifest.ts
 function createStorageManifest(domain) {
 	return {
@@ -2774,7 +2881,8 @@ const name = "@xrn1997/dsh-session-delete";
 * `super(ctx, "webServer")`），服务名与 `register({kind:'prefix', path, handler})` 的形状按
 * `dsh-host-webserver/lib/index.js` 与 `README.md` 原文读实，不是猜的。
 *
-* 清单（storage domain 绑定）与数据根各有一个家：`src/trash/storage-manifest.ts`、`src/ports/home.ts`。
+* 清册的三层各有各的家：raw 绑定 `src/trash/storage-manifest.ts`、读面（对账 + 读）`src/trash/ledger.ts`、
+* 数据根 `src/ports/home.ts`。这里只把它们接起来，任何一层都不在组合根里长判据。
 */
 const inject = [
 	"workspaceRegistry",
@@ -2789,11 +2897,14 @@ const inject = [
 * 在 `register` 里直接抛（`webserver: duplicate prefix route "…"`），响亮失败而不是悄悄覆盖。
 */
 function apply(ctx) {
+	const fs = createFsPort();
+	const home = resolveHome();
+	const rawManifest = createHostStorageManifest(ctx);
 	const deps = {
-		fs: createFsPort(),
+		fs,
 		host: createHostPort(ctx),
-		manifest: createHostStorageManifest(ctx),
-		home: resolveHome(),
+		ledger: createTrashLedger(rawManifest, fs, home),
+		home,
 		now: () => Date.now()
 	};
 	const webServer = ctx.webServer;