@xrn1997/dsh-session-delete 0.3.0 → 0.3.1

package/lib/client.js

@@ -95,8 +95,8 @@ window.__ModuleLoader__.load({
 		/**
 		* 可见文案（界面标签与提示）＋接上宿主 Client locale 服务的那一步。
 		*
-		* **例外：渠道错误原文。** `src/client/receipt.ts` 的 missing-id、`src/client/remote.ts` 的
-		* 幂等空值与取数通道错误是协议诊断原文，固定中文、不随 locale；它们不进本字典。
+		* **例外：渠道错误原文。** `src/client/receipt.ts` 的 missing-id 与单条幂等空值、
+		* `src/client/remote.ts` 的取数通道错误是协议诊断原文，固定中文、不随 locale；它们不进本字典。
 		*
 		* ## 为什么不是散在各组件里的中文字面量
 		*
@@ -445,6 +445,13 @@ window.__ModuleLoader__.load({
 		* 在这之前每个文件各写一遍「`let` 现场 + `Set<() => void>` + `notify` + `useSyncExternalStore`」，
 		* 各自的 seq / revision 也在分头维护。现在订阅/通告只住这一处。
 		*
+		* 另有一个**懒读快照**变体（`createLazyStore`）：值由组件树之外的事实源（宿主 DOM）现读，
+		* 脏了才重读；订阅脚手架仍住这里，观察者生命周期由调用方挂 `onFirstSubscribe` / `onLastUnsubscribe`。
+		*
+		* 还有一个**最新票句柄**（`createLatestWins`）：并发的异步读里"只有最新那次可以落地"原先在每个
+		* 调用方各写一遍自增序号，现在只住这一处。它只拥有 compare-and-set——防抖、轮询、焦点策略仍是
+		* 调用方的现场，不搬进来。
+		*
 		* 语义（四条，别在调用方另算一遍）：
 		* - `set` / `update` 用 `Object.is` 判"变过"：同一个引用不重渲染（React 的 snapshot 契约要求）。
 		* - `publish(make)` 递增**本实例**的 seq（从 1 起）并**总是**通告——seq 是组件重挂载的 key
@@ -497,6 +504,55 @@ window.__ModuleLoader__.load({
 				}
 			};
 		}
+		function createLazyStore(initial, read, lifecycle = {}) {
+			let cached = initial;
+			let dirty = true;
+			const listeners = /* @__PURE__ */ new Set();
+			const notify = () => {
+				for (const listener of listeners) listener();
+			};
+			return {
+				get() {
+					if (dirty) {
+						cached = read();
+						dirty = false;
+					}
+					return cached;
+				},
+				invalidate() {
+					dirty = true;
+					notify();
+				},
+				subscribe(listener) {
+					const reattaching = listeners.size === 0;
+					listeners.add(listener);
+					if (reattaching) {
+						dirty = true;
+						lifecycle.onFirstSubscribe?.();
+					}
+					return () => {
+						listeners.delete(listener);
+						if (listeners.size > 0) return;
+						lifecycle.onLastUnsubscribe?.();
+						dirty = true;
+					};
+				}
+			};
+		}
+		function createLatestWins() {
+			let seq = 0;
+			return {
+				issue() {
+					const token = ++seq;
+					return { get current() {
+						return token === seq;
+					} };
+				},
+				invalidate() {
+					seq += 1;
+				}
+			};
+		}
 		//#endregion
 		//#region src/client/batch-selection-store.ts
 		/**
@@ -584,12 +640,18 @@ window.__ModuleLoader__.load({
 		//#endregion
 		//#region src/client/host-rows.ts
 		/**
-		* 宿主会话行的**DOM 适配**（2026-10-20）：可见行解析、全选判定、模式内的整行点击守卫。
+		* 宿主会话行的**DOM 适配**：可见行解析、全选判定、模式内的整行点击守卫。
 		*
 		* 从 `batch-select.tsx` 拆出来的理由：选中集本身（模式 + 名单）只住 `batch-selection-store.ts`；
 		* 本文件只回答**页面上**的两件事——"现在 DOM 里有哪些可选的会话行"与"在这个行上点一下算不算选中"。
 		* 两边的唯一交界是 `data-row-key`（宿主会话行的稳定标记）和行尾兜底登记的那张 `rowInfo` 表。
 		*
+		* **为什么渲染走快照**：可见行是组件树之外的状态（宿主的 DOM）。每个组件各自在渲染期查一遍，
+		* 同一帧看到什么就取决于副作用顺序，而且 DOM 变了也不会触发重渲染。这里交给 `useSyncExternalStore`：
+		* DOM 观察（`MutationObserver`）与行登记都留在本适配器里，只把缓存标脏并通告订阅者；组件读缓存快照，
+		* 干净时拿到同一个引用（React 的 snapshot 契约），脏了才重读。事件路径（全选）仍走 `readVisibleSelectableRows`
+		* 的当场读。裁决见 ADR-0015。
+		*
 		* **为什么整行点击要抢在 document 捕获阶段**：宿主的会话行自己带 `onClick = open(sessionId)`，
 		* 第三方没有官方的"别切会话"开关；模式内点行要变成"勾/取消"，只能抢在 React 根监听之前把事件吃掉。
 		*/
@@ -599,14 +661,47 @@ window.__ModuleLoader__.load({
 		* 只增不删：会话 id 不复用，行被过滤掉也不会拿旧标题冒充新行。
 		*/
 		const rowInfo = /* @__PURE__ */ new Map();
-		/** 行尾兜底勾选开关登记一行：模式内与模式外都要登记（守卫进模式的那一帧就得有标题）。 */
+		/**
+		* 渲染侧快照 + DOM 观察：订阅脚手架住 `store.ts` 的 `createLazyStore`；这里只提供读法与
+		* 观察者生命周期。宿主行的去留只体现在 `data-row-key` 节点上（增删、属性落定），文本变化
+		* 不算（标题只认 `rowInfo` 的登记值）。首个订阅者起开始观察，最后一个走了断开。
+		*/
+		const EMPTY_ROWS = [];
+		let observer;
+		function startObserving() {
+			if (observer !== void 0 || typeof MutationObserver === "undefined") return;
+			observer = new MutationObserver(() => visibleRows.invalidate());
+			observer.observe(document.body, {
+				childList: true,
+				subtree: true,
+				attributes: true,
+				attributeFilter: ["data-row-key"]
+			});
+		}
+		function stopObserving() {
+			observer?.disconnect();
+			observer = void 0;
+		}
+		const visibleRows = createLazyStore(EMPTY_ROWS, readVisibleSelectableRows, {
+			onFirstSubscribe: startObserving,
+			onLastUnsubscribe: stopObserving
+		});
+		/**
+		* 行尾兜底勾选开关登记一行：模式内与模式外都要登记（守卫进模式的那一帧就得有标题）。
+		* 只有标题／运行态**真的变了**才标脏：重渲染时的同值登记不该把快照翻新一遍。
+		*/
 		function registerHostRowInfo(sessionId, info) {
+			const current = rowInfo.get(sessionId);
+			if (current?.title === info.title && current.live === info.live) return;
 			rowInfo.set(sessionId, info);
+			visibleRows.invalidate();
 		}
 		/**
 		* 「当前可见」的可选行：侧栏里**已渲染**的会话行（`data-row-key="session:…"`）——折叠组、
 		* 归档过滤外的行不在 DOM 里，宿主隐藏的 subagent 也不在；在跑的行跳过（与置灰勾选框同口径）。
 		* 标题/运行态来自行尾兜底登记的 `rowInfo`（模式内它对每个非空行都渲染）；DOM 序就是侧栏顺序。
+		*
+		* 这是**当场读**：事件路径（点「全选」那一刻的页面）与测试用它；渲染侧读下面的快照。
 		*/
 		function readVisibleSelectableRows() {
 			const rows = [];
@@ -626,6 +721,24 @@ window.__ModuleLoader__.load({
 			}
 			return rows;
 		}
+		/**
+		* `enabled === false` 时的稳定替身：同一个空表、不订阅、不读 DOM。
+		* 浮条是 `shell.overlay` 的常驻槽位，模式外若照常订阅，body 上每次变更（以及每次行登记）
+		* 都会白叫醒它重渲染一次。
+		*/
+		function getEmptyRowsSnapshot() {
+			return EMPTY_ROWS;
+		}
+		function noopSubscribe() {
+			return () => {};
+		}
+		/**
+		* 渲染侧只读快照 + DOM 观察订阅；首个订阅者起开始观察，最后一个走了断开。
+		* `enabled === false` 不订阅也不读 DOM——行列表只随多选态存在，模式外不必付观察的成本。
+		*/
+		function useVisibleSelectableRows(enabled) {
+			return (0, react.useSyncExternalStore)(enabled ? visibleRows.subscribe : noopSubscribe, enabled ? visibleRows.get : getEmptyRowsSnapshot, enabled ? visibleRows.get : getEmptyRowsSnapshot);
+		}
 		/** 全选：把当前可见可选行按 DOM 序追加；已在名单里的由 `addPicks` 自己跳过，原有选中保持在前。 */
 		function selectAllVisible() {
 			addPicks(readVisibleSelectableRows());
@@ -636,10 +749,8 @@ window.__ModuleLoader__.load({
 		* - 有选中、但当前没有可见可选行（全折叠/过滤掉）⇒ 只能清空，也显示取消全选；
 		* - 其余（含 0 条）⇒ 全选。
 		*/
-		function allVisibleSelected() {
-			const picks = getSelection().picks;
+		function areAllVisibleRowsSelected(rows, picks) {
 			if (picks.length === 0) return false;
-			const rows = readVisibleSelectableRows();
 			if (rows.length === 0) return true;
 			const chosen = new Set(picks.map((item) => item.sessionId));
 			return rows.every((row) => chosen.has(row.sessionId));
@@ -780,9 +891,14 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region src/client/receipt.ts
+		/** 浏览器半自己的未分类诊断码（通道打不通 / 非信封 / 单条协议错）。它不过线，线上失败码仍归 `shared/wire.ts`。 */
+		const CLIENT_UNKNOWN_CODE = "client/unknown";
 		function missingOutcomeMessage(action, id) {
 			return `批量通道没回这一条的结果：${action} ${id}`;
 		}
+		function singleNullMessage(action, id) {
+			return `单条动作回了幂等空值：${action} ${id}`;
+		}
 		function isFailureVerdict(verdict) {
 			return verdict.kind === "failed" || verdict.kind === "neutral" || verdict.kind === "missing";
 		}
@@ -790,7 +906,7 @@ window.__ModuleLoader__.load({
 		function failureMessage(verdict) {
 			return verdict.kind === "failed" || verdict.kind === "neutral" ? verdict.error.message : verdict.message;
 		}
-		function decode$1(action, outcome) {
+		function decode$1(action, outcome, options) {
 			if (outcome.action !== action) return void 0;
 			const typed = outcome;
 			if (!typed.ok) return action === "orphan-clean" && typed.error.code === SESSION_DELETE_CODES["not-found"] ? {
@@ -803,22 +919,30 @@ window.__ModuleLoader__.load({
 				error: typed.error
 			};
 			const value = typed.value;
-			return value === null ? {
+			if (value === null) return options.single === true ? {
+				kind: "failed",
+				id: typed.id,
+				error: {
+					code: CLIENT_UNKNOWN_CODE,
+					message: singleNullMessage(action, typed.id)
+				}
+			} : {
 				kind: "already-gone",
 				id: typed.id
-			} : {
+			};
+			return {
 				kind: "ok",
 				id: typed.id,
 				value
 			};
 		}
-		function readReceipt(action, requestedIds, outcomes) {
+		function readReceipt(action, requestedIds, outcomes, options = {}) {
 			const wanted = [...new Set(requestedIds)];
 			const wantedSet = new Set(wanted);
 			const byId = /* @__PURE__ */ new Map();
 			for (const outcome of outcomes) {
 				if (!wantedSet.has(outcome.id) || byId.has(outcome.id)) continue;
-				const verdict = decode$1(action, outcome);
+				const verdict = decode$1(action, outcome, options);
 				if (verdict !== void 0) byId.set(outcome.id, verdict);
 			}
 			const verdicts = wanted.map((id) => byId.get(id) ?? {
@@ -831,6 +955,50 @@ window.__ModuleLoader__.load({
 				byId: new Map(verdicts.map((verdict) => [verdict.id, verdict]))
 			};
 		}
+		/**
+		* N=1 的读法：null 折成协议错，类型面因此不含 `already-gone`（下面那次过滤只服务类型收窄，
+		* single 读法运行期不会产出它）。`applyOne` 用它之后只剩「按 id 取一条 + 抛失败」。
+		*/
+		function readSingleReceipt(action, id, outcomes) {
+			const verdicts = readReceipt(action, [id], outcomes, { single: true }).verdicts.filter((verdict) => verdict.kind !== "already-gone");
+			return {
+				verdicts,
+				byId: new Map(verdicts.map((verdict) => [verdict.id, verdict]))
+			};
+		}
+		function isRestoreEntry(value) {
+			return typeof value === "object" && value !== null && "sessionId" in value;
+		}
+		function isEntryWithId(value) {
+			return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string";
+		}
+		/**
+		* `/apply` 成功支回执里的条目 id（delete / restore 的 `value.id`）；purge 的聚合值与 count 的数字值跳过。
+		* 撤销名单只收 `ok` 支的条目 id：already-gone 是「已被同批前一条带走」的幂等条，跟着组走，不单列。
+		*/
+		function landedEntryIds(receipt) {
+			const ids = [];
+			for (const verdict of receipt.verdicts) if (verdict.kind === "ok" && isEntryWithId(verdict.value)) ids.push(verdict.value.id);
+			return ids;
+		}
+		/**
+		* restore 回执里真正回盘的会话 id：`ok` 支取条目上的 `sessionId`；`already-gone` 没有行，
+		* 由调用方给条目查找兜底。purge / count 的 `ok` 值没有 `sessionId`，会被跳过。
+		*/
+		function restoredSessionIds(receipt, sessionIdOfEntry) {
+			const ids = [];
+			for (const verdict of receipt.verdicts) {
+				if (verdict.kind === "ok") {
+					if (isRestoreEntry(verdict.value)) ids.push(verdict.value.sessionId);
+					continue;
+				}
+				if (verdict.kind === "already-gone" && sessionIdOfEntry !== void 0) {
+					const sessionId = sessionIdOfEntry(verdict.id);
+					if (sessionId !== void 0) ids.push(sessionId);
+				}
+			}
+			return ids;
+		}
 		//#endregion
 		//#region src/client/remote.ts
 		/**
@@ -878,11 +1046,11 @@ window.__ModuleLoader__.load({
 				...reason.details === void 0 ? {} : { details: reason.details }
 			};
 			if (reason instanceof Error) return {
-				code: "client/unknown",
+				code: CLIENT_UNKNOWN_CODE,
 				message: reason.message
 			};
 			return {
-				code: "client/unknown",
+				code: CLIENT_UNKNOWN_CODE,
 				message: String(reason)
 			};
 		}
@@ -989,23 +1157,18 @@ window.__ModuleLoader__.load({
 			}
 		}
 		/**
-		* **N=1 的 `apply`**：一个动作 + 一个 id → 那一条的成功支（`value` 按动作收窄）。
+		* **N=1 的 `apply`**：一个动作 + 一个 id → 那一条的成功支（`value` 必然非空）。
 		*
-		* 三条判据都在这一处：
+		* 三件事各归一个家：
 		* - **按发出去的那个 id** 取结果（取"第一条"会把别条的成败安在这条头上）；
-		* - 一条没回是**通道的错**，不是"没做成"（后者住在 outcome 的 `ok:false` 里）；
-		* - `null` 是批量里"已被同批前一条带走"的幂等值——N=1 永远不会命中它，回 `null` 只能是通道答错了，
-		*   所以同样按通道错抛，不冒充成功。
-		*
-		* 成/败/幂等/缺失的判读只走 {@link readReceipt}（一个家）。
+		* - 成/败/幂等/缺失与「单条 null 是协议错」的判读只走 {@link readSingleReceipt}；
+		* - 这里只把 verdict 折成「拿到值 / 抛失败」。
 		*/
 		async function applyOne(deps, action, id) {
-			const outcomes = await deps.applyOutcomes(action, [id]);
-			const verdict = readReceipt(action, [id], outcomes).byId.get(id);
+			const verdict = readSingleReceipt(action, id, await deps.applyOutcomes(action, [id])).byId.get(id);
 			if (verdict === void 0) throw new Error(missingOutcomeMessage(action, id));
 			if (verdict.kind === "failed" || verdict.kind === "neutral") throwRemoteFailure(verdict.error);
 			if (verdict.kind === "missing") throw new Error(verdict.message);
-			if (verdict.kind === "already-gone") throw new Error(`单条动作回了幂等空值：${action} ${id}`);
 			return {
 				id,
 				action,
@@ -1497,6 +1660,32 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
+		//#region src/client/busy-gate.ts
+		/**
+		* 「这一趟还算忙」的一枚闸——面板与两个确认框共用的一份实现（各面各持一枚实例）。
+		*
+		* 为什么收回一处：三个面要的是同一套判据，各写一份只会漂移出第二套。闸的判据只有一条：
+		* 任务落地或抛错都把 busy 放回 false；不做引用计数——同一实例同一时刻只跑一趟写动作，多一层计数
+		* 只会把「这一趟什么时候算完」变成第二个判据。
+		*
+		* 边界：闸只拥有 busy 的生命周期，不拥有防抖、不拥有排队、不拥有重读（那是 `runWrite` 的整趟）。
+		*/
+		function useBusyGate() {
+			const [busy, setBusy] = (0, react.useState)(false);
+			const around = (0, react.useCallback)(async (task) => {
+				setBusy(true);
+				try {
+					return await task();
+				} finally {
+					setBusy(false);
+				}
+			}, []);
+			return (0, react.useMemo)(() => ({
+				busy,
+				around
+			}), [busy, around]);
+		}
+		//#endregion
 		//#region src/client/ui/Button.tsx
 		/**
 		* `Button`（**照抄** `@deepseek-ai/dsh-client-ui-primitives@0.2.0-rc.2` 的 Button，出处与三条改写规则
@@ -1671,6 +1860,32 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
+		//#region src/client/trash-store.ts
+		/**
+		* 回收站清单的**失效通告台**：动过回收站的动作戳一下，清单面板据此重新取数。
+		*
+		* 为什么需要它（真机反馈）：回收站面板是「挂载时取一次数」（`useEffect(refreshAll)`），而删除发生在
+		* **侧栏菜单**那边（`delete-confirm.tsx` 的常驻宿主），两者没有共同的父组件——删完之后中央那个
+		* 面板（如果正开着）不会自己重读，用户得切走再切回来（= 重新挂载）才看得见新条目。撤销（`undo-toast.tsx`）
+		* 同理。
+		*
+		* 形状与两个邻居同款（`undo-toast.tsx` 的通知台、`delete-confirm.tsx` 的现场）：**模块级现场**，
+		* 订阅/通告那套只住在 `store.ts` 的 `createStore` 里——这些现场都挂在 `shell.overlay`／`main`
+		* 这些各不相邻的座位上，模块级是它们唯一的共同点。
+		*
+		* 语义只有"变过"这一件事：一个递增的修订号（测试收场时归零）。面板把它写进 effect 的依赖里，
+		* 戳一次重读一次；不需要知道是谁动的、动了什么（清单本体永远是问宿主要）。
+		*/
+		const revisionStore = createStore(0);
+		/** 通告一次"回收站变过了"（删除成功、撤销成功；面板自己的恢复/彻底删除则就地重读）。 */
+		function invalidateTrash() {
+			revisionStore.update((revision) => revision + 1);
+		}
+		/** 供面板订阅。 */
+		function useTrashRevision() {
+			return revisionStore.use();
+		}
+		//#endregion
 		//#region src/client/ui/Toast.tsx
 		/**
 		* `Toast`（**照抄** `@deepseek-ai/dsh-client-ui-primitives@0.2.0-rc.2` 的 Toast，出处与三条改写规则
@@ -1729,12 +1944,130 @@ window.__ModuleLoader__.load({
 			}), document.body);
 		}
 		//#endregion
+		//#region src/client/undo-toast.tsx
+		/**
+		* 撤销提示（docs/ui-spec.md 状态 ③）：删除成功后一条可撤销的横幅。
+		*
+		* 为什么是**独立组件 + 模块级通知台**，而不是死在菜单行里：宿主的菜单行随菜单**一起卸载**
+		* （真产物 Menu 的注释原文 "the rows unmount with the list"），而提示要在菜单关掉之后还活着。
+		* 宿主的官方配方同形——会话行的动作把请求写进一个模块级 store，`shell.overlay` 里的
+		* `workspace.row-toast` 读它（asar 原文：`inject("shell.overlay", … id: "workspace.row-toast" …
+		* inject: rowToastInjected … }, RowActionToast)`，而
+		* `rowToastInjected = () => ({ hooks: { toast: rowToast }, dismissToast, undoArchive: unarchiveSession })`）。
+		* 本文件就是那份 store + 那个常驻组件。
+		*
+		* 状态源走 `store.ts` 的 `createStore`（内部用 React 自带的 `useSyncExternalStore`）——
+		* 不引 `@deepseek-ai/dsh-client-store`（它在平台表内，但这里用不着；React 就够，少一条平台依赖）。
+		*/
+		const noticeStore = createStore(null);
+		/** 删除成功后发布一条撤销提示（单条）。 */
+		function publishUndoNotice(input) {
+			noticeStore.publish((seq) => ({
+				seq,
+				kind: "one",
+				entryId: input.entryId,
+				title: input.title
+			}));
+		}
+		/** 批量删除成功后发布一条撤销提示（2026-10-17）：覆盖上一条，只报这一次移走的条数。 */
+		function publishUndoBatchNotice(input) {
+			noticeStore.publish((seq) => ({
+				seq,
+				kind: "batch",
+				entryIds: input.entryIds,
+				n: input.n
+			}));
+		}
+		/** 整条横幅不再留：撤销成了、停留时间走完，或清空回收站把所有落点一起清了。
+		*  与下面 `dismissUndoNotice` 的分别是「整条不再留」与「按条目匹配」——清空之后没有条目还能撤销，
+		*  所以那一路不需要名单。 */
+		function clearUndoNotice() {
+			noticeStore.set(null);
+		}
+		/**
+		* 某个条目已经在别处恢复：把指向它的横幅熄掉。
+		* 批量里任一命中就清整条——名单少了、计数没变，留着就是一条会骗人的「撤销」动作。
+		*/
+		function dismissUndoNotice(entryIds) {
+			const wanted = new Set(entryIds);
+			noticeStore.update((current) => {
+				if (current === null) return current;
+				if (current.kind === "one") return wanted.has(current.entryId) ? null : current;
+				return current.entryIds.some((id) => wanted.has(id)) ? null : current;
+			});
+		}
+		/** 供组件订阅。 */
+		function useUndoNotice() {
+			return noticeStore.use();
+		}
+		/** 提示停留时长。**6 秒** 定死在本行（比 Toast 默认的 3 秒长）——`docs/ui-spec.md` §2 状态 ③ 只指到这里，不抄这个数。 */
+		const UNDO_HOLD_MS = 6e3;
+		/** 这次撤销开始时的那条横幅还在吗——期间被新删除覆盖、或由面板恢复熄灭时，旧请求不许改写它。 */
+		function ownsNotice(current) {
+			return noticeStore.get() === current;
+		}
+		/** 撤销失败：把原因换到同一条横幅上（seq 递增 ⇒ Toast 重挂载、重新计停留）。 */
+		function failNotice(current, message) {
+			if (!ownsNotice(current)) return;
+			noticeStore.publish((seq) => ({
+				...current,
+				seq,
+				failure: message
+			}));
+		}
+		/** 撤销：单条与批量都走**一次** `applyOutcomes('restore', ids)`（`runWrite` 判读；单条带 `single: true`，
+		*  null 是协议错）；失败就把原因换到同一条横幅上，不静默。 */
+		async function undo(deps, current) {
+			const ids = current.kind === "one" ? [current.entryId] : current.entryIds;
+			if (current.kind === "one" && current.entryId === "") return;
+			const outcome = await restoreFromUndo(deps, {
+				ids,
+				single: current.kind === "one"
+			});
+			if (!outcome.ok) {
+				failNotice(current, outcome.failure.message);
+				return;
+			}
+			const failure = outcome.failures.values().next().value;
+			if (failure !== void 0) {
+				failNotice(current, failure);
+				return;
+			}
+			if (ownsNotice(current)) clearUndoNotice();
+		}
+		/**
+		* 常驻的撤销提示宿主。挂 `shell.overlay`（框架级浮层；槽位说明原文 "a toast stack or a status
+		* pill all belong here"，见 asar 里 `shell.overlay` 的声明）：没有待撤销的事时什么都不渲染。
+		*/
+		function UndoToast({ deps, t = zhTranslate }) {
+			const current = useUndoNotice();
+			if (current === null) return null;
+			const { seq, failure } = current;
+			if (failure !== void 0) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Toast, {
+				text: failure,
+				icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconWarningOutlineRegular, { size: 16 }),
+				holdMs: UNDO_HOLD_MS,
+				onDone: clearUndoNotice
+			}, seq);
+			const canUndo = current.kind === "one" ? current.entryId !== "" : current.entryIds.length > 0;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Toast, {
+				tone: "success",
+				text: current.kind === "one" ? t("undo.moved", { title: current.title === "" ? t("undo.session") : current.title }) : t("undo.movedBatch", { n: current.n }),
+				holdMs: UNDO_HOLD_MS,
+				actions: canUndo ? [{
+					label: t("undo.undo"),
+					onClick: () => void undo(deps, current)
+				}] : void 0,
+				onDone: clearUndoNotice
+			}, seq);
+		}
+		//#endregion
 		//#region src/client/main-view.ts
 		let client;
-		/** 我们自己关掉的主视图会话：只有这里记过的，撤销恢复后才会重开。 */
+		/** 我们自己关掉的主视图会话：只有这里记过的，撤销恢复后才会重开；面板恢复用 `forgetMainView` 清掉。 */
 		let closedByUs = /* @__PURE__ */ new Set();
-		/** 重开排队的最新序号：后一次删除/恢复（或重开）让前一次的等待作废（只开最新那条）。 */
-		let openToken = 0;
+		/** 重开排队的最新票：后一次删除/恢复（或重开）签发新票，前一次的等待随之作废（只开最新那条）。 */
+		const reopen = createLatestWins();
 		/** 入口激活时绑一次；之后每次调用再读服务（客户端插件激活顺序早于 `uiWorkspace` 也没关系）。 */
 		function bindMainView(ctx) {
 			client = ctx;
@@ -1763,7 +2096,7 @@ window.__ModuleLoader__.load({
 		*/
 		function afterDelete(sessionIds) {
 			if (sessionIds.length === 0) return;
-			openToken += 1;
+			reopen.invalidate();
 			const ui = uiWorkspaceOf();
 			if (ui === void 0) return;
 			const current = currentSessionOf(ui);
@@ -1777,29 +2110,36 @@ window.__ModuleLoader__.load({
 		* 撤销恢复成功后调用：把**我们自己关掉的**那几个会话重新打开（只认 `afterDelete` 记过的）。
 		*
 		* 一批里只有最后一条会开（`targets[targets.length - 1]`）：主视图一次只装一个会话，而撤销恢复
-		* 的成功条数可能多于一条；`openWhenListed` 的 token 守卫保证前一条的等待不会后落地抢焦点。
+		* 的成功条数可能多于一条；`openWhenListed` 的最新票守卫保证前一条的等待不会后落地抢焦点。
 		* 任何更新的删除/恢复都会先作废旧等待；这里只负责「这一次要开哪一条」。
 		*/
 		function afterRestore(sessionIds) {
 			if (sessionIds.length === 0) return;
-			openToken += 1;
+			reopen.invalidate();
 			const targets = sessionIds.filter((id) => closedByUs.has(id));
 			if (targets.length === 0) return;
 			for (const id of targets) closedByUs.delete(id);
 			openWhenListed(targets[targets.length - 1]);
 		}
 		/**
+		* 面板恢复已经替这些会话完成了“回来”的结算：只忘掉我们关过的那几条，不重开、不抢焦点。
+		* 它不动 `reopen`：同一会话不会既在等重开、又躺在回收站里等面板恢复；在等的重开属于另一条动作。
+		*/
+		function forgetMainView(sessionIds) {
+			for (const id of sessionIds) closedByUs.delete(id);
+		}
+		/**
 		* 把会话重新打开：`api-session/added` 从宿主发出到客户端摘要表落地有一拍（WS 与 HTTP 响应各走
 		* 各的），`openSession` 的目标必须先出现在清单里才不会抛「unknown session」——所以先等它出现，
 		* 最多 2 秒；期间用户若已经选了别的会话就不再抢焦点。等不到就什么都不做，行还在那里。
 		*
-		* **token 守卫**（`openToken`）：开始等待时取一个序号，立即开与每次 tick 都核对；后一次删除/
-		* 恢复（或 `resetMainView`）推进序号，前一次的等待就不再打开、也不再续时。
+		* **最新票守卫**（`reopen`）：开始等待时签一张票，立即开与每次 tick 都核对；后一次删除/
+		* 恢复（或 `resetMainView`）签发新票或作废当前票，前一次的等待就不再打开、也不再续时。
 		*/
 		function openWhenListed(sessionId) {
 			const ui = uiWorkspaceOf();
 			if (ui === void 0) return;
-			const token = ++openToken;
+			const ticket = reopen.issue();
 			const listReady = () => {
 				try {
 					return ui.sessions?.list?.getSnapshot()?.byId?.[sessionId] !== void 0;
@@ -1812,7 +2152,7 @@ window.__ModuleLoader__.load({
 				return current === void 0 || current === sessionId;
 			};
 			const open = () => {
-				if (token !== openToken) return;
+				if (!ticket.current) return;
 				if (!canTakeFocus()) return;
 				try {
 					ui.openSession?.(sessionId);
@@ -1824,7 +2164,7 @@ window.__ModuleLoader__.load({
 			}
 			let attempts = 0;
 			const tick = () => {
-				if (token !== openToken) return;
+				if (!ticket.current) return;
 				attempts += 1;
 				if (listReady()) {
 					open();
@@ -1835,151 +2175,184 @@ window.__ModuleLoader__.load({
 			setTimeout(tick, 100);
 		}
 		//#endregion
-		//#region src/client/trash-store.ts
-		/**
-		* 回收站清单的**失效通告台**：动过回收站的动作戳一下，清单面板据此重新取数。
-		*
-		* 为什么需要它（真机反馈）：回收站面板是「挂载时取一次数」（`useEffect(reload)`），而删除发生在
-		* **侧栏菜单**那边（`delete-confirm.tsx` 的常驻宿主），两者没有共同的父组件——删完之后中央那个
-		* 面板（如果正开着）不会自己重读，用户得切走再切回来（= 重新挂载）才看得见新条目。撤销（`undo-toast.tsx`）
-		* 同理。
-		*
-		* 形状与两个邻居同款（`undo-toast.tsx` 的通知台、`delete-confirm.tsx` 的现场）：**模块级现场**，
-		* 订阅/通告那套只住在 `store.ts` 的 `createStore` 里——这些现场都挂在 `shell.overlay`／`main`
-		* 这些各不相邻的座位上，模块级是它们唯一的共同点。
-		*
-		* 语义只有"变过"这一件事：一个递增的修订号（测试收场时归零）。面板把它写进 effect 的依赖里，
-		* 戳一次重读一次；不需要知道是谁动的、动了什么（清单本体永远是问宿主要）。
-		*/
-		const revisionStore = createStore(0);
-		/** 通告一次"回收站变过了"（删除成功、撤销成功；面板自己的恢复/彻底删除则就地重读）。 */
-		function invalidateTrash() {
-			revisionStore.update((revision) => revision + 1);
+		//#region src/client/write-settlement.ts
+		const NO_PRESENTATION = {
+			delete: {},
+			restore: {},
+			purge: {},
+			count: {},
+			"orphan-clean": {}
+		};
+		/** 没有呈现材质的座位用它：抛掉按 action 的联合，调用点不用各自造一个空对象字面量。 */
+		function noPresentation(action) {
+			return NO_PRESENTATION[action];
+		}
+		function settleWrite(success, presentation) {
+			switch (success.action) {
+				case "delete": {
+					const seat = presentation;
+					afterDelete(success.successIds);
+					seat.invalidate?.();
+					if (success.anySuccess) {
+						const [first, ...rest] = landedEntryIds(success.receipt);
+						if (first !== void 0) {
+							const entryIds = [first, ...rest];
+							seat.publishUndo?.({
+								entryIds,
+								n: success.successIds.length
+							});
+						}
+					}
+					return;
+				}
+				case "restore": {
+					const seat = presentation;
+					const restored = restoredSessionIds(success.receipt, seat.sessionIdOfEntry);
+					if (seat.panelSeat !== true) afterRestore(restored);
+					seat.invalidate?.();
+					if (!success.anySuccess) return;
+					seat.dismissUndo?.(success.successIds);
+					if (seat.panelSeat === true) forgetMainView(restored);
+					seat.clearDetailCache?.(success.successIds);
+					return;
+				}
+				case "purge": {
+					const seat = presentation;
+					if (success.anySuccess) {
+						seat.dismissUndo?.(success.successIds);
+						seat.clearDetailCache?.(success.successIds);
+					}
+					return;
+				}
+				case "count":
+				case "orphan-clean": return;
+				default: return success.action;
+			}
 		}
-		/** 供面板订阅。 */
-		function useTrashRevision() {
-			return revisionStore.use();
+		//#endregion
+		//#region src/client/write.ts
+		async function runWrite(input) {
+			const lifecycle = async () => {
+				const ids = [...new Set(input.ids)];
+				const outcome = await callRemote(() => input.deps.applyOutcomes(input.action, ids));
+				if (!outcome.ok) {
+					const failures = new Map(ids.map((id) => [id, outcome.failure.message]));
+					const failed = {
+						ok: false,
+						action: input.action,
+						ids,
+						failure: outcome.failure,
+						failures
+					};
+					await input.refresh?.(failed);
+					return failed;
+				}
+				const single = input.single === true && ids.length === 1;
+				const receipt = readReceipt(input.action, ids, outcome.value, { single });
+				const failures = /* @__PURE__ */ new Map();
+				for (const verdict of receipt.verdicts) if (isFailureVerdict(verdict)) failures.set(verdict.id, failureMessage(verdict));
+				const successIds = receipt.verdicts.filter((verdict) => verdict.kind === "ok" || verdict.kind === "already-gone").map((verdict) => verdict.id);
+				const success = {
+					ok: true,
+					action: input.action,
+					ids,
+					receipt,
+					failures,
+					successIds,
+					anySuccess: successIds.length > 0
+				};
+				settleWrite(success, input.presentation ?? noPresentation(input.action));
+				await input.refresh?.(success);
+				return success;
+			};
+			return input.gate === void 0 ? lifecycle() : input.gate.around(lifecycle);
 		}
 		//#endregion
-		//#region src/client/write-commit.ts
-		/**
-		* 回收站面板之外发生的写入（菜单删除、批量删除、撤销恢复）的**跨槽位收尾顺序**：
-		* 主视图收尾 → 失效回收站 → 撤销通告。面板自己的写入，本地 refresh / 缓存的
-		* 生命周期仍住在 controller 与 query 里。
-		*/
-		function commitExternalDelete(input) {
-			afterDelete(input.sessionIds);
-			invalidateTrash();
-			input.publishUndo();
+		//#region src/client/write-seats.ts
+		/** 会话行菜单的单删座位：一条会话、`single` 读法、成功发单条撤销横幅。交回这条会话的失败原文。 */
+		async function deleteSessionFromMenu(deps, input, gate) {
+			return (await runWrite({
+				deps,
+				action: "delete",
+				ids: [input.sessionId],
+				single: true,
+				presentation: {
+					invalidate: invalidateTrash,
+					publishUndo: ({ entryIds }) => publishUndoNotice({
+						entryId: entryIds[0],
+						title: input.title
+					})
+				},
+				gate
+			})).failures.get(input.sessionId) ?? null;
 		}
-		function commitExternalRestore(sessionIds) {
-			afterRestore(sessionIds);
-			invalidateTrash();
+		/** 批量删除座位（宿主会话列表的多选 → 批量确认框）：一次 `/apply`，撤销名单只收 ok 支的条目 id（跟着组走的幂等条不单列）。
+		*  只收 id：标题是浮条的呈现，不参与这一次写入。 */
+		async function deleteSessionsFromBatch(deps, ids, gate) {
+			return (await runWrite({
+				deps,
+				action: "delete",
+				ids,
+				presentation: {
+					invalidate: invalidateTrash,
+					publishUndo: ({ entryIds, n }) => publishUndoBatchNotice({
+						entryIds,
+						n
+					})
+				},
+				gate
+			})).failures;
 		}
-		//#endregion
-		//#region src/client/undo-toast.tsx
-		/**
-		* 撤销提示（docs/ui-spec.md 状态 ③）：删除成功后一条可撤销的横幅。
-		*
-		* 为什么是**独立组件 + 模块级通知台**，而不是死在菜单行里：宿主的菜单行随菜单**一起卸载**
-		* （真产物 Menu 的注释原文 "the rows unmount with the list"），而提示要在菜单关掉之后还活着。
-		* 宿主的官方配方同形——会话行的动作把请求写进一个模块级 store，`shell.overlay` 里的
-		* `workspace.row-toast` 读它（asar 原文：`inject("shell.overlay", … id: "workspace.row-toast" …
-		* inject: rowToastInjected … }, RowActionToast)`，而
-		* `rowToastInjected = () => ({ hooks: { toast: rowToast }, dismissToast, undoArchive: unarchiveSession })`）。
-		* 本文件就是那份 store + 那个常驻组件。
-		*
-		* 状态源走 `store.ts` 的 `createStore`（内部用 React 自带的 `useSyncExternalStore`）——
-		* 不引 `@deepseek-ai/dsh-client-store`（它在平台表内，但这里用不着；React 就够，少一条平台依赖）。
-		*/
-		const noticeStore = createStore(null);
-		/** 删除成功后发布一条撤销提示（单条）。 */
-		function publishUndoNotice(input) {
-			noticeStore.publish((seq) => ({
-				seq,
-				kind: "one",
-				entryId: input.entryId,
-				title: input.title
-			}));
-		}
-		/** 批量删除成功后发布一条撤销提示（2026-10-17）：覆盖上一条，只报这一次移走的条数。 */
-		function publishUndoBatchNotice(input) {
-			noticeStore.publish((seq) => ({
-				seq,
-				kind: "batch",
-				entryIds: input.entryIds,
-				n: input.n
-			}));
-		}
-		/** 撤销成功后把提示收掉（用户点「撤销」、或横幅自己走完停留时间）。 */
-		function clearUndoNotice() {
-			noticeStore.set(null);
-		}
-		/** 供组件订阅。 */
-		function useUndoNotice() {
-			return noticeStore.use();
+		/** 外部恢复座位（撤销横幅）：没有 busy 面，不传闸；主视图重开归 settlement，这里只让清单失效。 */
+		function restoreFromUndo(deps, input) {
+			return runWrite({
+				deps,
+				action: "restore",
+				ids: input.ids,
+				single: input.single,
+				presentation: { invalidate: invalidateTrash }
+			});
 		}
-		/** 提示停留时长。**6 秒** 定死在本行（比 Toast 默认的 3 秒长）——`docs/ui-spec.md` §2 状态 ③ 只指到这里，不抄这个数。 */
-		const UNDO_HOLD_MS = 6e3;
-		/** 撤销失败：把原因换到同一条横幅上（seq 递增 ⇒ Toast 重挂载、重新计停留）。 */
-		function failNotice(current, message) {
-			noticeStore.publish((seq) => ({
-				...current,
-				seq,
-				failure: message
-			}));
+		/** 面板恢复座位：面板已替这条完成「回来」的结算 ⇒ `panelSeat`；撤销横幅与详情缓存都按落地条目收。 */
+		function restoreFromPanel(input) {
+			return runWrite({
+				deps: input.deps,
+				action: "restore",
+				ids: input.ids,
+				single: input.single,
+				presentation: {
+					panelSeat: true,
+					dismissUndo: dismissUndoNotice,
+					clearDetailCache: input.clearDetailCache,
+					sessionIdOfEntry: (entryId) => input.entries?.find((entry) => entry.id === entryId)?.sessionId
+				},
+				gate: input.gate,
+				refresh: input.refreshAfterWrite
+			});
 		}
-		/** 撤销：单条 `restore(entryId)`、批量**一次** `applyOutcomes('restore', entryIds)`；失败就把原因换到同一条横幅上，不静默。 */
-		async function undo(deps, current) {
-			if (current.kind === "one" && current.entryId === "") return;
-			if (current.kind === "one") {
-				const outcome = await callRemote(() => applyOne(deps, "restore", current.entryId));
-				if (!outcome.ok) {
-					failNotice(current, outcome.failure.message);
-					return;
-				}
-				commitExternalRestore([outcome.value.value.sessionId]);
-			} else {
-				const outcome = await callRemote(() => deps.applyOutcomes("restore", current.entryIds));
-				if (!outcome.ok) {
-					failNotice(current, outcome.failure.message);
-					return;
-				}
-				const receipt = readReceipt("restore", current.entryIds, outcome.value);
-				commitExternalRestore(receipt.verdicts.flatMap((verdict) => verdict.kind === "ok" && verdict.value !== null ? [verdict.value.sessionId] : []));
-				const failure = receipt.verdicts.find(isFailureVerdict);
-				if (failure !== void 0) {
-					failNotice(current, failureMessage(failure));
-					return;
-				}
-			}
-			clearUndoNotice();
+		/** 面板彻底删除座位：永久删除也让指向这些条目的撤销横幅熄灭（settlement 的 purge 支负责）。 */
+		function purgeFromPanel(input) {
+			return runWrite({
+				deps: input.deps,
+				action: "purge",
+				ids: input.ids,
+				presentation: {
+					dismissUndo: dismissUndoNotice,
+					clearDetailCache: input.clearDetailCache
+				},
+				gate: input.gate,
+				refresh: input.refreshAfterWrite
+			});
 		}
-		/**
-		* 常驻的撤销提示宿主。挂 `shell.overlay`（框架级浮层；槽位说明原文 "a toast stack or a status
-		* pill all belong here"，见 asar 里 `shell.overlay` 的声明）：没有待撤销的事时什么都不渲染。
-		*/
-		function UndoToast({ deps, t = zhTranslate }) {
-			const current = useUndoNotice();
-			if (current === null) return null;
-			const { seq, failure } = current;
-			if (failure !== void 0) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Toast, {
-				text: failure,
-				icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconWarningOutlineRegular, { size: 16 }),
-				holdMs: UNDO_HOLD_MS,
-				onDone: clearUndoNotice
-			}, seq);
-			const canUndo = current.kind === "one" ? current.entryId !== "" : current.entryIds.length > 0;
-			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Toast, {
-				tone: "success",
-				text: current.kind === "one" ? t("undo.moved", { title: current.title === "" ? t("undo.session") : current.title }) : t("undo.movedBatch", { n: current.n }),
-				holdMs: UNDO_HOLD_MS,
-				actions: canUndo ? [{
-					label: t("undo.undo"),
-					onClick: () => void undo(deps, current)
-				}] : void 0,
-				onDone: clearUndoNotice
-			}, seq);
+		/** 无主子会话清理座位：不碰回收站失效与撤销，回执判读仍归 `use-trash-query.ts`。 */
+		function cleanOrphansFromPanel(input) {
+			return runWrite({
+				deps: input.deps,
+				action: "orphan-clean",
+				ids: input.ids,
+				gate: input.gate,
+				refresh: input.refreshAfterWrite
+			});
 		}
 		//#endregion
 		//#region src/client/delete-confirm.tsx
@@ -2001,7 +2374,7 @@ window.__ModuleLoader__.load({
 		*
 		* - **菜单行只发请求**：`DeleteMenuItem` 把 `{ sessionId, title }` 写进本文件的模块级现场；
 		* - **确认框由本文件的宿主渲染与提交**：`DeleteConfirmHost` 挂在 `shell.overlay` 上，从现场读请求，
-		*   自己持有 busy / failure。于是「提交删除 → 失败原文上屏 → 再点一次重试 → 成功后发撤销提示」
+		*   自己持有这趟的闸与 failure。于是「提交删除 → 失败原文上屏 → 再点一次重试 → 成功后发撤销提示」
 		*   整条链路都在菜单子树之外，菜单关不关都不影响它。
 		*
 		* 现场是**模块级**的（本仓既有的客户端模式：视图内路由与跨卸载的现场都住在模块级 store，
@@ -2057,7 +2430,8 @@ window.__ModuleLoader__.load({
 		* 用户可以再点一次（不是一次失败就永久锁死）。
 		*/
 		function ConfirmDialog({ request: current, deps, t }) {
-			const [busy, setBusy] = (0, react.useState)(false);
+			/** 这一趟的闸：写入座位把 apply → 收尾 → 重读整趟包在里面，`busy` 期间主按钮按住。 */
+			const gate = useBusyGate();
 			const [failure, setFailure] = (0, react.useState)(null);
 			/**
 			* 这条会话在盘上带着多少个后代。删除是按组走的（组语义见 `src/trash/groups.ts`），而宿主的客户端本来就把孩子那几行
@@ -2076,22 +2450,15 @@ window.__ModuleLoader__.load({
 				};
 			}, [deps, current.sessionId]);
 			const confirm = async () => {
-				setBusy(true);
 				setFailure(null);
-				const outcome = await callRemote(() => applyOne(deps, "delete", current.sessionId).then((item) => item.value));
-				setBusy(false);
-				if (!outcome.ok) {
-					setFailure(outcome.failure.message);
+				const failure = await deleteSessionFromMenu(deps, {
+					sessionId: current.sessionId,
+					title: current.title
+				}, gate);
+				if (failure !== null) {
+					setFailure(failure);
 					return;
 				}
-				const entry = outcome.value;
-				commitExternalDelete({
-					sessionIds: [current.sessionId],
-					publishUndo: () => publishUndoNotice({
-						entryId: entry.id,
-						title: current.title
-					})
-				});
 				clearDeleteRequest();
 			};
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Modal, {
@@ -2105,7 +2472,7 @@ window.__ModuleLoader__.load({
 					children: t("common.cancel")
 				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
 					variant: "primary",
-					disabled: busy,
+					disabled: gate.busy,
 					onClick: () => void confirm(),
 					children: t("dialog.confirm")
 				})] }),
@@ -2215,15 +2582,14 @@ window.__ModuleLoader__.load({
 			overflow: "auto"
 		};
 		function BatchConfirmDialog({ request: current, deps, t }) {
-			const [busy, setBusy] = (0, react.useState)(false);
+			/** 这一趟的闸：写入座位把 apply → 收尾 → 重读整趟包在里面，`busy` 期间主按钮按住。 */
+			const gate = useBusyGate();
 			/** 逐条失败原文：`sessionId → 信封的 message`。失败**不关框**（与单删同款）。 */
 			const [failures, setFailures] = (0, react.useState)(/* @__PURE__ */ new Map());
 			/** 开框那一刻现问的子会话计数；`null` = 有一条读不到 ⇒ 那两半句整句不说（不许拿 0 冒充"没有"）。 */
 			const [counts, setCounts] = (0, react.useState)(null);
 			const ids = current.items.map((item) => item.sessionId);
 			const failedIds = [...failures.keys()];
-			/** 首轮发全部；重试轮只发失败的那些（成功的已经不在名单里了）。 */
-			const pendingIds = failedIds.length > 0 ? failedIds : ids;
 			const totalKids = counts === null ? 0 : [...counts.values()].reduce((sum, n) => sum + n, 0);
 			(0, react.useEffect)(() => {
 				let alive = true;
@@ -2235,43 +2601,8 @@ window.__ModuleLoader__.load({
 				};
 			}, [deps, current.seq]);
 			const run = async () => {
-				setBusy(true);
 				setFailures(/* @__PURE__ */ new Map());
-				const outcome = await callRemote(() => deps.applyOutcomes("delete", pendingIds));
-				setBusy(false);
-				if (!outcome.ok) {
-					setFailures(new Map(pendingIds.map((id) => [id, outcome.failure.message])));
-					return;
-				}
-				const receipt = readReceipt("delete", pendingIds, outcome.value);
-				const moved = [];
-				const deletedSessionIds = [];
-				const failed = /* @__PURE__ */ new Map();
-				let okCount = 0;
-				for (const verdict of receipt.verdicts) switch (verdict.kind) {
-					case "failed":
-					case "neutral":
-					case "missing":
-						failed.set(verdict.id, failureMessage(verdict));
-						break;
-					case "ok":
-						okCount += 1;
-						deletedSessionIds.push(verdict.id);
-						if (verdict.value !== null) moved.push(verdict.value.id);
-						break;
-					case "already-gone":
-						okCount += 1;
-						deletedSessionIds.push(verdict.id);
-				}
-				commitExternalDelete({
-					sessionIds: deletedSessionIds,
-					publishUndo: () => {
-						if (okCount > 0) publishUndoBatchNotice({
-							entryIds: moved,
-							n: okCount
-						});
-					}
-				});
+				const failed = await deleteSessionsFromBatch(deps, current.items.map((item) => item.sessionId), gate);
 				shrinkPicksToFailures([...failed.keys()]);
 				if (failed.size === 0) {
 					clearDeleteBatchRequest();
@@ -2291,7 +2622,7 @@ window.__ModuleLoader__.load({
 					children: t("common.cancel")
 				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
 					variant: "primary",
-					disabled: busy,
+					disabled: gate.busy,
 					onClick: () => void run(),
 					children: failedIds.length > 0 ? t("dialog.batch.retry", { n: failedIds.length }) : t("batch.run", { n: ids.length })
 				})] }),
@@ -2339,7 +2670,8 @@ window.__ModuleLoader__.load({
 		* all belong here"）。
 		*
 		* 那个 K 是**勾选变化后防抖 300ms 的一次批量 count**（`/apply` 的 `action:'count'`，一组 id 一次），
-		* 并且带**序号守卫**：在飞的旧响应不许盖掉新名单的读数（与 2026-10-17 `c66f082` 那条 `reloadSeq` 同一个道理）。
+		* 并且带**最新票守卫**：在飞的旧响应不许盖掉新名单的读数（compare-and-set 住 `createLatestWins`，
+		* 防抖本身仍在下面这个 effect 里）。
 		* 读不到就整句不说——K 是合计，缺一条就是假数（「不许拿 0 冒充没有」）。
 		*/
 		/** 勾选变化后到发问之间的等待：连勾十条不该发十次 count。 */
@@ -2347,25 +2679,30 @@ window.__ModuleLoader__.load({
 		function BatchBar({ deps, t = zhTranslate }) {
 			const { selecting, picks } = useSelection();
 			useSelectionRowClickGuard();
+			const visibleRows = useVisibleSelectableRows(selecting);
 			const [counts, setCounts] = (0, react.useState)(null);
 			const [expanded, setExpanded] = (0, react.useState)(false);
-			const seqRef = (0, react.useRef)(0);
+			const [latest] = (0, react.useState)(createLatestWins);
 			(0, react.useEffect)(() => {
 				const ids = picks.map((item) => item.sessionId);
-				const seq = seqRef.current += 1;
+				const ticket = latest.issue();
 				const timer = setTimeout(() => {
 					fetchCounts(deps, ids).then((result) => {
-						if (seq === seqRef.current) setCounts(result);
+						if (ticket.current) setCounts(result);
 					});
 				}, COUNT_DEBOUNCE_MS);
 				return () => clearTimeout(timer);
-			}, [deps, picks]);
+			}, [
+				deps,
+				latest,
+				picks
+			]);
 			(0, react.useEffect)(() => {
 				if (!selecting || picks.length === 0) setExpanded(false);
 			}, [selecting, picks.length]);
 			if (!selecting) return null;
 			const kids = counts === null ? 0 : picks.reduce((sum, item) => sum + (counts.get(item.sessionId) ?? 0), 0);
-			const allPicked = allVisibleSelected();
+			const allPicked = areAllVisibleRowsSelected(visibleRows, picks);
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 				className: "sd-batch-bar",
 				"data-dsh-session-delete": "batch-bar",
@@ -2552,97 +2889,504 @@ window.__ModuleLoader__.load({
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconTrashOutlineRegular, { size });
 		}
 		//#endregion
-		//#region node_modules/.pnpm/comma-separated-tokens@2.0.3/node_modules/comma-separated-tokens/index.js
-		/**
-		* Serialize an array of strings or numbers to comma-separated tokens.
-		*
-		* @param {Array<string|number>} values
-		*   List of tokens.
-		* @param {Options} [options]
-		*   Configuration for `stringify` (optional).
-		* @returns {string}
-		*   Comma-separated tokens.
-		*/
-		function stringify$1(values, options) {
-			const settings = options || {};
-			return (values[values.length - 1] === "" ? [...values, ""] : values).join((settings.padRight ? " " : "") + "," + (settings.padLeft === false ? "" : " ")).trim();
-		}
-		//#endregion
-		//#region node_modules/.pnpm/estree-util-is-identifier-name@3.0.0/node_modules/estree-util-is-identifier-name/lib/index.js
-		const nameRe = /^[$_\p{ID_Start}][$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
-		const nameReJsx = /^[$_\p{ID_Start}][-$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
-		/** @type {Options} */
-		const emptyOptions$3 = {};
+		//#region src/client/ui/recipe.ts
 		/**
-		* Checks if the given value is a valid identifier name.
-		*
-		* @param {string} name
-		*   Identifier to check.
-		* @param {Options | null | undefined} [options]
-		*   Configuration (optional).
-		* @returns {boolean}
-		*   Whether `name` can be an identifier.
+		* 安静的红：**只给字色、不给底**。宿主控件的 `.sd-button-ghost:hover` / `:active` 是普通类，
+		* 而作者态的内联 `background` 永远赢过类规则 ⇒ 铺了底的红按钮在点错之前不给任何视觉回应。
+		* 整页唯一那块实心红另有写法（`variant="primary"` + 就地覆盖 primary 那对 token），不在这里。
 		*/
-		function name$1(name, options) {
-			return ((options || emptyOptions$3).jsx ? nameReJsx : nameRe).test(name);
-		}
+		const QUIET_DANGER = { color: "var(--dsw-alias-state-error-primary)" };
+		/** 单行截断。宽档那一列与可拖的分栏天然会挤文字，逐处手写这三行就会各写各的。 */
+		const ELLIPSIS = {
+			overflow: "hidden",
+			textOverflow: "ellipsis",
+			whiteSpace: "nowrap"
+		};
 		//#endregion
-		//#region node_modules/.pnpm/hast-util-whitespace@3.0.0/node_modules/hast-util-whitespace/lib/index.js
+		//#region src/client/trash-view.ts
+		/** 卡片配方：宿主设置面的 fill/stroke 底层 token + 官方 `lg` 圆角。 */
+		const CARD = {
+			display: "flex",
+			alignItems: "center",
+			gap: 14,
+			minWidth: 0,
+			padding: "9px 14px",
+			background: "var(--dsw-alias-bg-layer-2)",
+			border: "0.5px solid var(--dsw-alias-border-l4)",
+			borderRadius: "var(--dsw-radius-lg)"
+		};
+		/** 选中行：底色与描边都换成宿主"选中"那一档（`trash-panel.tsx` 头注里有这两枚 token 的实测取值）。 */
+		const CARD_SELECTED = {
+			...CARD,
+			background: "var(--dsw-alias-button-ghost-active-fill)",
+			border: "0.5px solid var(--dsw-alias-button-ghost-active-border)"
+		};
 		/**
-		* @typedef {import('hast').Nodes} Nodes
+		* **整页唯一那块实心红**的写法：`variant="primary"` + 在元素上覆盖 primary 那对填充 token。
+		* 宿主插件管理页的 danger 按钮就是这个写法（asar @21658274），所以 hover 仍走 `.primary:hover` 类。
 		*/
-		const re = /[ \t\n\f\r]/g;
+		const BULK_DANGER = {
+			"--dsw-alias-button-primary-fill": "var(--dsw-alias-state-error-primary)",
+			"--dsw-alias-button-primary-hover": "var(--dsw-alias-state-error-primary)"
+		};
 		/**
-		* Check if the given value is *inter-element whitespace*.
-		*
-		* @param {Nodes | string} thing
-		*   Thing to check (`Node` or `string`).
-		* @returns {boolean}
-		*   Whether the `value` is inter-element whitespace (`boolean`): consisting of
-		*   zero or more of space, tab (`\t`), line feed (`\n`), carriage return
-		*   (`\r`), or form feed (`\f`); if a node is passed it must be a `Text` node,
-		*   whose `value` field is checked.
+		* 项目名怎么念：宿主的 `projectKey` 把 cwd 里的 `/`、`\`、`:` 全折成**一个** `-` ⇒ 分隔符那部分有损、
+		* 拆不回真实路径；但**非分隔符那部分可逆**（`~XXXX` 十六进制码元，字面 `~` 编成 `~007E`）。
+		* 摘掉 `--…--` 裹边、还原这些转义，剩下的原样摆出来，完整串交给组头 `title`。
+		* 字母表只有一份：还原走 `shared/wire.ts`。
 		*/
-		function whitespace(thing) {
-			return typeof thing === "object" ? thing.type === "text" ? empty$1(thing.value) : false : empty$1(thing);
+		function projectLabel(projectDir, t) {
+			const bare = unescapeProjectKey(projectDir.replace(/^--/, "").replace(/--$/, ""));
+			return bare === "" || bare === "_no-cwd" ? t("trash.project.unknown") : bare;
 		}
-		/**
-		* @param {string} value
-		* @returns {boolean}
-		*/
-		function empty$1(value) {
-			return value.replace(re, "") === "";
+		/** 按项目分组：组内按删除时间倒序，组间按各组最新一条倒序（刚删掉的那个项目排在最上面）。 */
+		function groupByProject(entries, t) {
+			const byProject = /* @__PURE__ */ new Map();
+			for (const entry of [...entries].sort((a, b) => b.deletedAt - a.deletedAt)) {
+				const list = byProject.get(entry.projectDir);
+				if (list === void 0) byProject.set(entry.projectDir, [entry]);
+				else list.push(entry);
+			}
+			return [...byProject].map(([projectDir, list]) => ({
+				projectDir,
+				label: projectLabel(projectDir, t),
+				latest: list[0].deletedAt,
+				entries: list
+			})).sort((a, b) => b.latest - a.latest);
 		}
 		//#endregion
-		//#region node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/lib/util/schema.js
-		/**
-		* @import {Schema as SchemaType, Space} from 'property-information'
-		*/
-		/** @type {SchemaType} */
-		var Schema = class {
-			/**
-			* @param {SchemaType['property']} property
-			*   Property.
-			* @param {SchemaType['normal']} normal
-			*   Normal.
-			* @param {Space | undefined} [space]
-			*   Space.
-			* @returns
-			*   Schema.
-			*/
-			constructor(property, normal, space) {
-				this.normal = normal;
-				this.property = property;
-				if (space) this.space = space;
-			}
+		//#region src/client/trash-confirm.tsx
+		/** 弹出的一批卡片（逐条说清这一批有哪些）：长清单在框内滚，标题与动作行留在框里。 */
+		const CARD_LIST = {
+			display: "flex",
+			flexDirection: "column",
+			gap: 6,
+			maxHeight: 280,
+			overflow: "auto",
+			marginBlockEnd: 10
 		};
-		Schema.prototype.normal = {};
-		Schema.prototype.property = {};
-		Schema.prototype.space = void 0;
-		//#endregion
-		//#region node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/lib/util/merge.js
 		/**
-		* @import {Info, Space} from 'property-information'
+		* 两种批量动作共用这一个确认框壳：`purge`（不可恢复）与 `restore`（加法，但一批条目多、去向是
+		* 各自的旧项目目录，点之前也要过一道）。标题、正文、确认键的措辞各处一套；批量恢复把选中条目
+		* 列成卡片（标题 + 项目名——恢复的去向是**每条各自的**旧项目目录，逐条列出来是这句话的正文）；
+		* 批量彻底删除只给条数——那批的"去哪"没有可说的，而"不可恢复"那句警告才是要读的。
+		*/
+		function TrashConfirm({ pending, restoreEntries, busy, t, onCancel, onConfirmPurge, onConfirmRestore }) {
+			if (pending.kind === "restore") return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Modal, {
+				open: true,
+				onClose: () => {
+					if (!busy) onCancel();
+				},
+				title: t("trash.confirm.restore", { count: pending.ids.length }),
+				closeLabel: t("common.close"),
+				footer: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
+					variant: "outline",
+					disabled: busy,
+					onClick: onCancel,
+					children: t("common.cancel")
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
+					variant: "primary",
+					disabled: busy,
+					onClick: () => onConfirmRestore(pending.ids),
+					children: t("trash.confirm.restoreNow")
+				})] }),
+				children: [restoreEntries.length === 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					style: CARD_LIST,
+					children: restoreEntries.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: {
+							...CARD,
+							flexDirection: "column",
+							alignItems: "stretch",
+							gap: 2,
+							padding: "9px 12px"
+						},
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								style: {
+									...ELLIPSIS,
+									fontSize: 13.5,
+									lineHeight: "19px"
+								},
+								children: entry.title === "" ? t("common.untitled") : entry.title
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								style: {
+									...ELLIPSIS,
+									fontSize: 12,
+									lineHeight: "16px",
+									color: "var(--dsw-alias-label-tertiary)"
+								},
+								children: projectLabel(entry.projectDir, t)
+							}),
+							entry.workspaceMissing === true ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								style: {
+									fontSize: 12,
+									lineHeight: "16px",
+									color: "var(--dsw-alias-label-tertiary)"
+								},
+								children: t("trash.row.workspaceGone")
+							}) : null
+						]
+					}, entry.id))
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t("trash.confirm.restore.body") })]
+			});
+			const title = pending.kind === "all" ? t("trash.confirm.all") : pending.kind === "entries" ? t("trash.confirm.bulk", { count: pending.ids.length }) : t("trash.confirm.one");
+			const strong = t("trash.confirm.body.strong");
+			const body = splitOn(t("trash.confirm.body", { strong }), strong);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Modal, {
+				open: true,
+				onClose: () => {
+					if (!busy) onCancel();
+				},
+				title,
+				closeLabel: t("common.close"),
+				footer: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
+					variant: "outline",
+					disabled: busy,
+					onClick: onCancel,
+					children: t("common.cancel")
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
+					variant: "primary",
+					style: BULK_DANGER,
+					disabled: busy,
+					onClick: onConfirmPurge,
+					children: t("trash.confirm.purge")
+				})] }),
+				children: [pending.kind === "entry" ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					style: {
+						...CARD,
+						flexDirection: "column",
+						alignItems: "stretch",
+						gap: 2,
+						padding: "10px 12px",
+						marginBlockEnd: 10
+					},
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						style: {
+							...ELLIPSIS,
+							fontSize: 13.5,
+							lineHeight: "19px"
+						},
+						children: pending.entry.title === "" ? t("common.untitled") : pending.entry.title
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						style: {
+							...ELLIPSIS,
+							fontSize: 12,
+							lineHeight: "16px",
+							color: "var(--dsw-alias-label-tertiary)"
+						},
+						children: t("trash.confirm.one.meta", {
+							project: projectLabel(pending.entry.projectDir, t),
+							at: absoluteText(pending.entry.deletedAt),
+							size: fileSizeText(pending.entry.releaseBytes)
+						})
+					})]
+				}) : null, /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", { children: [
+					body[0],
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("b", {
+						style: { color: "var(--dsw-alias-state-error-primary)" },
+						children: body[1]
+					}),
+					body[2]
+				] })]
+			});
+		}
+		/** 无主子会话的清理确认框（2026-10-19）。载荷是刚扫出来的那份报告，界面不重算。 */
+		function OrphanConfirm({ report, busy, t, onCancel, onConfirm }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Modal, {
+				open: true,
+				onClose: () => {
+					if (!busy) onCancel();
+				},
+				title: t("trash.orphans.confirm", { count: report.totalSessions }),
+				closeLabel: t("common.close"),
+				footer: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
+					variant: "outline",
+					disabled: busy,
+					onClick: onCancel,
+					children: t("common.cancel")
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
+					variant: "primary",
+					style: BULK_DANGER,
+					disabled: busy,
+					onClick: onConfirm,
+					children: t("trash.orphans.clean")
+				})] }),
+				children: [
+					report.groups.length === 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						style: CARD_LIST,
+						children: report.groups.map((group) => {
+							const text = t("trash.orphans.group", {
+								project: projectLabel(group.projectDir, t),
+								count: group.sessions,
+								size: fileSizeText(group.bytes)
+							});
+							return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								title: text,
+								style: {
+									...CARD,
+									padding: "9px 12px",
+									fontSize: 13,
+									lineHeight: "19px"
+								},
+								children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+									style: {
+										...ELLIPSIS,
+										minWidth: 0,
+										flex: "1 1 auto"
+									},
+									children: text
+								})
+							}, group.projectDir);
+						})
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t("trash.orphans.body") }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: {
+							fontSize: 12,
+							lineHeight: "17px",
+							color: "var(--dsw-alias-label-tertiary)"
+						},
+						children: t("trash.orphans.cacheNote")
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/orphan-maintenance.tsx
+		function OrphanMaintenance({ query, busy, t }) {
+			const { orphanReport, orphanFailure, orphanNotice, orphanConfirm } = query;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+				orphanReport !== null && orphanReport.totalSessions > 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					"data-dsh-session-delete": "orphan-banner",
+					style: {
+						...CARD,
+						alignItems: "flex-start",
+						gap: 12,
+						marginBottom: 10
+					},
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: {
+								display: "inline-flex",
+								flex: "none",
+								paddingTop: 2,
+								color: "var(--dsw-alias-state-warn-primary)"
+							},
+							"aria-hidden": "true",
+							children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconWarningOutlineRegular, { size: 16 })
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: {
+								display: "flex",
+								flexDirection: "column",
+								gap: 2,
+								flex: "1 1 auto",
+								minWidth: 0
+							},
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								style: {
+									fontSize: 13,
+									lineHeight: "19px"
+								},
+								children: t("trash.orphans.banner", { count: orphanReport.totalSessions })
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								style: {
+									fontSize: 12,
+									lineHeight: "16px",
+									color: "var(--dsw-alias-label-tertiary)"
+								},
+								children: t("trash.orphans.meta", {
+									size: fileSizeText(orphanReport.totalBytes),
+									parents: orphanReport.missingParents
+								})
+							})]
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
+							variant: "outline",
+							size: "sm",
+							style: { flex: "none" },
+							disabled: busy,
+							onClick: () => {
+								if (busy) return;
+								query.openOrphanPreview();
+							},
+							children: t("trash.orphans.open")
+						})
+					]
+				}) : null,
+				orphanFailure !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					role: "status",
+					style: {
+						...CARD,
+						alignItems: "flex-start",
+						gap: 10,
+						marginBottom: 10,
+						padding: "10px 12px"
+					},
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: {
+								display: "inline-flex",
+								flex: "none",
+								color: "var(--dsw-alias-state-error-primary)"
+							},
+							"aria-hidden": "true",
+							children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconWarningOutlineRegular, { size: 15 })
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: {
+								flex: "1 1 auto",
+								minWidth: 0,
+								wordBreak: "break-word",
+								fontSize: 12,
+								lineHeight: "17px",
+								color: "var(--dsw-alias-state-error-primary)"
+							},
+							children: orphanFailure
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
+							variant: "outline",
+							size: "sm",
+							style: { flex: "none" },
+							disabled: busy,
+							onClick: () => void query.refreshAll(),
+							children: t("common.retry")
+						})
+					]
+				}) : null,
+				orphanNotice !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					"data-dsh-session-delete": "orphan-notice",
+					role: "status",
+					style: {
+						...CARD,
+						alignItems: "flex-start",
+						gap: 10,
+						marginBottom: 10,
+						padding: "10px 12px"
+					},
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						style: {
+							display: "inline-flex",
+							flex: "none",
+							paddingTop: 2,
+							color: "var(--dsw-alias-label-tertiary)"
+						},
+						"aria-hidden": "true",
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconWarningOutlineRegular, { size: 15 })
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						style: {
+							flex: "1 1 auto",
+							minWidth: 0,
+							wordBreak: "break-word",
+							fontSize: 12,
+							lineHeight: "17px",
+							color: "var(--dsw-alias-label-secondary)"
+						},
+						children: orphanNotice
+					})]
+				}) : null,
+				orphanConfirm && orphanReport !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(OrphanConfirm, {
+					report: orphanReport,
+					busy,
+					t,
+					onCancel: () => query.setOrphanConfirm(false),
+					onConfirm: () => void query.cleanOrphans()
+				}) : null
+			] });
+		}
+		//#endregion
+		//#region node_modules/.pnpm/comma-separated-tokens@2.0.3/node_modules/comma-separated-tokens/index.js
+		/**
+		* Serialize an array of strings or numbers to comma-separated tokens.
+		*
+		* @param {Array<string|number>} values
+		*   List of tokens.
+		* @param {Options} [options]
+		*   Configuration for `stringify` (optional).
+		* @returns {string}
+		*   Comma-separated tokens.
+		*/
+		function stringify$1(values, options) {
+			const settings = options || {};
+			return (values[values.length - 1] === "" ? [...values, ""] : values).join((settings.padRight ? " " : "") + "," + (settings.padLeft === false ? "" : " ")).trim();
+		}
+		//#endregion
+		//#region node_modules/.pnpm/estree-util-is-identifier-name@3.0.0/node_modules/estree-util-is-identifier-name/lib/index.js
+		const nameRe = /^[$_\p{ID_Start}][$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
+		const nameReJsx = /^[$_\p{ID_Start}][-$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
+		/** @type {Options} */
+		const emptyOptions$3 = {};
+		/**
+		* Checks if the given value is a valid identifier name.
+		*
+		* @param {string} name
+		*   Identifier to check.
+		* @param {Options | null | undefined} [options]
+		*   Configuration (optional).
+		* @returns {boolean}
+		*   Whether `name` can be an identifier.
+		*/
+		function name$1(name, options) {
+			return ((options || emptyOptions$3).jsx ? nameReJsx : nameRe).test(name);
+		}
+		//#endregion
+		//#region node_modules/.pnpm/hast-util-whitespace@3.0.0/node_modules/hast-util-whitespace/lib/index.js
+		/**
+		* @typedef {import('hast').Nodes} Nodes
+		*/
+		const re = /[ \t\n\f\r]/g;
+		/**
+		* Check if the given value is *inter-element whitespace*.
+		*
+		* @param {Nodes | string} thing
+		*   Thing to check (`Node` or `string`).
+		* @returns {boolean}
+		*   Whether the `value` is inter-element whitespace (`boolean`): consisting of
+		*   zero or more of space, tab (`\t`), line feed (`\n`), carriage return
+		*   (`\r`), or form feed (`\f`); if a node is passed it must be a `Text` node,
+		*   whose `value` field is checked.
+		*/
+		function whitespace(thing) {
+			return typeof thing === "object" ? thing.type === "text" ? empty$1(thing.value) : false : empty$1(thing);
+		}
+		/**
+		* @param {string} value
+		* @returns {boolean}
+		*/
+		function empty$1(value) {
+			return value.replace(re, "") === "";
+		}
+		//#endregion
+		//#region node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/lib/util/schema.js
+		/**
+		* @import {Schema as SchemaType, Space} from 'property-information'
+		*/
+		/** @type {SchemaType} */
+		var Schema = class {
+			/**
+			* @param {SchemaType['property']} property
+			*   Property.
+			* @param {SchemaType['normal']} normal
+			*   Normal.
+			* @param {Space | undefined} [space]
+			*   Space.
+			* @returns
+			*   Schema.
+			*/
+			constructor(property, normal, space) {
+				this.normal = normal;
+				this.property = property;
+				if (space) this.space = space;
+			}
+		};
+		Schema.prototype.normal = {};
+		Schema.prototype.property = {};
+		Schema.prototype.space = void 0;
+		//#endregion
+		//#region node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/lib/util/merge.js
+		/**
+		* @import {Info, Space} from 'property-information'
 		*/
 		/**
 		* @param {ReadonlyArray<Schema>} definitions
@@ -24507,21 +25251,29 @@ window.__ModuleLoader__.load({
 			});
 		});
 		//#endregion
-		//#region src/client/ui/recipe.ts
+		//#region src/client/trash-detail.tsx
 		/**
-		* 安静的红：**只给字色、不给底**。宿主控件的 `.sd-button-ghost:hover` / `:active` 是普通类，
-		* 而作者态的内联 `background` 永远赢过类规则 ⇒ 铺了底的红按钮在点错之前不给任何视觉回应。
-		* 整页唯一那块实心红另有写法（`variant="primary"` + 就地覆盖 primary 那对 token），不在这里。
+		* 回收站的**详情块**（docs/ui-spec.md 的四态）。
+		*
+		* 它**不自己取数**：选中、缓存、失败与重读全在面板控制器（`use-trash-panel-controller.ts`）手里，
+		* 这里只把一个状态画出来——
+		* 所以它能被单独测穿（喂四种状态，断四张形状）。
+		*
+		* 三个不能让步的点：
+		* ① **动作不住在这里**（2026-10-15 真机反馈后定，与 2026-10-01 那版同形）：「恢复」「彻底删除…」
+		*    在清单行右侧。搬进详情那一阵子，左栏为了只放标题被压到 316px，读起来就是"左侧太窄"——
+		*    动作回行内之后左栏需要的宽度也回来了（420px，理由写在面板常量处）。
+		* ② **标题优先用清册那一份**：保证「行里叫 A、点开也叫 A」，清册标题是空串才回落到日志里的
+		*    `session/title`。
+		* ③ **注入条数与截断条数必须上屏**：正文比日志里的 `user/message` 少一大截是**过滤的结果**，
+		*    页面上要说清少掉的是什么、多少条，不能让它读起来像"这条会话就这么点内容"。
+		*
+		* 皮肤**只由 token 决定**，且 token 与消息行的声明都来自宿主自己那两张表（`MessageItem.module.css` /
+		* `AssistantMarkdown.module.css` / `MarkdownText.module.css`，逐字抄，来源与差异记在 `ui/markdown.css`
+		* 文件头）——字号一律走 `--dsh-content-font-*` 那根轴，不再写宿主同类面的字面量 px。
+		* **助手正文走 Markdown，用户提问走原话**（2026-10-15 真机反馈后改；见 `markdown.tsx` 那三行收口）：
+		* 助手的 `text` 段本身就是 markdown 源，用 `pre-wrap` 摆出来就是用户说的"对话内容没渲染、是一整块纯文本"。
 		*/
-		const QUIET_DANGER = { color: "var(--dsw-alias-state-error-primary)" };
-		/** 单行截断。宽档那一列与可拖的分栏天然会挤文字，逐处手写这三行就会各写各的。 */
-		const ELLIPSIS = {
-			overflow: "hidden",
-			textOverflow: "ellipsis",
-			whiteSpace: "nowrap"
-		};
-		//#endregion
-		//#region src/client/trash-detail.tsx
 		const SHELL = {
 			display: "flex",
 			flexDirection: "column",
@@ -24943,309 +25695,158 @@ window.__ModuleLoader__.load({
 				listWidth,
 				max,
 				resizing,
-				handleProps: {
-					role: "separator",
-					"aria-orientation": "vertical",
-					"aria-label": label,
-					"aria-valuenow": listWidth,
-					"aria-valuemin": min,
-					"aria-valuemax": max,
-					tabIndex: 0,
-					...resizing ? { "data-dragging": "" } : {},
-					onPointerDown,
-					onPointerMove,
-					onPointerUp: stop,
-					onPointerCancel: stop,
-					onKeyDown
-				}
-			};
-		}
-		//#endregion
-		//#region src/client/use-panel-width.ts
-		/**
-		* 观测**面板自己那一块**的宽度（回收站的断点全靠它，docs/ui-spec.md）。
-		*
-		* 为什么不是 `window.innerWidth`：这块住在宿主的中央列里，**侧栏折叠/展开、拖动分栏**都会改它的宽度
-		* 而 window 一点不动——只听 window 的 resize 会在侧栏折叠后拿着旧宽度画错形态。
-		*
-		* 量的是**盒子的 border-box 宽**（`getBoundingClientRect().width`），不是 `contentRect.width`：
-		* 后者已经扣掉内边距，而"多宽才分两栏"那个阈值说的是整块盒子——拿扣过内边垫的数去比就是**扣两次**，
-		* 结果明明够宽却退化成下钻（2026-10-15 真机反馈后定的判据）。
-		*
-		* 首帧读一次当前宽度，之后跟着 RO 走；读到 0 就是窄档 ⇒ **窄档是默认、宽档要被证明**。
-		* RO 缺席（不可能的宿主）时停在窄档：功能一条不少，只是同屏两栏变成下钻。
-		*/
-		function usePanelWidth(ref) {
-			const [width, setWidth] = (0, react.useState)(0);
-			(0, react.useEffect)(() => {
-				const el = ref.current;
-				if (el === null) return;
-				setWidth(el.getBoundingClientRect().width);
-				const observer = new ResizeObserver((entries) => {
-					const target = entries[0]?.target;
-					if (target !== void 0) setWidth(target.getBoundingClientRect().width);
-				});
-				observer.observe(el);
-				return () => {
-					observer.disconnect();
-				};
-			}, [ref]);
-			return width;
-		}
-		//#endregion
-		//#region src/client/trash-view.ts
-		/** 卡片配方：宿主设置面的 fill/stroke 底层 token + 官方 `lg` 圆角。 */
-		const CARD = {
-			display: "flex",
-			alignItems: "center",
-			gap: 14,
-			minWidth: 0,
-			padding: "9px 14px",
-			background: "var(--dsw-alias-bg-layer-2)",
-			border: "0.5px solid var(--dsw-alias-border-l4)",
-			borderRadius: "var(--dsw-radius-lg)"
-		};
-		/** 选中行：底色与描边都换成宿主"选中"那一档（`trash-panel.tsx` 头注里有这两枚 token 的实测取值）。 */
-		const CARD_SELECTED = {
-			...CARD,
-			background: "var(--dsw-alias-button-ghost-active-fill)",
-			border: "0.5px solid var(--dsw-alias-button-ghost-active-border)"
-		};
-		/**
-		* **整页唯一那块实心红**的写法：`variant="primary"` + 在元素上覆盖 primary 那对填充 token。
-		* 宿主插件管理页的 danger 按钮就是这个写法（asar @21658274），所以 hover 仍走 `.primary:hover` 类。
-		*/
-		const BULK_DANGER = {
-			"--dsw-alias-button-primary-fill": "var(--dsw-alias-state-error-primary)",
-			"--dsw-alias-button-primary-hover": "var(--dsw-alias-state-error-primary)"
-		};
-		/**
-		* 项目名怎么念：宿主的 `projectKey` 把 cwd 里的 `/`、`\`、`:` 全折成**一个** `-` ⇒ 分隔符那部分有损、
-		* 拆不回真实路径；但**非分隔符那部分可逆**（`~XXXX` 十六进制码元，字面 `~` 编成 `~007E`）。
-		* 摘掉 `--…--` 裹边、还原这些转义，剩下的原样摆出来，完整串交给组头 `title`。
-		* 字母表只有一份：还原走 `shared/wire.ts`。
-		*/
-		function projectLabel(projectDir, t) {
-			const bare = unescapeProjectKey(projectDir.replace(/^--/, "").replace(/--$/, ""));
-			return bare === "" || bare === "_no-cwd" ? t("trash.project.unknown") : bare;
-		}
-		/** 按项目分组：组内按删除时间倒序，组间按各组最新一条倒序（刚删掉的那个项目排在最上面）。 */
-		function groupByProject(entries, t) {
-			const byProject = /* @__PURE__ */ new Map();
-			for (const entry of [...entries].sort((a, b) => b.deletedAt - a.deletedAt)) {
-				const list = byProject.get(entry.projectDir);
-				if (list === void 0) byProject.set(entry.projectDir, [entry]);
-				else list.push(entry);
-			}
-			return [...byProject].map(([projectDir, list]) => ({
-				projectDir,
-				label: projectLabel(projectDir, t),
-				latest: list[0].deletedAt,
-				entries: list
-			})).sort((a, b) => b.latest - a.latest);
+				handleProps: {
+					role: "separator",
+					"aria-orientation": "vertical",
+					"aria-label": label,
+					"aria-valuenow": listWidth,
+					"aria-valuemin": min,
+					"aria-valuemax": max,
+					tabIndex: 0,
+					...resizing ? { "data-dragging": "" } : {},
+					onPointerDown,
+					onPointerMove,
+					onPointerUp: stop,
+					onPointerCancel: stop,
+					onKeyDown
+				}
+			};
 		}
 		//#endregion
-		//#region src/client/trash-confirm.tsx
-		/** 弹出的一批卡片（逐条说清这一批有哪些）：长清单在框内滚，标题与动作行留在框里。 */
-		const CARD_LIST = {
-			display: "flex",
-			flexDirection: "column",
-			gap: 6,
-			maxHeight: 280,
-			overflow: "auto",
-			marginBlockEnd: 10
-		};
+		//#region src/client/use-panel-width.ts
 		/**
-		* 两种批量动作共用这一个确认框壳：`purge`（不可恢复）与 `restore`（加法，但一批条目多、去向是
-		* 各自的旧项目目录，点之前也要过一道）。标题、正文、确认键的措辞各处一套；批量恢复把选中条目
-		* 列成卡片（标题 + 项目名——恢复的去向是**每条各自的**旧项目目录，逐条列出来是这句话的正文）；
-		* 批量彻底删除只给条数——那批的"去哪"没有可说的，而"不可恢复"那句警告才是要读的。
+		* 观测**面板自己那一块**的宽度（回收站的断点全靠它，docs/ui-spec.md）。
+		*
+		* 为什么不是 `window.innerWidth`：这块住在宿主的中央列里，**侧栏折叠/展开、拖动分栏**都会改它的宽度
+		* 而 window 一点不动——只听 window 的 resize 会在侧栏折叠后拿着旧宽度画错形态。
+		*
+		* 量的是**盒子的 border-box 宽**（`getBoundingClientRect().width`），不是 `contentRect.width`：
+		* 后者已经扣掉内边距，而"多宽才分两栏"那个阈值说的是整块盒子——拿扣过内边垫的数去比就是**扣两次**，
+		* 结果明明够宽却退化成下钻（2026-10-15 真机反馈后定的判据）。
+		*
+		* 首帧读一次当前宽度，之后跟着 RO 走；读到 0 就是窄档 ⇒ **窄档是默认、宽档要被证明**。
+		* RO 缺席（不可能的宿主）时停在窄档：功能一条不少，只是同屏两栏变成下钻。
 		*/
-		function TrashConfirm({ pending, restoreEntries, busy, t, onCancel, onConfirmPurge, onConfirmRestore }) {
-			if (pending.kind === "restore") return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Modal, {
-				open: true,
-				onClose: () => {
-					if (!busy) onCancel();
-				},
-				title: t("trash.confirm.restore", { count: pending.ids.length }),
-				closeLabel: t("common.close"),
-				footer: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
-					variant: "outline",
-					disabled: busy,
-					onClick: onCancel,
-					children: t("common.cancel")
-				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
-					variant: "primary",
-					disabled: busy,
-					onClick: () => onConfirmRestore(pending.ids),
-					children: t("trash.confirm.restoreNow")
-				})] }),
-				children: [restoreEntries.length === 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-					style: CARD_LIST,
-					children: restoreEntries.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-						style: {
-							...CARD,
-							flexDirection: "column",
-							alignItems: "stretch",
-							gap: 2,
-							padding: "9px 12px"
-						},
-						children: [
-							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-								style: {
-									...ELLIPSIS,
-									fontSize: 13.5,
-									lineHeight: "19px"
-								},
-								children: entry.title === "" ? t("common.untitled") : entry.title
-							}),
-							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-								style: {
-									...ELLIPSIS,
-									fontSize: 12,
-									lineHeight: "16px",
-									color: "var(--dsw-alias-label-tertiary)"
-								},
-								children: projectLabel(entry.projectDir, t)
-							}),
-							entry.workspaceMissing === true ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-								style: {
-									fontSize: 12,
-									lineHeight: "16px",
-									color: "var(--dsw-alias-label-tertiary)"
-								},
-								children: t("trash.row.workspaceGone")
-							}) : null
-						]
-					}, entry.id))
-				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t("trash.confirm.restore.body") })]
-			});
-			const title = pending.kind === "all" ? t("trash.confirm.all") : pending.kind === "entries" ? t("trash.confirm.bulk", { count: pending.ids.length }) : t("trash.confirm.one");
-			const strong = t("trash.confirm.body.strong");
-			const body = splitOn(t("trash.confirm.body", { strong }), strong);
-			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Modal, {
-				open: true,
-				onClose: () => {
-					if (!busy) onCancel();
-				},
-				title,
-				closeLabel: t("common.close"),
-				footer: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
-					variant: "outline",
-					disabled: busy,
-					onClick: onCancel,
-					children: t("common.cancel")
-				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
-					variant: "primary",
-					style: BULK_DANGER,
-					disabled: busy,
-					onClick: onConfirmPurge,
-					children: t("trash.confirm.purge")
-				})] }),
-				children: [pending.kind === "entry" ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-					style: {
-						...CARD,
-						flexDirection: "column",
-						alignItems: "stretch",
-						gap: 2,
-						padding: "10px 12px",
-						marginBlockEnd: 10
-					},
-					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-						style: {
-							...ELLIPSIS,
-							fontSize: 13.5,
-							lineHeight: "19px"
-						},
-						children: pending.entry.title === "" ? t("common.untitled") : pending.entry.title
-					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-						style: {
-							...ELLIPSIS,
-							fontSize: 12,
-							lineHeight: "16px",
-							color: "var(--dsw-alias-label-tertiary)"
-						},
-						children: t("trash.confirm.one.meta", {
-							project: projectLabel(pending.entry.projectDir, t),
-							at: absoluteText(pending.entry.deletedAt),
-							size: fileSizeText(pending.entry.releaseBytes)
-						})
-					})]
-				}) : null, /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", { children: [
-					body[0],
-					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("b", {
-						style: { color: "var(--dsw-alias-state-error-primary)" },
-						children: body[1]
-					}),
-					body[2]
-				] })]
-			});
+		function usePanelWidth(ref) {
+			const [width, setWidth] = (0, react.useState)(0);
+			(0, react.useEffect)(() => {
+				const el = ref.current;
+				if (el === null) return;
+				setWidth(el.getBoundingClientRect().width);
+				const observer = new ResizeObserver((entries) => {
+					const target = entries[0]?.target;
+					if (target !== void 0) setWidth(target.getBoundingClientRect().width);
+				});
+				observer.observe(el);
+				return () => {
+					observer.disconnect();
+				};
+			}, [ref]);
+			return width;
 		}
-		/** 无主子会话的清理确认框（2026-10-19）。载荷是刚扫出来的那份报告，界面不重算。 */
-		function OrphanConfirm({ report, busy, t, onCancel, onConfirm }) {
-			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Modal, {
-				open: true,
-				onClose: () => {
-					if (!busy) onCancel();
-				},
-				title: t("trash.orphans.confirm", { count: report.totalSessions }),
-				closeLabel: t("common.close"),
-				footer: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
-					variant: "outline",
-					disabled: busy,
-					onClick: onCancel,
-					children: t("common.cancel")
-				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
-					variant: "primary",
-					style: BULK_DANGER,
-					disabled: busy,
-					onClick: onConfirm,
-					children: t("trash.orphans.clean")
-				})] }),
-				children: [
-					report.groups.length === 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-						style: CARD_LIST,
-						children: report.groups.map((group) => {
-							const text = t("trash.orphans.group", {
-								project: projectLabel(group.projectDir, t),
-								count: group.sessions,
-								size: fileSizeText(group.bytes)
-							});
-							return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-								title: text,
-								style: {
-									...CARD,
-									padding: "9px 12px",
-									fontSize: 13,
-									lineHeight: "19px"
-								},
-								children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-									style: {
-										...ELLIPSIS,
-										minWidth: 0,
-										flex: "1 1 auto"
-									},
-									children: text
-								})
-							}, group.projectDir);
-						})
-					}),
-					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t("trash.orphans.body") }),
-					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
-						style: {
-							fontSize: 12,
-							lineHeight: "17px",
-							color: "var(--dsw-alias-label-tertiary)"
-						},
-						children: t("trash.orphans.cacheNote")
-					})
-				]
-			});
+		//#endregion
+		//#region src/client/trash-nav.ts
+		/**
+		* 清单的**键盘导航面**：方向键走环、Enter / Space 的双重语义、roving tabindex 的落点，
+		* 以及窄档下钻里按 Esc 退回清单并把焦点交还给那一行。
+		*
+		* 为什么收回一处：这几条判据此前劈在 `trash-panel.tsx`（键盘分支与 `activeDescendantId` /
+		* `tabStopId` 两枚只读）与 `use-trash-panel-controller.ts`（Esc 的两个 effect 与那笔焦点账）之间。
+		* 它们说的其实是同一件事——"屏幕上从上到下的那一串行里，谁是光标、谁拿 tab 落点、Esc 之后焦点
+		* 还给谁"——而那份顺序只在面板手里（`ordered` 只含展开的组）。收进一个 module 之后面板只交输入
+		* 与四个动作，控制器不再知道焦点这回事。
+		*
+		* 它**不查文档、不认选择器**：焦点动作由调用方注入 `focusRow`，DOM 查询仍留在面板——行是在那儿
+		* 渲染出来的，选择器只在那儿有权威。它只读事件的 `target` 来判断这一下该不该归清单：从行内按钮 /
+		* 勾选框起来的 Enter / Space 是人家的激活键，不是清单的下钻或勾选。
+		*
+		* 三条原样搬来的判据（界面现状住 `docs/ui-spec.md` 的「键盘」那条；这里只留「为什么这么定」）：
+		* - **方向键走环**：未选中时 ↓ 落第一条、↑ 落最后一条；到端回卷，不是撞墙。
+		* - **`aria-activedescendant` 只指向在 DOM 里的行**：选中那行被折叠起来时它就不存在，指过去是
+		*   假引用。tab 落点（清单里唯一的 tab 巢）走同一条可见性规则，但**永远有一行拿着**——否则一次
+		*   没点过时全行都是 `-1`，键盘根本进不来清单。焦点所在的行就是激活目标：选中行被折叠时，
+		*   Enter / Space 落在拿 tab 落点的那一条上，而不是一声不响。
+		* - **Esc 只在下钻期间生效**：监听挂 `document`，因为窄档下钻时清单**不在 DOM 里**；退回后把焦点
+		*   交还选中那一行**一次**，交完就清账，后续重渲染不再重复抢焦点。
+		*/
+		/** 事件是不是清单自己的：从行（`role="option"`）或容器起来才算；行内按钮 / 勾选框的 Enter / Space
+		*  归它们自己。测试里的窄事件没有 `target`，按清单自己的处理。 */
+		function isListOwnedEvent(event) {
+			const target = event.target;
+			if (target == null || target === event.currentTarget) return true;
+			return typeof target.getAttribute === "function" && target.getAttribute("role") === "option";
+		}
+		function useTrashNav(input) {
+			const { ordered, selectedId, selectMode, drillEnabled, drilled, select, toggleCheck, exitDrill, focusRow } = input;
+			/** Esc 退出下钻后要交还焦点的那一行；等 `drilled` 落地、清单回到 DOM 之后再用一次。 */
+			const refocusRow = (0, react.useRef)(null);
+			/** 折叠起来的组只是收掉那一列，选中的 id 还留着——所以这条可见性得逐条对账，不能只看非空。 */
+			const activeDescendantId = ordered.some((entry) => entry.id === selectedId) ? selectedId : null;
+			const tabStopId = activeDescendantId ?? ordered[0]?.id ?? null;
+			const onListKeyDown = (0, react.useCallback)((event) => {
+				if (ordered.length === 0 || !isListOwnedEvent(event)) return;
+				const index = ordered.findIndex((entry) => entry.id === selectedId);
+				if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+					event.preventDefault();
+					const step = event.key === "ArrowDown" ? 1 : -1;
+					const next = index < 0 ? step > 0 ? 0 : ordered.length - 1 : (index + step + ordered.length) % ordered.length;
+					const target = ordered[next];
+					select(target);
+					focusRow(target.id);
+					return;
+				}
+				if (event.key === "Enter" || event.key === " ") {
+					const target = ordered[index >= 0 ? index : 0];
+					if (target === void 0) return;
+					event.preventDefault();
+					if (selectMode) {
+						toggleCheck(target.id);
+						return;
+					}
+					if (drillEnabled) select(target, { drill: true });
+					else select(target);
+				}
+			}, [
+				drillEnabled,
+				focusRow,
+				ordered,
+				select,
+				selectMode,
+				selectedId,
+				toggleCheck
+			]);
+			(0, react.useEffect)(() => {
+				if (!drilled || !drillEnabled) return;
+				const onKey = (event) => {
+					if (event.key !== "Escape") return;
+					refocusRow.current = selectedId;
+					exitDrill();
+				};
+				document.addEventListener("keydown", onKey);
+				return () => {
+					document.removeEventListener("keydown", onKey);
+				};
+			}, [
+				drillEnabled,
+				drilled,
+				exitDrill,
+				selectedId
+			]);
+			(0, react.useEffect)(() => {
+				if (drilled || refocusRow.current === null) return;
+				focusRow(refocusRow.current);
+				refocusRow.current = null;
+			}, [drilled, focusRow]);
+			return {
+				activeDescendantId,
+				tabStopId,
+				onListKeyDown
+			};
 		}
 		//#endregion
 		//#region src/client/use-trash-panel-controller.ts
 		/**
-		* 回收站面板的**状态机**：谁被选中、详情缓存、窄档下钻与 Esc 交还焦点、清单换版后的清场、
+		* 回收站面板的**状态机**：谁被选中、详情缓存、窄档下钻、清单换版后的清场、
 		* 宽档自动选中、"别处动过回收站"的失效重读，以及确认后的写动作（恢复/批量/清空）与失败落点。
 		*
 		* 面板接入后，这套语义只住这里；面板自己只留布局与行内动作。搬过来的判据一条不改：
@@ -25259,48 +25860,24 @@ window.__ModuleLoader__.load({
 		* - **自动选中只认 `selectedId === null`**：同一拍里选中的那条消失时，自动选中看到的是旧选中
 		*   （非 null）⇒ 不抢；清场落地后的下一拍才接住新清单的第一条。判据是这道 null 门，不是两个
 		*   effect 的声明顺序（顺序反过来也拦得住）。
-		* - **失效通告只戳重读**：`useTrashRevision` 变了就 `query.refresh()`，与挂载时同一条路；它不碰
-		*   选中、不碰详情缓存（清单换了自会有上面的清场来收尾）。
+		* - **失效通告只戳重读**：`useTrashRevision` 变了就 `query.refreshAfterWrite()`；挂载那拍才走
+		*   `refreshAll()`。它不碰选中、不碰详情缓存（清单换了自会有上面的清场来收尾）。
 		* - **动作成功就丢缓存**：恢复/批量彻底删除成功的条目、清空成功的全部条目，详情缓存必须在同一趟里
 		*   失效——否则这条会话再被删回来时会摆着上一世的正文。失败只按 `actionFailure[id]` 留原文，不碰缓存。
-		* - **Esc 只在 drilled 期间挂 document 监听**：记下 `selectedId` 再退出下钻，渲染落地后把焦点交还
-		*   那一行**一次**；`back()`（「← 返回清单」）只收下钻、不动焦点。控制器自己不查 DOM——焦点动作
-		*   走注入的 `focusRow`。
+		* - **`back()` 只收下钻、不动焦点**：Esc 那条（下钻期间挂 document 监听、退回后把焦点交还那一行
+		*   一次）住 `trash-nav.ts`；控制器不查 DOM、也不认识焦点。
 		*
 		* **失败原文不翻译**：`detailFailure.message` 与 `actionFailure[id]` 都是 Node 半给的原文
 		* （`callRemote` 的 `failure.message`），原样交给详情块与清单行上屏。
 		*
-		* `busy` 是面板那枚全局闸（写动作在飞）的读数：闸本体也由本 module 导出（`useTrashPanelGate`），
-		* `restore` / `confirmApply` 用同一个 `gate.around` 把「动作 + 清单重读」整个包住；闸开着时谁该
-		* 禁用由面板决定。`kind:'all'` 的清空**不再套一层** `around`——`query.emptyTrash` 自己已经包了
-		* 同一枚闸。
+		* `busy` 是面板那枚全局闸（写动作在飞）的读数，闸本体住 `busy-gate.ts`；`restore` / `confirmApply`
+		* 把闸交给写入座位（`write-seats.ts`），由 `runWrite` 把「动作 + 收尾 + 清单重读」整趟包住——控制器
+		* 不再自己 `around`；闸开着时谁该禁用由面板决定。`kind:'all'` 的清空不是 `/apply` 座位：
+		* `query.emptyTrash` 自己包同一枚闸。
 		*/
-		/**
-		* 闸本体（从 `trash-panel.tsx` 的函数体原样收进来）：任务落地或抛错都把 `busy` 放回 false。
-		* 不做引用计数：面板同一时刻只允许一趟写动作（按钮在 `busy` 期间全被按住），多一层计数只会
-		* 把"这一趟什么时候算完"变成第二个判据。
-		*
-		* 返回值经 `useMemo` 稳定：`gate` 进 `restore` / `confirmApply` 的 `useCallback` 依赖，每次渲染
-		* 换个新对象会让那两个回调跟着失效，进而把引用它们的 effect 也带着重跑。
-		*/
-		function useTrashPanelGate() {
-			const [busy, setBusy] = (0, react.useState)(false);
-			const around = (0, react.useCallback)(async (task) => {
-				setBusy(true);
-				try {
-					return await task();
-				} finally {
-					setBusy(false);
-				}
-			}, []);
-			return (0, react.useMemo)(() => ({
-				busy,
-				around
-			}), [busy, around]);
-		}
 		function useTrashPanelController(input) {
-			const { deps, gate, query, ordered, canAutoSelect, focusRow } = input;
-			const { entries, refresh, emptyTrash } = query;
+			const { deps, gate, query, ordered, canAutoSelect } = input;
+			const { entries, refreshAll, refreshAfterWrite, emptyTrash } = query;
 			const [selectedId, setSelectedId] = (0, react.useState)(null);
 			const [drilled, setDrilled] = (0, react.useState)(false);
 			const [loadingId, setLoadingId] = (0, react.useState)(null);
@@ -25309,12 +25886,21 @@ window.__ModuleLoader__.load({
 			const [actionFailure, setActionFailure] = (0, react.useState)({});
 			/** 面板存活期内每条只读一次（本机量级不值得预读，也不值得重复读）。 */
 			const detailCache = (0, react.useRef)(/* @__PURE__ */ new Map());
-			/** Esc 退出下钻后要交还焦点的那一行；等 `drilled` 落地、清单回到 DOM 之后再用一次。 */
-			const refocusRow = (0, react.useRef)(null);
+			/** 挂载那一拍做完整刷新（清单 + 残留），之后失效通告只走写后刷新。 */
+			const firstRefresh = (0, react.useRef)(true);
 			const revision = useTrashRevision();
 			(0, react.useEffect)(() => {
-				refresh();
-			}, [refresh, revision]);
+				if (firstRefresh.current) {
+					firstRefresh.current = false;
+					refreshAll();
+					return;
+				}
+				refreshAfterWrite();
+			}, [
+				refreshAll,
+				refreshAfterWrite,
+				revision
+			]);
 			/**
 			* 选一条：命中缓存就直接摆（不经过 loading），没命中才去读那条会话自己的日志。
 			* `drill` 是窄档的第二步语义（点行 = 选中并下钻；方向键 = 只移动选中）。
@@ -25344,6 +25930,9 @@ window.__ModuleLoader__.load({
 				setSelectedId(null);
 				setDrilled(false);
 			}, [entries, selectedId]);
+			(0, react.useEffect)(() => {
+				if (canAutoSelect && drilled) setDrilled(false);
+			}, [canAutoSelect, drilled]);
 			(0, react.useEffect)(() => {
 				if (canAutoSelect && selectedId === null && ordered.length > 0) select(ordered[0]);
 			}, [
@@ -25353,28 +25942,6 @@ window.__ModuleLoader__.load({
 				select
 			]);
 			/**
-			* 下钻里按 Esc 退回清单：监听挂 `document`，因为窄档下钻时清单**不在 DOM 里**——挂在容器上的
-			* Esc 是一条永远收不到的死路径。退回后把焦点交还给选中的那一行（行还没进 DOM，记一笔等这一拍
-			* 渲染完再交，见下一个 effect）。
-			*/
-			(0, react.useEffect)(() => {
-				if (!drilled) return;
-				const onKey = (event) => {
-					if (event.key !== "Escape") return;
-					refocusRow.current = selectedId;
-					setDrilled(false);
-				};
-				document.addEventListener("keydown", onKey);
-				return () => {
-					document.removeEventListener("keydown", onKey);
-				};
-			}, [drilled, selectedId]);
-			(0, react.useEffect)(() => {
-				if (drilled || refocusRow.current === null) return;
-				focusRow(refocusRow.current);
-				refocusRow.current = null;
-			}, [drilled, focusRow]);
-			/**
 			* 选中那条从**全量条目**里找，不从 `ordered`（只含展开的组）里找：折叠组只是把那一列收掉，
 			* 右栏那条不该跟着消失——详情读的是这条会话，跟清单怎么分段无关。
 			*/
@@ -25409,7 +25976,7 @@ window.__ModuleLoader__.load({
 			const retry = (0, react.useCallback)(() => {
 				if (selected !== null) select(selected);
 			}, [selected, select]);
-			/** 退出下钻（「← 返回清单」）：选中留着，详情不清；焦点不动（只有 Esc 会交还焦点）。 */
+			/** 退出下钻（「← 返回清单」）：选中留着，详情不清；焦点不动（Esc 那条归 `trash-nav.ts`）。 */
 			const back = (0, react.useCallback)(() => {
 				setDrilled(false);
 			}, []);
@@ -25420,10 +25987,16 @@ window.__ModuleLoader__.load({
 					[entryId]: message
 				}));
 			}, []);
+			/** 成功支（含 already-gone）的条目丢详情缓存。 */
+			const clearDetailCache = (0, react.useCallback)((successIds) => {
+				for (const id of successIds) detailCache.current.delete(id);
+			}, []);
 			/**
-			* 单条恢复：**先清掉这一行的旧失败**（再点一次不该还挂着上一次的原文），再把手势包进 `around`。
+			* 单条恢复：**先清掉这一行的旧失败**（再点一次不该还挂着上一次的原文），再把整趟交给面板恢复座位。
 			* 成功要丢详情缓存 + 重读清单——缓存不失效的话，这条会话再被删回来时会直接摆出上一世的正文。
-			* `refresh` 留在 `around` 里：否则旧清单还在屏上，同一个动作能被再点一次。
+			* 失败也重读：组回滚可能自己失败（`details.rollbackFailures`），清单不能继续摆旧行。
+			* 「重读也在这趟里」由 `runWrite` 的闸保证：旧清单还在屏上时同一个动作不能被再点一次。
+			* 单条恢复走 `single` 读法，`already-gone` 不可能出现，座位里那条查找兜底在此不会命中。
 			*/
 			const restore = (0, react.useCallback)(async (entry) => {
 				setActionFailure((current) => {
@@ -25431,74 +26004,62 @@ window.__ModuleLoader__.load({
 					delete next[entry.id];
 					return next;
 				});
-				await gate.around(async () => {
-					const outcome = await callRemote(() => applyOne(deps, "restore", entry.id));
-					if (!outcome.ok) {
-						failRow(entry.id, outcome.failure.message);
-						return;
-					}
-					detailCache.current.delete(entry.id);
-					await refresh();
-				});
+				const failure = (await restoreFromPanel({
+					deps,
+					ids: [entry.id],
+					single: true,
+					entries,
+					gate,
+					refreshAfterWrite,
+					clearDetailCache
+				})).failures.get(entry.id);
+				if (failure !== void 0) failRow(entry.id, failure);
 			}, [
+				clearDetailCache,
 				deps,
+				entries,
 				failRow,
 				gate,
-				refresh
+				refreshAfterWrite
 			]);
 			/**
-			* 一段批量 → 组件状态：成功的丢详情缓存，失败的原文落回它自己那一行。整批一次上屏。
-			* **请求了但没回的 id 也是失败**（通道的错），落 missing 原文，不静默当成成功。
-			*/
-			const settleOutcomes = (0, react.useCallback)((action, ids, outcomes) => {
-				const receipt = readReceipt(action, ids, outcomes);
-				const failures = [];
-				for (const verdict of receipt.verdicts) switch (verdict.kind) {
-					case "ok":
-					case "already-gone":
-						detailCache.current.delete(verdict.id);
-						break;
-					case "failed":
-					case "neutral":
-					case "missing": failures.push({
-						id: verdict.id,
-						message: failureMessage(verdict)
-					});
-				}
-				if (failures.length === 0) return;
-				setActionFailure((current) => {
-					const next = { ...current };
-					for (const failure of failures) next[failure.id] = failure.message;
-					return next;
-				});
-			}, []);
-			/**
 			* 批量彻底删除 / 批量恢复**共用这一条**：一次 `apply` 把整批交给 Node 半，逐条成败住在
-			* `ApplyOutcome` 里 ⇒ 不再"每条一次全量重读"。顶层失败（路由自检 / 通道断）是**这一批一条都没落地**
-			* ——原文要落到每一个 id 上，别让清单看起来"删成功了"。
+			* `WriteOutcome` 里 ⇒ 不再"每条一次全量重读"。顶层失败（路由自检 / 通道断）只说明没拿到信封，
+			* 不能断言哪几条落地：原文保守地铺到每一个 id（别让清单看起来"删成功了"），清单照样重读。
 			*/
 			const confirmApply = (0, react.useCallback)(async (action, ids) => {
-				await gate.around(async () => {
-					const outcome = await callRemote(() => deps.applyOutcomes(action, ids));
+				const settle = (outcome) => {
 					setPending(null);
-					if (!outcome.ok) setActionFailure((current) => {
-						const next = { ...current };
-						for (const id of ids) next[id] = outcome.failure.message;
-						return next;
-					});
-					else settleOutcomes(action, ids, outcome.value);
-					await refresh();
+					return refreshAfterWrite(outcome);
+				};
+				const seat = {
+					deps,
+					ids,
+					gate,
+					refreshAfterWrite: settle,
+					clearDetailCache
+				};
+				const outcome = action === "purge" ? await purgeFromPanel(seat) : await restoreFromPanel({
+					...seat,
+					entries
+				});
+				if (outcome.failures.size === 0) return;
+				setActionFailure((current) => {
+					const next = { ...current };
+					for (const [id, message] of outcome.failures) next[id] = message;
+					return next;
 				});
 			}, [
+				clearDetailCache,
 				deps,
+				entries,
 				gate,
-				refresh,
-				settleOutcomes
+				refreshAfterWrite
 			]);
 			/**
 			* 确认框上的「确认」按 `pending` 的形状分派：三条按条目标都委托 `confirmApply`（一段 `/apply`）；
-			* 清空是**聚合回执**、形状不同，走 `query.emptyTrash`——它自己已经包了同一枚闸与重读，这里
-			* **不再套第二层 `around`**（双套会让外层 busy 提前落下）。
+			* 清空是**聚合回执**、形状不同，走 `query.emptyTrash`——`emptyTrash` 自己包闸；这条不是 `/apply`
+			* 座位，别在外面再包一层（双套会让外层 busy 提前落下）。
 			*/
 			const confirmPurge = (0, react.useCallback)(async () => {
 				const target = pending;
@@ -25537,7 +26098,7 @@ window.__ModuleLoader__.load({
 		* 清册读数与无主子会话的**取数编排**。
 		*
 		* 它从 `trash-panel.tsx` 的函数体里整块搬出来，连同三条承重规矩：
-		* ① **到达序号**：在飞的 `list` / `orphans` 不保证按发起顺序落地（对账耗时随盘上条目数摆动），
+		* ① **最新票**：在飞的 `list` / `orphans` 不保证按发起顺序落地（对账耗时随盘上条目数摆动），
 		*    后到的旧响应不许盖掉刚发生的动作带来的新状态；
 		* ② **先清单后扫描**：`GET /orphans` 判"父没了"吃的是清册，而清册要由 `/list` 那次对账才与
 		*    `session-trash/` 的目录持平——反过来接，刚被手工搬进回收站的父会被报成失踪父；
@@ -25545,67 +26106,133 @@ window.__ModuleLoader__.load({
 		*
 		* 清理（`/apply` 的 `orphan-clean`）也住这里：它与扫描共用同一份报告与同一组提示，"读"与"写"分家
 		* 会让 `busy` 与重读顺序那条判据劈成两半。`busy` 本身不归它管——那是面板的一枚全局闸，通过
-		* `around` 传进来（`around` 里跑的就是"这一趟还算忙"）。
+		* `gate` 传进来（闸里跑的就是"这一趟还算忙"）。
 		*/
-		function useTrashQuery({ deps, t, around }) {
+		function useTrashQuery({ deps, t, gate }) {
 			const [entries, setEntries] = (0, react.useState)(null);
 			const [listFailure, setListFailure] = (0, react.useState)(null);
 			const [orphanReport, setOrphanReport] = (0, react.useState)(null);
 			const [orphanFailure, setOrphanFailure] = (0, react.useState)(null);
 			const [orphanNotice, setOrphanNotice] = (0, react.useState)(null);
 			const [orphanConfirm, setOrphanConfirm] = (0, react.useState)(false);
-			const reloadSeq = (0, react.useRef)(0);
-			const reload = (0, react.useCallback)(async () => {
-				const seq = ++reloadSeq.current;
+			/** 报告的同步只读镜像：`refreshAfterWrite` 需要区分「未知」与「已有读数」，又不把 identity 绑在 state 上。 */
+			const orphanReportRef = (0, react.useRef)(null);
+			const setReport = (0, react.useCallback)((report) => {
+				orphanReportRef.current = report;
+				setOrphanReport(report);
+			}, []);
+			/** 清单的同步只读镜像：`refreshAfterWrite` 要在发下一次读**之前**按"当前清单"判要不要强制重扫，
+			*  又不能让回调跟着渲染期 state 换代。 */
+			const entriesRef = (0, react.useRef)(null);
+			const [reloadLatest] = (0, react.useState)(createLatestWins);
+			const reloadRows = (0, react.useCallback)(async () => {
+				const ticket = reloadLatest.issue();
 				const outcome = await callRemote(() => deps.list());
-				if (seq !== reloadSeq.current) return false;
+				if (!ticket.current) return "stale";
 				if (!outcome.ok) {
 					setListFailure(outcome.failure.message);
+					entriesRef.current = null;
 					setEntries(null);
-					return false;
+					return "failed";
 				}
 				setListFailure(null);
+				entriesRef.current = outcome.value;
 				setEntries(outcome.value);
-				return true;
-			}, [deps]);
-			const orphanScanSeq = (0, react.useRef)(0);
-			const scanOrphans = (0, react.useCallback)(async () => {
-				const seq = ++orphanScanSeq.current;
+				return "ok";
+			}, [deps, reloadLatest]);
+			const [orphanLatest] = (0, react.useState)(createLatestWins);
+			/** 强制重扫标记：先记再读清单；这次读输给后发读时，由赢家消费，强制不丢。 */
+			const pendingForcedRescan = (0, react.useRef)(false);
+			/** 清单这一拍读失败：清掉报告与提示、作废在飞的旧扫描（晚到的读数不能把报告写回来），
+			*  并丢掉挂起的强制重扫（报告已回 null，下一次成功刷新本来就会重扫）。 */
+			const clearOrphanState = (0, react.useCallback)(() => {
+				orphanLatest.invalidate();
+				pendingForcedRescan.current = false;
+				setReport(null);
+				setOrphanFailure(null);
+				setOrphanNotice(null);
+				setOrphanConfirm(false);
+			}, [orphanLatest, setReport]);
+			const rescanOrphans = (0, react.useCallback)(async () => {
+				const ticket = orphanLatest.issue();
 				const outcome = await callRemote(() => deps.scanOrphans());
-				if (seq !== orphanScanSeq.current) return;
+				if (!ticket.current) return;
 				if (!outcome.ok) {
-					setOrphanReport(null);
+					setReport(null);
 					setOrphanNotice(null);
 					setOrphanConfirm(false);
 					setOrphanFailure(t("trash.orphans.failure", { message: outcome.failure.message }));
 					return;
 				}
-				setOrphanReport(outcome.value);
+				setReport(outcome.value);
 				setOrphanFailure(null);
 				setOrphanNotice(null);
-			}, [deps, t]);
-			const refresh = (0, react.useCallback)(async () => {
-				if (!await reload()) {
-					setOrphanReport(null);
-					setOrphanFailure(null);
-					setOrphanNotice(null);
-					setOrphanConfirm(false);
+			}, [
+				deps,
+				orphanLatest,
+				setReport,
+				t
+			]);
+			/** 显式全量刷新：清单读失败时连残留报告一起清掉（这一拍不知道盘上长什么样）；被顶掉则让位。
+			*  它总要扫残留，所以顺手消费掉之前挂起的强制重扫。 */
+			const refreshAll = (0, react.useCallback)(async () => {
+				const listed = await reloadRows();
+				if (listed === "stale") return;
+				if (listed === "failed") {
+					clearOrphanState();
 					return;
 				}
-				await scanOrphans();
-			}, [reload, scanOrphans]);
-			const emptyTrash = (0, react.useCallback)(() => around(async () => {
+				pendingForcedRescan.current = false;
+				await rescanOrphans();
+			}, [
+				clearOrphanState,
+				reloadRows,
+				rescanOrphans
+			]);
+			/**
+			* 写后与失效通告：清单必重读；要不要顺带重扫残留由 `needsOrphanRescan` 从这次的 outcome 派生：
+			* purge 与 orphan-clean 总要扫（撤掉的父、被带走的孩子都可能留下新孤儿，报告为空也只是这一拍为空）；
+			* delete 与组根恢复可以省——孩子跟着父走，报告为空时扫了也只会得到空报告。**报告 `null` 不是"空的"**：
+			* 它表示从没扫到（挂载刷新被顶掉 / 扫描失败），这时重扫是唯一能把未知变成已知的路；失效通告没有
+			* outcome，仍按报告未知或非空才扫。
+			* 强制重扫先记标记再读清单：若这次读输给后发的 refresh，赢家会看到标记并补扫，强制不丢。
+			* 清单读失败时清空报告与提示：这一拍不知道盘上长什么样，旧读数不能继续当现状。
+			*/
+			const refreshAfterWriteInternal = (0, react.useCallback)(async (forceRescan) => {
+				if (forceRescan) pendingForcedRescan.current = true;
+				const listed = await reloadRows();
+				if (listed === "stale") return;
+				if (listed === "failed") {
+					clearOrphanState();
+					return;
+				}
+				const pending = pendingForcedRescan.current;
+				pendingForcedRescan.current = false;
+				if (pending) {
+					await rescanOrphans();
+					return;
+				}
+				const current = orphanReportRef.current;
+				if (current === null || current.totalSessions > 0) await rescanOrphans();
+			}, [
+				clearOrphanState,
+				reloadRows,
+				rescanOrphans
+			]);
+			const refreshAfterWrite = (0, react.useCallback)((outcome) => refreshAfterWriteInternal(outcome !== void 0 && needsOrphanRescan(outcome, entriesRef.current)), [refreshAfterWriteInternal]);
+			const emptyTrash = (0, react.useCallback)(() => gate.around(async () => {
 				const outcome = await callRemote(() => deps.emptyTrash());
 				if (!outcome.ok) {
 					setListFailure(outcome.failure.message);
 					return false;
 				}
-				await refresh();
+				clearUndoNotice();
+				await refreshAfterWriteInternal(true);
 				return true;
 			}), [
-				around,
+				gate,
 				deps,
-				refresh
+				refreshAfterWriteInternal
 			]);
 			return {
 				entries,
@@ -25620,48 +26247,54 @@ window.__ModuleLoader__.load({
 					setOrphanNotice(null);
 					setOrphanConfirm(true);
 				},
-				reload,
-				scanOrphans,
-				refresh,
-				cleanOrphans: (0, react.useCallback)(() => {
+				reloadRows,
+				rescanOrphans,
+				refreshAll,
+				refreshAfterWrite,
+				cleanOrphans: (0, react.useCallback)(async () => {
 					if (orphanReport === null || orphanReport.roots.length === 0) {
 						setOrphanConfirm(false);
-						return Promise.resolve();
+						return;
 					}
-					return around(async () => {
-						setOrphanFailure(null);
-						setOrphanNotice(null);
-						const outcome = await callRemote(() => deps.applyOutcomes("orphan-clean", orphanReport.roots));
+					setOrphanFailure(null);
+					setOrphanNotice(null);
+					const settle = (outcome) => {
 						setOrphanConfirm(false);
-						await refresh();
-						if (!outcome.ok) {
-							setOrphanFailure(t("trash.orphans.failure", { message: outcome.failure.message }));
-							return;
-						}
-						const failures = readReceipt("orphan-clean", orphanReport.roots, outcome.value).verdicts.filter(isFailureVerdict);
-						const gone = failures.filter((verdict) => verdict.kind === "neutral");
-						const failed = failures.filter((verdict) => verdict.kind !== "neutral");
-						const partialRemoved = failed.reduce((sum, verdict) => sum + detailNumber(verdict.kind === "failed" ? verdict.error.details : void 0, "removed"), 0);
-						const partialBytes = failed.reduce((sum, verdict) => sum + detailNumber(verdict.kind === "failed" ? verdict.error.details : void 0, "freedBytes"), 0);
-						if (gone.length > 0) setOrphanNotice(t("trash.orphans.cleanGone", { count: gone.length }));
-						if (failed.length > 0) {
-							const message = failureMessage(failed[0]);
-							const base = t("trash.orphans.cleanFailed", {
-								count: failed.length,
-								message
-							});
-							const partial = partialRemoved > 0 || partialBytes > 0 ? ` ${t("trash.orphans.cleanPartial", {
-								removed: partialRemoved,
-								size: fileSizeText(partialBytes)
-							})}` : "";
-							setOrphanFailure(`${base}${partial}`);
-						}
+						return refreshAfterWrite(outcome);
+					};
+					const outcome = await cleanOrphansFromPanel({
+						deps,
+						ids: orphanReport.roots,
+						gate,
+						refreshAfterWrite: settle
 					});
+					if (!outcome.ok) {
+						setOrphanFailure(t("trash.orphans.failure", { message: outcome.failure.message }));
+						return;
+					}
+					const failures = outcome.receipt.verdicts.filter(isFailureVerdict);
+					const gone = failures.filter((verdict) => verdict.kind === "neutral");
+					const failed = failures.filter((verdict) => verdict.kind !== "neutral");
+					const partialRemoved = failed.reduce((sum, verdict) => sum + detailNumber(verdict.kind === "failed" ? verdict.error.details : void 0, "removed"), 0);
+					const partialBytes = failed.reduce((sum, verdict) => sum + detailNumber(verdict.kind === "failed" ? verdict.error.details : void 0, "freedBytes"), 0);
+					if (gone.length > 0) setOrphanNotice(t("trash.orphans.cleanGone", { count: gone.length }));
+					if (failed.length > 0) {
+						const message = failureMessage(failed[0]);
+						const base = t("trash.orphans.cleanFailed", {
+							count: failed.length,
+							message
+						});
+						const partial = partialRemoved > 0 || partialBytes > 0 ? ` ${t("trash.orphans.cleanPartial", {
+							removed: partialRemoved,
+							size: fileSizeText(partialBytes)
+						})}` : "";
+						setOrphanFailure(`${base}${partial}`);
+					}
 				}, [
-					around,
 					deps,
+					gate,
 					orphanReport,
-					refresh,
+					refreshAfterWrite,
 					t
 				]),
 				emptyTrash
@@ -25672,6 +26305,30 @@ window.__ModuleLoader__.load({
 			const value = details?.[key];
 			return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 		}
+		/**
+		* 写后要不要强制重扫残留：只看这次写的动作、它请求的 id 与**发读前**的清单。
+		* - purge / orphan-clean 总要扫：语料缺席时故意留下的盘上后代、被带走父行留下的孩子，报告为空也可能是新孤儿。
+		* - restore 只在清单未知（不知道恢复的是什么）、清单里已经找不到这个 id（这一拍不能断言它不是孩子），
+		*   或恢复的是露面的孩子（父行已摘，回到语料后可能无主）时扫；组根恢复把孩子一起带回，不新增孤儿。
+		* - delete / count 不扫。新动作必须在这里选一条，别静默落到"不扫"。裁决见 ADR-0016。
+		*/
+		function needsOrphanRescan(outcome, entries) {
+			switch (outcome.action) {
+				case "purge":
+				case "orphan-clean": return true;
+				case "restore": {
+					if (entries === null) return true;
+					const byId = new Map(entries.map((entry) => [entry.id, entry]));
+					return outcome.ids.some((id) => {
+						const entry = byId.get(id);
+						return entry === void 0 || entry.parentEntryId !== void 0;
+					});
+				}
+				case "delete":
+				case "count": return false;
+				default: return outcome.action;
+			}
+		}
 		//#endregion
 		//#region src/client/use-trash-selection.ts
 		/**
@@ -25943,14 +26600,14 @@ window.__ModuleLoader__.load({
 			});
 		}
 		function TrashPanel({ deps, t = zhTranslate }) {
-			/** 面板唯一的一枚全局闸（写动作在飞时按住一排按钮）：本体住控制器 module，查询侧的写动作也吃它。 */
-			const gate = useTrashPanelGate();
+			/** 面板唯一的一枚全局闸（写动作在飞时按住一排按钮）：本体住 `busy-gate.ts`，查询侧的写动作也吃它。 */
+			const gate = useBusyGate();
 			const query = useTrashQuery({
 				deps,
 				t,
-				around: gate.around
+				gate
 			});
-			const { entries, listFailure, orphanReport, orphanFailure, orphanNotice, orphanConfirm, setOrphanConfirm, refresh } = query;
+			const { entries, listFailure, refreshAll } = query;
 			const listRef = (0, react.useRef)(null);
 			const rootRef = (0, react.useRef)(null);
 			const width = usePanelWidth(rootRef);
@@ -25974,12 +26631,12 @@ window.__ModuleLoader__.load({
 				entries,
 				groups
 			});
-			/** 行的 DOM 查询留给面板；控制器只拿"把焦点还给哪一行"这个动作（不认选择器）。 */
+			/** 行的 DOM 查询留给面板；导航只拿"把焦点还给哪一行"这个动作（不认选择器）。 */
 			const focusRow = (0, react.useCallback)((entryId) => {
 				(listRef.current?.querySelector(`[data-entry-id="${entryId}"]`))?.focus();
 			}, []);
 			/**
-			* 选中 / 详情缓存 / 清单换版清场 / 宽档自动选中 / Esc 交还焦点 / 写动作与失败落点，整块住在
+			* 选中 / 详情缓存 / 清单换版清场 / 宽档自动选中 / 写动作与失败落点，整块住在
 			* `use-trash-panel-controller.ts`。布局常量不搬进控制器：面板只交两样从布局算出来的面——
 			* 屏幕上的顺序 `ordered`（只含展开的组）与"这一档要不要自动选中"（`canAutoSelect: split`）。
 			*/
@@ -25988,36 +26645,23 @@ window.__ModuleLoader__.load({
 				gate,
 				query,
 				ordered,
-				canAutoSelect: split,
+				canAutoSelect: split
+			});
+			/**
+			* 键盘导航（↑↓ 走环、Enter/Space、tab 落点、Esc 交还焦点）整块住在 `trash-nav.ts`。
+			* 屏幕顺序与四个动作从这里进去；它不查 DOM——`focusRow` 是面板交出去的那一动作。
+			*/
+			const nav = useTrashNav({
+				ordered,
+				selectedId: controller.selectedId,
+				selectMode,
+				drillEnabled: !split,
+				drilled: controller.drilled,
+				select: controller.select,
+				toggleCheck,
+				exitDrill: controller.back,
 				focusRow
 			});
-			const onListKeyDown = (event) => {
-				if (ordered.length === 0) return;
-				const index = ordered.findIndex((entry) => entry.id === controller.selectedId);
-				if (event.key === "ArrowDown" || event.key === "ArrowUp") {
-					event.preventDefault();
-					const step = event.key === "ArrowDown" ? 1 : -1;
-					const next = index < 0 ? step > 0 ? 0 : ordered.length - 1 : (index + step + ordered.length) % ordered.length;
-					const target = ordered[next];
-					controller.select(target);
-					focusRow(target.id);
-					return;
-				}
-				if (event.key === "Enter" || event.key === " ") {
-					if (index < 0) return;
-					event.preventDefault();
-					if (selectMode) {
-						toggleCheck(ordered[index].id);
-						return;
-					}
-					controller.select(ordered[index], { drill: true });
-				}
-			};
-			/** 清理那批无主子会话：整块住在 `useTrashQuery.cleanOrphans`（扫描的报告、两种失败的分流、先刷新后落提示
-			*  都在那一条里）；这里只负责把确认框收起来。 */
-			const confirmOrphans = async () => {
-				await query.cleanOrphans();
-			};
 			/**
 			* 详细信息那块的选中集合：确认框要把"这一批有哪些、要去哪"摆出来，靠的全量条目是从勾选 id 反查
 			* （顺序已经是"清单从上往下"）——清单里找不到的 id 是别的窗口刚动过，滤掉不等于丢动作
@@ -26034,14 +26678,6 @@ window.__ModuleLoader__.load({
 			* 在准备批量恢复时是假话——那类具体警告归各自的确认框，这里只留两件事：回收站在哪、不自动过期。
 			*/
 			const noteParts = splitOn(t("trash.footer.note", { dir: TRASH_DIR }), TRASH_DIR);
-			/** `aria-activedescendant` 只能指向**在 DOM 里**的那一行：折叠起来之后它就是不存在，指过去是假引用。 */
-			const activeDescendantId = ordered.some((entry) => entry.id === controller.selectedId) ? controller.selectedId : null;
-			/**
-			* 清单里那个唯一的 tab 落点（roving tabindex）。它必须**永远有一行拿着**：窄档不自动选中，
-			* 只按"选中那行拿 0"来给的话，一次没点过时全行都是 `-1`，键盘根本进不来清单。
-			* 落点与 `aria-activedescendant` 同一条可见性规则——选中那行被折叠起来时落到第一条可见行。
-			*/
-			const tabStopId = activeDescendantId ?? ordered[0]?.id ?? null;
 			/**
 			* 清单容器（roving tabindex 那个唯一的 tab 巢）。`flex:'1 1 auto'` 是**空态居中链**的一节：
 			* 空态块自己有 `flex:1` + `justifyContent:center`，但要有**有高度的**父链才居得起来——本层是
@@ -26053,10 +26689,10 @@ window.__ModuleLoader__.load({
 				"data-dsh-session-delete": "trash-list",
 				role: "listbox",
 				"aria-label": t("detail.list.label"),
-				"aria-activedescendant": activeDescendantId === null ? void 0 : `sd-trash-${activeDescendantId}`,
+				"aria-activedescendant": nav.activeDescendantId === null ? void 0 : `sd-trash-${nav.activeDescendantId}`,
 				"aria-multiselectable": selectMode ? true : void 0,
 				tabIndex: -1,
-				onKeyDown: onListKeyDown,
+				onKeyDown: nav.onListKeyDown,
 				style: {
 					display: "flex",
 					flexDirection: "column",
@@ -26111,7 +26747,7 @@ window.__ModuleLoader__.load({
 							variant: "outline",
 							size: "sm",
 							style: { flex: "none" },
-							onClick: () => void refresh(),
+							onClick: () => void refreshAll(),
 							children: t("common.retry")
 						})
 					]
@@ -26258,7 +26894,7 @@ window.__ModuleLoader__.load({
 							id: `sd-trash-${entry.id}`,
 							role: "option",
 							"aria-selected": selectMode ? isChecked : isSelected,
-							tabIndex: entry.id === tabStopId ? 0 : -1,
+							tabIndex: entry.id === nav.tabStopId ? 0 : -1,
 							"data-dsh-session-delete": "trash-row",
 							"data-entry-id": entry.id,
 							style: isSelected ? CARD_SELECTED : CARD,
@@ -26351,7 +26987,10 @@ window.__ModuleLoader__.load({
 										variant: "outline",
 										size: "sm",
 										disabled: controller.busy,
-										onClick: () => void controller.restore(entry),
+										onClick: (event) => {
+											event.stopPropagation();
+											controller.restore(entry);
+										},
 										children: t("trash.row.restore")
 									}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
 										variant: "ghost",
@@ -26359,10 +26998,13 @@ window.__ModuleLoader__.load({
 										style: QUIET_DANGER,
 										icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconTrashOutlineRegular, { size: 13 }),
 										disabled: controller.busy,
-										onClick: () => controller.setPending({
-											kind: "entry",
-											entry
-										}),
+										onClick: (event) => {
+											event.stopPropagation();
+											controller.setPending({
+												kind: "entry",
+												entry
+											});
+										},
 										children: t("trash.row.purge")
 									})]
 								})
@@ -26468,135 +27110,11 @@ window.__ModuleLoader__.load({
 							}) : null]
 						})
 					}),
-					orphanReport !== null && orphanReport.totalSessions > 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-						"data-dsh-session-delete": "orphan-banner",
-						style: {
-							...CARD,
-							alignItems: "flex-start",
-							gap: 12,
-							marginBottom: 10
-						},
-						children: [
-							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-								style: {
-									display: "inline-flex",
-									flex: "none",
-									paddingTop: 2,
-									color: "var(--dsw-alias-state-warn-primary)"
-								},
-								"aria-hidden": "true",
-								children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconWarningOutlineRegular, { size: 16 })
-							}),
-							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-								style: {
-									display: "flex",
-									flexDirection: "column",
-									gap: 2,
-									flex: "1 1 auto",
-									minWidth: 0
-								},
-								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-									style: {
-										fontSize: 13,
-										lineHeight: "19px"
-									},
-									children: t("trash.orphans.banner", { count: orphanReport.totalSessions })
-								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-									style: {
-										fontSize: 12,
-										lineHeight: "16px",
-										color: "var(--dsw-alias-label-tertiary)"
-									},
-									children: t("trash.orphans.meta", {
-										size: fileSizeText(orphanReport.totalBytes),
-										parents: orphanReport.missingParents
-									})
-								})]
-							}),
-							/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
-								variant: "outline",
-								size: "sm",
-								style: { flex: "none" },
-								disabled: controller.busy,
-								onClick: () => {
-									if (controller.busy) return;
-									query.openOrphanPreview();
-								},
-								children: t("trash.orphans.open")
-							})
-						]
-					}) : null,
-					orphanFailure !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-						role: "status",
-						style: {
-							...CARD,
-							alignItems: "flex-start",
-							gap: 10,
-							marginBottom: 10,
-							padding: "10px 12px"
-						},
-						children: [
-							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-								style: {
-									display: "inline-flex",
-									flex: "none",
-									color: "var(--dsw-alias-state-error-primary)"
-								},
-								"aria-hidden": "true",
-								children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconWarningOutlineRegular, { size: 15 })
-							}),
-							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-								style: {
-									flex: "1 1 auto",
-									minWidth: 0,
-									wordBreak: "break-word",
-									fontSize: 12,
-									lineHeight: "17px",
-									color: "var(--dsw-alias-state-error-primary)"
-								},
-								children: orphanFailure
-							}),
-							/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
-								variant: "outline",
-								size: "sm",
-								style: { flex: "none" },
-								disabled: controller.busy,
-								onClick: () => void refresh(),
-								children: t("common.retry")
-							})
-						]
-					}) : null,
-					orphanNotice !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-						"data-dsh-session-delete": "orphan-notice",
-						role: "status",
-						style: {
-							...CARD,
-							alignItems: "flex-start",
-							gap: 10,
-							marginBottom: 10,
-							padding: "10px 12px"
-						},
-						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-							style: {
-								display: "inline-flex",
-								flex: "none",
-								paddingTop: 2,
-								color: "var(--dsw-alias-label-tertiary)"
-							},
-							"aria-hidden": "true",
-							children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconWarningOutlineRegular, { size: 15 })
-						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-							style: {
-								flex: "1 1 auto",
-								minWidth: 0,
-								wordBreak: "break-word",
-								fontSize: 12,
-								lineHeight: "17px",
-								color: "var(--dsw-alias-label-secondary)"
-							},
-							children: orphanNotice
-						})]
-					}) : null,
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(OrphanMaintenance, {
+						query,
+						busy: controller.busy,
+						t
+					}),
 					toolbar,
 					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 						style: BODY,
@@ -26701,14 +27219,7 @@ window.__ModuleLoader__.load({
 						onCancel: () => controller.setPending(null),
 						onConfirmPurge: () => void controller.confirmPurge(),
 						onConfirmRestore: (ids) => void controller.confirmApply("restore", ids)
-					}),
-					orphanConfirm && orphanReport !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(OrphanConfirm, {
-						report: orphanReport,
-						busy: controller.busy,
-						t,
-						onCancel: () => setOrphanConfirm(false),
-						onConfirm: () => void confirmOrphans()
-					}) : null
+					})
 				]
 			});
 		}