@xrn1997/dsh-session-delete 0.4.0 → 0.6.0

package/lib/client.js

@@ -196,7 +196,7 @@ window.__ModuleLoader__.load({
 			"detail.notSelected": "选中一条会话，看它讲了什么",
 			"detail.loading": "正在读这条会话…",
 			"detail.readFailed": "这条会话的正文读不出来",
-			"detail.noBody": "这条会话没有可显示的文字",
+			"detail.noBody": "这条会话没有可显示的内容",
 			"detail.field.created": "创建",
 			"detail.field.lastActivity": "最后活动",
 			"detail.field.deletedAt": "删除于",
@@ -205,8 +205,9 @@ window.__ModuleLoader__.load({
 			"detail.field.size": "大小",
 			"detail.field.turns": "轮数",
 			"detail.field.userMessages": "提问",
-			"detail.field.assistantMessages": "回复",
+			"detail.field.assistantMessages": "助手消息",
 			"detail.field.toolCalls": "工具调用",
+			"detail.field.injections": "注入上下文",
 			"detail.field.models": "模型",
 			"detail.field.project": "项目",
 			"detail.field.sessionId": "会话 id",
@@ -214,10 +215,36 @@ window.__ModuleLoader__.load({
 			"detail.field.wasArchived": "原本归档",
 			"detail.value.yes": "是",
 			"detail.value.no": "否",
+			"detail.value.spanLessThanHour": "不足 1 小时",
 			"detail.value.spanHours": "{n} 小时",
 			"detail.value.spanDays": "{n} 天",
-			"detail.messages.hidden": "另有 {count} 条宿主注入的上下文未显示",
-			"detail.messages.omitted": "还有 {count} 条未显示",
+			"detail.block.reasoning": "思考",
+			"detail.block.tool": "工具调用",
+			"detail.block.injection": "上下文注入",
+			"detail.block.system": "系统消息",
+			"detail.block.compaction": "上下文已压缩",
+			"detail.block.args": "参数",
+			"detail.block.result": "结果",
+			"detail.block.noResult": "日志在调用结束前结束，没有结果",
+			"detail.block.status.ok": "成功",
+			"detail.block.status.error": "失败",
+			"detail.block.status.unfinished": "未完成",
+			"detail.block.truncated": "已截断",
+			"detail.loadOlder": "加载更早",
+			"detail.loadOlder.loading": "正在加载更早…",
+			"detail.expandAll": "全部展开",
+			"detail.collapseAll": "全部折叠",
+			"detail.injection.runtimeContext": "运行上下文",
+			"detail.injection.timeContext": "时间上下文",
+			"detail.injection.agentInstructions": "Agent 指令",
+			"detail.injection.skillCatalog": "技能目录",
+			"detail.injection.agentMessage": "子会话消息",
+			"detail.injection.subagentSettled": "子会话结束",
+			"detail.injection.toolJobs": "后台任务",
+			"detail.injection.skillInvocation": "技能调用",
+			"detail.injection.userApproval": "用户批准",
+			"detail.injection.goal": "目标",
+			"detail.injection.other": "其他上下文",
 			"detail.image": "[图片]",
 			"detail.image.alt": "[图片 · {alt}]",
 			"detail.attachment.file": "文件",
@@ -229,6 +256,9 @@ window.__ModuleLoader__.load({
 			"detail.attachment.saving": "保存中…",
 			"detail.attachment.saveFailed": "保存失败：{message}",
 			"detail.back": "← 返回清单",
+			"detail.subagents.header": "子会话（{n}） · {size}",
+			"detail.subagents.truncated": "仅列出前 {shown} 条，共 {total} 条",
+			"detail.backToParent": "← 返回父会话",
 			"detail.list.label": "回收站清单",
 			"detail.role.user": "你",
 			"detail.role.assistant": "助手",
@@ -253,7 +283,8 @@ window.__ModuleLoader__.load({
 			"undo.movedBatch": "{n} 条会话已移入回收站",
 			"undo.moved": "{title} 已移入回收站",
 			"undo.session": "会话",
-			"undo.undo": "撤销"
+			"undo.undo": "撤销",
+			"undo.failedBatch": "{n} 条会话未能撤销：{reasons}"
 		};
 		/** en：与 `ZH` 逐键镜像（键集合由 `Record<CopyKey, string>` 盯住，漏一个就编译不过）。
 		*  单位词与宿主 en 侧 `relativeTime` 的写法对齐（宿主 en 的桶就是 `5min` / `3h` / `2d` / `4mo` / `1y`）。 */
@@ -348,7 +379,7 @@ window.__ModuleLoader__.load({
 			"detail.notSelected": "Select a session to see what it was about",
 			"detail.loading": "Reading this session…",
 			"detail.readFailed": "Could not read this session’s log",
-			"detail.noBody": "This session has no readable text",
+			"detail.noBody": "This session has nothing to show",
 			"detail.field.created": "Created",
 			"detail.field.lastActivity": "Last activity",
 			"detail.field.deletedAt": "Deleted",
@@ -357,8 +388,9 @@ window.__ModuleLoader__.load({
 			"detail.field.size": "Size",
 			"detail.field.turns": "Turns",
 			"detail.field.userMessages": "Prompts",
-			"detail.field.assistantMessages": "Replies",
+			"detail.field.assistantMessages": "Assistant messages",
 			"detail.field.toolCalls": "Tool calls",
+			"detail.field.injections": "Injected contexts",
 			"detail.field.models": "Model",
 			"detail.field.project": "Project",
 			"detail.field.sessionId": "Session id",
@@ -366,10 +398,36 @@ window.__ModuleLoader__.load({
 			"detail.field.wasArchived": "Was archived",
 			"detail.value.yes": "Yes",
 			"detail.value.no": "No",
+			"detail.value.spanLessThanHour": "< 1 h",
 			"detail.value.spanHours": "{n} h",
 			"detail.value.spanDays": "{n} d",
-			"detail.messages.hidden": "{count} injected context records not shown",
-			"detail.messages.omitted": "{count} more messages not shown",
+			"detail.block.reasoning": "Thinking",
+			"detail.block.tool": "Tool call",
+			"detail.block.injection": "Context injection",
+			"detail.block.system": "System message",
+			"detail.block.compaction": "Context compacted",
+			"detail.block.args": "Arguments",
+			"detail.block.result": "Result",
+			"detail.block.noResult": "The log ended before this call returned a result",
+			"detail.block.status.ok": "OK",
+			"detail.block.status.error": "Failed",
+			"detail.block.status.unfinished": "Unfinished",
+			"detail.block.truncated": "Truncated",
+			"detail.loadOlder": "Load earlier",
+			"detail.loadOlder.loading": "Loading earlier…",
+			"detail.expandAll": "Expand all",
+			"detail.collapseAll": "Collapse all",
+			"detail.injection.runtimeContext": "Runtime context",
+			"detail.injection.timeContext": "Time context",
+			"detail.injection.agentInstructions": "Agent instructions",
+			"detail.injection.skillCatalog": "Skill catalog",
+			"detail.injection.agentMessage": "Subagent message",
+			"detail.injection.subagentSettled": "Subagent finished",
+			"detail.injection.toolJobs": "Background jobs",
+			"detail.injection.skillInvocation": "Skill invocation",
+			"detail.injection.userApproval": "User approval",
+			"detail.injection.goal": "Goal",
+			"detail.injection.other": "Other context",
 			"detail.image": "[Image]",
 			"detail.image.alt": "[Image · {alt}]",
 			"detail.attachment.file": "File",
@@ -381,6 +439,9 @@ window.__ModuleLoader__.load({
 			"detail.attachment.saving": "Saving…",
 			"detail.attachment.saveFailed": "Save failed: {message}",
 			"detail.back": "← Back to list",
+			"detail.subagents.header": "Subagent sessions ({n}) · {size}",
+			"detail.subagents.truncated": "Showing the first {shown} of {total} subagent sessions",
+			"detail.backToParent": "← Back to parent session",
 			"detail.list.label": "Trash list",
 			"detail.role.user": "You",
 			"detail.role.assistant": "Assistant",
@@ -405,7 +466,8 @@ window.__ModuleLoader__.load({
 			"undo.movedBatch": "{n} sessions were moved to the trash",
 			"undo.moved": "{title} was moved to the trash",
 			"undo.session": "the session",
-			"undo.undo": "Undo"
+			"undo.undo": "Undo",
+			"undo.failedBatch": "{n} sessions could not be undone: {reasons}"
 		};
 		/** 与宿主 `translate` 同一条替换规则（`{name}`，参数缺席时原样留下占位符）。 */
 		function interpolate(template, params) {
@@ -432,6 +494,27 @@ window.__ModuleLoader__.load({
 			return (key, params) => bound(key, params);
 		}
 		/**
+		* `MarkdownBody`（`markdown.tsx`）memo comparator 的**语言探针**：借一句固定键的译文，当
+		* 「当前是哪种语言」的读数。为什么借译文而不问 locale 服务：宿主 locale 服务的窄镜像不暴露
+		* 当前语言（受窄镜像形状约束，不做 `locale()` 探针），当前语言只能从 `t` 的输出里读出来。
+		*
+		* 为什么必须在**渲染时**现算、由调用方存进 props：宿主 `t` 读的是**当前** locale，若在
+		* comparator 里现调，prev/next 那一拍都取到新值、恒等，换语言就漏了——只有渲染那一刻算好的
+		* 那份才是换语言那一拍的读数。
+		*
+		* 为什么拿 `t` 的输出当读数、而不是拿 `t` 的身份：宿主 `t` 是 `bind` 出来的**稳定身份**
+		* （`createTranslate` 一次客户端激活只造一个），换语言后同一个 `t` 吐另一套词——身份不变、
+		* 词变了，所以判据必须是这个词（探针值）而不是身份本身。
+		*
+		* 「借哪句」的知识只住这里：调用方与测试一律传 `probe={localeProbe(t)}`，不各自记得借哪句。
+		*
+		* **失效模式**：借的那句若在两种语言下译成同一个字面，探针就分不出换语言——memo 恒等、旧语言滞留。
+		* 这条由 `tests/client/markdown.test.tsx` 的换语言用例兜住；换借句或改那句译文时先看它红不红。
+		*/
+		function localeProbe(t) {
+			return t("common.close");
+		}
+		/**
 		* 把一句话里内嵌的那一段拆出来：`'…文件，之后没有任何副本可以恢复。'` 交给调用面用 `<b>` 包中间那段。
 		*
 		* 为什么不留成"前段 / 内嵌段 / 后段"三个键：那等于把英文和中文的语序各钉一次，两段翻译各自
@@ -489,16 +572,19 @@ window.__ModuleLoader__.load({
 		* （`delete-confirm.tsx`）、批量删除请求（`batch-confirm.tsx`）、撤销提示（`undo-notices.ts`）、
 		* 批量选中集（`batch-selection-store.ts`）等。它们都挂在 `shell.overlay` / `main` / 菜单行这些
 		* 互不相邻的座位上，模块级是唯一的共同点。
-		* 在这之前每个文件各写一遍「`let` 现场 + `Set<() => void>` + `notify` + `useSyncExternalStore`」，
+		* 在这之前每个文件各写一遍「`let` 现场 + 监听集合 + `notify` + `useSyncExternalStore`」，
 		* 各自的 seq / revision 也在分头维护。现在订阅/通告只住这一处。
 		*
-		* 另有一个**懒读快照**变体（`createLazyStore`）：值由组件树之外的事实源（宿主 DOM）现读，
-		* 脏了才重读；订阅脚手架仍住这里，观察者生命周期由调用方挂 `onFirstSubscribe` / `onLastUnsubscribe`。
+		* 另有一个**懒读快照**变体（`createLazyStore`）：值由组件树之外的事实源（如宿主行槽位登记）现读，
+		* 脏了才重读；订阅脚手架仍住这里。
 		*
 		* 还有一个**最新票句柄**（`createLatestWins`）：并发的异步读里"只有最新那次可以落地"原先在每个
 		* 调用方各写一遍自增序号，现在只住这一处。它只拥有 compare-and-set——防抖、轮询、焦点策略仍是
 		* 调用方的现场，不搬进来。
 		*
+		* 以及一枚**引用归一 hook**（`useLatest`）：输入逐渲染换新对象时，回调经它只读最新那一份，
+		* 身份恒稳、可安全进 effect 依赖。这一形状也只住这一处，调用方不再各写一遍「ref + 每渲染写回」。
+		*
 		* 语义（四条，别在调用方另算一遍）：
 		* - `set` / `update` 用 `Object.is` 判"变过"：同一个引用不重渲染（React 的 snapshot 契约要求）。
 		* - `publish(make)` 递增**本实例**的 seq（从 1 起）并**总是**通告——seq 是组件重挂载的 key
@@ -551,7 +637,7 @@ window.__ModuleLoader__.load({
 				}
 			};
 		}
-		function createLazyStore(initial, read, lifecycle = {}) {
+		function createLazyStore(initial, read) {
 			let cached = initial;
 			let dirty = true;
 			const listeners = /* @__PURE__ */ new Set();
@@ -571,17 +657,11 @@ window.__ModuleLoader__.load({
 					notify();
 				},
 				subscribe(listener) {
-					const reattaching = listeners.size === 0;
+					if (listeners.size === 0) dirty = true;
 					listeners.add(listener);
-					if (reattaching) {
-						dirty = true;
-						lifecycle.onFirstSubscribe?.();
-					}
 					return () => {
 						listeners.delete(listener);
-						if (listeners.size > 0) return;
-						lifecycle.onLastUnsubscribe?.();
-						dirty = true;
+						if (listeners.size === 0) dirty = true;
 					};
 				}
 			};
@@ -600,170 +680,155 @@ window.__ModuleLoader__.load({
 				}
 			};
 		}
-		//#endregion
-		//#region src/client/batch-selection-store.ts
 		/**
-		* 宿主列表批量删除的**选中集现场**：多选模式 + 选中名单，一份合并快照。
-		*
-		* 从 `batch-select.tsx` 拆出来的理由：多选态与选中集是**同一次交互的两半**（进入模式才出现勾选框，
-		* 退出模式连名单一起清），读写它们的却有四个座位——菜单里的入口（`batch-menu-item.tsx`）、行首
-		* 勾选框、行尾兜底、overlay 上的浮条与确认框。状态住这一处，`batch-select.tsx` 只剩控件，
-		* `host-rows.ts` 只回答"页面上现在有哪些行、点行算不算选中"。订阅/通告那套仍只住在 `store.ts`
-		* 的 `createStore` 里，本文件不另写一份。
-		*
-		* **合并快照**而不是两个 store：两半的变化总是成对出现（`exitSelection` 清两半），订阅者
-		* （勾选框、浮条）两半都要读；分两份只会让"进模式的那一帧"出现两次通告、两个快照不同步的缝。
-		*
-		* 名单只收槽位投影原样给的 `sessionId` / `displayTitle`（浏览器半不自己拼 id）：**逐条勾选序 = 名单序**；
-		* 「全选」追加的条目按 `host-rows.ts` 读到的 DOM 序接在后面。`/apply` 那条「保持输入顺序」吃到的就是这份名单序。
+		* 引用归一：输入允许调用方逐渲染换新对象，回调只经这份 ref 读**最新**那一份，于是依赖它的回调
+		* 身份恒稳、调用方的 effect 可以放心把它们当依赖——「输入必须是稳定引用」的隐式契约就此不存在
+		* （issue #8 第 3 条）。写回在 effect 里（提交后），与 React 的渲染期只读约定一致。
+		* 这一形状的唯一实现：别在调用方再手写一份「useRef + 每渲染写回」。
 		*/
-		const INITIAL = {
-			selecting: false,
-			picks: []
-		};
-		const selectionStore = createStore(INITIAL);
-		function getSelection() {
-			return selectionStore.get();
-		}
-		function getPicks() {
-			return getSelection().picks;
-		}
-		/** 供组件订阅：模式与名单是同一次交互的两半，读它们的组件订同一份快照。 */
-		function useSelection() {
-			return selectionStore.use();
-		}
-		/** 「⋯ → 多选」按下时进入；重复进入是幂等的（同一份快照，不发通告）。 */
-		function enterSelection() {
-			selectionStore.update((current) => current.selecting ? current : {
-				...current,
-				selecting: true
-			});
-		}
-		/** 退出模式并清空名单：多选态和选中集是同一次交互的两半，退出后不该留下看不见的名单。 */
-		function exitSelection() {
-			selectionStore.update((current) => current.selecting || current.picks.length > 0 ? INITIAL : current);
-		}
-		/** 翻转一条：没选过就排队尾，选过就摘掉（列表里永远不会有重复 id）。 */
-		function togglePick(item) {
-			selectionStore.update((current) => {
-				const at = current.picks.findIndex((candidate) => candidate.sessionId === item.sessionId);
-				return {
-					...current,
-					picks: at === -1 ? [...current.picks, item] : current.picks.filter((candidate) => candidate.sessionId !== item.sessionId)
-				};
-			});
-		}
-		/** 清空名单但**留在多选态**（「取消全选」那颗）；已经空了就不发通告。 */
-		function clearPicks() {
-			selectionStore.update((current) => current.picks.length === 0 ? current : {
-				...current,
-				picks: []
-			});
-		}
-		/** 只追加还没选过的条目；名单序 = 原有选中在前、新条目按传入序接在后面。没有新条目就不发通告。 */
-		function addPicks(items) {
-			selectionStore.update((current) => {
-				const chosen = new Set(current.picks.map((item) => item.sessionId));
-				const additions = [];
-				for (const item of items) {
-					if (chosen.has(item.sessionId)) continue;
-					chosen.add(item.sessionId);
-					additions.push(item);
-				}
-				return additions.length === 0 ? current : {
-					...current,
-					picks: [...current.picks, ...additions]
-				};
+		function useLatest(value) {
+			const ref = (0, react.useRef)(value);
+			(0, react.useEffect)(() => {
+				ref.current = value;
 			});
-		}
-		/** 执行后收缩：只留失败名单（空数组 = 全清）。成功的随通告从侧栏消失，不该留在名单里。 */
-		function shrinkPicksToFailures(failedSessionIds) {
-			const keep = new Set(failedSessionIds);
-			selectionStore.update((current) => ({
-				...current,
-				picks: current.picks.filter((item) => keep.has(item.sessionId))
-			}));
+			return ref;
 		}
 		//#endregion
 		//#region src/client/host-rows.ts
 		/**
-		* 宿主会话行的 DOM 适配：可见行解析、全选判定、模式内整行点击守卫。
+		* 宿主会话行的适配：**可见行由槽位组件登记**；选择动作与模式内整行点击守卫住 `batch-pick.ts`。
+		*
+		* 选中集（模式 + 名单）只住 `batch-selection-store.ts`；本文件只回答页面上的「当前有哪些可勾选的
+		* 会话行」：行槽位开关的挂载登记、渲染快照与按 id 的行查找。「这一行可不可勾」的 live 判据
+		* 也只住这里（`pickableRowOf` / `readVisibleSelectableRows`）。DOM 只用于守卫认行，且那处 DOM
+		* 读取随守卫住在 `batch-pick.ts`（ADR-0034 记下的受约束偏离）。
 		*
-		* 选中集（模式 + 名单）只住 batch-selection-store.ts；本文件只回答页面上的两件事：
-		* 当前 DOM 里有哪些可选行，以及在某一行上点击是否算选中。交界是 data-row-key 与行尾登记的
-		* rowInfo。渲染走 useSyncExternalStore 快照（ADR-0015）；事件路径（全选）走当场读。
-		* 模式内整行点击在 document 捕获阶段拦截，避免触发宿主的会话切换。
+		* 为什么不再扫 DOM：宿主的行槽位只在行可见时挂载，行首/行尾两颗开关（`BatchPickCheckbox` /
+		* `BatchPickButton`）都会登记 `{title, live}`；挂载/卸载就是「这一行在不在可见集合」的契约，
+		* 不需要 MutationObserver。
 		*/
 		/**
-		* 守卫从 `data-row-key` 反解出 sessionId，但拿不到槽位投影的标题／运行态 ⇒ 行尾兜底那颗
-		* （它对每个非空行都渲染，哪怕 CSS 把整排藏起来）在 effect 里把这两件登记进这张表。
-		* 只增不删：会话 id 不复用，行被过滤掉也不会拿旧标题冒充新行。
+		* 守卫从 `data-row-key` 反解出 sessionId，但拿不到槽位投影的标题／运行态 ⇒ 行首/行尾开关
+		* 在 effect 里把这两件登记进这张表。生命周期跟着**行槽位组件的挂载**走：卸载即注销
+		* （{@link unregisterHostRowInfo}），表的大小被"当前渲染的行"钉住，而不是随用过的会话只增不减；
+		* 行重挂载时 effect 会重新登记。**这张表就是可见行的事实源**（ADR-0034），不再由 DOM 行列表反查。
+		*
+		* **按挂载实例计数**：同一个会话在 DOM 里可能有两行（重复行），两行各挂一组开关；
+		* 其中一颗卸载时不能把另一颗还在用的登记一起摘掉——那会让这一行从"全选"里消失、标题也变空。
 		*/
 		const rowInfo = /* @__PURE__ */ new Map();
 		/**
-		* 渲染侧快照 + DOM 观察：订阅脚手架住 `store.ts` 的 `createLazyStore`；这里只提供读法与
-		* 观察者生命周期。宿主行的去留只体现在 `data-row-key` 节点上（增删、属性落定），文本变化
-		* 不算（标题只认 `rowInfo` 的登记值）。首个订阅者起开始观察，最后一个走了断开。
+		* 渲染侧快照：`rowInfo` 变了才标脏；订阅脚手架住 `store.ts` 的 `createLazyStore`。
+		* `readVisibleSelectableRows` 按登记顺序（宿主渲染顺序）返回，不再观察 DOM。
 		*/
 		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"]
-			});
+		const visibleRows = createLazyStore(EMPTY_ROWS, readVisibleSelectableRows);
+		const EMPTY_ROW_INFO = {
+			title: "",
+			live: false
+		};
+		/**
+		* 行槽位开关登记一行：模式内与模式外都要登记（守卫进模式的那一帧就得有标题）。
+		* 每次登记算**多一个挂载实例**；不给 info 时只占位，随后由 {@link updateHostRowInfo} 填值。
+		*/
+		function registerHostRowInfo(sessionId, info) {
+			const current = rowInfo.get(sessionId);
+			if (current === void 0) {
+				rowInfo.set(sessionId, {
+					info: info ?? EMPTY_ROW_INFO,
+					owners: 1
+				});
+				visibleRows.invalidate();
+				return;
+			}
+			current.owners += 1;
+			if (info !== void 0 && (current.info.title !== info.title || current.info.live !== info.live)) {
+				current.info = info;
+				visibleRows.invalidate();
+			}
 		}
-		function stopObserving() {
-			observer?.disconnect();
-			observer = void 0;
+		/**
+		* 标题/运行态变了就地更新：**不注销、不重登记**，否则这一行会被挪到登记序末尾（ADR-0034 决定 2）。
+		*/
+		function updateHostRowInfo(sessionId, info) {
+			const current = rowInfo.get(sessionId);
+			if (current === void 0) return;
+			const title = info.title === "" ? current.info.title : info.title;
+			if (current.info.title === title && current.info.live === info.live) return;
+			current.info = {
+				title,
+				live: info.live
+			};
+			visibleRows.invalidate();
 		}
-		const visibleRows = createLazyStore(EMPTY_ROWS, readVisibleSelectableRows, {
-			onFirstSubscribe: startObserving,
-			onLastUnsubscribe: stopObserving
-		});
 		/**
-		* 行尾兜底勾选开关登记一行：模式内与模式外都要登记（守卫进模式的那一帧就得有标题）。
-		* 只有标题／运行态**真的变了**才标脏：重渲染时的同值登记不该把快照翻新一遍。
+		* 槽位组件共用的登记生命周期：挂载登记、卸载注销；标题/运行态变化只走更新口。
+		* 两次 effect 分工是顺序契约：先占住首次登记序，再填值。
 		*/
-		function registerHostRowInfo(sessionId, info) {
+		function useHostRowRegistration(sessionId, info) {
+			(0, react.useEffect)(() => {
+				registerHostRowInfo(sessionId);
+				return () => {
+					unregisterHostRowInfo(sessionId);
+				};
+			}, [sessionId]);
+			const { title, live } = info;
+			(0, react.useEffect)(() => {
+				updateHostRowInfo(sessionId, {
+					title,
+					live
+				});
+			}, [
+				sessionId,
+				title,
+				live
+			]);
+		}
+		/** 行槽位开关卸载时调用：那一行已经离开渲染树，登记跟着走。
+		*  还有别的挂载实例在用同一行（重复行）就只减计数，不摘登记。 */
+		function unregisterHostRowInfo(sessionId) {
 			const current = rowInfo.get(sessionId);
-			if (current?.title === info.title && current.live === info.live) return;
-			rowInfo.set(sessionId, info);
+			if (current === void 0) return;
+			if (current.owners > 1) {
+				current.owners -= 1;
+				return;
+			}
+			rowInfo.delete(sessionId);
 			visibleRows.invalidate();
 		}
+		/** `live` 行不可勾：与置灰的勾选框、守卫拦下的整行点击同一条判据。 */
+		function isPickable(info) {
+			return !info.live;
+		}
+		/**
+		* 守卫与全选共用的一行读数：这一行此刻可勾选时交回登记（含标题）；未登记或在跑回 `undefined`。
+		* 登记表是可见行的事实源，所以"没登记"就是"这一行此刻不在可见集合里"。
+		*/
+		function pickableRowOf(sessionId) {
+			const entry = rowInfo.get(sessionId);
+			return entry === void 0 || !isPickable(entry.info) ? void 0 : entry.info;
+		}
 		/**
-		* 「当前可见」的可选行：侧栏里**已渲染**的会话行（`data-row-key="session:…"`）——折叠组、
-		* 归档过滤外的行不在 DOM 里，宿主隐藏的 subagent 也不在；在跑的行跳过（与置灰勾选框同口径）。
-		* 标题/运行态来自行尾兜底登记的 `rowInfo`（模式内它对每个非空行都渲染）；DOM 序就是侧栏顺序。
+		* 「当前可见」的可选行：**已登记**的会话行（槽位开关还挂在渲染树上）——折叠组、归档过滤外的行
+		* 没有挂载，因此没有登记；在跑的行跳过（与置灰勾选框同口径）。标题/运行态来自登记值；
+		* 顺序是登记顺序（宿主按列表顺序挂载行）。
 		*
 		* 这是**当场读**：事件路径（点「全选」那一刻的页面）与测试用它；渲染侧读下面的快照。
 		*/
 		function readVisibleSelectableRows() {
 			const rows = [];
-			const seen = /* @__PURE__ */ new Set();
-			for (const row of document.querySelectorAll("[data-row-key^=\"session:\"]")) {
-				const key = row.getAttribute("data-row-key") ?? "";
-				if (!key.startsWith("session:")) continue;
-				const sessionId = key.slice(8);
-				if (sessionId === "" || seen.has(sessionId)) continue;
-				const info = rowInfo.get(sessionId);
-				if (info === void 0 || info.live) continue;
-				seen.add(sessionId);
+			for (const [sessionId, entry] of rowInfo) {
+				if (!isPickable(entry.info)) continue;
 				rows.push({
 					sessionId,
-					title: info.title
+					title: entry.info.title
 				});
 			}
 			return rows;
 		}
 		/**
-		* `enabled === false` 时的稳定替身：同一个空表、不订阅、不读 DOM。
-		* 浮条是 `shell.overlay` 的常驻槽位，模式外若照常订阅，body 上每次变更（以及每次行登记）
-		* 都会白叫醒它重渲染一次。
+		* `enabled === false` 时的稳定替身：同一个空表、不订阅、不读登记。
+		* 浮条是 `shell.overlay` 的常驻槽位，模式外若照常订阅，每次行登记都会白叫醒它重渲染一次。
 		*/
 		function getEmptyRowsSnapshot() {
 			return EMPTY_ROWS;
@@ -772,126 +837,97 @@ window.__ModuleLoader__.load({
 			return () => {};
 		}
 		/**
-		* 渲染侧只读快照 + DOM 观察订阅；首个订阅者起开始观察，最后一个走了断开。
-		* `enabled === false` 不订阅也不读 DOM——行列表只随多选态存在，模式外不必付观察的成本。
+		* 渲染侧只读快照 + 登记订阅；`enabled === false` 不订阅也不读登记——行列表只随多选态存在，
+		* 模式外不必付订阅的成本。
 		*/
 		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());
-		}
-		/**
-		* 同一个切换口该显示「全选」还是「取消全选」：
-		* - 有选中、且当前可见可选行全都选中 ⇒ 取消全选；
-		* - 有选中、但当前没有可见可选行（全折叠/过滤掉）⇒ 只能清空，也显示取消全选；
-		* - 其余（含 0 条）⇒ 全选。
-		*/
-		function areAllVisibleRowsSelected(rows, picks) {
-			if (picks.length === 0) return false;
-			if (rows.length === 0) return true;
-			const chosen = new Set(picks.map((item) => item.sessionId));
-			return rows.every((row) => chosen.has(row.sessionId));
-		}
-		/** 行内这些元素有自己的动作：模式内也不许被"点行=勾选"吃掉。 */
-		const INTERACTIVE_IN_ROW = "button, a, input, select, textarea, [role=\"menuitem\"], [role=\"menu\"], [data-dsh-session-delete=\"batch-pick\"]";
-		/**
-		* 多选态内的整行点击守卫（document 捕获阶段）。
-		*
-		* 边界：行里的按钮 / 链接 / 输入 / 菜单项一律放行（否则 ⋯ 菜单、归档、置顶、单删都点不动）；
-		* 双击的第二下与 dblclick 不翻转（第一下已经选中，第二下不能又反掉，也不能打开宿主的重命名）。
-		* 认行靠 `data-row-key="session:…"`——宿主将来改掉这个属性，最差是模式内点行不生效，
-		* 勾选框本身仍在。模式外不挂监听：这时点行必须还是宿主的"打开会话"。
-		*/
-		function useSelectionRowClickGuard() {
-			const selecting = useSelection().selecting;
-			(0, react.useEffect)(() => {
-				if (!selecting) return;
-				const handle = (event) => {
-					if (!(event.target instanceof Element)) return;
-					const row = event.target.closest("[data-row-key^=\"session:\"]");
-					if (row === null) return;
-					if (event.target.closest(INTERACTIVE_IN_ROW) !== null) return;
-					event.preventDefault();
-					event.stopPropagation();
-					if (event.type === "dblclick" || event.type === "click" && event.detail > 1) return;
-					const key = row.getAttribute("data-row-key") ?? "";
-					if (!key.startsWith("session:")) return;
-					const sessionId = key.slice(8);
-					if (sessionId === "") return;
-					const info = rowInfo.get(sessionId);
-					if (info?.live === true) return;
-					togglePick({
-						sessionId,
-						title: info?.title ?? ""
-					});
-				};
-				document.addEventListener("click", handle, true);
-				document.addEventListener("dblclick", handle, true);
-				return () => {
-					document.removeEventListener("click", handle, true);
-					document.removeEventListener("dblclick", handle, true);
-				};
-			}, [selecting]);
-		}
-		//#endregion
-		//#region src/shared/wire.ts
 		/**
-		* 跨半 wire 契约：前缀、九个端点、请求/响应形状与失败码。
-		* Node 半（src/api/dispatch.ts）与浏览器半（src/client/remote.ts）共用这一份，不各写字面量。
-		*
-		* 构建约束：本文件零运行时依赖、无 import；浏览器半把整个文件 inline 进 bundle。
-		* 信封 {ok:true,value} / {ok:false,error:{code,message,details?}} 也是两半的共同契约。
-		*/
-		/**
-		* 插件专属前缀。
-		*
-		* 为什么必须带插件名：宿主 web server 的 `register({kind:'prefix', path})` 对**重复的 (kind, path)
-		* 直接抛错**（`dsh-host-webserver` 原文 `webserver: duplicate ${route.kind} route "${route.path}"`），
-		* 撞了就是整棵插件树 boot 失败——所以这条路径是与生态的硬边界，不是显示好不好看的问题。
+		* 唯一的取数基础路径：宿主 `/api` + 插件前缀。九段 exact Fetch 路由、客户端探测与附件 URL
+		* 都从它起；`SESSION_DELETE_API_PREFIX` 只作为段名的相对前缀与错误原文。
 		*/
-		const SESSION_DELETE_API_PREFIX = "/dsh-session-delete-api";
-		/** 九个段名（相对前缀）。写动作统一走一段 `/apply`：一次 HTTP 带一组 id、逐条回结果；
+		const OFFICIAL_SESSION_DELETE_API_PREFIX = `/api/dsh-session-delete-api`;
+		/** 九个段名（相对前缀）。**每项 `{ path, method }` 两键**：某段用什么方法也是线上形状的一部分
+		*  （ADR-0003），家就在这一张表——路由记录（`src/api/route-table.ts`）逐行投影（`ROUTES.x.method`），
+		*  浏览器半的 GET 段同样投影、写段把 `ROUTES.x.method` 交给 `src/client/remote.ts` 的 `post()`，
+		*  两半都不逐段手写一份。
+		*  写动作统一走一段 `/apply`：一次 HTTP 带一组 id、逐条回结果；
 		*  单条就是长度为 1 的批量，仓里不留第二条执行路径。
-		*  - `GET /list`：对账并读清单（`session-trash/` 里的目录是准）。
-		*  - `GET /ping`：最便宜的在/不在（不碰清册、不碰盘、不进链），供客户端探测。
-		*  - `POST /detail`：单条详情（用 POST 表达一个读，判据在 `src/api/route-table.ts`）。
-		*  - `POST /apply`：批量执行一个动作（`delete` / `restore` / `purge` / `count` / `orphan-clean`），逐条回 `ApplyOutcome`。
-		*  - `POST /empty`：清空回收站（聚合回执，不按条回）。
-		*  - `GET /orphans`：无主子会话的扫描报告（纯读）。清理是 `/apply` 的第五个动作，
+		*  - `list`：对账并读清单（`session-trash/` 里的目录是准）。
+		*  - `ping`：最便宜的在/不在（不碰清册、不碰盘、不进链），供客户端探测。
+		*  - `detail`：单条详情（用 POST 表达一个读，判据在 `src/api/route-table.ts` 的 detail 行）。
+		*  - `apply`：批量执行一个动作（`delete` / `restore` / `purge` / `count` / `orphan-clean`），逐条回 `ApplyOutcome`。
+		*  - `empty`：清空回收站（聚合回执，不按条回）。
+		*  - `orphans`：无主子会话的扫描报告（纯读）。清理是 `/apply` 的第五个动作，
 		*    这一段只负责"有多少、在哪、多大"。
-		*  - `GET /attachment`：附件原始字节（全仓唯一的二进制响应段；失败仍回 JSON 信封）。
-		*  - `GET /attachment-orphans`：无引用图片对象的扫描报告（纯读；数量/字节 + 供预览的对象清单）。
-		*  - `POST /attachment-clean`：清掉报告那一刻无引用的图片对象（聚合回执 `AttachmentCleanupWire`）。 */
+		*  - `attachment`：附件原始字节（全仓唯一的二进制响应段；失败仍回 JSON 信封）。
+		*  - `attachmentOrphans`：无引用图片对象的扫描报告（纯读；数量/字节 + 供预览的对象清单）。
+		*  - `attachmentClean`：清掉报告那一刻无引用的图片对象（聚合回执 `AttachmentCleanupWire`）。 */
 		const ROUTES = {
-			list: "/list",
+			list: {
+				path: "/list",
+				method: "GET"
+			},
 			/** 通道的"在不在"专用：没有入参、没有副作用、没有磁盘读。 */
-			ping: "/ping",
+			ping: {
+				path: "/ping",
+				method: "GET"
+			},
 			/** 单条详情（读回收站目录里那条会话自己的日志）。 */
-			detail: "/detail",
+			detail: {
+				path: "/detail",
+				method: "POST"
+			},
 			/** 一组 id 上的同一个动作；删除确认框那句「含 N 个子会话」也走这里（`action: 'count'`，纯读语义）。 */
-			apply: "/apply",
+			apply: {
+				path: "/apply",
+				method: "POST"
+			},
 			/** 清空回收站。 */
-			empty: "/empty",
+			empty: {
+				path: "/empty",
+				method: "POST"
+			},
 			/** 纯读：扫描回收站之外的无主子会话（父已不在语料/清册）。 */
-			orphans: "/orphans",
+			orphans: {
+				path: "/orphans",
+				method: "GET"
+			},
 			/** 附件字节（图片/普通文件）：全仓唯一的二进制响应段，读的是宿主附件库。 */
-			attachment: "/attachment",
+			attachment: {
+				path: "/attachment",
+				method: "GET"
+			},
 			/** 纯读：扫全部引用源与附件库 `objects`，报无引用图片的数量、字节与预览清单。 */
-			attachmentOrphans: "/attachment-orphans",
+			attachmentOrphans: {
+				path: "/attachment-orphans",
+				method: "GET"
+			},
 			/** 聚合清理：只删 `objects` 下无引用的图片，回 `AttachmentCleanupWire`。 */
-			attachmentClean: "/attachment-clean"
+			attachmentClean: {
+				path: "/attachment-clean",
+				method: "POST"
+			}
 		};
 		/** 请求参数名：浏览器半发、Node 半读，同名同义（`empty` 没有入参）。
 		*  附件段是 **query 参数**（GET 二进制响应，没有请求体）。 */
 		const PARAMS = {
 			entryId: "entryId",
+			/** `/detail` 的分页游标：只取这个块序号之前的块。缺省 = 从尾部取。 */
+			before: "before",
 			action: "action",
 			ids: "ids",
 			attachmentId: "id",
 			attachmentKind: "kind",
-			attachmentName: "name"
+			attachmentName: "name",
+			/** 图片引用的媒体类型 / 宽高：只给宿主 `attachments.readImage` 做引用校验，不参与路径拼接。 */
+			attachmentMediaType: "mediaType",
+			/** 字节数：图片支与文件支都带——它是宿主读面的引用一部分，并先过 `maxAttachmentBytes` 闸
+			*  （别为一张已知超限的图让宿主整份读出来）。 */
+			attachmentBytes: "bytes",
+			attachmentWidth: "width",
+			attachmentHeight: "height"
 		};
 		/**
 		* 进程内判别「这已经是一次失败」——**按标记位认，不按 `instanceof`**（跨 realm / 跨 bundle 都不成立）。
@@ -906,6 +942,21 @@ window.__ModuleLoader__.load({
 			const candidate = value;
 			return candidate.isDSHRemoteError === true && typeof candidate.code === "string";
 		}
+		/**
+		* 运行期判形「这段 JSON 是不是信封」。中间层（反代 / SPA 兜底）会回 `{}`、`{"error":"…"}` 这类
+		* 不是信封的 JSON；判形不过就该走「回的不是信封」诊断，而不是把垃圾喂给展开层炸出
+		* TypeError / "undefined" 上屏（issue #8 第 1 条）。判据就是两臂的形状：`ok` 必须是布尔，
+		* `ok:true` 须带 `value` 键（值可以是 null），`ok:false` 的 `error` 须是带 string `code`/`message` 的对象。
+		*/
+		function isRemoteResult(value) {
+			if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+			const body = value;
+			if (typeof body.ok !== "boolean") return false;
+			if (body.ok) return "value" in body;
+			if (typeof body.error !== "object" || body.error === null) return false;
+			const error = body.error;
+			return typeof error.code === "string" && typeof error.message === "string";
+		}
 		const SESSION_DELETE_CODES = {
 			live: "sessiondelete/live",
 			"not-found": "sessiondelete/not-found",
@@ -1104,6 +1155,7 @@ window.__ModuleLoader__.load({
 				};
 			}
 			const landedIds = receipt.action === "delete" ? landedEntryIds(receipt) : receipt.action === "restore" ? restoredSessionIds(receipt, sessionIdOfEntry) : [];
+			const attachmentCleanup = summarizeAttachmentCleanup(receipt);
 			return {
 				summary: {
 					successIds,
@@ -1112,7 +1164,7 @@ window.__ModuleLoader__.load({
 					partial,
 					landedIds,
 					anySuccess: successIds.length > 0,
-					attachmentCleanup: summarizeAttachmentCleanup(receipt)
+					...attachmentCleanup !== void 0 ? { attachmentCleanup } : {}
 				},
 				failures
 			};
@@ -1153,11 +1205,15 @@ window.__ModuleLoader__.load({
 		//#endregion
 		//#region src/client/remote.ts
 		/**
-		* 浏览器半的取数通道：同源 fetch /dsh-session-delete-api，并处理信封与失败原文。
+		* 浏览器半的取数通道：同源 fetch 宿主 `connection.fetch` 的 exact Fetch 路由（`/api` + 插件前缀）。
+		* 信封与失败原文在这一层收口。
 		*
-		* - 路由是宿主 web server 上的插件前缀；官方 remote.<namespace> 需要生成的 Typert 描述符，
-		*   第三方无法动态挂载，因此走这条薄线（ADR-0009）。
-		* - 九段：list / ping / orphans / detail / apply / empty / attachment / attachment-orphans / attachment-clean；
+		* - 九段注册在宿主 `connection.fetch.register` 上，鉴权归宿主 `/api` bridge（ADR-0033）；
+		*   没有旧前缀 fallback——支持面是 web UI 与桌面端，二者的标准组合都装 `client-connection`。
+		*   官方 remote.<namespace> 仍不可用（第三方拿不到 Typert 描述符的动态发现挂载点）。
+		* - 九段的**段名与方法**住 `src/shared/wire.ts` 的结构化段名表（`ROUTES` 每项 `{ path, method }`），
+		*   本文件只投影路径（`prefix + ROUTES.x.path`）与方法（GET 段直接取 `ROUTES.x.method`，写段把它
+		*   交给 `post()`）——方法字面量不在本文件出现第二份；
 		*   写动作统一走 apply；`attachment` 是唯一二进制段，由 `src/client/attachment-view.tsx` 直接拼地址，
 		*   不经过本文件的信封通道；`attachment-orphans`（纯读）与 `attachment-clean`（聚合写）是孤儿附件的两段。
 		* - 信封与官方 unary 面同形：{ok:true,value} / {ok:false,error}。HTTP 往返本身失败才 reject；
@@ -1225,63 +1281,74 @@ window.__ModuleLoader__.load({
 				};
 			}
 		}
+		/** 宿主 `/api` 的 401/403 是纯文本，不是本插件信封：固定中文原文只住这里（浏览器半唯一消费者）。 */
+		const UNTRUSTED_MESSAGE = "非受信来源";
+		const UNAUTHENTICATED_MESSAGE = "需要宿主的 Web 身份：请用 dsh web 打印的那一行 URL 打开页面后重试";
 		/**
 		* 一次 HTTP 往返 → 信封。**`ok:false` 也是落地**（返回，不抛）；只有往返本身失败才抛：
-		* 打不通（宿主没起来 / 路由没挂）或回的不是信封（前缀路由缺席时请求会落到 SPA 兜底处理器上，
-		* 回的是 index.html）。两种抛都带原文，组件侧的 `failureOf` 会把它们显示成 `client/unknown` + 原因。
+		* 打不通（宿主没起来 / 路由没挂）或回的不是信封（中间层回 `{}` / `{"error":"…"}` 这类非信封 JSON，
+		* 或 SPA 兜底的 index.html——判形住 `isRemoteResult`，几种都落同一条诊断）。两种抛都带原文，
+		* 组件侧的 `failureOf` 会把它们显示成 `client/unknown` + 原因。
 		*/
 		async function requestEnvelope(path, init) {
 			let response;
 			try {
 				response = await fetch(path, init);
 			} catch (reason) {
-				throw new Error(`取数通道打不通：${reason instanceof Error ? reason.message : String(reason)}`);
+				throw new Error(`取数通道打不通：${reason instanceof Error ? reason.message : String(reason)}`, { cause: reason });
 			}
+			let body;
 			try {
-				return await response.json();
+				body = await response.json();
 			} catch {
+				body = void 0;
+			}
+			if (!isRemoteResult(body)) {
+				if (response.status === 401) throw new Error(UNAUTHENTICATED_MESSAGE);
+				if (response.status === 403) throw new Error(UNTRUSTED_MESSAGE);
 				throw new Error(`取数通道回的不是信封（HTTP ${String(response.status)}）`);
 			}
+			return body;
 		}
 		/**
-		* 前缀路由的 fetch 实现。**相对路径**：不拼 base、不认 origin——页面本身就是从宿主 web server
-		* 加载的，同源是这条薄线的全部前提。本机（含转发落在回环的桌面壳）靠回环 + Origin/Referer 过栅栏；
-		* 远程（LAN / 反代）客户端另由宿主 `connection` 判「已认证的 Web 身份」，所以这条通道**只对**
-		* `dsh web` 打印的 URL 打开过的页面成立（凭据是那行 URL 换来的 cookie，不是插件自己的秘密）。
+		* exact Fetch 路由的 fetch 实现。**相对路径**：不拼 host、不认 origin——页面本身就是从宿主页面
+		* 加载的，同源是这条通道的全部前提；鉴权归宿主 `/api` bridge（ADR-0033）。所以这条通道**只对**
+		* 宿主页面打开过、带宿主身份的客户端成立（凭据是那次访问换来的 cookie，不是插件自己的秘密）。
 		*/
-		function createHttpRemote(prefix = SESSION_DELETE_API_PREFIX) {
-			const post = (body) => ({
-				method: "POST",
+		function createHttpRemote() {
+			const post = (route, body) => ({
+				method: route.method,
 				headers: { "content-type": "application/json" },
 				body: JSON.stringify(body)
 			});
 			return {
-				list: () => requestEnvelope(prefix + ROUTES.list, { method: "GET" }),
-				ping: () => requestEnvelope(prefix + ROUTES.ping, { method: "GET" }),
-				orphans: () => requestEnvelope(prefix + ROUTES.orphans, { method: "GET" }),
-				attachmentOrphans: () => requestEnvelope(prefix + ROUTES.attachmentOrphans, { method: "GET" }),
-				attachmentClean: () => requestEnvelope(prefix + ROUTES.attachmentClean, post({})),
-				detail: (entryId) => requestEnvelope(prefix + ROUTES.detail, post({ [PARAMS.entryId]: entryId })),
-				apply: (action, ids) => requestEnvelope(prefix + ROUTES.apply, post({
+				list: () => requestEnvelope(OFFICIAL_SESSION_DELETE_API_PREFIX + ROUTES.list.path, { method: ROUTES.list.method }),
+				ping: () => requestEnvelope(OFFICIAL_SESSION_DELETE_API_PREFIX + ROUTES.ping.path, { method: ROUTES.ping.method }),
+				orphans: () => requestEnvelope(OFFICIAL_SESSION_DELETE_API_PREFIX + ROUTES.orphans.path, { method: ROUTES.orphans.method }),
+				attachmentOrphans: () => requestEnvelope(OFFICIAL_SESSION_DELETE_API_PREFIX + ROUTES.attachmentOrphans.path, { method: ROUTES.attachmentOrphans.method }),
+				attachmentClean: () => requestEnvelope(OFFICIAL_SESSION_DELETE_API_PREFIX + ROUTES.attachmentClean.path, post(ROUTES.attachmentClean, {})),
+				detail: (entryId, before) => requestEnvelope(OFFICIAL_SESSION_DELETE_API_PREFIX + ROUTES.detail.path, post(ROUTES.detail, {
+					[PARAMS.entryId]: entryId,
+					...before === void 0 ? {} : { [PARAMS.before]: before }
+				})),
+				apply: (action, ids) => requestEnvelope(OFFICIAL_SESSION_DELETE_API_PREFIX + ROUTES.apply.path, post(ROUTES.apply, {
 					[PARAMS.action]: action,
 					[PARAMS.ids]: [...ids]
 				})),
-				empty: () => requestEnvelope(prefix + ROUTES.empty, post({}))
+				empty: () => requestEnvelope(OFFICIAL_SESSION_DELETE_API_PREFIX + ROUTES.empty.path, post(ROUTES.empty, {}))
 			};
 		}
 		/**
-		* 取数通道探测：一次 `GET /ping` 走通（或走到）就是"通道在"。
+		* 探测唯一通道：一次 `GET /ping` 回成功信封（`pong`）才注册入口。
 		*
-		* 判据是**「拿到信封」而不是「操作成功」**：`{ok:false, error}` 也是一次成功的往返（路由在、依赖接上了、
-		* 错误映射也生效了），那时该做的是把入口显示出来、让原文上屏；只有往返本身失败才算通道缺席 ⇒
-		* 一个槽位贡献都不注册（docs/architecture.md §3「通道探测决定入口出现与否」）。
-		*
-		* 探测用一次零成本的 `GET /ping`，不读清单，避免每次页面加载都跑全表对账。
+		* - 401/403 是宿主 `/api` 的纯文本身份/归属失败：入口不出现，不装禁用态。
+		* - 失败信封 / 404 / 非信封同样按不可用处理：`/api` 网关对未知路径也可能回错误形状，
+		*   不能据此把入口摆出来让每个动作都失败。
 		*/
 		async function probeChannel(raw) {
 			try {
-				await raw.ping();
-				return true;
+				const result = await raw.ping();
+				return result.ok && result.value === "pong";
 			} catch {
 				return false;
 			}
@@ -1325,12 +1392,96 @@ window.__ModuleLoader__.load({
 				scanOrphans: () => raw.orphans().then((result) => unwrapRemoteResult(result)),
 				scanAttachmentOrphans: () => raw.attachmentOrphans().then((result) => unwrapRemoteResult(result)),
 				cleanAttachmentOrphans: () => raw.attachmentClean().then((result) => unwrapRemoteResult(result)),
-				detail: (entryId) => raw.detail(entryId).then((result) => unwrapRemoteResult(result)),
+				detail: (entryId, before) => raw.detail(entryId, before).then((result) => unwrapRemoteResult(result)),
 				applyOutcomes: applyOnce,
 				emptyTrash: () => raw.empty().then((result) => unwrapRemoteResult(result))
 			};
 		}
 		//#endregion
+		//#region src/client/batch-selection-store.ts
+		/**
+		* 宿主列表批量删除的**选中集现场**：多选模式 + 选中名单，一份合并快照。
+		*
+		* 从 `batch-select.tsx` 拆出来的理由：多选态与选中集是**同一次交互的两半**（进入模式才出现勾选框，
+		* 退出模式连名单一起清），读写它们的却有四个座位——菜单里的入口（`batch-menu-item.tsx`）、行首
+		* 勾选框、行尾兜底、overlay 上的浮条与确认框。状态住这一处，`batch-select.tsx` 只剩控件，
+		* `host-rows.ts` 只回答"页面上现在有哪些行、点行算不算选中"。订阅/通告那套仍只住在 `store.ts`
+		* 的 `createStore` 里，本文件不另写一份。
+		*
+		* **合并快照**而不是两个 store：两半的变化总是成对出现（`exitSelection` 清两半），订阅者
+		* （勾选框、浮条）两半都要读；分两份只会让"进模式的那一帧"出现两次通告、两个快照不同步的缝。
+		*
+		* 名单只收槽位投影原样给的 `sessionId` / `displayTitle`（浏览器半不自己拼 id）：**逐条勾选序 = 名单序**；
+		* 「全选」追加的条目按 `host-rows.ts` 的槽位登记序接在后面。`/apply` 那条「保持输入顺序」吃到的就是这份名单序。
+		*/
+		const INITIAL = {
+			selecting: false,
+			picks: []
+		};
+		const selectionStore = createStore(INITIAL);
+		function getSelection() {
+			return selectionStore.get();
+		}
+		function getPicks() {
+			return getSelection().picks;
+		}
+		/** 供组件订阅：模式与名单是同一次交互的两半，读它们的组件订同一份快照。 */
+		function useSelection() {
+			return selectionStore.use();
+		}
+		/** 「⋯ → 多选」按下时进入；重复进入是幂等的（同一份快照，不发通告）。 */
+		function enterSelection() {
+			selectionStore.update((current) => current.selecting ? current : {
+				...current,
+				selecting: true
+			});
+		}
+		/** 退出模式并清空名单：多选态和选中集是同一次交互的两半，退出后不该留下看不见的名单。 */
+		function exitSelection() {
+			selectionStore.update((current) => current.selecting || current.picks.length > 0 ? INITIAL : current);
+		}
+		/** 翻转一条：没选过就排队尾，选过就摘掉（列表里永远不会有重复 id）。 */
+		function togglePick(item) {
+			selectionStore.update((current) => {
+				const at = current.picks.findIndex((candidate) => candidate.sessionId === item.sessionId);
+				return {
+					...current,
+					picks: at === -1 ? [...current.picks, item] : current.picks.filter((candidate) => candidate.sessionId !== item.sessionId)
+				};
+			});
+		}
+		/** 清空名单但**留在多选态**（「取消全选」那颗）；已经空了就不发通告。 */
+		function clearPicks() {
+			selectionStore.update((current) => current.picks.length === 0 ? current : {
+				...current,
+				picks: []
+			});
+		}
+		/** 只追加还没选过的条目；名单序 = 原有选中在前、新条目按传入序接在后面。没有新条目就不发通告。 */
+		function addPicks(items) {
+			selectionStore.update((current) => {
+				const chosen = new Set(current.picks.map((item) => item.sessionId));
+				const additions = [];
+				for (const item of items) {
+					if (chosen.has(item.sessionId)) continue;
+					chosen.add(item.sessionId);
+					additions.push(item);
+				}
+				return additions.length === 0 ? current : {
+					...current,
+					picks: [...current.picks, ...additions]
+				};
+			});
+		}
+		/** 执行后收缩：只留失败名单（空数组 = 全清）。成功的随通告从侧栏消失，不该留在名单里。 */
+		function shrinkPicksToFailures(failedSessionIds) {
+			const keep = new Set(failedSessionIds);
+			selectionStore.update((current) => ({
+				...current,
+				picks: current.picks.filter((item) => keep.has(item.sessionId))
+			}));
+		}
+		//#endregion
 		//#region src/client/ui/Checkbox.tsx
 		/**
 		* 勾选框，回收站多选态用。
@@ -1499,7 +1650,7 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region src/client/ui/ui.css?dsh-css-text
-		var ui_default = "/*\r\n * 本插件自己的控件样式（**不再 require 宿主的 `@deepseek-ai/dsh-client-ui-primitives`**）。\r\n *\r\n * 出处：逐条抄自 `@deepseek-ai/dsh-client-ui-primitives@0.2.0-rc.2` 随包发布的明文 CSS\r\n * （`lib/Button.module.css`、`Tag.module.css`、`Modal.module.css`、`Tooltip.module.css`、\r\n * `Toast.module.css`、`Menu.module.css`；2026-10-15 又加两张：`lib/Checkbox.module.css`、\r\n * `lib/DisclosureRow.module.css`，以及 `dsh-client-ui-conversation` 里的\r\n * `ConversationRoot.module.css` 的 `.widthHandle` 那一族——宿主自己那根可拖的宽度把手；\r\n * 2026-10-17 又加一张，也是首张来自 ui-primitives 之外的包：`dsh-client-ui-workspace` 的\r\n * `Rows.module.css` 的 `.iconButton` 那一族——会话行尾悬停排那颗按钮的基底（行尾兜底勾选开关\r\n * 要跟宿主自己的归档/置顶同形）。\r\n * 这是官方给第三方 UI 插件的处方：\r\n * 「copy markup, CSS, and behavior from the primitive into the plugin … Rename copied classes under\r\n * your plugin's prefix, keep only `--dsw-alias-*` token references」（宿主技能\r\n * `cordis-plugin-development/references/practices.md` 原文）。理由是那个包**随宿主换代而变、且不经类型检查**，\r\n * 一个抛错的组件会把整个槽位条目打空（控制台 `slot entry crashed in '<slot>'`）。\r\n *\r\n * 三条改写规则：\r\n * 1. **类名全部加本插件前缀 `sd-`**（原来是 CSS module 的哈希名，全局无冲突由前缀承担）。\r\n * 2. **配色一律走 token**，一个颜色的字面量都没有——所以宿主换主题、改名 token 时最差是难看，\r\n *    不会崩。几何量（圆角/阴影/层级）同样取 token；**只有字号/行高/尺寸是字面量 px**，与官方 CSS 逐字一致。\r\n * 3. **`@keyframes` 全部改名**（`sd-` 前缀）：它们是全局命名空间，撞名会互相覆盖。\r\n *\r\n * 只收本插件真正用到的部分：Button 的 `primary`/`ghost`/`outline` 三档与 `md`/`sm` 两号\r\n * （没有 `toolbar` 变体、没有 `lg`）、Tag 的 `danger` 一档、Modal 的全部骨架、Tooltip 的三个方位、\r\n * Toast 全部、Menu 行的全部（含 danger 态与 separator）、Checkbox 的全部、DisclosureRow 的\r\n * 折叠头那一半（没有 `data-state` 那档状态点）、宽度把手的视觉与光标。**没抄进来的就是本插件不用的**，\r\n * 不预先铺开——宿主那套里还有几十个变体与控件，抄全了等于把它的表面积整个搬进来。\r\n *\r\n * **六处不是抄本**：① `.sd-resizing`（拖动期间挂在面板根上、关掉文字选中）——宿主那份没有对应的类，\r\n * 它的把手由 JS 侧的 pointer capture 承担；② `[data-dsh-session-delete=\"trash-row\"]:focus-visible`\r\n * （清单那一行的键盘焦点描边，复用选中态那枚 `ghost-active-border`）——宿主那套表里行不是可聚焦\r\n * div，我们这一行是 `role=\"option\"` 且要吃 ↑↓，而这一代 `--dsw-focus-ring-color` 是 `transparent`；\r\n * ③ `.sd-rowaction-button` 的 `[aria-pressed='true']` 与 `:disabled` 两档（2026-10-17）——\r\n * 官方那颗 `iconButton` 只有常态与 hover，勾选开关要有\"按下\"和\"这条删不动\"两档，token 与回收站\r\n * 选中行同源（`--dsw-alias-button-ghost-active-*`）；④ `.sd-batch-bar`（同日）——宿主没有\"浮条\"\r\n * 这件控件，四件 token 自拼；⑤ 宿主行的批量选中底色与兜底隐藏（同日改版）——宿主的行选中态不归\r\n * 第三方，整行可见性靠 `data-row-key` + `:has`，token 与回收站选中行同源；行首格在场时行尾兜底退场；\r\n * ⑥ `.sd-batch-pick-leading`（同日）——宿主行首那格只给 16×20，勾选框要一层 inline-flex 包装才压得回\r\n * 同样大小，官方没有这层包装。\r\n * 整张表里就这六条是我们自造的，标在这里，\r\n * 下次做「与官方逐条比对」时它属于**已知差异**，不是漂移。\r\n *\r\n * **另有一处已知差异不住在本文件**：回收站组头那颗按钮的整套 UA reset。宿主 `DisclosureRow` 那份是\r\n * `div`，没有这个坑；我们这行要做成可点的 `<button>`，UA 样式表会把背景、边框、内距、字体、居中与\r\n * flex 基线一起渗进来（真机上就是项目名整条居中，2026-10-15 截图）。它写在\r\n * `src/client/trash-panel.tsx` 组头那一行的 inline 样式上，**具体 reset 了哪几项由\r\n * `tests/skeleton.test.ts` 逐条钉住**（不在这里再抄一份名单）——所以「与官方逐条比对」时本表仍然只数\r\n * 上面那六条，这条不算进抄本差异。\r\n */\r\n\r\n/* ────────────────────────── Button ────────────────────────── */\r\n\r\n.sd-button {\r\n  box-sizing: border-box;\r\n  display: inline-flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  gap: 4px;\r\n  border: none;\r\n  border-radius: var(--dsw-radius-md);\r\n  cursor: pointer;\r\n  font-size: 14px;\r\n  line-height: 22px;\r\n  color: var(--dsw-alias-label-primary);\r\n  background: transparent;\r\n  padding: 0 14px;\r\n}\r\n\r\n.sd-button:disabled {\r\n  cursor: not-allowed;\r\n  opacity: 0.4;\r\n}\r\n\r\n.sd-button-md {\r\n  height: 36px;\r\n}\r\n\r\n/* 紧凑档：尺寸不随填充/描边换档（官方原文的注释即此意）。 */\r\n.sd-button-sm {\r\n  height: 28px;\r\n  font-size: 12px;\r\n  line-height: 18px;\r\n  padding: 0 10px;\r\n  border-radius: var(--dsw-radius-sm);\r\n}\r\n\r\n.sd-button-primary {\r\n  background: var(--dsw-alias-button-primary-fill);\r\n  color: var(--dsw-alias-label-primary-foreground);\r\n}\r\n\r\n.sd-button-primary:hover:not(:disabled) {\r\n  background: var(--dsw-alias-button-primary-hover);\r\n}\r\n\r\n.sd-button-ghost:hover:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-hover);\r\n}\r\n\r\n.sd-button-ghost:active:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-active);\r\n}\r\n\r\n.sd-button-outline {\r\n  border: 0.5px solid var(--dsw-alias-border-l3);\r\n  background: transparent;\r\n}\r\n\r\n.sd-button-outline:hover:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-hover);\r\n}\r\n\r\n.sd-button-icon {\r\n  display: inline-flex;\r\n  width: 16px;\r\n  height: 16px;\r\n  align-items: center;\r\n  justify-content: center;\r\n}\r\n\r\n/* ────────────────────────── Tag ────────────────────────── */\r\n\r\n/* 胶囊几何固定：一个 tag 在哪里都是同一个尺寸，只有色板随 tone 走。 */\r\n.sd-tag {\r\n  display: inline-flex;\r\n  align-items: center;\r\n  border-radius: 999px;\r\n  corner-shape: round;\r\n  padding: 1px 8px;\r\n  font-size: 11px;\r\n  line-height: 17px;\r\n  font-weight: 500;\r\n  white-space: nowrap;\r\n}\r\n\r\n/* 状态色自带填充：底色由自身颜色 10% 混出，换色板时底与字一起走，不需要第二个 token。 */\r\n.sd-tag-danger {\r\n  background: color-mix(in srgb, var(--dsw-alias-state-error-primary) 10%, transparent);\r\n  color: var(--dsw-alias-state-error-primary);\r\n}\r\n\r\n/* ────────────────────────── Modal ────────────────────────── */\r\n\r\n/* 整视口层（figma Mask + Dialog）：蒙层 + 居中卡片。四边留 24px，上下按外壳公布的浮层内缩加宽，\r\n   高卡片才不会顶到外壳。卡片按这个内边距盒取尺寸：消费方用 `max-height:100%` 收口，不自己算视口。 */\r\n.sd-modal-root {\r\n  pointer-events: auto;\r\n  position: fixed;\r\n  inset: 0;\r\n  z-index: 1000;\r\n  display: flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  padding: max(24px, var(--dsh-frame-overlay-top, 24px)) 24px;\r\n}\r\n\r\n/* 只有绘制避让原生标题栏；根仍然挡住背景点击。 */\r\n.sd-modal-mask {\r\n  position: absolute;\r\n  inset: var(--dsh-frame-chrome-top, 0px) 0 0;\r\n  backdrop-filter: var(--dsw-mask-blur);\r\n}\r\n\r\n.sd-modal-mask::after {\r\n  content: '';\r\n  position: absolute;\r\n  inset: 0;\r\n  background: var(--dsw-alias-bg-mask-1);\r\n  animation: sd-modal-enter var(--ds-transition-duration) var(--ds-ease-in-out);\r\n}\r\n\r\n.sd-modal-dialog {\r\n  box-sizing: border-box;\r\n  position: relative;\r\n  z-index: 1;\r\n  display: flex;\r\n  flex-direction: column;\r\n  gap: 20px;\r\n  width: min(380px, 100%);\r\n  padding: 0 0 24px;\r\n  overflow: hidden;\r\n  border: 0;\r\n  border-radius: var(--dsw-radius-panel);\r\n  background: var(--dsw-alias-bg-layer-2);\r\n  box-shadow: var(--dsw-elevation-prominent);\r\n  animation: sd-modal-enter var(--ds-transition-duration) var(--ds-ease-in-out);\r\n}\r\n\r\n@keyframes sd-modal-enter {\r\n  from { opacity: 0; }\r\n  to { opacity: 1; }\r\n}\r\n\r\n@media (prefers-reduced-motion: reduce) {\r\n  .sd-modal-mask::after,\r\n  .sd-modal-dialog { animation: none; }\r\n}\r\n\r\n.sd-modal-dialog:focus {\r\n  outline: none;\r\n}\r\n\r\n.sd-modal-content {\r\n  display: flex;\r\n  flex-direction: column;\r\n  width: 100%;\r\n}\r\n\r\n/* 头行：标题左、关闭钮右。 */\r\n.sd-modal-header {\r\n  display: flex;\r\n  align-items: center;\r\n  justify-content: space-between;\r\n  gap: 8px;\r\n  padding: 22px 14px 12px 24px;\r\n}\r\n\r\n.sd-modal-title {\r\n  margin: 0;\r\n  font-size: 16px;\r\n  line-height: 24px;\r\n  font-weight: 500;\r\n  color: var(--dsw-alias-label-primary);\r\n}\r\n\r\n.sd-modal-close {\r\n  flex: none;\r\n  display: inline-flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  width: 28px;\r\n  height: 28px;\r\n  border: none;\r\n  border-radius: var(--dsw-radius-sm);\r\n  background: transparent;\r\n  cursor: pointer;\r\n  color: var(--dsw-alias-label-secondary);\r\n}\r\n\r\n.sd-modal-close:hover {\r\n  background: var(--dsw-alias-interactive-bg-hover);\r\n}\r\n\r\n.sd-modal-body {\r\n  display: flex;\r\n  flex-direction: column;\r\n  min-width: 0;\r\n  margin-top: 20px;\r\n  padding: 0 24px;\r\n}\r\n\r\n.sd-modal-footer {\r\n  display: flex;\r\n  align-items: center;\r\n  justify-content: flex-end;\r\n  gap: 8px;\r\n  padding: 0 24px;\r\n}\r\n\r\n/* ────────────────────────── Tooltip ────────────────────────── */\r\n\r\n.sd-tooltip-bubble {\r\n  display: inline-flex;\r\n  align-items: center;\r\n  gap: 8px;\r\n  position: fixed;\r\n  z-index: 100;\r\n  /* 定宽收缩只按 `left` 到视口右缘量，靠右的锚点会提前折行；\r\n     `max-content` 只按文案定宽，再用半个视口收口。 */\r\n  width: max-content;\r\n  max-width: 50vw;\r\n  padding: 3px 7px;\r\n  border-radius: var(--dsw-radius-sm);\r\n  background: var(--dsw-alias-tooltip-bg);\r\n  color: var(--dsw-static-neutral-bluish-00);\r\n  font-size: 13px;\r\n  line-height: 20px;\r\n  white-space: pre-line;\r\n  /* 不可断的长 token（URL、路径）不许顶破 max-width。 */\r\n  overflow-wrap: break-word;\r\n  pointer-events: none;\r\n  animation: sd-tooltip-in 150ms var(--ds-ease-in-out);\r\n}\r\n\r\n.sd-tooltip-bubble[data-portal] { z-index: 1100; }\r\n.sd-tooltip-label { min-width: 0; }\r\n\r\n.sd-tooltip-bubble[data-side='right'] {\r\n  transform: translateY(-50%);\r\n}\r\n\r\n.sd-tooltip-bubble[data-side='bottom'] {\r\n  transform: translateX(-50%);\r\n}\r\n\r\n.sd-tooltip-bubble[data-side='top'] {\r\n  transform: translate(-50%, -100%);\r\n}\r\n\r\n@keyframes sd-tooltip-in {\r\n  from { opacity: 0; }\r\n}\r\n\r\n@media (prefers-reduced-motion: reduce) {\r\n  .sd-tooltip-bubble {\r\n    animation: none;\r\n  }\r\n}\r\n\r\n/* ────────────────────────── Toast ────────────────────────── */\r\n\r\n/* 淡出延迟由组件以 `--dsh-toast-hold` 给出 ⇒ 同一个值同时驱动卸载计时器与这段动画，\r\n   两者不可能再对不上。淡出**时长**仍需与组件里的 FADE_MS 一致（没有 owner 会改它）。 */\r\n.sd-toast {\r\n  position: fixed;\r\n  top: 40px;\r\n  left: 50%;\r\n  /* 高过图片灯箱底层的 1000：预览开着时报错也必须读得到。 */\r\n  z-index: 1100;\r\n  /* 通告不截点击。 */\r\n  pointer-events: none;\r\n  display: flex;\r\n  align-items: center;\r\n  gap: 10px;\r\n  /* 定宽盒设了 `left` 只按右侧空间收缩（-50% 的位移发生在定尺之后）⇒ 靠窗边的横幅会提前折行。\r\n     `max-content` 只按文案定宽，再由下面的 max-width 收口。 */\r\n  width: max-content;\r\n  max-width: min(640px, calc(100vw - 48px));\r\n  padding: 12px 16px;\r\n  border-radius: var(--dsw-radius-lg);\r\n  /* 设计平台的 toast 表面在**两套主题下都是深的**（浅色 bluish-800 / 深色 bluish-750），\r\n     所以这里的字色与动作色是固定值，不随主题翻转。 */\r\n  background: var(--dsw-alias-toast-bg);\r\n  color: var(--dsw-alias-toast-label);\r\n  font-size: 14px;\r\n  line-height: 22px;\r\n  box-shadow: var(--dsw-shadow-lv3);\r\n  transform: translateX(-50%);\r\n  animation:\r\n    sd-toast-in 160ms ease-out,\r\n    sd-toast-fade 1000ms ease var(--dsh-toast-hold, 3000ms) forwards;\r\n}\r\n\r\n.sd-toast-icon {\r\n  display: grid;\r\n  place-items: center;\r\n  flex: none;\r\n  color: var(--dsw-alias-state-warn-label);\r\n}\r\n\r\n.sd-toast-icon-success {\r\n  color: var(--dsw-alias-state-success-primary);\r\n}\r\n\r\n.sd-toast-text {\r\n  min-width: 0;\r\n}\r\n\r\n.sd-toast-action {\r\n  display: inline;\r\n  padding: 0;\r\n  border: 0;\r\n  background: none;\r\n  color: var(--dsw-static-deepseek-400);\r\n  font: inherit;\r\n  cursor: pointer;\r\n  /* 动作文字与周围文案之间的呼吸位。 */\r\n  margin-inline: 3px;\r\n  /* 横幅表面整体是穿透点击的，只有动作文字接指针。 */\r\n  pointer-events: auto;\r\n}\r\n\r\n.sd-toast-action:hover {\r\n  opacity: 0.8;\r\n}\r\n\r\n@keyframes sd-toast-in {\r\n  from {\r\n    opacity: 0;\r\n    transform: translate(-50%, -6px);\r\n  }\r\n\r\n  to {\r\n    opacity: 1;\r\n    transform: translate(-50%, 0);\r\n  }\r\n}\r\n\r\n@keyframes sd-toast-fade {\r\n  to {\r\n    opacity: 0;\r\n    visibility: hidden;\r\n  }\r\n}\r\n\r\n/* 减动效去掉滑入；延迟淡出（透明度变化、不是位移）仍然在定时卸载前收掉横幅。 */\r\n@media (prefers-reduced-motion: reduce) {\r\n  .sd-toast {\r\n    animation: sd-toast-fade 1000ms ease var(--dsh-toast-hold, 3000ms) forwards;\r\n  }\r\n}\r\n\r\n/* ────────────────────────── 菜单行 ────────────────────────── */\r\n\r\n.sd-menu-item-wrap {\r\n  position: relative;\r\n}\r\n\r\n/* 菜单格：紧凑文字、图标与选中间距。 */\r\n.sd-menu-item {\r\n  display: flex;\r\n  align-items: center;\r\n  gap: 6px;\r\n  width: 100%;\r\n  min-height: 34px;\r\n  padding: 6px 8px;\r\n  border: none;\r\n  border-radius: var(--dsw-radius-md);\r\n  background: transparent;\r\n  cursor: pointer;\r\n  font-size: 13px;\r\n  line-height: 20px;\r\n  color: var(--dsw-alias-label-primary);\r\n  text-align: left;\r\n}\r\n\r\n.sd-menu-item:hover:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-hover);\r\n}\r\n\r\n/* 方向键移动的是真焦点 ⇒ 键盘所在的那一行拿指针同款填充；填充就是这一行的焦点呈现，\r\n   浏览器默认的 ring 再叠一层就重了。 */\r\n.sd-menu-item:focus-visible:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-hover);\r\n  outline: none;\r\n}\r\n\r\n.sd-menu-item:disabled {\r\n  opacity: 0.4;\r\n  cursor: not-allowed;\r\n}\r\n\r\n.sd-menu-item-icon {\r\n  display: inline-flex;\r\n  flex: none;\r\n  width: 14px;\r\n  height: 14px;\r\n  align-items: center;\r\n  justify-content: center;\r\n  color: var(--dsw-alias-menu-icon);\r\n}\r\n\r\n.sd-menu-item-icon svg {\r\n  width: 14px;\r\n  height: 14px;\r\n}\r\n\r\n.sd-menu-item-label {\r\n  flex: 1;\r\n  min-width: 0;\r\n  overflow: hidden;\r\n  text-overflow: ellipsis;\r\n  white-space: nowrap;\r\n}\r\n\r\n/* 破坏性行：error 字/图标 + danger 悬停底。 */\r\n.sd-menu-item-danger {\r\n  color: var(--dsw-alias-state-error-primary);\r\n}\r\n\r\n.sd-menu-item-danger .sd-menu-item-icon {\r\n  color: var(--dsw-alias-state-error-primary);\r\n}\r\n\r\n.sd-menu-item-danger:hover:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-hover-danger);\r\n}\r\n\r\n.sd-menu-item-danger:focus-visible:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-hover-danger);\r\n  outline: none;\r\n}\r\n\r\n/* 分隔格：发丝线上下的间距。取 l2 而不是 l1——l1 在这个表面上几乎看不见。 */\r\n.sd-menu-separator {\r\n  height: 0.5px;\r\n  margin: 3px 2px;\r\n  background: var(--dsw-alias-border-l2);\r\n}\r\n\r\n/* ────────────────────────── Checkbox ────────────────────────── */\r\n/* 抄 `lib/Checkbox.module.css` 全部四条声明，逐字。勾选框本体是**原生 input** + `accent-color`，\r\n   不是自绘的圆框——回收站多选态用它（清单行左侧那一格）。 */\r\n\r\n.sd-checkbox {\r\n  display: inline-flex;\r\n  align-items: center;\r\n  gap: 6px;\r\n  font-size: 14px;\r\n  line-height: 20px;\r\n  color: var(--dsw-alias-label-primary);\r\n  cursor: pointer;\r\n}\r\n\r\n.sd-checkbox input {\r\n  flex: 0 0 auto;\r\n  width: 16px;\r\n  height: 16px;\r\n  margin: 0;\r\n  accent-color: var(--dsw-alias-brand-primary);\r\n  cursor: inherit;\r\n}\r\n\r\n.sd-checkbox input:focus-visible {\r\n  outline: var(--dsw-focus-ring-width) solid var(--dsw-focus-ring-color, var(--dsw-alias-state-business-primary));\r\n  outline-offset: 2px;\r\n}\r\n\r\n.sd-checkbox:has(input:disabled) {\r\n  cursor: default;\r\n  opacity: 0.5;\r\n}\r\n\r\n/* ────────────────────────── DisclosureRow（分组折叠头） ────────────────────────── */\r\n/* 抄 `lib/DisclosureRow.module.css` 的 `.root`/`.row`/`.leading`/`.title` 与那两枚 glyph 的\r\n   显隐。没抄进来的是 `StateDot`（`svg[data-state]`）那一档——它说\"这是状态标记不是文字装饰\"，\r\n   我们的组头没有状态点。行高与 leading 盒走 `--dsh-content-font-delta` 那根轴，\r\n   标题字号走 secondary 档：宿主的\"设置里调正文字号\"会一起推着它走。 */\r\n\r\n.sd-disclosure {\r\n  display: flex;\r\n  flex-direction: column;\r\n  width: 100%;\r\n  min-width: 0;\r\n}\r\n\r\n.sd-disclosure-row {\r\n  position: relative;\r\n  overflow: hidden;\r\n  display: flex;\r\n  align-items: center;\r\n  height: calc(24px + var(--dsh-content-font-delta, 0px));\r\n  min-width: 0;\r\n  color: var(--dsw-alias-label-tertiary);\r\n  transition: color 100ms ease;\r\n}\r\n\r\n.sd-disclosure-row[data-expandable] {\r\n  cursor: pointer;\r\n}\r\n\r\n.sd-disclosure-row:hover {\r\n  color: var(--dsw-alias-label-secondary);\r\n}\r\n\r\n.sd-disclosure-leading {\r\n  position: relative;\r\n  flex: none;\r\n  width: calc(16px + var(--dsh-content-font-delta, 0px));\r\n  height: calc(16px + var(--dsh-content-font-delta, 0px));\r\n  display: inline-flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  margin-right: 6px;\r\n  padding: 0;\r\n  border: none;\r\n  background: none;\r\n  color: inherit;\r\n}\r\n\r\n.sd-disclosure-leading svg:not([data-state]) {\r\n  width: calc(14px + var(--dsh-content-font-delta, 0px));\r\n  height: calc(14px + var(--dsh-content-font-delta, 0px));\r\n}\r\n\r\nbutton.sd-disclosure-leading {\r\n  cursor: pointer;\r\n}\r\n\r\n.sd-disclosure-title {\r\n  flex: none;\r\n  font-size: var(--dsh-content-font-size-secondary, 13px);\r\n  line-height: calc(24px + var(--dsh-content-font-delta, 0px));\r\n  color: inherit;\r\n}\r\n\r\n@media (prefers-reduced-motion: reduce) {\r\n  .sd-disclosure-row {\r\n    transition: none;\r\n  }\r\n}\r\n\r\n/* ────────────────────────── 宽度把手（可拖的分栏线） ────────────────────────── */\r\n/* 抄 `ConversationRoot.module.css` 的 `.widthHandle` 一族：10px 的命中区、`col-resize` 光标、\r\n   平时不画、悬停或拖动时才浮出一条 2px 的 `--dsw-alias-scrollbar-bg-l1` 短标（那条渐变里\r\n   `--dsh-width-handle-pointer-y` 的兜底是 50%，宿主靠 JS 跟着指针走；我们不跟，\r\n   停在中间——少一条 pointermove 上的写字，视觉上是同一族东西）。\r\n   与宿主的差别只有位置：它绝对定位在会话栏两侧，我们这根住在两栏之间的那一格 flex 位里，\r\n   所以 `top/bottom/position` 那三样交给内联布局，这里只留视觉与光标。 */\r\n\r\n.sd-width-handle {\r\n  position: relative;\r\n  z-index: 0;\r\n  cursor: col-resize;\r\n  align-self: stretch;\r\n  flex: 0 0 10px;\r\n  width: 10px;\r\n  padding: 0;\r\n  border: none;\r\n  background: none;\r\n}\r\n\r\n.sd-width-handle::after {\r\n  content: \"\";\r\n  background: linear-gradient(\r\n    to bottom,\r\n    transparent calc(var(--dsh-width-handle-pointer-y, 50%) - 36px),\r\n    var(--dsw-alias-scrollbar-bg-l1) calc(var(--dsh-width-handle-pointer-y, 50%) - 8px),\r\n    var(--dsw-alias-scrollbar-bg-l1) calc(var(--dsh-width-handle-pointer-y, 50%) + 8px),\r\n    transparent calc(var(--dsh-width-handle-pointer-y, 50%) + 36px)\r\n  );\r\n  opacity: 0;\r\n  pointer-events: none;\r\n  border-radius: 2px;\r\n  width: 2px;\r\n  position: absolute;\r\n  top: 0;\r\n  bottom: 0;\r\n  left: 4px;\r\n}\r\n\r\n.sd-width-handle:hover::after,\r\n.sd-width-handle[data-dragging]::after {\r\n  opacity: 1;\r\n}\r\n\r\n.sd-width-handle:focus-visible {\r\n  outline: none;\r\n}\r\n\r\n.sd-width-handle:focus-visible::after {\r\n  opacity: 1;\r\n}\r\n\r\n/* 本插件自造的第一条（不是抄本，见文件头点名）：拖动期间整块面板别把文字选上了。 */\r\n.sd-resizing {\r\n  user-select: none;\r\n  cursor: col-resize;\r\n}\r\n\r\n/* 本插件自造的第二条（不是抄本，见文件头点名）：清单行是 `role=\"option\"` 的可聚焦 div，而这一代\r\n   `--dsw-focus-ring-color` 逐字是 `transparent`（2026-10-15 实测）——不自己描一条，键盘走\r\n   ↑↓ 选会话时就没有任何焦点可见性。描边**复用选中态那枚** `ghost-active-border`，不新造颜色；\r\n   0.5px 与 `outline-offset: 1px` 是行的描边宽度与一档外移，不动布局（outline 不进滚动区）。 */\r\n[data-dsh-session-delete=\"trash-row\"]:focus-visible {\r\n  outline: 0.5px solid var(--dsw-alias-button-ghost-active-border);\r\n  outline-offset: 1px;\r\n}\r\n\r\n/* 会话行尾悬停排那颗**兜底**勾选开关（状态点行 / 归档行；行首主勾选是原生 Checkbox）。\r\n   基底**逐字抄** `dsh-client-ui-workspace` 的 `Rows.module.css` 的 `.iconButton` / `.iconButton:hover`，\r\n   只改类名——兜底开关要跟同排宿主自己的归档/置顶同形，尺寸与色档都不自己发明。 */\r\n.sd-rowaction-button {\r\n  border-radius: var(--dsw-radius-xs);\r\n  cursor: pointer;\r\n  width: 16px;\r\n  height: 16px;\r\n  color: var(--dsw-alias-label-tertiary);\r\n  background: 0 0;\r\n  border: none;\r\n  flex: none;\r\n  justify-content: center;\r\n  align-items: center;\r\n  padding: 0;\r\n  display: inline-flex;\r\n}\r\n.sd-rowaction-button:hover {\r\n  color: var(--dsw-alias-label-primary);\r\n}\r\n\r\n/* 本插件自造的第三条（不是抄本，见文件头点名）：官方那颗只有常态与 hover，勾选开关还要有\r\n   「已按下」与「这条删不动」两档。按下档**复用回收站选中行那两枚** `ghost-active-*`，不新造颜色；\r\n   禁用档走 opacity。 */\r\n.sd-rowaction-button[aria-pressed='true'] {\r\n  background: var(--dsw-alias-button-ghost-active-fill);\r\n  box-shadow: inset 0 0 0 1px var(--dsw-alias-button-ghost-active-border);\r\n  color: var(--dsw-alias-label-primary);\r\n}\r\n.sd-rowaction-button:disabled {\r\n  opacity: 0.4;\r\n  cursor: not-allowed;\r\n}\r\n\r\n/* 本插件自造的第⑥条（不是抄本，见文件头点名）：行首 16px 格里的勾选框（2026-10-17 改版，**只在\r\n   多选模式内渲染**）。格本身由宿主居中（16×20），这里只把包装层压成同样大小；勾选框本体是回收站\r\n   多选同款原生 input（`.sd-checkbox`，见上）。 */\r\n.sd-batch-pick-leading {\r\n  display: inline-flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n}\r\n\r\n/* 本插件自造的第⑤条（不是抄本，见文件头点名）：宿主行自己的选中态只归它自己，批量选择要有整行\r\n   底色；行首格在场时行尾兜底要退场（两条入口不许同屏）。两条都只认宿主行已有的\r\n   `data-row-key`；将来这个属性改名，最差是底色不亮 / 兜底多露一颗，勾选本身仍在。 */\r\n[data-row-key^=\"session:\"]:has([data-dsh-session-delete=\"batch-pick\"][data-checked=\"true\"]) {\r\n  background: var(--dsw-alias-button-ghost-active-fill);\r\n  box-shadow: inset 0 0 0 0.5px var(--dsw-alias-button-ghost-active-border);\r\n}\r\n[data-row-key^=\"session:\"]:has([data-dsh-session-delete=\"batch-pick\"][data-seat=\"leading\"]) .sd-batch-pick-action {\r\n  display: none;\r\n}\r\n\r\n/* 本插件自造的第四条（不是抄本，见文件头点名）：批量删除的浮条。宿主没有\"浮条\"这件控件，形状照\r\n   本插件自己的浮层口径来——固定底部居中，表面/描边/圆角/高程四件全走 token（与单删那张目标卡同源）。\r\n   **层级必须低于确认框（`.sd-modal-root` 1000）**：2026-10-17 真机发现浮条在 1100 时会盖住确认框、\r\n   还能抢它的按钮；撤销横幅与 Tooltip 是瞬时通告、保持 1100。列方向：清单在上、操作行在下；\r\n   清单限高可滚，默认收起（见 `batch-bar.tsx`）。**宽度按内容展开**（`max-content`，最多视口减 48）：\r\n   只写 `left:50% + width:auto` 时 shrink-to-fit 只拿左半屏，新增「全选/取消全选」后会把「退出多选」\r\n   挤到第二行；窄到 max-width 还放不下才由 `.sd-batch-bar-main` 的 `flex-wrap` 兜底。 */\r\n.sd-batch-bar {\r\n  position: fixed;\r\n  bottom: 24px;\r\n  left: 50%;\r\n  transform: translateX(-50%);\r\n  z-index: 900;\r\n  width: max-content;\r\n  max-width: calc(100vw - 48px);\r\n  display: flex;\r\n  flex-direction: column;\r\n  align-items: stretch;\r\n  gap: 8px;\r\n  padding: 8px 12px;\r\n  background: var(--dsw-alias-bg-layer-2);\r\n  border: 0.5px solid var(--dsw-alias-border-l4);\r\n  border-radius: var(--dsw-radius-lg);\r\n  box-shadow: var(--dsw-elevation-prominent);\r\n  font-size: 12px;\r\n  line-height: 18px;\r\n}\r\n\r\n.sd-batch-bar-main {\r\n  display: flex;\r\n  align-items: center;\r\n  gap: 8px;\r\n  flex-wrap: wrap;\r\n}\r\n\r\n.sd-batch-bar-hint {\r\n  color: var(--dsw-alias-label-tertiary);\r\n}\r\n\r\n.sd-batch-bar-list-head {\r\n  display: flex;\r\n  align-items: center;\r\n  gap: 8px;\r\n  flex-wrap: wrap;\r\n}\r\n\r\n/* 汇总的第二句（含 K 个子会话）比条数轻一档，和列表行里的 chip 同级。 */\r\n.sd-batch-bar-list-head span + span {\r\n  color: var(--dsw-alias-label-tertiary);\r\n}\r\n\r\n.sd-batch-bar-list {\r\n  display: flex;\r\n  flex-direction: column;\r\n  gap: 2px;\r\n  max-height: 240px;\r\n  overflow: auto;\r\n  margin: 0;\r\n  padding: 0 0 8px;\r\n  border-bottom: 0.5px solid var(--dsw-alias-border-l4);\r\n  list-style: none;\r\n}\r\n\r\n.sd-batch-bar-item {\r\n  display: flex;\r\n  align-items: center;\r\n  gap: 8px;\r\n  min-width: 0;\r\n}\r\n\r\n.sd-batch-bar-title {\r\n  flex: 1;\r\n  min-width: 0;\r\n  overflow: hidden;\r\n  text-overflow: ellipsis;\r\n  white-space: nowrap;\r\n  color: var(--dsw-alias-label-secondary);\r\n}\r\n\r\n.sd-batch-bar-meta {\r\n  flex: none;\r\n  color: var(--dsw-alias-label-tertiary);\r\n}\r\n\r\n.sd-batch-bar-remove {\r\n  display: inline-flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  flex: none;\r\n  width: 16px;\r\n  height: 16px;\r\n  padding: 0;\r\n  border: none;\r\n  border-radius: var(--dsw-radius-xs);\r\n  background: 0 0;\r\n  color: var(--dsw-alias-label-tertiary);\r\n  cursor: pointer;\r\n}\r\n\r\n.sd-batch-bar-remove:hover {\r\n  color: var(--dsw-alias-label-primary);\r\n  background: var(--dsw-alias-interactive-bg-hover);\r\n}\r\n";
+		var ui_default = "/*\r\n * 本插件自己的控件样式（**不再 require 宿主的 `@deepseek-ai/dsh-client-ui-primitives`**）。\r\n *\r\n * 出处：逐条抄自 `@deepseek-ai/dsh-client-ui-primitives@0.2.0-rc.2` 随包发布的明文 CSS\r\n * （`lib/Button.module.css`、`Tag.module.css`、`Modal.module.css`、`Tooltip.module.css`、\r\n * `Toast.module.css`、`Menu.module.css`；2026-10-15 又加两张：`lib/Checkbox.module.css`、\r\n * `lib/DisclosureRow.module.css`，以及 `dsh-client-ui-conversation` 里的\r\n * `ConversationRoot.module.css` 的 `.widthHandle` 那一族——宿主自己那根可拖的宽度把手；\r\n * 2026-10-17 又加一张，也是首张来自 ui-primitives 之外的包：`dsh-client-ui-workspace` 的\r\n * `Rows.module.css` 的 `.iconButton` 那一族——会话行尾悬停排那颗按钮的基底（行尾兜底勾选开关\r\n * 要跟宿主自己的归档/置顶同形）。\r\n * 这是官方给第三方 UI 插件的处方：\r\n * 「copy markup, CSS, and behavior from the primitive into the plugin … Rename copied classes under\r\n * your plugin's prefix, keep only `--dsw-alias-*` token references」（宿主技能\r\n * `cordis-plugin-development/references/practices.md` 原文）。理由是那个包**随宿主换代而变、且不经类型检查**，\r\n * 一个抛错的组件会把整个槽位条目打空（控制台 `slot entry crashed in '<slot>'`）。\r\n *\r\n * 三条改写规则：\r\n * 1. **类名全部加本插件前缀 `sd-`**（原来是 CSS module 的哈希名，全局无冲突由前缀承担）。\r\n * 2. **配色一律走 token**，一个颜色的字面量都没有——所以宿主换主题、改名 token 时最差是难看，\r\n *    不会崩。几何量（圆角/阴影/层级）同样取 token；**只有字号/行高/尺寸是字面量 px**，与官方 CSS 逐字一致。\r\n * 3. **`@keyframes` 全部改名**（`sd-` 前缀）：它们是全局命名空间，撞名会互相覆盖。\r\n *\r\n * 只收本插件真正用到的部分：Button 的 `primary`/`ghost`/`outline` 三档与 `md`/`sm` 两号\r\n * （没有 `toolbar` 变体、没有 `lg`）、Tag 的 `danger` 一档、Modal 的全部骨架、Tooltip 的三个方位、\r\n * Toast 全部、Menu 行的全部（含 danger 态与 separator）、Checkbox 的全部、DisclosureRow 的\r\n * 折叠头那一半（没有 `data-state` 那档状态点）、宽度把手的视觉与光标。**没抄进来的就是本插件不用的**，\r\n * 不预先铺开——宿主那套里还有几十个变体与控件，抄全了等于把它的表面积整个搬进来。\r\n *\r\n * **七处不是抄本**：① `.sd-resizing`（拖动期间挂在面板根上、关掉文字选中）——宿主那份没有对应的类，\r\n * 它的把手由 JS 侧的 pointer capture 承担；② `[data-dsh-session-delete=\"trash-row\"]:focus-visible`\r\n * （清单那一行的键盘焦点描边，复用选中态那枚 `ghost-active-border`）——宿主那套表里行不是可聚焦\r\n * div，我们这一行是 `role=\"row\"` 且要吃 ↑↓，而这一代 `--dsw-focus-ring-color` 是 `transparent`；\r\n * ③ `.sd-rowaction-button` 的 `[aria-pressed='true']` 与 `:disabled` 两档（2026-10-17）——\r\n * 官方那颗 `iconButton` 只有常态与 hover，勾选开关要有\"按下\"和\"这条删不动\"两档，token 与回收站\r\n * 选中行同源（`--dsw-alias-button-ghost-active-*`）；④ `.sd-batch-bar`（同日）——宿主没有\"浮条\"\r\n * 这件控件，四件 token 自拼；⑤ 宿主行的批量选中底色与兜底隐藏（同日改版）——宿主的行选中态不归\r\n * 第三方，整行可见性靠 `data-row-key` + `:has`，token 与回收站选中行同源；行首格在场时行尾兜底退场；\r\n * ⑥ `.sd-batch-pick-leading`（同日）——宿主行首那格只给 16×20，勾选框要一层 inline-flex 包装才压得回\r\n * 同样大小，官方没有这层包装；⑦ `.sd-toast-action:disabled`（2026-11-01）——撤销横幅在飞时那颗动作要\r\n * 看着就按不动，官方 Toast 的 action 没有禁用档，而我们这份自带 `color`、浏览器默认置灰不生效，\r\n * 档位与③的禁用档同源（`opacity` + `not-allowed`）。\r\n * 整张表里就这七条是我们自造的，标在这里，\r\n * 下次做「与官方逐条比对」时它属于**已知差异**，不是漂移。\r\n *\r\n * **另有一处已知差异不住在本文件**：回收站组头那颗按钮的整套 UA reset。宿主 `DisclosureRow` 那份是\r\n * `div`，没有这个坑；我们这行要做成可点的 `<button>`，UA 样式表会把背景、边框、内距、字体、居中与\r\n * flex 基线一起渗进来（真机上就是项目名整条居中，2026-10-15 截图）。它写在\r\n * `src/client/trash-panel.tsx` 组头那一行的 inline 样式上，**具体 reset 了哪几项由\r\n * `tests/skeleton.test.ts` 逐条钉住**（不在这里再抄一份名单）——所以「与官方逐条比对」时本表仍然只数\r\n * 上面那些，这条不算进抄本差异。\r\n */\r\n\r\n/* ────────────────────────── Button ────────────────────────── */\r\n\r\n.sd-button {\r\n  box-sizing: border-box;\r\n  display: inline-flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  gap: 4px;\r\n  border: none;\r\n  border-radius: var(--dsw-radius-md);\r\n  cursor: pointer;\r\n  font-size: 14px;\r\n  line-height: 22px;\r\n  color: var(--dsw-alias-label-primary);\r\n  background: transparent;\r\n  padding: 0 14px;\r\n}\r\n\r\n.sd-button:disabled {\r\n  cursor: not-allowed;\r\n  opacity: 0.4;\r\n}\r\n\r\n.sd-button-md {\r\n  height: 36px;\r\n}\r\n\r\n/* 紧凑档：尺寸不随填充/描边换档（官方原文的注释即此意）。 */\r\n.sd-button-sm {\r\n  height: 28px;\r\n  font-size: 12px;\r\n  line-height: 18px;\r\n  padding: 0 10px;\r\n  border-radius: var(--dsw-radius-sm);\r\n}\r\n\r\n.sd-button-primary {\r\n  background: var(--dsw-alias-button-primary-fill);\r\n  color: var(--dsw-alias-label-primary-foreground);\r\n}\r\n\r\n.sd-button-primary:hover:not(:disabled) {\r\n  background: var(--dsw-alias-button-primary-hover);\r\n}\r\n\r\n.sd-button-ghost:hover:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-hover);\r\n}\r\n\r\n.sd-button-ghost:active:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-active);\r\n}\r\n\r\n.sd-button-outline {\r\n  border: 0.5px solid var(--dsw-alias-border-l3);\r\n  background: transparent;\r\n}\r\n\r\n.sd-button-outline:hover:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-hover);\r\n}\r\n\r\n.sd-button-icon {\r\n  display: inline-flex;\r\n  width: 16px;\r\n  height: 16px;\r\n  align-items: center;\r\n  justify-content: center;\r\n}\r\n\r\n/* ────────────────────────── Tag ────────────────────────── */\r\n\r\n/* 胶囊几何固定：一个 tag 在哪里都是同一个尺寸，只有色板随 tone 走。 */\r\n.sd-tag {\r\n  display: inline-flex;\r\n  align-items: center;\r\n  border-radius: 999px;\r\n  corner-shape: round;\r\n  padding: 1px 8px;\r\n  font-size: 11px;\r\n  line-height: 17px;\r\n  font-weight: 500;\r\n  white-space: nowrap;\r\n}\r\n\r\n/* 状态色自带填充：底色由自身颜色 10% 混出，换色板时底与字一起走，不需要第二个 token。 */\r\n.sd-tag-danger {\r\n  background: color-mix(in srgb, var(--dsw-alias-state-error-primary) 10%, transparent);\r\n  color: var(--dsw-alias-state-error-primary);\r\n}\r\n\r\n/* ────────────────────────── Modal ────────────────────────── */\r\n\r\n/* 整视口层（figma Mask + Dialog）：蒙层 + 居中卡片。四边留 24px，上下按外壳公布的浮层内缩加宽，\r\n   高卡片才不会顶到外壳。卡片按这个内边距盒取尺寸：消费方用 `max-height:100%` 收口，不自己算视口。 */\r\n.sd-modal-root {\r\n  pointer-events: auto;\r\n  position: fixed;\r\n  inset: 0;\r\n  z-index: 1000;\r\n  display: flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  padding: max(24px, var(--dsh-frame-overlay-top, 24px)) 24px;\r\n}\r\n\r\n/* 只有绘制避让原生标题栏；根仍然挡住背景点击。 */\r\n.sd-modal-mask {\r\n  position: absolute;\r\n  inset: var(--dsh-frame-chrome-top, 0px) 0 0;\r\n  backdrop-filter: var(--dsw-mask-blur);\r\n}\r\n\r\n.sd-modal-mask::after {\r\n  content: '';\r\n  position: absolute;\r\n  inset: 0;\r\n  background: var(--dsw-alias-bg-mask-1);\r\n  animation: sd-modal-enter var(--ds-transition-duration) var(--ds-ease-in-out);\r\n}\r\n\r\n.sd-modal-dialog {\r\n  box-sizing: border-box;\r\n  position: relative;\r\n  z-index: 1;\r\n  display: flex;\r\n  flex-direction: column;\r\n  gap: 20px;\r\n  width: min(380px, 100%);\r\n  padding: 0 0 24px;\r\n  overflow: hidden;\r\n  border: 0;\r\n  border-radius: var(--dsw-radius-panel);\r\n  background: var(--dsw-alias-bg-layer-2);\r\n  box-shadow: var(--dsw-elevation-prominent);\r\n  animation: sd-modal-enter var(--ds-transition-duration) var(--ds-ease-in-out);\r\n}\r\n\r\n@keyframes sd-modal-enter {\r\n  from { opacity: 0; }\r\n  to { opacity: 1; }\r\n}\r\n\r\n@media (prefers-reduced-motion: reduce) {\r\n  .sd-modal-mask::after,\r\n  .sd-modal-dialog { animation: none; }\r\n}\r\n\r\n.sd-modal-dialog:focus {\r\n  outline: none;\r\n}\r\n\r\n.sd-modal-content {\r\n  display: flex;\r\n  flex-direction: column;\r\n  width: 100%;\r\n}\r\n\r\n/* 头行：标题左、关闭钮右。 */\r\n.sd-modal-header {\r\n  display: flex;\r\n  align-items: center;\r\n  justify-content: space-between;\r\n  gap: 8px;\r\n  padding: 22px 14px 12px 24px;\r\n}\r\n\r\n.sd-modal-title {\r\n  margin: 0;\r\n  font-size: 16px;\r\n  line-height: 24px;\r\n  font-weight: 500;\r\n  color: var(--dsw-alias-label-primary);\r\n}\r\n\r\n.sd-modal-close {\r\n  flex: none;\r\n  display: inline-flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  width: 28px;\r\n  height: 28px;\r\n  border: none;\r\n  border-radius: var(--dsw-radius-sm);\r\n  background: transparent;\r\n  cursor: pointer;\r\n  color: var(--dsw-alias-label-secondary);\r\n}\r\n\r\n.sd-modal-close:hover {\r\n  background: var(--dsw-alias-interactive-bg-hover);\r\n}\r\n\r\n.sd-modal-body {\r\n  display: flex;\r\n  flex-direction: column;\r\n  min-width: 0;\r\n  margin-top: 20px;\r\n  padding: 0 24px;\r\n}\r\n\r\n.sd-modal-footer {\r\n  display: flex;\r\n  align-items: center;\r\n  justify-content: flex-end;\r\n  gap: 8px;\r\n  padding: 0 24px;\r\n}\r\n\r\n/* ────────────────────────── Tooltip ────────────────────────── */\r\n\r\n.sd-tooltip-bubble {\r\n  display: inline-flex;\r\n  align-items: center;\r\n  gap: 8px;\r\n  position: fixed;\r\n  z-index: 100;\r\n  /* 定宽收缩只按 `left` 到视口右缘量，靠右的锚点会提前折行；\r\n     `max-content` 只按文案定宽，再用半个视口收口。 */\r\n  width: max-content;\r\n  max-width: 50vw;\r\n  padding: 3px 7px;\r\n  border-radius: var(--dsw-radius-sm);\r\n  background: var(--dsw-alias-tooltip-bg);\r\n  color: var(--dsw-static-neutral-bluish-00);\r\n  font-size: 13px;\r\n  line-height: 20px;\r\n  white-space: pre-line;\r\n  /* 不可断的长 token（URL、路径）不许顶破 max-width。 */\r\n  overflow-wrap: break-word;\r\n  pointer-events: none;\r\n  animation: sd-tooltip-in 150ms var(--ds-ease-in-out);\r\n}\r\n\r\n.sd-tooltip-bubble[data-portal] { z-index: 1100; }\r\n.sd-tooltip-label { min-width: 0; }\r\n\r\n.sd-tooltip-bubble[data-side='right'] {\r\n  transform: translateY(-50%);\r\n}\r\n\r\n.sd-tooltip-bubble[data-side='bottom'] {\r\n  transform: translateX(-50%);\r\n}\r\n\r\n.sd-tooltip-bubble[data-side='top'] {\r\n  transform: translate(-50%, -100%);\r\n}\r\n\r\n@keyframes sd-tooltip-in {\r\n  from { opacity: 0; }\r\n}\r\n\r\n@media (prefers-reduced-motion: reduce) {\r\n  .sd-tooltip-bubble {\r\n    animation: none;\r\n  }\r\n}\r\n\r\n/* ────────────────────────── Toast ────────────────────────── */\r\n\r\n/* 淡出延迟由组件以 `--dsh-toast-hold` 给出 ⇒ 同一个值同时驱动卸载计时器与这段动画，\r\n   两者不可能再对不上。淡出**时长**仍需与组件里的 FADE_MS 一致（没有 owner 会改它）。 */\r\n.sd-toast {\r\n  position: fixed;\r\n  top: 40px;\r\n  left: 50%;\r\n  /* 高过图片灯箱底层的 1000：预览开着时报错也必须读得到。 */\r\n  z-index: 1100;\r\n  /* 通告不截点击。 */\r\n  pointer-events: none;\r\n  display: flex;\r\n  align-items: center;\r\n  gap: 10px;\r\n  /* 定宽盒设了 `left` 只按右侧空间收缩（-50% 的位移发生在定尺之后）⇒ 靠窗边的横幅会提前折行。\r\n     `max-content` 只按文案定宽，再由下面的 max-width 收口。 */\r\n  width: max-content;\r\n  max-width: min(640px, calc(100vw - 48px));\r\n  padding: 12px 16px;\r\n  border-radius: var(--dsw-radius-lg);\r\n  /* 设计平台的 toast 表面在**两套主题下都是深的**（浅色 bluish-800 / 深色 bluish-750），\r\n     所以这里的字色与动作色是固定值，不随主题翻转。 */\r\n  background: var(--dsw-alias-toast-bg);\r\n  color: var(--dsw-alias-toast-label);\r\n  font-size: 14px;\r\n  line-height: 22px;\r\n  box-shadow: var(--dsw-shadow-lv3);\r\n  transform: translateX(-50%);\r\n  animation:\r\n    sd-toast-in 160ms ease-out,\r\n    sd-toast-fade 1000ms ease var(--dsh-toast-hold, 3000ms) forwards;\r\n}\r\n\r\n.sd-toast-icon {\r\n  display: grid;\r\n  place-items: center;\r\n  flex: none;\r\n  color: var(--dsw-alias-state-warn-label);\r\n}\r\n\r\n.sd-toast-icon-success {\r\n  color: var(--dsw-alias-state-success-primary);\r\n}\r\n\r\n.sd-toast-text {\r\n  min-width: 0;\r\n}\r\n\r\n.sd-toast-action {\r\n  display: inline;\r\n  padding: 0;\r\n  border: 0;\r\n  background: none;\r\n  color: var(--dsw-static-deepseek-400);\r\n  font: inherit;\r\n  cursor: pointer;\r\n  /* 动作文字与周围文案之间的呼吸位。 */\r\n  margin-inline: 3px;\r\n  /* 横幅表面整体是穿透点击的，只有动作文字接指针。 */\r\n  pointer-events: auto;\r\n}\r\n\r\n.sd-toast-action:hover {\r\n  opacity: 0.8;\r\n}\r\n\r\n/* 本插件自造的第七条（不是抄本，见文件头点名）：撤销横幅在飞时那颗动作要**看着就按不动**。\r\n   官方 Toast 的 action 只有常态与 hover，没有禁用档；而 `.sd-toast-action` 自带 `color`，\r\n   浏览器默认的置灰根本不生效（真机上只会看见一个光标照常是手、点下去没反应的「撤销」）。\r\n   禁用档与行尾勾选开关同源（`opacity` + `not-allowed`），不新造颜色。 */\r\n.sd-toast-action:disabled {\r\n  opacity: 0.4;\r\n  cursor: not-allowed;\r\n}\r\n\r\n@keyframes sd-toast-in {\r\n  from {\r\n    opacity: 0;\r\n    transform: translate(-50%, -6px);\r\n  }\r\n\r\n  to {\r\n    opacity: 1;\r\n    transform: translate(-50%, 0);\r\n  }\r\n}\r\n\r\n@keyframes sd-toast-fade {\r\n  to {\r\n    opacity: 0;\r\n    visibility: hidden;\r\n  }\r\n}\r\n\r\n/* 减动效去掉滑入；延迟淡出（透明度变化、不是位移）仍然在定时卸载前收掉横幅。 */\r\n@media (prefers-reduced-motion: reduce) {\r\n  .sd-toast {\r\n    animation: sd-toast-fade 1000ms ease var(--dsh-toast-hold, 3000ms) forwards;\r\n  }\r\n}\r\n\r\n/* ────────────────────────── 菜单行 ────────────────────────── */\r\n\r\n.sd-menu-item-wrap {\r\n  position: relative;\r\n}\r\n\r\n/* 菜单格：紧凑文字、图标与选中间距。 */\r\n.sd-menu-item {\r\n  display: flex;\r\n  align-items: center;\r\n  gap: 6px;\r\n  width: 100%;\r\n  min-height: 34px;\r\n  padding: 6px 8px;\r\n  border: none;\r\n  border-radius: var(--dsw-radius-md);\r\n  background: transparent;\r\n  cursor: pointer;\r\n  font-size: 13px;\r\n  line-height: 20px;\r\n  color: var(--dsw-alias-label-primary);\r\n  text-align: left;\r\n}\r\n\r\n.sd-menu-item:hover:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-hover);\r\n}\r\n\r\n/* 方向键移动的是真焦点 ⇒ 键盘所在的那一行拿指针同款填充；填充就是这一行的焦点呈现，\r\n   浏览器默认的 ring 再叠一层就重了。 */\r\n.sd-menu-item:focus-visible:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-hover);\r\n  outline: none;\r\n}\r\n\r\n.sd-menu-item:disabled {\r\n  opacity: 0.4;\r\n  cursor: not-allowed;\r\n}\r\n\r\n.sd-menu-item-icon {\r\n  display: inline-flex;\r\n  flex: none;\r\n  width: 14px;\r\n  height: 14px;\r\n  align-items: center;\r\n  justify-content: center;\r\n  color: var(--dsw-alias-menu-icon);\r\n}\r\n\r\n.sd-menu-item-icon svg {\r\n  width: 14px;\r\n  height: 14px;\r\n}\r\n\r\n.sd-menu-item-label {\r\n  flex: 1;\r\n  min-width: 0;\r\n  overflow: hidden;\r\n  text-overflow: ellipsis;\r\n  white-space: nowrap;\r\n}\r\n\r\n/* 破坏性行：error 字/图标 + danger 悬停底。 */\r\n.sd-menu-item-danger {\r\n  color: var(--dsw-alias-state-error-primary);\r\n}\r\n\r\n.sd-menu-item-danger .sd-menu-item-icon {\r\n  color: var(--dsw-alias-state-error-primary);\r\n}\r\n\r\n.sd-menu-item-danger:hover:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-hover-danger);\r\n}\r\n\r\n.sd-menu-item-danger:focus-visible:not(:disabled) {\r\n  background: var(--dsw-alias-interactive-bg-hover-danger);\r\n  outline: none;\r\n}\r\n\r\n/* 分隔格：发丝线上下的间距。取 l2 而不是 l1——l1 在这个表面上几乎看不见。 */\r\n.sd-menu-separator {\r\n  height: 0.5px;\r\n  margin: 3px 2px;\r\n  background: var(--dsw-alias-border-l2);\r\n}\r\n\r\n/* ────────────────────────── Checkbox ────────────────────────── */\r\n/* 抄 `lib/Checkbox.module.css` 全部四条声明，逐字。勾选框本体是**原生 input** + `accent-color`，\r\n   不是自绘的圆框——回收站多选态用它（清单行左侧那一格）。 */\r\n\r\n.sd-checkbox {\r\n  display: inline-flex;\r\n  align-items: center;\r\n  gap: 6px;\r\n  font-size: 14px;\r\n  line-height: 20px;\r\n  color: var(--dsw-alias-label-primary);\r\n  cursor: pointer;\r\n}\r\n\r\n.sd-checkbox input {\r\n  flex: 0 0 auto;\r\n  width: 16px;\r\n  height: 16px;\r\n  margin: 0;\r\n  accent-color: var(--dsw-alias-brand-primary);\r\n  cursor: inherit;\r\n}\r\n\r\n.sd-checkbox input:focus-visible {\r\n  outline: var(--dsw-focus-ring-width) solid var(--dsw-focus-ring-color, var(--dsw-alias-state-business-primary));\r\n  outline-offset: 2px;\r\n}\r\n\r\n.sd-checkbox:has(input:disabled) {\r\n  cursor: default;\r\n  opacity: 0.5;\r\n}\r\n\r\n/* ────────────────────────── DisclosureRow（分组折叠头） ────────────────────────── */\r\n/* 抄 `lib/DisclosureRow.module.css` 的 `.root`/`.row`/`.leading`/`.title` 与那两枚 glyph 的\r\n   显隐。没抄进来的是 `StateDot`（`svg[data-state]`）那一档——它说\"这是状态标记不是文字装饰\"，\r\n   我们的组头没有状态点。行高与 leading 盒走 `--dsh-content-font-delta` 那根轴，\r\n   标题字号走 secondary 档：宿主的\"设置里调正文字号\"会一起推着它走。 */\r\n\r\n.sd-disclosure {\r\n  display: flex;\r\n  flex-direction: column;\r\n  width: 100%;\r\n  min-width: 0;\r\n}\r\n\r\n.sd-disclosure-row {\r\n  position: relative;\r\n  overflow: hidden;\r\n  display: flex;\r\n  align-items: center;\r\n  height: calc(24px + var(--dsh-content-font-delta, 0px));\r\n  min-width: 0;\r\n  color: var(--dsw-alias-label-tertiary);\r\n  transition: color 100ms ease;\r\n}\r\n\r\n.sd-disclosure-row[data-expandable] {\r\n  cursor: pointer;\r\n}\r\n\r\n.sd-disclosure-row:hover {\r\n  color: var(--dsw-alias-label-secondary);\r\n}\r\n\r\n.sd-disclosure-leading {\r\n  position: relative;\r\n  flex: none;\r\n  width: calc(16px + var(--dsh-content-font-delta, 0px));\r\n  height: calc(16px + var(--dsh-content-font-delta, 0px));\r\n  display: inline-flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  margin-right: 6px;\r\n  padding: 0;\r\n  border: none;\r\n  background: none;\r\n  color: inherit;\r\n}\r\n\r\n.sd-disclosure-leading svg:not([data-state]) {\r\n  width: calc(14px + var(--dsh-content-font-delta, 0px));\r\n  height: calc(14px + var(--dsh-content-font-delta, 0px));\r\n}\r\n\r\nbutton.sd-disclosure-leading {\r\n  cursor: pointer;\r\n}\r\n\r\n.sd-disclosure-title {\r\n  flex: none;\r\n  font-size: var(--dsh-content-font-size-secondary, 13px);\r\n  line-height: calc(24px + var(--dsh-content-font-delta, 0px));\r\n  color: inherit;\r\n}\r\n\r\n@media (prefers-reduced-motion: reduce) {\r\n  .sd-disclosure-row {\r\n    transition: none;\r\n  }\r\n}\r\n\r\n/* ────────────────────────── 宽度把手（可拖的分栏线） ────────────────────────── */\r\n/* 抄 `ConversationRoot.module.css` 的 `.widthHandle` 一族：10px 的命中区、`col-resize` 光标、\r\n   平时不画、悬停或拖动时才浮出一条 2px 的 `--dsw-alias-scrollbar-bg-l1` 短标（那条渐变里\r\n   `--dsh-width-handle-pointer-y` 的兜底是 50%，宿主靠 JS 跟着指针走；我们不跟，\r\n   停在中间——少一条 pointermove 上的写字，视觉上是同一族东西）。\r\n   与宿主的差别只有位置：它绝对定位在会话栏两侧，我们这根住在两栏之间的那一格 flex 位里，\r\n   所以 `top/bottom/position` 那三样交给内联布局，这里只留视觉与光标。 */\r\n\r\n.sd-width-handle {\r\n  position: relative;\r\n  z-index: 0;\r\n  cursor: col-resize;\r\n  align-self: stretch;\r\n  flex: 0 0 10px;\r\n  width: 10px;\r\n  padding: 0;\r\n  border: none;\r\n  background: none;\r\n}\r\n\r\n.sd-width-handle::after {\r\n  content: \"\";\r\n  background: linear-gradient(\r\n    to bottom,\r\n    transparent calc(var(--dsh-width-handle-pointer-y, 50%) - 36px),\r\n    var(--dsw-alias-scrollbar-bg-l1) calc(var(--dsh-width-handle-pointer-y, 50%) - 8px),\r\n    var(--dsw-alias-scrollbar-bg-l1) calc(var(--dsh-width-handle-pointer-y, 50%) + 8px),\r\n    transparent calc(var(--dsh-width-handle-pointer-y, 50%) + 36px)\r\n  );\r\n  opacity: 0;\r\n  pointer-events: none;\r\n  border-radius: 2px;\r\n  width: 2px;\r\n  position: absolute;\r\n  top: 0;\r\n  bottom: 0;\r\n  left: 4px;\r\n}\r\n\r\n.sd-width-handle:hover::after,\r\n.sd-width-handle[data-dragging]::after {\r\n  opacity: 1;\r\n}\r\n\r\n.sd-width-handle:focus-visible {\r\n  outline: none;\r\n}\r\n\r\n.sd-width-handle:focus-visible::after {\r\n  opacity: 1;\r\n}\r\n\r\n/* 本插件自造的第一条（不是抄本，见文件头点名）：拖动期间整块面板别把文字选上了。 */\r\n.sd-resizing {\r\n  user-select: none;\r\n  cursor: col-resize;\r\n}\r\n\r\n/* 本插件自造的第二条（不是抄本，见文件头点名）：清单行是 `role=\"row\"` 的可聚焦 div，而这一代\r\n   `--dsw-focus-ring-color` 逐字是 `transparent`（2026-10-15 实测）——不自己描一条，键盘走\r\n   ↑↓ 选会话时就没有任何焦点可见性。描边**复用选中态那枚** `ghost-active-border`，不新造颜色；\r\n   0.5px 与 `outline-offset: 1px` 是行的描边宽度与一档外移，不动布局（outline 不进滚动区）。 */\r\n[data-dsh-session-delete=\"trash-row\"]:focus-visible {\r\n  outline: 0.5px solid var(--dsw-alias-button-ghost-active-border);\r\n  outline-offset: 1px;\r\n}\r\n\r\n/* 会话行尾悬停排那颗**兜底**勾选开关（状态点行 / 归档行；行首主勾选是原生 Checkbox）。\r\n   基底**逐字抄** `dsh-client-ui-workspace` 的 `Rows.module.css` 的 `.iconButton` / `.iconButton:hover`，\r\n   只改类名——兜底开关要跟同排宿主自己的归档/置顶同形，尺寸与色档都不自己发明。 */\r\n.sd-rowaction-button {\r\n  border-radius: var(--dsw-radius-xs);\r\n  cursor: pointer;\r\n  width: 16px;\r\n  height: 16px;\r\n  color: var(--dsw-alias-label-tertiary);\r\n  background: 0 0;\r\n  border: none;\r\n  flex: none;\r\n  justify-content: center;\r\n  align-items: center;\r\n  padding: 0;\r\n  display: inline-flex;\r\n}\r\n.sd-rowaction-button:hover {\r\n  color: var(--dsw-alias-label-primary);\r\n}\r\n\r\n/* 本插件自造的第三条（不是抄本，见文件头点名）：官方那颗只有常态与 hover，勾选开关还要有\r\n   「已按下」与「这条删不动」两档。按下档**复用回收站选中行那两枚** `ghost-active-*`，不新造颜色；\r\n   禁用档走 opacity。 */\r\n.sd-rowaction-button[aria-pressed='true'] {\r\n  background: var(--dsw-alias-button-ghost-active-fill);\r\n  box-shadow: inset 0 0 0 1px var(--dsw-alias-button-ghost-active-border);\r\n  color: var(--dsw-alias-label-primary);\r\n}\r\n.sd-rowaction-button:disabled {\r\n  opacity: 0.4;\r\n  cursor: not-allowed;\r\n}\r\n\r\n/* 本插件自造的第⑥条（不是抄本，见文件头点名）：行首 16px 格里的勾选框（2026-10-17 改版，**只在\r\n   多选模式内渲染**）。格本身由宿主居中（16×20），这里只把包装层压成同样大小；勾选框本体是回收站\r\n   多选同款原生 input（`.sd-checkbox`，见上）。 */\r\n.sd-batch-pick-leading {\r\n  display: inline-flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n}\r\n\r\n/* 本插件自造的第⑤条（不是抄本，见文件头点名）：宿主行自己的选中态只归它自己，批量选择要有整行\r\n   底色；行首格在场时行尾兜底要退场（两条入口不许同屏）。两条都只认宿主行已有的\r\n   `data-row-key`；将来这个属性改名，最差是底色不亮 / 兜底多露一颗，勾选本身仍在。 */\r\n[data-row-key^=\"session:\"]:has([data-dsh-session-delete=\"batch-pick\"][data-checked=\"true\"]) {\r\n  background: var(--dsw-alias-button-ghost-active-fill);\r\n  box-shadow: inset 0 0 0 0.5px var(--dsw-alias-button-ghost-active-border);\r\n}\r\n[data-row-key^=\"session:\"]:has([data-dsh-session-delete=\"batch-pick\"][data-seat=\"leading\"]) .sd-batch-pick-action {\r\n  display: none;\r\n}\r\n\r\n/* 本插件自造的第四条（不是抄本，见文件头点名）：批量删除的浮条。宿主没有\"浮条\"这件控件，形状照\r\n   本插件自己的浮层口径来——固定底部居中，表面/描边/圆角/高程四件全走 token（与单删那张目标卡同源）。\r\n   **层级必须低于确认框（`.sd-modal-root` 1000）**：2026-10-17 真机发现浮条在 1100 时会盖住确认框、\r\n   还能抢它的按钮；撤销横幅与 Tooltip 是瞬时通告、保持 1100。列方向：清单在上、操作行在下；\r\n   清单限高可滚，默认收起（见 `batch-bar.tsx`）。**宽度按内容展开**（`max-content`，最多视口减 48）：\r\n   只写 `left:50% + width:auto` 时 shrink-to-fit 只拿左半屏，新增「全选/取消全选」后会把「退出多选」\r\n   挤到第二行；窄到 max-width 还放不下才由 `.sd-batch-bar-main` 的 `flex-wrap` 兜底。 */\r\n.sd-batch-bar {\r\n  position: fixed;\r\n  bottom: 24px;\r\n  left: 50%;\r\n  transform: translateX(-50%);\r\n  z-index: 900;\r\n  width: max-content;\r\n  max-width: calc(100vw - 48px);\r\n  display: flex;\r\n  flex-direction: column;\r\n  align-items: stretch;\r\n  gap: 8px;\r\n  padding: 8px 12px;\r\n  background: var(--dsw-alias-bg-layer-2);\r\n  border: 0.5px solid var(--dsw-alias-border-l4);\r\n  border-radius: var(--dsw-radius-lg);\r\n  box-shadow: var(--dsw-elevation-prominent);\r\n  font-size: 12px;\r\n  line-height: 18px;\r\n}\r\n\r\n.sd-batch-bar-main {\r\n  display: flex;\r\n  align-items: center;\r\n  gap: 8px;\r\n  flex-wrap: wrap;\r\n}\r\n\r\n.sd-batch-bar-hint {\r\n  color: var(--dsw-alias-label-tertiary);\r\n}\r\n\r\n.sd-batch-bar-list-head {\r\n  display: flex;\r\n  align-items: center;\r\n  gap: 8px;\r\n  flex-wrap: wrap;\r\n}\r\n\r\n/* 汇总的第二句（含 K 个子会话）比条数轻一档，和列表行里的 chip 同级。 */\r\n.sd-batch-bar-list-head span + span {\r\n  color: var(--dsw-alias-label-tertiary);\r\n}\r\n\r\n.sd-batch-bar-list {\r\n  display: flex;\r\n  flex-direction: column;\r\n  gap: 2px;\r\n  max-height: 240px;\r\n  overflow: auto;\r\n  margin: 0;\r\n  padding: 0 0 8px;\r\n  border-bottom: 0.5px solid var(--dsw-alias-border-l4);\r\n  list-style: none;\r\n}\r\n\r\n.sd-batch-bar-item {\r\n  display: flex;\r\n  align-items: center;\r\n  gap: 8px;\r\n  min-width: 0;\r\n}\r\n\r\n.sd-batch-bar-title {\r\n  flex: 1;\r\n  min-width: 0;\r\n  overflow: hidden;\r\n  text-overflow: ellipsis;\r\n  white-space: nowrap;\r\n  color: var(--dsw-alias-label-secondary);\r\n}\r\n\r\n.sd-batch-bar-meta {\r\n  flex: none;\r\n  color: var(--dsw-alias-label-tertiary);\r\n}\r\n\r\n.sd-batch-bar-remove {\r\n  display: inline-flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  flex: none;\r\n  width: 16px;\r\n  height: 16px;\r\n  padding: 0;\r\n  border: none;\r\n  border-radius: var(--dsw-radius-xs);\r\n  background: 0 0;\r\n  color: var(--dsw-alias-label-tertiary);\r\n  cursor: pointer;\r\n}\r\n\r\n.sd-batch-bar-remove:hover {\r\n  color: var(--dsw-alias-label-primary);\r\n  background: var(--dsw-alias-interactive-bg-hover);\r\n}\r\n";
 		//#endregion
 		//#region src/client/ui/markdown.css?dsh-css-text
 		var markdown_default = "/**\r\n * 回收站详情里**会话正文**的排版（2026-10-15 真机反馈后新增）。\r\n *\r\n * 为什么单独一个文件而不并进 `ui.css`：`ui.css` 是\"照官方 primitives 逐字抄来的那一份表\"，\r\n * 那条 fidelity 核对（`docs/development.md` 的界面保真复核门）要的是它与官方明文**逐属性零差异**，只许文件头点名的几类例外\r\n * （类名前缀、`@keyframes` 改名，外加它点名的自造与已声明的差别）；条数不钉在这里，钉了就会漂成假基线。这一份抄的是\r\n * **另一个来源**（宿主 markdown 那一张表），混进去就把那份核对弄脏了。\r\n *\r\n * **来源（逐字抄，只改选择器与下面点名的三处）**：\r\n * `app.asar` 里 `@deepseek-ai/dsh-client-ui-primitives/lib/markdown/MarkdownText.module.css`\r\n * （`.markdown` 那一支；`.compact` 一支我们不用）+ `lib/markdown/CodeBlock.module.css` 的 `pre`。\r\n * token 名一个没换：`--dsw-font-markdown-*` / `--dsw-alias-markdown-*` / `--dsh-content-font-*`\r\n * 全是宿主会话区自己吃的那组，所以宿主调内容字号时，这里跟着一起动。\r\n *\r\n * 三处**有意**的差异，每条都是因为我们的 DOM 长不出宿主那个节点：\r\n * ① 宿主给表包一层 `.tableScroll`（div）再横向滚动；react-markdown 不产这层 ⇒ 滚动挂在 `table`\r\n *    自己身上（`display:block` + 匿名表盒）。这条得真机量过才算成立。\r\n * ② 宿主的代码卡有 banner 行（语言名 + 复制），四个圆角被拆成\"上圆角在 banner、下圆角在 pre\"；\r\n *    我们没有 banner ⇒ 圆角整块给 `pre`。\r\n * ③ 宿主的链接可点（点开外链/文件），我们不碰宿主导航，链接渲成不可点的文本 ⇒ 保留链接色与字重，\r\n *    **去掉** hover 的下划线（那是\"点我\"的邀请）。\r\n *\r\n * 抄过来但用不上的选择器已删：`.fileLink` / `.fileMention` / `.linkIcon` / `.image` / `.imageAlt`\r\n * （图片渲成本地化占位，见 `copy.ts` 的 `detail.image` / `detail.image.alt`）/ `.katex-display` /\r\n * `:global(.md-code-block)` / `.shiki`（高亮由宿主的 highlighter 提供，我们没有）。\r\n */\r\n.sd-md {\r\n  min-width: 0;\r\n  overflow-wrap: anywhere;\r\n  font: var(--dsw-font-markdown-base);\r\n  color: var(--dsw-alias-label-primary);\r\n}\r\n\r\n.sd-md strong {\r\n  font-weight: 600;\r\n}\r\n\r\n.sd-md h1 {\r\n  font: var(--dsw-font-markdown-h1);\r\n  margin: 32px 0 16px;\r\n}\r\n\r\n.sd-md h2 {\r\n  font: var(--dsw-font-markdown-h2);\r\n  margin: 32px 0 16px;\r\n}\r\n\r\n.sd-md h3 {\r\n  font: var(--dsw-font-markdown-h3);\r\n  margin: 32px 0 16px;\r\n}\r\n\r\n.sd-md h4 {\r\n  font: var(--dsw-font-markdown-h4);\r\n  margin: 16px 0;\r\n}\r\n\r\n.sd-md :where(h5, h6) {\r\n  font: var(--dsw-font-markdown-base-strong);\r\n  margin: 16px 0;\r\n}\r\n\r\n.sd-md :where(h1, h2, h3, h4, h5, h6) strong {\r\n  font-weight: inherit;\r\n}\r\n\r\n.sd-md p {\r\n  margin: 16px 0;\r\n}\r\n\r\n/* Tighten h4–h6 against a following list (design: 8px gap). */\r\n.sd-md :where(h4, h5, h6) + :where(ul, ol) {\r\n  margin-top: 8px;\r\n}\r\n\r\n.sd-md :where(h4, h5, h6):has(+ :where(ul, ol)) {\r\n  margin-bottom: 8px;\r\n}\r\n\r\n/* 见文件头差异③：颜色与字重照抄，hover 的 dotted 下划线不抄——这里没有可点的东西。 */\r\n.sd-md-link {\r\n  color: var(--dsw-alias-link);\r\n  font-weight: 500;\r\n}\r\n\r\n.sd-md :where(ul, ol) {\r\n  margin: 16px 0;\r\n  padding-left: 18px;\r\n}\r\n\r\n.sd-md li:not(:first-child) {\r\n  margin-top: 6px;\r\n}\r\n\r\n.sd-md li > :where(ul, ol) {\r\n  margin-top: 4px;\r\n}\r\n\r\n.sd-md li::marker {\r\n  line-height: 24px;\r\n  color: var(--dsw-alias-label-secondary);\r\n}\r\n\r\n/* Nested ol under ul/ol: markers inside (models sometimes emit this shape). */\r\n.sd-md :where(ul, ol) ol {\r\n  list-style-position: inside;\r\n  padding-left: 0;\r\n}\r\n\r\n.sd-md :where(ul, ol) ol li p {\r\n  display: inline;\r\n}\r\n\r\n.sd-md li > p {\r\n  margin: 8px 0;\r\n}\r\n\r\n.sd-md li > *:first-child {\r\n  margin-top: 0;\r\n}\r\n\r\n.sd-md li > *:last-child {\r\n  margin-bottom: 0;\r\n}\r\n\r\n.sd-md hr {\r\n  display: block;\r\n  border: none;\r\n  height: 0.5px;\r\n  margin: 32px 0;\r\n  background: var(--dsw-alias-border-l2);\r\n}\r\n\r\n.sd-md blockquote {\r\n  border-left: 2px solid var(--dsw-alias-label-caption);\r\n  margin: 16px 0 0;\r\n  padding-left: 14px;\r\n}\r\n\r\n/* 代码卡：宿主的卡片由 `.block`（底色+圆角）与其内 `pre`（字号+内边距）两层拼成。\r\n   我们只有 `pre` 这一层，所以两层的声明合成在这里——见文件头差异②。 */\r\n.sd-md pre {\r\n  font: var(--dsw-font-markdown-code-block);\r\n  margin: 16px 0;\r\n  padding: 16px;\r\n  color: var(--dsw-alias-label-primary);\r\n  background: var(--dsw-alias-markdown-code-block);\r\n  border-radius: var(--dsw-radius-lg);\r\n  overflow-x: auto;\r\n  white-space: pre-wrap;\r\n  word-break: break-all;\r\n}\r\n\r\n.sd-md pre code {\r\n  font: inherit;\r\n  background: none;\r\n  padding: 0;\r\n}\r\n\r\n.sd-md :not(pre) > code {\r\n  display: inline-flex;\r\n  align-items: center;\r\n  box-sizing: border-box;\r\n  font: var(--dsw-font-markdown-code);\r\n  font-family: var(--ds-font-family-code);\r\n  font-size: 0.875em !important;\r\n  background-color: var(--dsw-alias-markdown-inline-code);\r\n  border: 0.5px solid var(--dsw-alias-border-l1);\r\n  border-radius: var(--dsw-radius-sm);\r\n  padding: 0 5px;\r\n}\r\n\r\n.sd-md :where(h1, h2, h3, h4, h5, h6) code {\r\n  font: inherit;\r\n  font-family: var(--ds-font-family-code);\r\n}\r\n\r\n.sd-md input[type='checkbox'] {\r\n  margin: 0 8px 0 0;\r\n  accent-color: var(--dsw-alias-label-secondary);\r\n}\r\n\r\n/* 见文件头差异①：宿主是 `.tableScroll > table`，我们没有那层 div。 */\r\n.sd-md table {\r\n  display: block;\r\n  box-sizing: border-box;\r\n  max-width: 100%;\r\n  overflow-x: auto;\r\n  overscroll-behavior-x: contain;\r\n  border-collapse: collapse;\r\n  width: max-content;\r\n}\r\n\r\n.sd-md th {\r\n  text-align: start;\r\n  padding: 10px 16px;\r\n  border-bottom: 0.5px solid var(--dsw-alias-border-l3);\r\n  border-top: none;\r\n  font: var(--dsw-font-markdown-table-head);\r\n  max-width: 320px;\r\n  max-width: min(30vw, 320px);\r\n  min-width: 100px;\r\n}\r\n\r\n.sd-md td {\r\n  padding: 10px 16px;\r\n  border-bottom: 0.5px solid var(--dsw-alias-border-l2);\r\n  font: var(--dsw-font-markdown-table);\r\n  max-width: 320px;\r\n  max-width: min(30vw, 320px);\r\n  min-width: 100px;\r\n}\r\n\r\n.sd-md th:first-child,\r\n.sd-md td:first-child {\r\n  padding-left: 0;\r\n}\r\n\r\n.sd-md td:last-child {\r\n  padding-right: 0;\r\n}\r\n\r\n.sd-md table code {\r\n  font-size: 11px;\r\n}\r\n\r\n.sd-md > *:first-child,\r\n.sd-md p:first-child {\r\n  margin-top: 0 !important;\r\n}\r\n\r\n.sd-md > *:last-child,\r\n.sd-md p:last-child {\r\n  margin-bottom: 0 !important;\r\n}\r\n\r\n/* 图片在回收站里读不到（路径属于会话当时的 cwd），渲成一句说明，字色用宿主的 tertiary。 */\r\n.sd-md-image {\r\n  color: var(--dsw-alias-label-tertiary);\r\n  font-style: italic;\r\n}\r\n";
@@ -1689,21 +1840,6 @@ window.__ModuleLoader__.load({
 		//#endregion
 		//#region src/client/batch-select.tsx
 		/**
-		* 宿主列表批量删除的**控件面**：行首勾选框、行尾兜底开关，
-		* 以及确认框/浮条读的那一份计数问句。
-		*
-		* 入口在每行的「⋯」菜单里（`batch-menu-item.tsx`）：**按下才进入多选模式**，模式内才渲染勾选框、
-		* 才把整行点击变成"勾/取消"；退出模式清空名单。选中集只住 `batch-selection-store.ts`（模式 + 名单一份
-		* 合并快照）；"哪些行现在可见、点行算不算选中"只住 `host-rows.ts`。四处隔着槽位边界，只有模块级
-		* store 能让他们看见同一份名单；本文件不再持有任何现场。
-		*
-		* **为什么主勾选在行首**：宿主对行尾 `.rowActions` 是 `display:none`，只有 `row:hover` / 菜单打开
-		* 才出现（app.asar 0.2.0-rc.2 的 Rows 渲染）；行首 16px 格在无状态点时是空的，模式内可见。
-		* 宿主在「有状态点（运行中/待确认/未读完成）」与归档行不渲染行首格 ⇒ 这些行走行尾悬停兜底，
-		* 但模式内**点整行**也能选（`host-rows.ts` 的 `useSelectionRowClickGuard`），所以不依赖那颗小框。
-		* 两条勾选不会同时出现（`ui.css` 的 `:has` 兜底隐藏规则，靠宿主行的 `data-row-key`）。
-		*/
-		/**
 		* 一组会话的子会话计数（`/apply` 的 `action:'count'`，纯读、不进串行链）。
 		*
 		* **一条读不到就整份返回 null** ——界面上那两个数（浮条的 K、确认框的 K 与逐条 M）都是合计，
@@ -1724,8 +1860,12 @@ window.__ModuleLoader__.load({
 		* （行首格在宿主行那条 `onClick` 里面）。宿主对「有状态点」和归档行不渲染这一格，
 		* 那些行走 `BatchPickButton` 兜底；两条不会同时出现（见 `ui.css` 的兜底隐藏规则）。
 		*/
-		function BatchPickCheckbox({ sessionId, title, t = zhTranslate }) {
+		function BatchPickCheckbox({ sessionId, title, live = false, t = zhTranslate }) {
 			const { selecting, picks } = useSelection();
+			useHostRowRegistration(sessionId, {
+				title,
+				live
+			});
 			const on = picks.some((candidate) => candidate.sessionId === sessionId);
 			if (!selecting) return null;
 			const name = title === "" ? t("common.untitled") : title;
@@ -1754,16 +1894,10 @@ window.__ModuleLoader__.load({
 		function BatchPickButton({ sessionId, title, live = false, t = zhTranslate }) {
 			const { selecting, picks } = useSelection();
 			const on = picks.some((candidate) => candidate.sessionId === sessionId);
-			(0, react.useEffect)(() => {
-				registerHostRowInfo(sessionId, {
-					title,
-					live
-				});
-			}, [
-				sessionId,
+			useHostRowRegistration(sessionId, {
 				title,
 				live
-			]);
+			});
 			if (!selecting) return null;
 			const name = title === "" ? t("common.untitled") : title;
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Tooltip, {
@@ -1794,21 +1928,26 @@ window.__ModuleLoader__.load({
 		//#endregion
 		//#region src/client/busy-gate.ts
 		/**
-		* 「这一趟还算忙」的一枚闸——面板与两个确认框共用的一份实现（各面各持一枚实例）。
+		* 「这一趟还算忙」的一枚闸——面板、两个确认框与撤销横幅共用的一份实现（各面各持一枚实例）。
 		*
-		* 为什么收回一处：三个面要的是同一套判据，各写一份只会漂移出第二套。闸的判据只有一条：
-		* 任务落地或抛错都把 busy 放回 false；不做引用计数——同一实例同一时刻只跑一趟写动作，多一层计数
+		* 为什么收回一处：各面要的是同一套判据，各写一份只会漂移出第二套。闸的判据只有两条：
+		* 任务落地或抛错都把 busy 放回 false；同一实例同一时刻只跑一趟——在飞时再包一趟会被**同步**
+		* 挡回（`busy` 是 state，要等下一拍才上屏，同一 tick 的连点拦不住），不做引用计数，多一层计数
 		* 只会把「这一趟什么时候算完」变成第二个判据。
 		*
-		* 边界：闸只拥有 busy 的生命周期，不拥有防抖、不拥有排队、不拥有重读（那是 `runWrite` 的整趟）。
+		* 边界：闸只拥有 busy 的生命周期与同实例防重，不拥有防抖、不拥有排队、不拥有重读（那是 `runWrite` 的整趟）。
 		*/
 		function useBusyGate() {
 			const [busy, setBusy] = (0, react.useState)(false);
+			const flying = (0, react.useRef)(false);
 			const around = (0, react.useCallback)(async (task) => {
+				if (flying.current) return void 0;
+				flying.current = true;
 				setBusy(true);
 				try {
 					return await task();
 				} finally {
+					flying.current = false;
 					setBusy(false);
 				}
 			}, []);
@@ -2018,7 +2157,7 @@ window.__ModuleLoader__.load({
 		/**
 		* 回收站清单的**失效通告台**：动过回收站的动作戳一下，清单面板据此重新取数。
 		*
-		* 为什么需要它（真机反馈）：回收站面板是「挂载时取一次数」（`useEffect(refreshAll)`），而删除发生在
+		* 为什么需要它（真机反馈）：回收站面板是「挂载时取一次数」（`useEffect(reload)`），而删除发生在
 		* **侧栏菜单**那边（`delete-confirm.tsx` 的常驻宿主），两者没有共同的父组件——删完之后中央那个
 		* 面板（如果正开着）不会自己重读，用户得切走再切回来（= 重新挂载）才看得见新条目。撤销（`undo-notices.ts`）
 		* 同理。
@@ -2105,23 +2244,117 @@ window.__ModuleLoader__.load({
 			}));
 		}
 		//#endregion
+		//#region src/client/pending-open.ts
+		/**
+		* 重开等待的唯一生命周期：一张票、一条订阅、一个放弃 timer、一次 settle/cleanup。
+		*
+		* ADR-0036 的语义不变：**订阅优先、出现即开、最多等一个放弃边界、不轮询**。这里把这段状态机
+		* 收成一个可取消句柄：调用方 `schedule` 一次、`cancel` 一次；票、订阅、timer 与 settle 标志
+		* 都关在 implementation 里，不再由 main-view 在四个调用点成对手工清理。
+		*
+		* 依赖（store 的 subscribe、是否已出现、是否还能抢焦点、怎么打开）由调用方交进来——本模块不认宿主。
+		*/
+		/** 默认放弃边界：给宿主 `api-session/added` 到客户端摘要落地留一拍（ADR-0036 的产品决定）。 */
+		const DEFAULT_GIVE_UP_MS = 2e3;
+		function createPendingOpen(giveUpMs = DEFAULT_GIVE_UP_MS) {
+			const latest = createLatestWins();
+			let cleanup;
+			const cancel = () => {
+				latest.invalidate();
+				const stop = cleanup;
+				cleanup = void 0;
+				stop?.();
+			};
+			return {
+				cancel,
+				schedule(input) {
+					cancel();
+					const ticket = latest.issue();
+					let settled = false;
+					let unsubscribe;
+					let timer;
+					const unsubscribeNow = () => {
+						if (unsubscribe === void 0) return;
+						const stop = unsubscribe;
+						unsubscribe = void 0;
+						try {
+							stop();
+						} catch {}
+					};
+					const finish = () => {
+						if (settled) return;
+						settled = true;
+						if (timer !== void 0) {
+							clearTimeout(timer);
+							timer = void 0;
+						}
+						unsubscribeNow();
+						if (cleanup === finish) cleanup = void 0;
+					};
+					const open = () => {
+						if (!ticket.current || !input.canOpen()) {
+							finish();
+							return;
+						}
+						try {
+							input.open();
+						} finally {
+							finish();
+						}
+					};
+					if (input.isReady()) {
+						open();
+						return;
+					}
+					const subscribe = input.subscribe;
+					if (subscribe === void 0) return;
+					cleanup = finish;
+					let stop;
+					try {
+						stop = subscribe(() => {
+							if (input.isReady()) open();
+						});
+					} catch {
+						finish();
+						return;
+					}
+					unsubscribe = stop;
+					if (settled) {
+						unsubscribeNow();
+						return;
+					}
+					timer = setTimeout(finish, giveUpMs);
+					if (input.isReady()) open();
+				}
+			};
+		}
+		//#endregion
 		//#region src/client/main-view.ts
 		let client;
 		/** 我们自己关掉的主视图会话：只有这里记过的，撤销恢复后才会重开；面板恢复用 `forgetMainView` 清掉。 */
 		let closedByUs = /* @__PURE__ */ new Set();
-		/** 重开排队的最新票：后一次删除/恢复（或重开）签发新票，前一次的等待随之作废（只开最新那条）。 */
-		const reopen = createLatestWins();
+		/** 在等的重开：票、订阅、放弃 timer 与 cleanup 都归这个句柄（`src/client/pending-open.ts`）。 */
+		const pendingOpen = createPendingOpen();
 		/** 入口激活时绑一次；之后每次调用再读服务（客户端插件激活顺序早于 `uiWorkspace` 也没关系）。 */
 		function bindMainView(ctx) {
 			client = ctx;
+			if (typeof ctx.effect === "function") ctx.effect(() => () => {
+				pendingOpen.cancel();
+				closedByUs = /* @__PURE__ */ new Set();
+			}, "session-delete: main-view");
+		}
+		/** 宿主服务是否可用：把检查写成类型谓词，调用点拿到的就是 `ReadyUiWorkspace`。
+		*  `ctx.get` 的窄镜像声明成可能回 null（宿主可回 null），所以空值判据必须同时认 undefined / null。 */
+		function isReadyUiWorkspace(candidate) {
+			if (candidate === void 0 || candidate === null) return false;
+			if (typeof candidate.clearMain !== "function" || typeof candidate.openSession !== "function") return false;
+			if (candidate.selection === void 0 || typeof candidate.selection.getSnapshot !== "function") return false;
+			return true;
 		}
 		function uiWorkspaceOf() {
 			try {
 				const candidate = client?.get?.("uiWorkspace");
-				if (candidate === void 0 || candidate === null) return void 0;
-				if (typeof candidate.clearMain !== "function" || typeof candidate.openSession !== "function") return void 0;
-				if (candidate.selection === void 0 || typeof candidate.selection.getSnapshot !== "function") return void 0;
-				return candidate;
+				return isReadyUiWorkspace(candidate) ? candidate : void 0;
 			} catch {
 				return;
 			}
@@ -2139,7 +2372,7 @@ window.__ModuleLoader__.load({
 		*/
 		function afterDelete(sessionIds) {
 			if (sessionIds.length === 0) return;
-			reopen.invalidate();
+			pendingOpen.cancel();
 			const ui = uiWorkspaceOf();
 			if (ui === void 0) return;
 			const current = currentSessionOf(ui);
@@ -2158,11 +2391,13 @@ window.__ModuleLoader__.load({
 		*/
 		function afterRestore(sessionIds) {
 			if (sessionIds.length === 0) return;
-			reopen.invalidate();
+			pendingOpen.cancel();
 			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]);
+			const last = targets[targets.length - 1];
+			if (last === void 0) return;
+			openWhenListed(last);
 		}
 		/**
 		* 面板恢复已经替这些会话完成了“回来”的结算：只忘掉我们关过的那几条，不重开、不抢焦点。
@@ -2173,19 +2408,23 @@ window.__ModuleLoader__.load({
 		}
 		/**
 		* 把会话重新打开：`api-session/added` 从宿主发出到客户端摘要表落地有一拍（WS 与 HTTP 响应各走
-		* 各的），`openSession` 的目标必须先出现在清单里才不会抛「unknown session」——所以先等它出现，
-		* 最多 2 秒；期间用户若已经选了别的会话就不再抢焦点。等不到就什么都不做，行还在那里。
+		* 各的），`openSession` 的目标必须先出现在清单里才不会抛「unknown session」——先查一次快照，没有就
+		* **订阅**宿主快照 store；出现且票仍是当前、焦点没被抢走时打开。最多等 2 秒，一个放弃 timer，不轮询。
+		* 期间用户若已经选了别的会话就不再抢焦点。等不到就什么都不做，行还在那里。
 		*
-		* **最新票守卫**（`reopen`）：开始等待时签一张票，立即开与每次 tick 都核对；后一次删除/
-		* 恢复（或 `resetMainView`）签发新票或作废当前票，前一次的等待就不再打开、也不再续时。
+		* 这段状态机住 `src/client/pending-open.ts` 的 `createPendingOpen`：这里只把「查什么、能不能开、
+		* 怎么开」交进去；取消也只剩 `pendingOpen.cancel()` 一次。没有 `subscribe` 的旧 store 直接放弃
+		* 等待，不退回轮询（ADR-0036）。
 		*/
 		function openWhenListed(sessionId) {
 			const ui = uiWorkspaceOf();
 			if (ui === void 0) return;
-			const ticket = reopen.issue();
+			const store = ui.sessions?.list;
+			if (store === void 0) return;
+			const subscribe = typeof store.subscribe === "function" ? store.subscribe.bind(store) : void 0;
 			const listReady = () => {
 				try {
-					return ui.sessions?.list?.getSnapshot()?.byId?.[sessionId] !== void 0;
+					return store.getSnapshot()?.byId?.[sessionId] !== void 0;
 				} catch {
 					return false;
 				}
@@ -2194,28 +2433,16 @@ window.__ModuleLoader__.load({
 				const current = currentSessionOf(ui);
 				return current === void 0 || current === sessionId;
 			};
-			const open = () => {
-				if (!ticket.current) return;
-				if (!canTakeFocus()) return;
-				try {
-					ui.openSession?.(sessionId);
-				} catch {}
-			};
-			if (listReady()) {
-				open();
-				return;
-			}
-			let attempts = 0;
-			const tick = () => {
-				if (!ticket.current) return;
-				attempts += 1;
-				if (listReady()) {
-					open();
-					return;
+			pendingOpen.schedule({
+				subscribe,
+				isReady: listReady,
+				canOpen: canTakeFocus,
+				open: () => {
+					try {
+						ui.openSession(sessionId);
+					} catch {}
 				}
-				if (attempts < 20) setTimeout(tick, 100);
-			};
-			setTimeout(tick, 100);
+			});
 		}
 		//#endregion
 		//#region src/client/write-settlement.ts
@@ -2307,9 +2534,12 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region src/client/write-seats.ts
-		/** 会话行菜单的单删座位：一条会话、`single` 读法、成功发单条撤销横幅。交回这条会话的失败原文。 */
+		/** 会话行菜单的单删座位：一条会话、`single` 读法、成功发单条撤销横幅。交回这条会话的失败原文。
+		*  三种形状各有意思，不许互相冒充：字符串 = 这一条失败了（原文）；`null` = 跑了、这一条没有失败要说；
+		*  `undefined` = 闸把这一趟挡回来了、什么都没跑（框不收，等在飞那一趟的结论——先收就会把它的失败原文
+		*  落在已经卸载的确认框上）。 */
 		async function deleteSessionFromMenu(deps, input, gate) {
-			return (await runWrite({
+			const outcome = await runWrite({
 				deps,
 				action: "delete",
 				ids: [input.sessionId],
@@ -2322,10 +2552,13 @@ window.__ModuleLoader__.load({
 					})
 				},
 				gate
-			})).failures.get(input.sessionId) ?? null;
+			});
+			if (outcome === void 0) return void 0;
+			return outcome.failures.get(input.sessionId) ?? null;
 		}
 		/** 批量删除座位（宿主会话列表的多选 → 批量确认框）：一次 `/apply`，撤销名单只收 ok 支的条目 id（跟着组走的幂等条不单列）。
-		*  只收 id：标题是浮条的呈现，不参与这一次写入。 */
+		*  只收 id：标题是浮条的呈现，不参与这一次写入。**被闸挡回时交回 `undefined`**——这一趟没跑，
+		*  浮条与确认框都不许照着它收缩名单或关框（那会吞掉在飞那一趟的结果）。 */
 		async function deleteSessionsFromBatch(deps, ids, gate) {
 			return (await runWrite({
 				deps,
@@ -2339,19 +2572,42 @@ window.__ModuleLoader__.load({
 					})
 				},
 				gate
-			})).failures;
-		}
-		/** 外部恢复座位（撤销横幅）：没有 busy 面，不传闸；主视图重开归 settlement，这里只让清单失效。 */
-		function restoreFromUndo(deps, input) {
-			return runWrite({
+			}))?.failures;
+		}
+		/** 外部恢复座位：拥有整趟——ids 组装、runWrite、三种回执形状各改写一次横幅、成功收自己。
+		*  闸在调用方（横幅组件每条通知一枚）；座位不传闸（双套会让外层 busy 提前落）。
+		*  单条与批量都走**一次** `applyOutcomes('restore', ids)`（`runWrite` 判读；单条带 `single: true`，
+		*  null 是协议错）；失败就把原因换到同一条横幅上，不静默。多条逐条失败时横幅要说清**条数与各条
+		*  原因**（原因去重）——只显第一条会把条数与其余原因折没（issue #8 第 5 条）；单条失败仍原文上屏。
+		*  settlement 负责重开删除时被关掉的会话（只认 main-view 自己记过的）并让清单重读；
+		*  座位**不传 `dismissUndo`**——部分失败的回滚会让 settlement 先熄灭横幅，随后 `failNotice` 因
+		*  `ownsNotice` 落空而吞掉失败原文。 */
+		async function restoreFromUndo(deps, notice, t) {
+			const ids = notice.kind === "one" ? [notice.entryId] : notice.entryIds;
+			if (notice.kind === "one" && notice.entryId === "") return;
+			const outcome = await runWrite({
 				deps,
 				action: "restore",
-				ids: input.ids,
-				single: input.single,
+				ids,
+				single: notice.kind === "one",
 				presentation: { invalidate: invalidateTrash }
 			});
+			if (!outcome.ok) {
+				failNotice(notice, outcome.failure.message);
+				return;
+			}
+			const failure = outcome.failures.values().next().value;
+			if (failure !== void 0) {
+				failNotice(notice, outcome.failures.size > 1 ? t("undo.failedBatch", {
+					n: outcome.failures.size,
+					reasons: [...new Set(outcome.failures.values())].join(" · ")
+				}) : failure);
+				return;
+			}
+			if (ownsNotice(notice)) clearUndoNotice();
 		}
-		/** 面板恢复座位：面板已替这条完成「回来」的结算 ⇒ `panelSeat`；撤销横幅与详情缓存都按落地条目收。 */
+		/** 面板恢复座位：面板已替这条完成「回来」的结算 ⇒ `panelSeat`；撤销横幅与详情缓存都按落地条目收。
+		*  闸被面板那一趟占着时交回 `undefined`（连点不发第二条），面板照它什么都不改。 */
 		function restoreFromPanel(input) {
 			return runWrite({
 				deps: input.deps,
@@ -2368,7 +2624,8 @@ window.__ModuleLoader__.load({
 				refresh: input.refreshAfterWrite
 			});
 		}
-		/** 面板彻底删除座位：永久删除也让指向这些条目的撤销横幅熄灭（settlement 的 purge 支负责）。 */
+		/** 面板彻底删除座位：永久删除也让指向这些条目的撤销横幅熄灭（settlement 的 purge 支负责）。
+		*  与恢复座位同一条：闸被占着时交回 `undefined`，这一趟不改任何界面后果。 */
 		function purgeFromPanel(input) {
 			return runWrite({
 				deps: input.deps,
@@ -2466,6 +2723,7 @@ window.__ModuleLoader__.load({
 					sessionId: current.sessionId,
 					title: current.title
 				}, gate);
+				if (failure === void 0) return;
 				if (failure !== null) {
 					setFailure(failure);
 					return;
@@ -2603,7 +2861,7 @@ window.__ModuleLoader__.load({
 			const [counts, setCounts] = (0, react.useState)(null);
 			const ids = current.items.map((item) => item.sessionId);
 			const failedIds = [...failures.keys()];
-			const totalKids = counts === null ? 0 : [...counts.values()].reduce((sum, n) => sum + n, 0);
+			const totalKids = counts === null ? 0 : current.items.reduce((sum, item) => sum + (counts.get(item.sessionId) ?? 0), 0);
 			(0, react.useEffect)(() => {
 				let alive = true;
 				fetchCounts(deps, current.items.map((item) => item.sessionId)).then((result) => {
@@ -2616,6 +2874,7 @@ window.__ModuleLoader__.load({
 			const run = async () => {
 				setFailures(/* @__PURE__ */ new Map());
 				const failed = await deleteSessionsFromBatch(deps, current.items.map((item) => item.sessionId), gate);
+				if (failed === void 0) return;
 				shrinkPicksToFailures([...failed.keys()]);
 				if (failed.size === 0) {
 					clearDeleteBatchRequest();
@@ -2671,12 +2930,81 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
+		//#region src/client/batch-pick.ts
+		/**
+		* 批量选择的**动作面**：全选、全选判定与模式内整行点击守卫。
+		*
+		* 可见行的事实源仍住 `host-rows.ts`（槽位登记 + 快照）；选中集住 `batch-selection-store.ts`。
+		* 本文件只把两者接起来，于是依赖方向单向：`batch-pick` → `host-rows` / `batch-selection-store`；
+		* 浮条与行开关 → `batch-pick` / `host-rows`。`host-rows` 不再 import 任何选择动作。
+		*
+		* DOM 只在这里读一次 `data-row-key`（ADR-0034 记下的受约束偏离）：守卫把指针下的行映射成
+		* sessionId，再查登记；它不枚举行，也不维护行列表。
+		*/
+		/** 全选：把当前可见可选行按登记序追加；已在名单里的由 `addPicks` 自己跳过，原有选中保持在前。 */
+		function selectAllVisible() {
+			addPicks(readVisibleSelectableRows());
+		}
+		/**
+		* 同一个切换口该显示「全选」还是「取消全选」：
+		* - 有选中、且当前可见可选行全都选中 ⇒ 取消全选；
+		* - 有选中、但当前没有可见可选行（全折叠/过滤掉）⇒ 只能清空，也显示取消全选；
+		* - 其余（含 0 条）⇒ 全选。
+		*/
+		function areAllVisibleRowsSelected(rows, picks) {
+			if (picks.length === 0) return false;
+			if (rows.length === 0) return true;
+			const chosen = new Set(picks.map((item) => item.sessionId));
+			return rows.every((row) => chosen.has(row.sessionId));
+		}
+		/** 行内这些元素有自己的动作：模式内也不许被"点行=勾选"吃掉。 */
+		const INTERACTIVE_IN_ROW = "button, a, input, select, textarea, [role=\"menuitem\"], [role=\"menu\"], [data-dsh-session-delete=\"batch-pick\"]";
+		/**
+		* 多选态内的整行点击守卫（document 捕获阶段）。
+		*
+		* 边界：行里的按钮 / 链接 / 输入 / 菜单项一律放行（否则 ⋯ 菜单、归档、置顶、单删都点不动）；
+		* 双击的第二下与 dblclick 不翻转（第一下已经选中，第二下不能又反掉，也不能打开宿主的重命名）。
+		* 认行靠 `data-row-key="session:…"`——**这是本文件唯一一处 DOM 读**（ADR-0034）：宿主将来改掉这个
+		* 属性，最差是模式内点行不生效，勾选框本身仍在。模式外不挂监听：这时点行必须还是宿主的"打开会话"。
+		*/
+		function useSelectionRowClickGuard() {
+			const selecting = useSelection().selecting;
+			(0, react.useEffect)(() => {
+				if (!selecting) return;
+				const handle = (event) => {
+					if (!(event.target instanceof Element)) return;
+					const row = event.target.closest("[data-row-key^=\"session:\"]");
+					if (row === null) return;
+					if (event.target.closest(INTERACTIVE_IN_ROW) !== null) return;
+					event.preventDefault();
+					event.stopPropagation();
+					if (event.type === "dblclick" || event.type === "click" && event.detail > 1) return;
+					const key = row.getAttribute("data-row-key") ?? "";
+					if (!key.startsWith("session:")) return;
+					const sessionId = key.slice(8);
+					if (sessionId === "") return;
+					const info = pickableRowOf(sessionId);
+					if (info === void 0) return;
+					togglePick({
+						sessionId,
+						title: info.title
+					});
+				};
+				document.addEventListener("click", handle, true);
+				document.addEventListener("dblclick", handle, true);
+				return () => {
+					document.removeEventListener("click", handle, true);
+					document.removeEventListener("dblclick", handle, true);
+				};
+			}, [selecting]);
+		}
+		//#endregion
 		//#region src/client/batch-bar.tsx
 		/**
 		* 批量删除的浮条：**多选模式内常驻**（0 条也渲染，既显示模式又给退出入口），
 		* 汇总「已选 N 条」+（读得到时）「含 K 个子会话」；「查看已选」展开限高可滚动的标题清单
 		* （逐条可移除），回答"到底选了哪些"——清单默认收起，不把底部输入区盖住。
-		* 模式内的整行点击守卫也挂在这棵常驻宿主上（见 `host-rows.ts` 的 `useSelectionRowClickGuard`）。
+		* 模式内的整行点击守卫也挂在这棵常驻宿主上（见 `batch-pick.ts` 的 `useSelectionRowClickGuard`）。
 		*
 		* 为什么单独一个文件而不是并进 `batch-select.tsx`：那份是"行开关控件"，而浮条要点开确认框
 		* （要 import 它的现场）——两个方向合到一个文件上就是一圈。浮条住在
@@ -2923,12 +3251,16 @@ window.__ModuleLoader__.load({
 				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);
+			return [...byProject].flatMap(([projectDir, list]) => {
+				const first = list[0];
+				if (first === void 0) return [];
+				return [{
+					projectDir,
+					label: projectLabel(projectDir, t),
+					latest: first.deletedAt,
+					entries: list
+				}];
+			}).sort((a, b) => b.latest - a.latest);
 		}
 		//#endregion
 		//#region src/client/attachment-view.tsx
@@ -2936,8 +3268,10 @@ window.__ModuleLoader__.load({
 		* 回收站详情与设置页维护卡预览里的一条附件：图片给缩略图 + 放大框，普通文件给下载 chip。
 		*
 		* 三条口径：
-		* - **地址只由 `attachmentId` + `kind` 拼**：`/attachment` 段只认这两个参数寻址（`name` 只做下载名建议，
-		*   不参与路径推导，见 `src/api/attachment.ts`）。空串与缺席同义——空串不是一个名字，不写进查询串。
+		* - **地址只由 `attachmentId` + `kind` 寻址**：`/attachment` 段以这两个参数找对象；媒体元数据
+		*   （`mediaType` / `bytes` / `width` / `height`）只给宿主 `attachments` 服务做引用校验，`name` 只做
+		*   下载名建议，均不参与路径推导（见 `src/api/attachment.ts`）。空串与缺席同义——空串不是一个名字，
+		*   不写进查询串。
 		* - **图裂了就换占位**：缩略图与放大框共用同一份 `failed` 集合，`onError` 之后这一格改成「附件不可用」，
 		*   不把破图留在屏上（放大框里裂了也换）。普通文件走 `<a download>`，没有页面内失败面：服务端失败回
 		*   200 + JSON 信封，浏览器可能把这份错误响应存成文件。
@@ -2954,10 +3288,16 @@ window.__ModuleLoader__.load({
 		function attachmentUrl(a) {
 			const query = new URLSearchParams({
 				[PARAMS.attachmentId]: a.attachmentId,
-				[PARAMS.attachmentKind]: a.kind
+				[PARAMS.attachmentKind]: a.kind,
+				[PARAMS.attachmentBytes]: String(a.bytes)
 			});
+			if (a.kind === "image") {
+				if (a.mediaType !== void 0) query.set(PARAMS.attachmentMediaType, a.mediaType);
+				if (a.width !== void 0) query.set(PARAMS.attachmentWidth, String(a.width));
+				if (a.height !== void 0) query.set(PARAMS.attachmentHeight, String(a.height));
+			}
 			if (a.kind === "file" && a.name !== void 0 && a.name !== "") query.set(PARAMS.attachmentName, a.name);
-			return `${SESSION_DELETE_API_PREFIX}${ROUTES.attachment}?${query.toString()}`;
+			return `${OFFICIAL_SESSION_DELETE_API_PREFIX}${ROUTES.attachment.path}?${query.toString()}`;
 		}
 		/** 空串与缺席同义：宿主侧的 `name` 是可选建议名，空串不是名字（兜底文案与"不带 name 查询"都看它）。 */
 		function nameOf(a) {
@@ -3047,7 +3387,8 @@ window.__ModuleLoader__.load({
 				setSaveError(null);
 				try {
 					const response = await fetch(attachmentUrl(attachment));
-					const contentType = (response.headers.get("content-type") ?? "").split(";")[0].trim();
+					const mediaType = response.headers.get("content-type")?.split(";")[0];
+					const contentType = mediaType === void 0 ? "" : mediaType.trim();
 					if (!response.ok || !contentType.startsWith("image/")) {
 						let message = `HTTP ${String(response.status)}`;
 						if (contentType === "application/json") try {
@@ -3495,21 +3836,21 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region src/client/orphan-maintenance.tsx
-		function OrphanMaintenance({ query, busy, t }) {
-			const { orphanReport, orphanFailure, orphanNotice, orphanConfirm } = query;
+		function OrphanMaintenance({ section, t }) {
+			const { report, failure, notice, confirm, busy } = section;
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
-				orphanReport !== null && orphanReport.totalSessions > 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(MaintenanceBanner, {
+				report !== null && report.totalSessions > 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(MaintenanceBanner, {
 					slot: "orphan-banner",
 					busy,
 					t,
 					gapBelow: true,
-					onOpen: () => query.openOrphanPreview(),
+					onOpen: () => section.openPreview(),
 					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 						style: {
 							fontSize: 13,
 							lineHeight: "19px"
 						},
-						children: t("trash.orphans.banner", { count: orphanReport.totalSessions })
+						children: t("trash.orphans.banner", { count: report.totalSessions })
 					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 						style: {
 							fontSize: 12,
@@ -3517,19 +3858,19 @@ window.__ModuleLoader__.load({
 							color: "var(--dsw-alias-label-tertiary)"
 						},
 						children: t("trash.orphans.meta", {
-							size: fileSizeText(orphanReport.totalBytes),
-							parents: orphanReport.missingParents
+							size: fileSizeText(report.totalBytes),
+							parents: report.missingParents
 						})
 					})]
 				}) : null,
-				orphanFailure !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MaintenanceFailure, {
-					message: orphanFailure,
+				failure !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MaintenanceFailure, {
+					message: failure,
 					busy,
 					t,
 					gapBelow: true,
-					onRetry: () => void query.scanOrphans()
+					onRetry: () => void section.scan()
 				}) : null,
-				orphanNotice !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				notice !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 					"data-dsh-session-delete": "orphan-notice",
 					role: "status",
 					style: {
@@ -3557,29 +3898,127 @@ window.__ModuleLoader__.load({
 							lineHeight: "17px",
 							color: "var(--dsw-alias-label-secondary)"
 						},
-						children: orphanNotice
+						children: notice
 					})]
 				}) : null,
-				orphanConfirm && orphanReport !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(OrphanConfirm, {
-					report: orphanReport,
+				confirm && report !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(OrphanConfirm, {
+					report,
 					busy,
 					t,
-					onCancel: () => query.setOrphanConfirm(false),
-					onConfirm: () => void query.cleanOrphans()
+					onCancel: () => section.cancel(),
+					onConfirm: () => void section.clean()
 				}) : null
 			] });
 		}
 		//#endregion
+		//#region src/client/use-maintenance-section.ts
+		/**
+		* 维护卡一段维护的**泛型状态机**：报告 / 失败 / 中性提示 / 确认框 / 在飞档位 / 最新票 / 清完必重查。
+		* 孤儿会话与孤儿附件曾是这台机器按前缀各抄一份的两段——这里收成一台，两段各自只带自己的
+		* 远程调用、判据与拼句（`use-maintenance.ts` 两次实例化）。
+		*
+		* 三条承重规矩（ADR-0021）在这一层保证，两段都不可绕过：
+		* - **没有自动扫描**：本 module 不挂 effect、没有定时器；挂载只交初始态（报告 `null` = 尚未检查）。
+		* - **读不到就说读不到**：检查失败回 `null` + 原文（`scanFailureText` 由各段拼），不折成"没有发现"。
+		* - **清理后必重查**：清完立刻重读；回执句子由 `settle` 拼好后**等重查赢了才落地**——顺序反了，
+		*   重查成功会清掉旧提示，把这一趟的后果吞掉。
+		*
+		* **不变量由构造保证**：开确认框只有 `openPreview()` 一条路（先清旧失败与旧提示再开），收框只有
+		* `cancel()`（只收框，不碰提示 / 失败）；界面上写不出"裸把 confirm 摆 true"这种开门，于是
+		* "确认框开着、上一趟的失败句还挂着"的组合从类型上就不存在。`busy` 同理由段自己给
+		* （在飞即忙），不再作为 prop 逐层传。
+		*
+		* 动作是每渲染重建的普通闭包、不包 `useCallback`：config 每渲染本来就要重建，包了也稳定不下来；
+		* 这些动作只被点击触发，没有按身份依赖它们的 effect（`useIdleClose` 只在调用时读它们）。
+		*/
+		function useMaintenanceSection(config) {
+			const [report, setReport] = (0, react.useState)(null);
+			const [failure, setFailure] = (0, react.useState)(null);
+			const [notice, setNotice] = (0, react.useState)(null);
+			const [confirm, setConfirm] = (0, react.useState)(false);
+			const [phase, setPhase] = (0, react.useState)(null);
+			const [latest] = (0, react.useState)(createLatestWins);
+			/**
+			* 一次检查（不碰 phase）。交回这张票是否仍是赢家：清理后的重查被后发的检查顶掉时，
+			* 由赢家负责把读数与 busy 一起收尾，输家什么都不落地。**输家不许替赢家清 `phase`**——phase 归
+			* 赢下最新票的那一趟收尾，输家提前清会在赢家还在飞时把界面摆成空闲（忙碌收尾与
+			* `use-trash-query.ts` 的空闲判定是两套写法，判据不同源，别互相抄）。
+			*/
+			async function rescan() {
+				const ticket = latest.issue();
+				const outcome = await config.scan();
+				if (!ticket.current) return false;
+				config.onScanWon?.();
+				if (outcome.ok) {
+					setReport(outcome.value);
+					setFailure(null);
+					setNotice(null);
+					return true;
+				}
+				setReport(null);
+				setNotice(null);
+				setConfirm(false);
+				setFailure(config.scanFailureText(outcome.failure.message));
+				return true;
+			}
+			async function scan() {
+				setPhase("scanning");
+				if (await rescan()) setPhase(null);
+			}
+			async function clean() {
+				const before = report;
+				if (before === null) {
+					setConfirm(false);
+					return;
+				}
+				const pending = config.clean(before);
+				if (pending === null) {
+					setConfirm(false);
+					return;
+				}
+				setPhase("cleaning");
+				setFailure(null);
+				setNotice(null);
+				const outcome = await pending;
+				setConfirm(false);
+				const preset = config.beforeRescan?.(outcome);
+				if (preset !== null && preset !== void 0) setReport(preset);
+				if (!await rescan()) return;
+				const plan = config.settle(outcome, before);
+				if (plan.notice !== void 0) setNotice(plan.notice);
+				if (plan.failure !== void 0) setFailure(plan.failure);
+				setPhase(null);
+			}
+			function openPreview() {
+				setFailure(null);
+				setNotice(null);
+				setConfirm(true);
+			}
+			function cancel() {
+				setConfirm(false);
+			}
+			return {
+				report,
+				failure,
+				notice,
+				confirm,
+				phase,
+				busy: phase !== null,
+				scan,
+				openPreview,
+				clean,
+				cancel
+			};
+		}
+		//#endregion
 		//#region src/client/use-maintenance.ts
 		/**
-		* 插件设置页「维护」卡的手动编排：孤儿会话 + 孤儿附件，各一组读数、提示与动作。
+		* 插件设置页「维护」卡的手动编排：孤儿会话 + 孤儿附件两段。
 		*
-		* 三条承重规矩：
-		* - **没有自动扫描**：本 module 不挂 `useEffect`、没有定时器；只有用户点「检查 / 查看并清理 / 清理」
-		*   才发请求。挂载只交初始态（报告 `null` = 尚未检查）。
-		* - **读不到就说读不到**：两份报告失败都回 `null` + 原文，不折成「没有发现」。
-		* - **清理后必重查**：报告说的是"报告那一刻"的盘；清完立刻重读。回执里的中性 / 失败 / 部分计数
-		*   先读出来、重查之后再上屏——重查成功会清掉旧提示，顺序反了会把这一趟的后果吞掉。
+		* 状态机本身（报告 / 失败 / 中性提示 / 确认框 / 在飞档位 / 最新票 / 清完必重查）收在
+		* `src/client/use-maintenance-section.ts` 的泛型段 module 里，两段各实例化一次；这一层只剩薄 glue：
+		* 各段自己的远程调用、"没活可干"的判据与回执拼句。三条承重规矩（没有自动扫描 / 挂载只交初始态 /
+		* 没有定时器）由段 module 保证，这一层同样不挂 effect。
 		*
 		* 写动作走既有的两段：孤儿会话是 `/apply` 的 `orphan-clean`（回执判读复用 `receipt.ts` 的读法），
 		* 孤儿附件是聚合的 `POST /attachment-clean`（回执就是 `AttachmentCleanupWire` 本身）。
@@ -3603,178 +4042,63 @@ window.__ModuleLoader__.load({
 				size: fileSizeText(a.freedBytes)
 			}) : null;
 		}
+		/** orphan-clean 回执里的"没清成"句：服务端原文 + 部分计数（"删了一半才炸"的那部分释放量）。
+		*  首条失败由调用方在判过非空之后作为参数交进来——签名因此写明前提，函数体不必再赌 `failed[0]` 在。 */
+		function orphanCleanFailureSentence(summary, first, t) {
+			const message = first.error.message;
+			return `${t("trash.orphans.cleanFailed", {
+				count: summary.failed.length,
+				message
+			})}${summary.partial.removed > 0 || summary.partial.freedBytes > 0 ? ` ${t("trash.orphans.cleanPartial", {
+				removed: summary.partial.removed,
+				size: fileSizeText(summary.partial.freedBytes)
+			})}` : ""}`;
+		}
 		function useMaintenance({ deps, t }) {
-			const [orphanReport, setOrphanReport] = (0, react.useState)(null);
-			const [orphanFailure, setOrphanFailure] = (0, react.useState)(null);
-			const [orphanNotice, setOrphanNotice] = (0, react.useState)(null);
 			const [orphanAttachmentNotice, setOrphanAttachmentNotice] = (0, react.useState)(null);
-			const [orphanConfirm, setOrphanConfirm] = (0, react.useState)(false);
-			const [orphanPhase, setOrphanPhase] = (0, react.useState)(null);
-			const orphanBusy = orphanPhase !== null;
-			const [orphanLatest] = (0, react.useState)(createLatestWins);
-			/**
-			* 一次孤儿检查（不碰 busy / phase）。交回这张票是否仍是赢家：清理后的重查被后发的检查顶掉时，
-			* 由赢家负责把读数与 busy 一起收尾，输家什么都不落地。
-			*/
-			const rescanOrphans = (0, react.useCallback)(async () => {
-				const ticket = orphanLatest.issue();
-				const outcome = await callRemote(() => deps.scanOrphans());
-				if (!ticket.current) return false;
-				setOrphanAttachmentNotice(null);
-				if (!outcome.ok) {
-					setOrphanReport(null);
-					setOrphanNotice(null);
-					setOrphanConfirm(false);
-					setOrphanFailure(t("trash.orphans.failure", { message: outcome.failure.message }));
-					return true;
-				}
-				setOrphanReport(outcome.value);
-				setOrphanFailure(null);
-				setOrphanNotice(null);
-				return true;
-			}, [
-				deps,
-				orphanLatest,
-				t
-			]);
-			const scanOrphans = (0, react.useCallback)(async () => {
-				setOrphanPhase("scanning");
-				if (await rescanOrphans()) setOrphanPhase(null);
-			}, [rescanOrphans]);
-			const cleanOrphans = (0, react.useCallback)(async () => {
-				const report = orphanReport;
-				if (report === null || report.roots.length === 0) {
-					setOrphanConfirm(false);
-					return;
-				}
-				const roots = report.roots;
-				setOrphanPhase("cleaning");
-				setOrphanFailure(null);
-				setOrphanNotice(null);
-				setOrphanAttachmentNotice(null);
-				const outcome = await callRemote(() => deps.applyOutcomes("orphan-clean", roots));
-				setOrphanConfirm(false);
-				if (!outcome.ok) {
-					if (!await rescanOrphans()) return;
-					setOrphanFailure(t("trash.orphans.failure", { message: outcome.failure.message }));
-					setOrphanPhase(null);
-					return;
-				}
-				const { summary } = summarizeReceipt(readReceipt("orphan-clean", roots, outcome.value));
-				if (!await rescanOrphans()) return;
-				if (summary.neutralIds.length > 0) setOrphanNotice(t("trash.orphans.cleanGone", { count: summary.neutralIds.length }));
-				if (summary.failed.length > 0) {
-					const message = summary.failed[0].error.message;
-					const base = t("trash.orphans.cleanFailed", {
-						count: summary.failed.length,
-						message
-					});
-					const partial = summary.partial.removed > 0 || summary.partial.freedBytes > 0 ? ` ${t("trash.orphans.cleanPartial", {
-						removed: summary.partial.removed,
-						size: fileSizeText(summary.partial.freedBytes)
-					})}` : "";
-					setOrphanFailure(`${base}${partial}`);
-				}
-				if (summary.attachmentCleanup !== void 0) setOrphanAttachmentNotice(attachmentCleanupNotice(summary.attachmentCleanup, t));
-				setOrphanPhase(null);
-			}, [
-				deps,
-				orphanReport,
-				rescanOrphans,
-				t
-			]);
-			const openOrphanPreview = (0, react.useCallback)(() => {
-				setOrphanFailure(null);
-				setOrphanNotice(null);
-				setOrphanConfirm(true);
-			}, []);
-			const [attachmentReport, setAttachmentReport] = (0, react.useState)(null);
-			const [attachmentFailure, setAttachmentFailure] = (0, react.useState)(null);
-			const [attachmentNotice, setAttachmentNotice] = (0, react.useState)(null);
-			const [attachmentConfirm, setAttachmentConfirm] = (0, react.useState)(false);
-			const [attachmentPhase, setAttachmentPhase] = (0, react.useState)(null);
-			const attachmentBusy = attachmentPhase !== null;
-			const [attachmentLatest] = (0, react.useState)(createLatestWins);
-			const rescanAttachments = (0, react.useCallback)(async () => {
-				const ticket = attachmentLatest.issue();
-				const outcome = await callRemote(() => deps.scanAttachmentOrphans());
-				if (!ticket.current) return false;
-				if (!outcome.ok) {
-					setAttachmentReport(null);
-					setAttachmentNotice(null);
-					setAttachmentConfirm(false);
-					setAttachmentFailure(t("maintenance.attachments.scanFailed", { message: outcome.failure.message }));
-					return true;
-				}
-				setAttachmentReport(outcome.value);
-				setAttachmentFailure(null);
-				setAttachmentNotice(null);
-				return true;
-			}, [
-				attachmentLatest,
-				deps,
-				t
-			]);
-			const scanAttachmentOrphans = (0, react.useCallback)(async () => {
-				setAttachmentPhase("scanning");
-				if (await rescanAttachments()) setAttachmentPhase(null);
-			}, [rescanAttachments]);
-			const cleanAttachmentOrphans = (0, react.useCallback)(async () => {
-				const report = attachmentReport;
-				if (report === null || report.count === 0) {
-					setAttachmentConfirm(false);
-					return;
-				}
-				setAttachmentPhase("cleaning");
-				setAttachmentFailure(null);
-				setAttachmentNotice(null);
-				const outcome = await callRemote(() => deps.cleanAttachmentOrphans());
-				setAttachmentConfirm(false);
-				if (outcome.ok && outcome.value.failed === 0 && outcome.value.skipped === void 0) setAttachmentReport({
-					count: 0,
-					totalBytes: 0,
-					items: []
-				});
-				if (!await rescanAttachments()) return;
-				if (!outcome.ok) {
-					setAttachmentFailure(t("maintenance.attachments.cleanError", { message: outcome.failure.message }));
-					setAttachmentPhase(null);
-					return;
+			const orphans = useMaintenanceSection({
+				scan: () => callRemote(() => deps.scanOrphans()),
+				onScanWon: () => {
+					setOrphanAttachmentNotice(null);
+				},
+				clean: (report) => {
+					if (report.roots.length === 0) return null;
+					setOrphanAttachmentNotice(null);
+					return callRemote(() => deps.applyOutcomes("orphan-clean", report.roots));
+				},
+				scanFailureText: (message) => t("trash.orphans.failure", { message }),
+				settle: (outcome, report) => {
+					if (!outcome.ok) return { failure: t("trash.orphans.failure", { message: outcome.failure.message }) };
+					const { summary } = summarizeReceipt(readReceipt("orphan-clean", report.roots, outcome.value));
+					if (summary.attachmentCleanup !== void 0) setOrphanAttachmentNotice(attachmentCleanupNotice(summary.attachmentCleanup, t));
+					const plan = {};
+					if (summary.neutralIds.length > 0) plan.notice = t("trash.orphans.cleanGone", { count: summary.neutralIds.length });
+					const firstFailed = summary.failed[0];
+					if (firstFailed !== void 0) plan.failure = orphanCleanFailureSentence(summary, firstFailed, t);
+					return plan;
 				}
-				setAttachmentNotice(attachmentCleanupNotice(outcome.value, t));
-				setAttachmentPhase(null);
-			}, [
-				attachmentReport,
-				deps,
-				rescanAttachments,
-				t
-			]);
+			});
+			const attachments = useMaintenanceSection({
+				scan: () => callRemote(() => deps.scanAttachmentOrphans()),
+				clean: (report) => report.count === 0 ? null : callRemote(() => deps.cleanAttachmentOrphans()),
+				beforeRescan: (outcome) => {
+					if (!outcome.ok) return null;
+					const receipt = outcome.value;
+					return receipt.failed === 0 && receipt.skipped === void 0 ? {
+						count: 0,
+						totalBytes: 0,
+						items: []
+					} : null;
+				},
+				scanFailureText: (message) => t("maintenance.attachments.scanFailed", { message }),
+				settle: (outcome) => outcome.ok ? { notice: attachmentCleanupNotice(outcome.value, t) } : { failure: t("maintenance.attachments.cleanError", { message: outcome.failure.message }) }
+			});
 			return {
-				orphanReport,
-				orphanFailure,
-				orphanNotice,
-				orphanAttachmentNotice,
-				orphanConfirm,
-				orphanBusy,
-				orphanPhase,
-				scanOrphans,
-				openOrphanPreview,
-				cleanOrphans,
-				setOrphanConfirm,
-				attachmentReport,
-				attachmentFailure,
-				attachmentNotice,
-				attachmentConfirm,
-				attachmentBusy,
-				attachmentPhase,
-				scanAttachmentOrphans,
-				openAttachmentPreview: (0, react.useCallback)(() => {
-					setAttachmentFailure(null);
-					setAttachmentNotice(null);
-					setAttachmentConfirm(true);
-				}, []),
-				cleanAttachmentOrphans,
-				setAttachmentConfirm
+				orphans: {
+					...orphans,
+					attachmentNotice: orphanAttachmentNotice
+				},
+				attachments
 			};
 		}
 		//#endregion
@@ -3790,7 +4114,14 @@ window.__ModuleLoader__.load({
 			padding: "14px 16px"
 		};
 		/** 一段的标题行：标题 + 说明 + 状态 + 检查按钮。状态按优先级：清理中 / 检查中 / 检查失败 / 尚未检查 / 没有发现 / N。 */
-		function MaintenanceSection({ slot, title, hint, status, busy, onScan, t, children }) {
+		function MaintenanceSection({ slot, title, hint, count, countKey, section, onScan, t, children }) {
+			const status = statusText({
+				phase: section.phase,
+				failure: section.failure,
+				count,
+				countKey,
+				t
+			});
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 				"data-dsh-session-delete": slot,
 				style: {
@@ -3847,7 +4178,7 @@ window.__ModuleLoader__.load({
 							variant: "outline",
 							size: "sm",
 							style: { flex: "none" },
-							disabled: busy,
+							disabled: section.busy,
 							onClick: onScan,
 							children: t("maintenance.scan")
 						})
@@ -3871,46 +4202,46 @@ window.__ModuleLoader__.load({
 		* 孤儿附件段：报告 >0 时出横幅（数量 + 体积 + 查看并清理）；检查/清理失败在原位摆原文 + 重试；
 		* 上一趟清理的回执单独一行（已清 / 跳过 / 逐文件失败）。确认框把三条边界说完再动手。
 		*/
-		function AttachmentMaintenance({ query, busy, t }) {
-			const { attachmentReport, attachmentFailure, attachmentNotice, attachmentConfirm } = query;
+		function AttachmentMaintenance({ section, t }) {
+			const { report, failure, notice, confirm, busy } = section;
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
-				!busy && attachmentReport !== null && attachmentReport.count > 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MaintenanceBanner, {
+				!busy && report !== null && report.count > 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MaintenanceBanner, {
 					slot: "attachment-banner",
 					busy,
 					t,
-					onOpen: () => query.openAttachmentPreview(),
+					onOpen: () => section.openPreview(),
 					children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 						style: {
 							fontSize: 13,
 							lineHeight: "19px"
 						},
 						children: [
-							t("maintenance.attachments.count", { count: attachmentReport.count }),
+							t("maintenance.attachments.count", { count: report.count }),
 							" · ",
-							fileSizeText(attachmentReport.totalBytes)
+							fileSizeText(report.totalBytes)
 						]
 					})
 				}) : null,
-				attachmentFailure !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MaintenanceFailure, {
+				failure !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MaintenanceFailure, {
 					slot: "attachment-failure",
-					message: attachmentFailure,
+					message: failure,
 					busy,
 					t,
-					onRetry: () => void query.scanAttachmentOrphans()
+					onRetry: () => void section.scan()
 				}) : null,
-				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(AttachmentNotice, { message: attachmentNotice }),
-				attachmentConfirm && attachmentReport !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AttachmentConfirm, {
-					count: attachmentReport.count,
-					items: attachmentReport.items,
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(AttachmentNotice, { message: notice }),
+				confirm && report !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AttachmentConfirm, {
+					count: report.count,
+					items: report.items,
 					busy,
 					t,
-					onCancel: () => query.setAttachmentConfirm(false),
-					onConfirm: () => void query.cleanAttachmentOrphans()
+					onCancel: () => section.cancel(),
+					onConfirm: () => void section.clean()
 				}) : null
 			] });
 		}
 		/** 预览 + 确认：先摆出这些图片（点开可放大），再决定清不清；只清 `.dsh` 内无引用的图片副本。
-		*  `items` 只是预览清单（服务端最多给 200 条），`count` 才是这次要清理的总数。 */
+		*  `items` 只是预览清单（服务端按配置给条数，默认最多 200 条），`count` 才是这次要清理的总数。 */
 		function AttachmentConfirm({ count, items, busy, t, onCancel, onConfirm }) {
 			const { close, closeDisabled } = useIdleClose(busy, onCancel);
 			const attachments = items.map((item) => ({
@@ -3993,39 +4324,27 @@ window.__ModuleLoader__.load({
 						slot: "maintenance-orphans",
 						title: t("maintenance.orphans.title"),
 						hint: t("maintenance.orphans.hint"),
-						status: statusText({
-							phase: maintenance.orphanPhase,
-							failure: maintenance.orphanFailure,
-							count: maintenance.orphanReport?.totalSessions ?? null,
-							countKey: "maintenance.orphans.count",
-							t
-						}),
-						busy: maintenance.orphanBusy,
-						onScan: () => void maintenance.scanOrphans(),
+						count: maintenance.orphans.report?.totalSessions ?? null,
+						countKey: "maintenance.orphans.count",
+						section: maintenance.orphans,
+						onScan: () => void maintenance.orphans.scan(),
 						t,
 						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(OrphanMaintenance, {
-							query: maintenance,
-							busy: maintenance.orphanBusy,
+							section: maintenance.orphans,
 							t
-						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AttachmentNotice, { message: maintenance.orphanAttachmentNotice })]
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AttachmentNotice, { message: maintenance.orphans.attachmentNotice })]
 					}),
 					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(MaintenanceSection, {
 						slot: "maintenance-attachments",
 						title: t("maintenance.attachments.title"),
 						hint: t("maintenance.attachments.hint"),
-						status: statusText({
-							phase: maintenance.attachmentPhase,
-							failure: maintenance.attachmentFailure,
-							count: maintenance.attachmentReport?.count ?? null,
-							countKey: "maintenance.attachments.count",
-							t
-						}),
-						busy: maintenance.attachmentBusy,
-						onScan: () => void maintenance.scanAttachmentOrphans(),
+						count: maintenance.attachments.report?.count ?? null,
+						countKey: "maintenance.attachments.count",
+						section: maintenance.attachments,
+						onScan: () => void maintenance.attachments.scan(),
 						t,
 						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AttachmentMaintenance, {
-							query: maintenance,
-							busy: maintenance.attachmentBusy,
+							section: maintenance.attachments,
 							t
 						})
 					})
@@ -25997,14 +26316,13 @@ window.__ModuleLoader__.load({
 		}
 		/**
 		* `memo` 是必需的而不是优化：`react-markdown@10.1.0` 里**一处 memoization 都没有**（读实
-		* `node_modules/react-markdown/lib/index.js:175-178`——`Markdown()` 每次调用都 `createProcessor(options)`
+		* `node_modules/react-markdown/lib/index.js`——`Markdown()` 每次调用都 `createProcessor(options)`
 		* 再 `runSync(parse(file))`，`MarkdownHooks` 那一支也一样），而面板任何一次重渲（悬停、↑↓、
 		* 「刚刚删除」那句要读 `Date.now()`）都会走到这里 ⇒ 不按住就是每条助手回复每拍重解析一遍。
-		* 按住的条件是 `text` 与**探针 `localeKey`**（调用方在渲染时算好的一句固定键译文 `t('common.close')`）。
-		* `t` 本身是宿主 `bind` 出来的**稳定身份**（`copy.ts` 头注），一次客户端激活只造一个——拿身份当判据，
-		* 换语言就漏了：同一个 `t` 换 locale 后吐另一套词，烘进正文树的那句图片占位会滞留旧语言，而周围的
-		* 标签那一拍已经改口。探针也不能在 comparator 里现调 `t` 取——宿主 `t` 读的是**当前** locale，
-		* prev/next 那一拍都取到新值、恒等；只有渲染时算好存进 props 的那份才是换语言那一刻的读数。
+		* 按住的条件是 `text` 与**探针 `probe`**：一句按当前 locale 现算的译文，专给 comparator 当
+		* 「换语言了没」的读数。为什么必须渲染时现算存进 props、为什么宿主 `t` 只能当稳定身份而不是
+		* 语言读数、「借哪句」，这些都住 `copy.ts` 的 `localeProbe`——调用方与测试一律
+		* `probe={localeProbe(t)}`，「借哪句」的知识不散到各调用方。
 		* 探针没变 = 同语言同 `t` ⇒ 跳过重解析；变了（换语言或换 `t`）⇒ 重解析。
 		*/
 		const MarkdownBody = (0, react.memo)(function MarkdownBody({ text, t }) {
@@ -26017,7 +26335,7 @@ window.__ModuleLoader__.load({
 					children: text
 				})
 			});
-		}, (prev, next) => prev.text === next.text && prev.localeKey === next.localeKey);
+		}, (prev, next) => prev.text === next.text && prev.probe === next.probe);
 		//#endregion
 		//#region src/client/trash-detail.tsx
 		/**
@@ -26026,10 +26344,12 @@ window.__ModuleLoader__.load({
 		* 三条界面约束：
 		* - 动作（恢复/彻底删除）留在清单行右侧；详情只负责看。
 		* - 标题优先用清册标题，空串才回落到日志的 session/title。
-		* - 注入条数与截断条数必须上屏，避免正文变少被误读成“会话只有这些内容”。
+		* - 正文是**块**：用户/助手文字常显；思考、工具、注入、系统消息、压缩摘要默认折叠，折叠头给
+		*   标签 + 首行摘要（工具另给状态）。注入也铺进正文——这是对宿主 Chat 的有意偏离（它隐藏普通注入，
+		*   而这里的目标是「删之前看全」）；条数另进元信息表。
 		*
-		* 助手正文走 Markdown，用户提问保持原话；样式 token 与差异见 ui/markdown.css 文件头。
-		* 附件随消息位置渲染：用户气泡之上、助手正文之后；附件是那条消息的内容，不单开区块。
+		* 助手正文与思考走 Markdown，用户提问保持原话；工具参数/结果走等宽纯文本（限高可滚）。
+		* 附件随块位置渲染：用户气泡之上、助手正文之后、工具展开体末尾。
 		*/
 		const SHELL = {
 			display: "flex",
@@ -26039,11 +26359,24 @@ window.__ModuleLoader__.load({
 			height: "100%",
 			minWidth: 0
 		};
+		/** 返回键排在标题之后：排在之前会把整条标题的起点往右挤（docs/ui-spec.md 状态⑥）。
+		*  标题排按紧凑按钮（`ui.css` 的 `.sd-button-sm`）预留高度：宽档父详情没有返回键、孩子视图有，
+		*  不预留时下方元信息会在父子切换时跳 6px。 */
 		const HEAD = {
 			display: "flex",
 			alignItems: "flex-start",
-			gap: 10
+			gap: 10,
+			minHeight: 28
 		};
+		const TITLE_LINE = {
+			...ELLIPSIS,
+			flex: "1 1 auto",
+			minWidth: 0,
+			fontSize: 15,
+			fontWeight: 600,
+			lineHeight: "22px"
+		};
+		const BACK = { flex: "none" };
 		/** 元信息那张表：label 一列、值一列，窄档也不横向溢出。 */
 		const META = {
 			display: "grid",
@@ -26123,6 +26456,107 @@ window.__ModuleLoader__.load({
 			border: "0.5px solid var(--dsw-alias-border-l4)",
 			borderRadius: "var(--dsw-radius-lg)"
 		};
+		const BLOCK = {
+			display: "flex",
+			flexDirection: "column",
+			minWidth: 0
+		};
+		/** 折叠头：与清单组头共用 `sd-disclosure-row` 的布局/悬停/无障碍；这里把 button 的 UA 样式压掉。 */
+		const BLOCK_ROW = {
+			background: "none",
+			border: "none",
+			padding: 0,
+			font: "inherit",
+			textAlign: "start",
+			width: "100%",
+			minWidth: 0,
+			gap: 6
+		};
+		/** 标签不参与收缩：摘要是 `1 1 auto`，标签若也可缩，长结果会把「工具调用 / 来源」挤成几个字。 */
+		const BLOCK_TITLE = {
+			...ELLIPSIS,
+			flex: "none",
+			maxWidth: "50%",
+			fontWeight: 500,
+			fontSize: "var(--dsh-content-font-size-secondary, 13px)"
+		};
+		const BLOCK_SUMMARY = {
+			...ELLIPSIS,
+			flex: "1 1 auto",
+			minWidth: 0,
+			fontSize: 12,
+			lineHeight: "18px",
+			color: "var(--dsw-alias-label-tertiary)"
+		};
+		const BLOCK_META = {
+			flex: "none",
+			fontSize: 11.5,
+			lineHeight: "18px",
+			color: "var(--dsw-alias-label-tertiary)",
+			whiteSpace: "nowrap"
+		};
+		const BLOCK_BODY = {
+			display: "flex",
+			flexDirection: "column",
+			gap: 8,
+			padding: "8px 0 4px calc(22px + var(--dsh-content-font-delta, 0px))",
+			minWidth: 0
+		};
+		const PLAIN_BODY = {
+			whiteSpace: "pre-wrap",
+			wordBreak: "break-word",
+			fontSize: "var(--dsh-content-font-size-secondary, 13px)",
+			lineHeight: "20px",
+			color: "var(--dsw-alias-label-secondary)"
+		};
+		/** 工具参数/结果：等宽、保留换行、限高自滚——一段工具输出可能比整页还长。 */
+		const CODE_BLOCK = {
+			margin: 0,
+			padding: "8px 10px",
+			background: "var(--dsw-alias-bg-layer-2)",
+			border: "0.5px solid var(--dsw-alias-border-l4)",
+			borderRadius: "var(--dsw-radius-md)",
+			fontFamily: "var(--ds-font-family-code)",
+			fontSize: 12,
+			lineHeight: "18px",
+			whiteSpace: "pre-wrap",
+			wordBreak: "break-word",
+			maxHeight: 320,
+			overflow: "auto"
+		};
+		const SECTION_LABEL = {
+			fontSize: 11.5,
+			lineHeight: "16px",
+			color: "var(--dsw-alias-label-tertiary)"
+		};
+		/**
+		* 子会话行：折叠头同族的可点行，卡片底 + 小圆角；悬停走 sd-disclosure-row 的宿主配方。
+		* 两处内联覆盖各有理由：宿主类给折叠头钉死行高并随之裁溢出，导航行带内边距，须放开
+		* 高度按内容撑开，否则裁字；指针光标宿主只发给带展开语义的行，导航行不借那套语义，
+		* 光标就内联自给。
+		*/
+		const SUBAGENT_ROW = {
+			...BLOCK_ROW,
+			padding: "6px 10px",
+			height: "auto",
+			cursor: "pointer",
+			background: "var(--dsw-alias-bg-layer-2)",
+			border: "0.5px solid var(--dsw-alias-border-l4)",
+			borderRadius: "var(--dsw-radius-md)"
+		};
+		const TOOLBAR$1 = {
+			display: "flex",
+			alignItems: "center",
+			gap: 8,
+			flexWrap: "wrap",
+			minWidth: 0
+		};
+		const TRUNCATED = {
+			fontSize: 11.5,
+			lineHeight: "16px",
+			color: "var(--dsw-alias-label-tertiary)"
+		};
+		const ERROR_TEXT = { color: "var(--dsw-alias-state-error-primary)" };
 		const HOUR = 36e5;
 		const DAY = 864e5;
 		/** 日志里那两个时间戳缺省时的降级（`src/trash/detail.ts` 把初值写成 0，读不到就是 0）。 */
@@ -26130,11 +26564,13 @@ window.__ModuleLoader__.load({
 			return ms === 0 ? "—" : absoluteText(ms);
 		}
 		/** 活跃跨度：不足一天给小时，超过给天——都是"这条会话活了多久"这一个问题的答案。
-		*  两端任一缺省就**不答**：`Math.max(1, …)` 会把"不知道"报成"1 小时"，那是一条编出来的账。 */
+		*  两端任一缺省就**不答**（不把"不知道"报成任何量级）；不足一小时说"不足 1 小时"，
+		*  不把 10 分钟舍入成 1 小时冒充整点。 */
 		function spanText(from, to, t) {
 			if (from === 0 || to === 0) return void 0;
 			const ms = Math.max(0, to - from);
-			return ms < DAY ? t("detail.value.spanHours", { n: Math.max(1, Math.round(ms / HOUR)) }) : t("detail.value.spanDays", { n: Math.round(ms / DAY) });
+			if (ms < HOUR) return t("detail.value.spanLessThanHour");
+			return ms < DAY ? t("detail.value.spanHours", { n: Math.round(ms / HOUR) }) : t("detail.value.spanDays", { n: Math.round(ms / DAY) });
 		}
 		/** 详情头部显示的那句标题：清册优先，空串才回落到日志里的 `session/title`。 */
 		function titleOf(entry, detail, t) {
@@ -26142,7 +26578,246 @@ window.__ModuleLoader__.load({
 			if (detail !== void 0 && detail.logTitle !== "") return detail.logTitle;
 			return t("common.untitled");
 		}
-		function TrashDetail({ state, busy, wide, onRetry, onBack, t }) {
+		/** 折叠头的摘要：第一行非空文字。 */
+		function firstLine(text) {
+			return (text.split("\n").find((candidate) => candidate.trim() !== "") ?? "").trim();
+		}
+		/** Markdown 块的摘要去掉粗体星号（与宿主 ReasoningRow 同一手法）；纯文本块照原样。 */
+		function markdownSummary(text) {
+			return firstLine(text).replaceAll("**", "");
+		}
+		/** 宿主当前发过的 `source.kind` 全在这里；日志词表随宿主代次增长，新值先落到「其他上下文」。 */
+		const INJECTION_LABEL_KEYS = {
+			"runtime-context": "detail.injection.runtimeContext",
+			"time-context": "detail.injection.timeContext",
+			"agent-instructions": "detail.injection.agentInstructions",
+			"skill-catalog": "detail.injection.skillCatalog",
+			"agent-message": "detail.injection.agentMessage",
+			"subagent-settled": "detail.injection.subagentSettled",
+			"tool-jobs": "detail.injection.toolJobs",
+			"skill-invocation": "detail.injection.skillInvocation",
+			"user-approval": "detail.injection.userApproval",
+			"goal": "detail.injection.goal"
+		};
+		/** 来源标签 + 悬停原串：认不出的 kind 收进「其他上下文」，原串留在 title。 */
+		function injectionLabel(kind, t) {
+			const key = INJECTION_LABEL_KEYS[kind];
+			if (key !== void 0) {
+				const text = t(key);
+				return {
+					text,
+					title: text
+				};
+			}
+			return {
+				text: t("detail.injection.other"),
+				title: kind === "" ? t("detail.injection.other") : kind
+			};
+		}
+		function toolStatus(status, t) {
+			if (status === "ok") return t("detail.block.status.ok");
+			if (status === "error") return t("detail.block.status.error");
+			return t("detail.block.status.unfinished");
+		}
+		function isDisclosureBlock(block) {
+			return block.kind !== "user" && block.kind !== "assistant";
+		}
+		/** 一个可折叠块：折叠头一行（chevron + 标签 + 摘要 + 可选状态 + 时间），展开体由调用方给。 */
+		function Disclosure({ block, label, title, summary, status, time, open, onToggle, children }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				"data-sd-block": block.kind,
+				style: BLOCK,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+					type: "button",
+					className: "sd-disclosure-row",
+					"data-expandable": "",
+					"aria-expanded": open,
+					onClick: () => onToggle(block.id),
+					style: BLOCK_ROW,
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "sd-disclosure-leading",
+							style: { marginRight: 0 },
+							"aria-hidden": "true",
+							children: open ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconChevronDownOutlineRegular, { size: 14 }) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconChevronRightOutlineRegular, { size: 14 })
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: BLOCK_TITLE,
+							title: title ?? label,
+							children: label
+						}),
+						summary === "" ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: BLOCK_SUMMARY,
+							title: summary,
+							children: summary
+						}),
+						status === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: status.error ? {
+								...BLOCK_META,
+								...ERROR_TEXT
+							} : BLOCK_META,
+							children: status.text
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: BLOCK_META,
+							children: time
+						})
+					]
+				}), open ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					"data-sd-block-body": true,
+					style: BLOCK_BODY,
+					children
+				}) : null]
+			});
+		}
+		/** 单块载荷闸截断后的提示：各块共用同一句，别有的画省略号、有的只画字。 */
+		function TruncatedNote({ t }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				style: TRUNCATED,
+				children: t("detail.block.truncated")
+			});
+		}
+		/** 展开体走 Markdown 的折叠块（思考、压缩摘要）。 */
+		function markdownFold(block, label, context) {
+			const { open, toggle, probe, t } = context;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Disclosure, {
+				block,
+				label,
+				summary: markdownSummary(block.text),
+				time: timeText(block.time),
+				open: open.has(block.id),
+				onToggle: toggle,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(MarkdownBody, {
+					text: block.text,
+					t,
+					probe
+				}), block.truncated ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TruncatedNote, { t }) : null]
+			}, block.id);
+		}
+		/** 展开体走等宽原文的折叠块（注入、系统消息）：这两类带附件。 */
+		function plainFold(block, label, context, title) {
+			const { open, toggle, t } = context;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Disclosure, {
+				block,
+				label,
+				title,
+				summary: firstLine(block.text),
+				time: timeText(block.time),
+				open: open.has(block.id),
+				onToggle: toggle,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						style: PLAIN_BODY,
+						children: block.text
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(AttachmentStrip, {
+						attachments: block.attachments,
+						t,
+						align: "start"
+					}),
+					block.truncated ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TruncatedNote, { t }) : null
+				]
+			}, block.id);
+		}
+		/** 块联合新增成员而 `renderBlock` 没跟上时这里编译失败；运行时只可能是前后半版本错配，画空不炸整栏。 */
+		function unhandledBlock(block) {
+			return null;
+		}
+		function renderBlock(block, context) {
+			const { open, toggle, probe, t } = context;
+			switch (block.kind) {
+				case "user": return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					"data-sd-msg": "user",
+					style: USER_ROW,
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							style: META_LINE,
+							children: `${t("detail.role.user")} · ${timeText(block.time)}`
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)(AttachmentStrip, {
+							attachments: block.attachments,
+							t,
+							align: "end"
+						}),
+						block.text === "" ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							"data-sd-bubble": true,
+							style: BUBBLE,
+							children: block.text
+						}),
+						block.truncated ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TruncatedNote, { t }) : null
+					]
+				}, block.id);
+				case "assistant": return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					"data-sd-msg": "assistant",
+					style: ASSISTANT_ROW,
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							style: META_LINE,
+							children: `${t("detail.role.assistant")} · ${timeText(block.time)}`
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)(MarkdownBody, {
+							text: block.text,
+							t,
+							probe
+						}),
+						block.truncated ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TruncatedNote, { t }) : null,
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)(AttachmentStrip, {
+							attachments: block.attachments,
+							t,
+							align: "start"
+						})
+					]
+				}, block.id);
+				case "reasoning": return markdownFold(block, t("detail.block.reasoning"), context);
+				case "tool": return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Disclosure, {
+					block,
+					label: block.name === "" ? t("detail.block.tool") : block.name,
+					summary: firstLine(block.result) || firstLine(block.args),
+					status: {
+						text: toolStatus(block.status, t),
+						error: block.status === "error"
+					},
+					time: timeText(block.time),
+					open: open.has(block.id),
+					onToggle: toggle,
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							style: SECTION_LABEL,
+							children: t("detail.block.args")
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("pre", {
+							style: CODE_BLOCK,
+							children: block.args === "" ? "—" : block.args
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							style: SECTION_LABEL,
+							children: t("detail.block.result")
+						}),
+						block.status === "unfinished" && block.result === "" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							style: META_LINE,
+							children: t("detail.block.noResult")
+						}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("pre", {
+							style: CODE_BLOCK,
+							children: block.result === "" ? "—" : block.result
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)(AttachmentStrip, {
+							attachments: block.attachments,
+							t,
+							align: "start"
+						}),
+						block.argsTruncated || block.resultTruncated ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TruncatedNote, { t }) : null
+					]
+				}, block.id);
+				case "injection": {
+					const label = injectionLabel(block.sourceKind, t);
+					return plainFold(block, `${t("detail.block.injection")} · ${label.text}`, context, `${t("detail.block.injection")} · ${label.title}`);
+				}
+				case "system": return plainFold(block, t("detail.block.system"), context);
+				case "compaction": return markdownFold(block, t("detail.block.compaction"), context);
+				default: return unhandledBlock(block);
+			}
+		}
+		function TrashDetail({ state, busy, wide, onRetry, onBack, detailNav, pager, t }) {
 			if (state.kind === "idle") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 				style: {
 					display: "flex",
@@ -26159,29 +26834,32 @@ window.__ModuleLoader__.load({
 			});
 			const entry = state.entry;
 			const detail = state.kind === "ready" ? state.detail : void 0;
+			const title = titleOf(entry, detail, t);
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 				style: SHELL,
 				children: [
 					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						"data-dsh-session-delete": "trash-detail-head",
 						style: HEAD,
-						children: [wide ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							style: TITLE_LINE,
+							children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								title,
+								children: title
+							})
+						}), detailNav.parentContext !== void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
 							variant: "ghost",
 							size: "sm",
-							style: { flex: "none" },
+							style: BACK,
+							onClick: detailNav.parentContext.onBack,
+							title: detailNav.parentContext.title === "" ? t("common.untitled") : detailNav.parentContext.title,
+							children: t("detail.backToParent")
+						}) : wide ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
+							variant: "ghost",
+							size: "sm",
+							style: BACK,
 							onClick: onBack,
 							children: t("detail.back")
-						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-							style: { minWidth: 0 },
-							children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-								style: {
-									...ELLIPSIS,
-									fontSize: 15,
-									fontWeight: 600,
-									lineHeight: "22px"
-								},
-								title: titleOf(entry, detail, t),
-								children: titleOf(entry, detail, t)
-							})
 						})]
 					}),
 					state.kind === "loading" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LoadingBody, { t }) : null,
@@ -26236,8 +26914,10 @@ window.__ModuleLoader__.load({
 					detail === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReadyBody, {
 						entry,
 						detail,
+						detailNav,
+						pager,
 						t
-					})
+					}, entry.id)
 				]
 			});
 		}
@@ -26281,17 +26961,60 @@ window.__ModuleLoader__.load({
 			})] });
 		}
 		/**
-		* 有内容：元信息（时间 → 体量 → 位置三组的顺序）+ 正文。
+		* 有内容：元信息（时间 → 体量 → 位置三组的顺序）+ 子会话段 + 折叠块。
 		*
-		* 页面上**两本账分开读**：`提问`/`回复` 是过滤后的条数（注入那些由 `injectedCount` 单独说清，不并进
-		* 这两个数），**不受载荷闸影响**；正文是闸过的那一份（单条超限截断、累计到顶后整条不显示）。
-		* 于是「计数 421、正文 200」可以同时成立——怎么过滤、两个闸各是多少归 `src/trash/detail.ts`，这里只摆数。
+		* 页面上**两本账分开读**：元信息里的计数是整条日志的（注入条数也在表里）；
+		* 正文是分页取回来的块。`olderCursor` 非空时顶部出「加载更早」。
+		* 折叠状态只活在这个组件里；切条目用 `key={entry.id}` 重挂载，不会把 A 的展开状态带到 B。
 		*/
-		function ReadyBody({ entry, detail, t }) {
-			const folder = entry.id;
+		function ReadyBody({ entry, detail, detailNav, pager, t }) {
+			const { loadingOlder, olderFailure, onLoadOlder, scrollRef } = pager;
+			const [open, setOpen] = (0, react.useState)(() => /* @__PURE__ */ new Set());
+			/** 更早一页要 prepend 时的块数；换页回来（组件重挂载）这份意图会丢，那是可接受的边界。 */
+			const pendingScroll = (0, react.useRef)(null);
+			/** 上一次布局后的滚动高度：合并更早一页时用它算**真正插进来的高度**，不把请求在飞期间的
+			*  滚动或折叠变化也算进去。 */
+			const lastHeight = (0, react.useRef)(null);
+			const probe = localeProbe(t);
 			const project = detail.cwd === "" ? t("trash.project.unknown") : detail.cwd;
-			const localeKey = t("common.close");
-			const messages = detail.messages.filter((message) => message.text !== "" || message.attachments.length > 0);
+			const disclosureBlocks = detail.blocks.filter(isDisclosureBlock);
+			const allOpen = disclosureBlocks.length > 0 && disclosureBlocks.every((block) => open.has(block.id));
+			const openChild = detailNav.onOpenChild;
+			const toggle = (id) => {
+				setOpen((current) => {
+					const next = new Set(current);
+					if (next.has(id)) next.delete(id);
+					else next.add(id);
+					return next;
+				});
+			};
+			const toggleAll = () => {
+				setOpen(allOpen ? /* @__PURE__ */ new Set() : new Set(disclosureBlocks.map((block) => block.id)));
+			};
+			const loadOlder = () => {
+				const element = scrollRef?.current;
+				if (element !== null && element !== void 0) pendingScroll.current = { blocks: detail.blocks.length };
+				onLoadOlder();
+			};
+			(0, react.useLayoutEffect)(() => {
+				const element = scrollRef?.current;
+				const pending = pendingScroll.current;
+				if (element === null || element === void 0 || pending === null) return;
+				if (detail.blocks.length !== pending.blocks) {
+					pendingScroll.current = null;
+					if (lastHeight.current !== null) element.scrollTop += element.scrollHeight - lastHeight.current;
+					return;
+				}
+				if (!loadingOlder) pendingScroll.current = null;
+			}, [
+				detail.blocks.length,
+				loadingOlder,
+				scrollRef
+			]);
+			(0, react.useLayoutEffect)(() => {
+				const element = scrollRef?.current;
+				if (element !== null && element !== void 0) lastHeight.current = element.scrollHeight;
+			});
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
 				/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("dl", {
 					style: META,
@@ -26335,6 +27058,10 @@ window.__ModuleLoader__.load({
 							label: t("detail.field.toolCalls"),
 							children: String(detail.toolCallCount)
 						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Meta, {
+							label: t("detail.field.injections"),
+							children: String(detail.injectedCount)
+						}),
 						/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Meta, {
 							label: t("detail.field.models"),
 							children: detail.models.join(", ") || "—"
@@ -26351,8 +27078,8 @@ window.__ModuleLoader__.load({
 						}),
 						/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Meta, {
 							label: t("detail.field.trashDir"),
-							title: folder,
-							children: folder
+							title: entry.id,
+							children: entry.id
 						}),
 						/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Meta, {
 							label: t("detail.field.wasArchived"),
@@ -26360,46 +27087,98 @@ window.__ModuleLoader__.load({
 						})
 					]
 				}),
+				detail.subagents === void 0 || detail.subagents.length === 0 || openChild === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					"data-dsh-session-delete": "trash-subagents",
+					style: {
+						display: "flex",
+						flexDirection: "column",
+						gap: 6
+					},
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							style: SECTION_LABEL,
+							children: t("detail.subagents.header", {
+								n: detail.subagents.length,
+								size: fileSizeText(detail.subagents.reduce((sum, child) => sum + child.sizeBytes, 0))
+							})
+						}),
+						detail.subagents.map((child) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+							type: "button",
+							className: "sd-disclosure-row",
+							"data-dsh-session-delete": "trash-subagent-row",
+							"data-entry-id": child.id,
+							style: SUBAGENT_ROW,
+							onClick: () => openChild(child),
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+									style: {
+										...ELLIPSIS,
+										flex: "1 1 auto",
+										minWidth: 0
+									},
+									children: child.title === "" ? t("common.untitled") : child.title
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+									style: BLOCK_META,
+									children: fileSizeText(child.sizeBytes)
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+									style: BLOCK_META,
+									children: agoText(child.deletedAt, Date.now(), t)
+								})
+							]
+						}, child.id)),
+						detail.subagentsTotal === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							style: SECTION_LABEL,
+							"data-dsh-session-delete": "trash-subagents-truncated",
+							children: t("detail.subagents.truncated", {
+								shown: detail.subagents.length,
+								total: detail.subagentsTotal
+							})
+						})
+					]
+				}),
 				/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-					style: META_LINE,
-					children: [detail.injectedCount > 0 ? t("detail.messages.hidden", { count: detail.injectedCount }) : "", detail.omittedByPayloadCap > 0 ? `${detail.injectedCount > 0 ? " · " : ""}${t("detail.messages.omitted", { count: detail.omittedByPayloadCap })}` : ""]
+					style: TOOLBAR$1,
+					children: [
+						detail.olderCursor === null ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
+							variant: "outline",
+							size: "sm",
+							disabled: loadingOlder,
+							onClick: loadOlder,
+							children: loadingOlder ? t("detail.loadOlder.loading") : t("detail.loadOlder")
+						}),
+						olderFailure === null ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							role: "status",
+							style: {
+								...META_LINE,
+								minWidth: 0,
+								wordBreak: "break-word"
+							},
+							children: olderFailure
+						}),
+						disclosureBlocks.length === 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: { marginLeft: "auto" },
+							children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
+								variant: "ghost",
+								size: "sm",
+								onClick: toggleAll,
+								children: allOpen ? t("detail.collapseAll") : t("detail.expandAll")
+							})
+						})
+					]
 				}),
-				messages.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				detail.blocks.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 					style: META_LINE,
 					children: t("detail.noBody")
 				}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 					style: THREAD,
-					children: messages.map((message, index) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-						"data-sd-msg": message.role,
-						style: message.role === "user" ? USER_ROW : ASSISTANT_ROW,
-						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-							style: META_LINE,
-							children: `${message.role === "user" ? t("detail.role.user") : t("detail.role.assistant")} · ${timeText(message.time)}`
-						}), message.role === "user" ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(AttachmentStrip, {
-							attachments: message.attachments,
-							t,
-							align: "end"
-						}), message.text === "" && !message.truncated ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-							"data-sd-bubble": true,
-							style: BUBBLE,
-							children: [message.text, message.truncated ? "…" : ""]
-						})] }) : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
-							/* @__PURE__ */ (0, react_jsx_runtime.jsx)(MarkdownBody, {
-								text: message.text,
-								t,
-								localeKey
-							}),
-							message.truncated ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-								style: META_LINE,
-								children: "…"
-							}) : null,
-							/* @__PURE__ */ (0, react_jsx_runtime.jsx)(AttachmentStrip, {
-								attachments: message.attachments,
-								t,
-								align: "start"
-							})
-						] })]
-					}, `${message.time}-${index}`))
+					children: detail.blocks.map((block) => renderBlock(block, {
+						open,
+						toggle,
+						probe,
+						t
+					}))
 				})
 			] });
 		}
@@ -26496,7 +27275,7 @@ window.__ModuleLoader__.load({
 		*/
 		function usePanelWidth(ref) {
 			const [width, setWidth] = (0, react.useState)(0);
-			(0, react.useEffect)(() => {
+			(0, react.useLayoutEffect)(() => {
 				const el = ref.current;
 				if (el === null) return;
 				setWidth(el.getBoundingClientRect().width);
@@ -26515,7 +27294,7 @@ window.__ModuleLoader__.load({
 		//#region src/client/trash-nav.ts
 		/**
 		* 清单的键盘导航面：方向键走环、Enter/Space 的双重语义、roving tabindex 的落点，
-		* 以及窄档下钻里按 Esc 退回清单并把焦点交还给那一行。
+		* 以及窄档下钻里按 Esc 回退——孩子视图开着时先回父详情，再按一次才退出下钻并把焦点交还给那一行。
 		*
 		* 它不查自己的行、不认行选择器：焦点动作由调用方注入 focusRow，行的 DOM 查询留在面板；
 		* 唯一的文档查询是 Esc 让路判据（问 ui/top-layer.ts 当前有没有打开的 dialog/menu）。
@@ -26524,17 +27303,18 @@ window.__ModuleLoader__.load({
 		* 判据（界面现状见 docs/ui-spec.md「键盘」）：
 		* - 方向键走环：未选中时 ↓ 落第一条、↑ 落最后一条；到端回卷。
 		* - aria-activedescendant 只指向在 DOM 里的行；tab 落点永远有一行拿着。
-		* - Esc 只在下钻期间生效；退回后把焦点交还选中行一次；最上层是确认框/菜单时让路。
+		* - Esc 只在下钻期间生效，回退分两程（先收孩子视图、再退下钻）；退出下钻后把焦点交还选中行一次；
+		*   最上层是确认框/菜单时让路。
 		*/
-		/** 事件是不是清单自己的：从行（`role="option"`）或容器起来才算；行内按钮 / 勾选框的 Enter / Space
+		/** 事件是不是清单自己的：从行（`role="row"`）或容器起来才算；行内按钮 / 勾选框的 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";
+			return typeof target.getAttribute === "function" && target.getAttribute("role") === "row";
 		}
 		function useTrashNav(input) {
-			const { ordered, selectedId, selectMode, drillEnabled, drilled, select, toggleCheck, exitDrill, focusRow } = input;
+			const { ordered, selectedId, selectMode, drillEnabled, drilled, select, toggleCheck, back, focusRow } = input;
 			/** Esc 退出下钻后要交还焦点的那一行；等 `drilled` 落地、清单回到 DOM 之后再用一次。 */
 			const refocusRow = (0, react.useRef)(null);
 			/** 折叠起来的组只是收掉那一列，选中的 id 还留着——所以这条可见性得逐条对账，不能只看非空。 */
@@ -26548,6 +27328,7 @@ window.__ModuleLoader__.load({
 					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];
+					if (target === void 0) return;
 					select(target);
 					focusRow(target.id);
 					return;
@@ -26578,7 +27359,7 @@ window.__ModuleLoader__.load({
 					if (event.key !== "Escape" || event.defaultPrevented) return;
 					if (hasTopLayer(document)) return;
 					refocusRow.current = selectedId;
-					exitDrill();
+					back();
 				};
 				document.addEventListener("keydown", onKey);
 				return () => {
@@ -26587,7 +27368,7 @@ window.__ModuleLoader__.load({
 			}, [
 				drillEnabled,
 				drilled,
-				exitDrill,
+				back,
 				selectedId
 			]);
 			(0, react.useEffect)(() => {
@@ -26611,6 +27392,9 @@ window.__ModuleLoader__.load({
 		* - 读不到就说读不到：失败进 `unknown`（原文上屏），不折成"空的"。
 		* - 附件读数只住在写动作的回执里：清单重读读不出来，所以它单独一条提示、**最新的写赢**。
 		*
+		* 输入的引用**不需稳定**：`deps` / `t` / `gate` 经 `useLatest` 归一（判据住 `store.ts`），
+		* 返回的三个回调身份恒稳，可安全进调用方 effect 的依赖。
+		*
 		* 无主子会话的检查/清理**不在这一面**：那是插件设置页维护卡的手动动作（`use-maintenance.ts`）。
 		* 面板挂载、写后重读与清空都只碰清单，一次都不自动扫（ADR-0021）。
 		*/
@@ -26639,11 +27423,17 @@ window.__ModuleLoader__.load({
 		function useTrashQuery({ deps, t, gate }) {
 			const [list, setList] = (0, react.useState)({ status: "loading" });
 			const [attachmentNotice, setAttachmentNotice] = (0, react.useState)(null);
+			/** 输入引用归一（判据住 `store.ts` 的 `useLatest`）：回调经它读最新输入，身份恒稳。 */
+			const latest = useLatest({
+				deps,
+				t,
+				gate
+			});
 			/** 清单的唯一读法：签到一张票再发请求；输给后发的读时这一次什么都不落地（不让旧响应盖掉新状态）。 */
 			const [reloadLatest] = (0, react.useState)(createLatestWins);
 			const reload = (0, react.useCallback)(async () => {
 				const ticket = reloadLatest.issue();
-				const outcome = await callRemote(() => deps.list());
+				const outcome = await callRemote(() => latest.current.deps.list());
 				if (!ticket.current) return;
 				if (!outcome.ok) {
 					setList({
@@ -26656,7 +27446,7 @@ window.__ModuleLoader__.load({
 					status: "ready",
 					rows: outcome.value
 				});
-			}, [deps, reloadLatest]);
+			}, [reloadLatest]);
 			/**
 			* 附件读数上屏：`skipped`（这一轮部分或整体没敢清）优先于 `failed`（逐文件真出错）——前者是原因，
 			* 后者只是件数。**`removed > 0` 时不许说成"整轮没清"**：那一轮清掉了 `removed` 件，只是没清完，
@@ -26668,21 +27458,20 @@ window.__ModuleLoader__.load({
 					setAttachmentNotice(null);
 					return;
 				}
-				const skipped = attachmentSkippedSentence(a, t);
+				const skipped = attachmentSkippedSentence(a, latest.current.t);
 				if (skipped !== null) {
 					setAttachmentNotice(skipped);
 					return;
 				}
-				setAttachmentNotice(a.failed > 0 ? t("trash.attachments.failed", { count: a.failed }) : null);
-			}, [t]);
+				setAttachmentNotice(a.failed > 0 ? latest.current.t("trash.attachments.failed", { count: a.failed }) : null);
+			}, []);
 			return {
 				list,
 				attachmentNotice,
 				noteAttachmentCleanup,
-				refreshAll: reload,
-				refreshAfterWrite: reload,
-				emptyTrash: (0, react.useCallback)(() => gate.around(async () => {
-					const outcome = await callRemote(() => deps.emptyTrash());
+				reload,
+				emptyTrash: (0, react.useCallback)(() => latest.current.gate.around(async () => {
+					const outcome = await callRemote(() => latest.current.deps.emptyTrash());
 					if (!outcome.ok) {
 						reloadLatest.invalidate();
 						setList({
@@ -26697,8 +27486,6 @@ window.__ModuleLoader__.load({
 					noteAttachmentCleanup(outcome.value.attachments);
 					return true;
 				}), [
-					gate,
-					deps,
 					reload,
 					reloadLatest,
 					noteAttachmentCleanup
@@ -26708,7 +27495,7 @@ window.__ModuleLoader__.load({
 		//#endregion
 		//#region src/client/use-trash-panel-controller.ts
 		/**
-		* 回收站面板状态机：选中、详情缓存、窄档下钻、清单换版清场、宽档自动选中、
+		* 回收站面板状态机：选中、孩子视图、详情缓存、窄档下钻、清单换版清场、宽档自动选中、
 		* 失效重读，以及确认后的恢复/批量/清空与失败落点。
 		*
 		* 关键判据：
@@ -26716,36 +27503,87 @@ window.__ModuleLoader__.load({
 		* - 详情成功读数按条目 id 缓存；失败不缓存，重试会重新读。
 		* - 选中 id 不在新清单里 ⇒ 丢缓存、清选中、退出下钻；清单读不到（null）不算“没了”。
 		* - 自动选中只在 selectedId 为 null 时接管。
-		* - 失效通告只触发 refreshAfterWrite()；动作成功必须在同一趟里丢详情缓存。
-		* - back() 只收下钻，不碰焦点；失败原文不翻译。
+		* - 失效通告与挂载都只触发 reload()；动作成功必须在同一趟里丢详情缓存。
+		* - back() 先收孩子视图、再收下钻，不碰焦点；失败原文不翻译。
+		*/
+		/**
+		* 「渲染态 + 同步镜像」成对出现时的唯一写口：setter 同步更新 ref。`setState` 要等下一拍，
+		* 而落地判「用户还在不在这一条」（`loadOlder` 的晚到结果）是同一 tick 里的事。写只走 setter——
+		* 再手写一处 `ref.current = x` 就是第二份同步，两处迟早漂移。
+		*/
+		function useSyncedRef(initial) {
+			const ref = (0, react.useRef)(initial);
+			const [value, setValue] = (0, react.useState)(initial);
+			return [
+				value,
+				(0, react.useCallback)((next) => {
+					ref.current = next;
+					setValue(next);
+				}, []),
+				ref
+			];
+		}
+		/**
+		* 在飞句柄：`/detail` 与「更早一页」各持一份。两条时间线各有自己的载体，别混——判重在
+		* **同步**这一侧（`begin`：同一 tick 连点不发第二条；登记按条目，A 在飞不挡 B，也绝不放
+		* 同一条进两条），上屏在 **state** 那一侧（渲染位单槽要等下一拍，只回答「当前这条转不转圈」）。
+		* 置位/清位只走这四个方法，不再一对 state+ref 镜像各写一份同步。
 		*/
+		function useInFlight() {
+			const flying = (0, react.useRef)(/* @__PURE__ */ new Set());
+			const [shownId, setShownId] = (0, react.useState)(null);
+			const show = (0, react.useCallback)((id) => setShownId(id), []);
+			const begin = (0, react.useCallback)((id) => {
+				if (flying.current.has(id)) return false;
+				flying.current.add(id);
+				return true;
+			}, []);
+			const end = (0, react.useCallback)((id) => {
+				flying.current.delete(id);
+				setShownId((current) => current === id ? null : current);
+			}, []);
+			const clear = (0, react.useCallback)(() => {
+				flying.current.clear();
+				setShownId(null);
+			}, []);
+			return [shownId, (0, react.useMemo)(() => ({
+				show,
+				begin,
+				end,
+				clear
+			}), [
+				show,
+				begin,
+				end,
+				clear
+			])];
+		}
 		function useTrashPanelController(input) {
 			const { deps, gate, query, ordered, canAutoSelect } = input;
-			const { list, refreshAll, refreshAfterWrite, emptyTrash, noteAttachmentCleanup } = query;
+			const { list, reload, emptyTrash, noteAttachmentCleanup } = query;
 			const entries = listView(list).rows;
-			const [selectedId, setSelectedId] = (0, react.useState)(null);
+			const [selectedId, setSelectedId, selectedIdRef] = useSyncedRef(null);
+			/** 详情主体可以离清单：孩子视图开着时画的是孩子，`selectedId` 仍指着父行。 */
+			const [childView, setChildView, childViewRef] = useSyncedRef(null);
 			const [drilled, setDrilled] = (0, react.useState)(false);
-			const [loadingId, setLoadingId] = (0, react.useState)(null);
+			const [detailShown, detailFlight] = useInFlight();
 			const [detailFailure, setDetailFailure] = (0, react.useState)(null);
+			const [olderShown, olderFlight] = useInFlight();
+			const [olderFailureState, setOlderFailure] = (0, react.useState)(null);
+			/** 缓存是 ref：合并更早一页后要有一个**必然变化**的 state 把新对象推上屏（极快的响应会把
+			*  分页渲染位的置位/清位合批成净零变化，React 会直接 bail out）。 */
+			const [detailVersion, setDetailVersion] = (0, react.useState)(0);
 			const [pending, setPending] = (0, react.useState)(null);
 			const [actionFailure, setActionFailure] = (0, react.useState)({});
 			/** 面板存活期内每条只读一次（本机量级不值得预读，也不值得重复读）。 */
 			const detailCache = (0, react.useRef)(/* @__PURE__ */ new Map());
-			/** 挂载那一拍读一次清单，之后失效通告只走写后刷新（两条名字不同，读法是同一条）。 */
-			const firstRefresh = (0, react.useRef)(true);
+			/** 失效重读的载体：`reload` 回调经 `useLatest` 读最新那一份（判据住 `store.ts`），
+			*  失效 effect 的判据只有 `revision`——挂载首拍与后续通告现在是同一个动作，不再分两支。 */
+			const refreshers = useLatest({ reload });
 			const revision = useTrashRevision();
 			(0, react.useEffect)(() => {
-				if (firstRefresh.current) {
-					firstRefresh.current = false;
-					refreshAll();
-					return;
-				}
-				refreshAfterWrite();
-			}, [
-				refreshAll,
-				refreshAfterWrite,
-				revision
-			]);
+				refreshers.current.reload();
+			}, [revision]);
 			(0, react.useEffect)(() => {
 				if (pending !== null && !gate.busy && list.status === "unknown") setPending(null);
 			}, [
@@ -26753,40 +27591,108 @@ window.__ModuleLoader__.load({
 				list.status,
 				pending
 			]);
+			/** 按 entryId 确保详情在缓存里：命中直接摆，没命中读一次（在飞闸挡重复）。
+			*  选中（select）与孩子视图（openChild）共用这一条读路——缓存/在飞/失败都按 entryId 键控，
+			*  谁在屏幕上是 subject 的事，不是读路的事。 */
+			const ensureDetail = (0, react.useCallback)(async (entryId) => {
+				if (detailCache.current.has(entryId)) {
+					detailFlight.show(null);
+					setDetailFailure(null);
+					return;
+				}
+				detailFlight.show(entryId);
+				setDetailFailure(null);
+				if (!detailFlight.begin(entryId)) return;
+				const outcome = await callRemote(() => deps.detail(entryId));
+				detailFlight.end(entryId);
+				if (outcome.ok) detailCache.current.set(entryId, outcome.value);
+				else setDetailFailure({
+					entryId,
+					message: outcome.failure.message
+				});
+			}, [deps, detailFlight]);
 			/**
 			* 选一条：命中缓存就直接摆（不经过 loading），没命中才去读那条会话自己的日志。
 			* `drill` 是窄档的第二步语义（点行 = 选中并下钻；方向键 = 只移动选中）。
+			* 选清单行就是回清单：孩子视图跟着收掉（详情主体交还给选中那条）。
 			*/
 			const select = (0, react.useCallback)(async (entry, options = {}) => {
+				setChildView(null);
 				setSelectedId(entry.id);
+				setOlderFailure(null);
 				if (options.drill === true) setDrilled(true);
-				if (detailCache.current.has(entry.id)) {
-					setLoadingId(null);
-					setDetailFailure(null);
+				await ensureDetail(entry.id);
+			}, [ensureDetail]);
+			const openChild = (0, react.useCallback)(async (child) => {
+				setChildView(child);
+				setOlderFailure(null);
+				await ensureDetail(child.id);
+			}, [ensureDetail]);
+			const closeChild = (0, react.useCallback)(() => {
+				setChildView(null);
+				setOlderFailure(null);
+			}, []);
+			/**
+			* 按当前详情的 `olderCursor` 取更早一页，拼到现有块前面。
+			*
+			* 三条判据：没有游标 / 这一条已有更早页在飞 ⇒ 不发请求（同一 tick 连点、或切走再切回都撞
+			* 在飞登记——晚到的第二条注定落不了屏，白打一次往返）；用户已经切走或缓存已被换掉 ⇒ 晚到的
+			* 页**不落屏**（A 的更早页不许盖掉 B）；失败只走 `olderFailure`，已读到的正文照旧是 ready。
+			*/
+			const loadOlder = (0, react.useCallback)(async () => {
+				const entryId = childView?.id ?? selectedId;
+				if (entryId === null) return;
+				const cached = detailCache.current.get(entryId);
+				if (cached === void 0 || cached.olderCursor === null) return;
+				olderFlight.show(entryId);
+				setOlderFailure(null);
+				if (!olderFlight.begin(entryId)) return;
+				const cursor = cached.olderCursor;
+				const outcome = await callRemote(() => deps.detail(entryId, cursor));
+				olderFlight.end(entryId);
+				if ((childViewRef.current?.id ?? selectedIdRef.current) !== entryId) return;
+				const current = detailCache.current.get(entryId);
+				if (current !== cached) return;
+				if (outcome.ok) {
+					detailCache.current.set(entryId, {
+						...current,
+						blocks: [...outcome.value.blocks, ...current.blocks],
+						olderCursor: outcome.value.olderCursor
+					});
+					setDetailVersion((version) => version + 1);
 					return;
 				}
-				setLoadingId(entry.id);
-				setDetailFailure(null);
-				const outcome = await callRemote(() => deps.detail(entry.id));
-				setLoadingId((current) => current === entry.id ? null : current);
-				if (outcome.ok) detailCache.current.set(entry.id, outcome.value);
-				else setDetailFailure({
-					entryId: entry.id,
+				setOlderFailure({
+					entryId,
 					message: outcome.failure.message
 				});
-			}, [deps]);
+			}, [
+				deps,
+				childView,
+				selectedId,
+				olderFlight
+			]);
 			(0, react.useEffect)(() => {
 				if (entries === null || selectedId === null) return;
 				if (entries.some((entry) => entry.id === selectedId)) return;
 				detailCache.current.delete(selectedId);
 				setSelectedId(null);
+				setChildView(null);
+				olderFlight.clear();
 				setDrilled(false);
-			}, [entries, selectedId]);
+				setOlderFailure(null);
+			}, [
+				entries,
+				selectedId,
+				setSelectedId,
+				olderFlight
+			]);
 			(0, react.useEffect)(() => {
 				if (canAutoSelect && drilled) setDrilled(false);
 			}, [canAutoSelect, drilled]);
 			(0, react.useEffect)(() => {
-				if (canAutoSelect && selectedId === null && ordered.length > 0) select(ordered[0]);
+				const first = ordered[0];
+				if (canAutoSelect && selectedId === null && first !== void 0) select(first);
 			}, [
 				canAutoSelect,
 				selectedId,
@@ -26798,6 +27704,34 @@ window.__ModuleLoader__.load({
 			* 右栏那条不该跟着消失——详情读的是这条会话，跟清单怎么分段无关。
 			*/
 			const selected = (0, react.useMemo)(() => (entries ?? []).find((entry) => entry.id === selectedId) ?? null, [entries, selectedId]);
+			/** 详情现在画谁：孩子视图开着就是孩子，否则是清单选中那条。孩子不在清单里，
+			*  所以它是离清单的导航态——selectedId 不动，清场/自动选中/组动作全部照旧。 */
+			const subject = childView ?? selected;
+			/**
+			* 详情的导航面（ADR-0029 单级判据的唯一实现，住控制器）：
+			* - 孩子视图没开（主体是清单选中那条）⇒ `onOpenChild` 在场、`parentContext` 缺席。
+			*   在孩子视图里再开一层会造出第二套导航路径，还会让那颗返回指着孙辈说话（更深一代走清单可达，
+			*   判据住 `src/trash/groups.ts`），所以入口只在这半边交出。
+			* - 孩子视图开着 ⇒ `onOpenChild` 缺席、`parentContext` 交回父：title 是**选中行的原文**
+			*   （未命名兜底由视图按 t 处理，控制器不碰翻译），onBack 收孩子视图。
+			* - `selected` 为 null（清单换版把父行收走的那一帧，清场 effect 随后也把孩子视图收掉）
+			*   ⇒ `parentContext` 缺席：返回键不能指着一个不存在的父。
+			*/
+			const detailNav = (0, react.useMemo)(() => {
+				if (childView === null) return { onOpenChild: (child) => {
+					openChild(child);
+				} };
+				if (selected === null) return {};
+				return { parentContext: {
+					title: selected.title,
+					onBack: closeChild
+				} };
+			}, [
+				childView,
+				selected,
+				openChild,
+				closeChild
+			]);
 			/** 恢复确认框要摆的这一批：按勾选顺序，清单里已经找不到的 id 滤掉
 			*  （别的窗口刚动过；重读会把勾选也剔掉）。单条与整站确认框不摆条目，各自念自己的那一句。 */
 			const pendingEntries = (0, react.useMemo)(() => {
@@ -26806,39 +27740,58 @@ window.__ModuleLoader__.load({
 				return pending.ids.map((id) => byId.get(id)).filter((entry) => entry !== void 0);
 			}, [entries, pending]);
 			const detail = (0, react.useMemo)(() => {
-				if (selected === null) return { kind: "idle" };
-				if (loadingId === selected.id) return {
+				if (subject === null) return { kind: "idle" };
+				if (detailShown === subject.id) return {
 					kind: "loading",
-					entry: selected
+					entry: subject
 				};
-				const cached = detailCache.current.get(selected.id);
+				const cached = detailCache.current.get(subject.id);
 				if (cached !== void 0) return {
 					kind: "ready",
-					entry: selected,
+					entry: subject,
 					detail: cached
 				};
-				if (detailFailure?.entryId === selected.id) return {
+				if (detailFailure?.entryId === subject.id) return {
 					kind: "failed",
-					entry: selected,
+					entry: subject,
 					message: detailFailure.message
 				};
 				return {
 					kind: "loading",
-					entry: selected
+					entry: subject
 				};
 			}, [
-				selected,
-				loadingId,
-				detailFailure
+				subject,
+				detailShown,
+				detailFailure,
+				detailVersion
 			]);
+			/** 分页/失败都只对当前详情主体上屏（孩子视图开着就是孩子）；切到别的条目时它们是别人家的旧账。 */
+			const subjectId = subject?.id ?? null;
+			const loadingOlder = subjectId !== null && olderShown === subjectId;
+			const olderFailure = olderFailureState !== null && olderFailureState.entryId === subjectId ? olderFailureState.message : null;
 			/** 「重试」只重读当前这一条，不牵清单。 */
 			const retry = (0, react.useCallback)(() => {
+				if (childView !== null) {
+					ensureDetail(childView.id);
+					return;
+				}
 				if (selected !== null) select(selected);
-			}, [selected, select]);
-			/** 退出下钻（「← 返回清单」）：选中留着，详情不清；焦点不动（Esc 那条归 `trash-nav.ts`）。 */
+			}, [
+				childView,
+				ensureDetail,
+				selected,
+				select
+			]);
+			/** 窄档返回/Esc 的两程：孩子视图开着先回父详情（仍下钻），再按一次才退出下钻。
+			*  选中留着，详情不清；焦点不动（Esc 那条归 `trash-nav.ts`）。 */
 			const back = (0, react.useCallback)(() => {
+				if (childView !== null) {
+					closeChild();
+					return;
+				}
 				setDrilled(false);
-			}, []);
+			}, [childView, closeChild]);
 			const request = (0, react.useCallback)((action) => {
 				setPending(action);
 			}, []);
@@ -26856,38 +27809,51 @@ window.__ModuleLoader__.load({
 			const clearDetailCache = (0, react.useCallback)((successIds) => {
 				for (const id of successIds) detailCache.current.delete(id);
 			}, []);
+			/** 清掉这些行的旧失败；没有任何一行挂着失败时原样返回，不触发多余的一拍。 */
+			const clearRowFailures = (0, react.useCallback)((ids) => {
+				setActionFailure((current) => {
+					let changed = false;
+					const next = { ...current };
+					for (const id of ids) if (Object.hasOwn(next, id)) {
+						delete next[id];
+						changed = true;
+					}
+					return changed ? next : current;
+				});
+			}, []);
 			/**
 			* 单条恢复：**先清掉这一行的旧失败**（再点一次不该还挂着上一次的原文），再把整趟交给面板恢复座位。
 			* 成功要丢详情缓存 + 重读清单——缓存不失效的话，这条会话再被删回来时会直接摆出上一世的正文。
 			* 失败也重读：组回滚可能自己失败（`details.rollbackFailures`），清单不能继续摆旧行。
-			* 「重读也在这趟里」由 `runWrite` 的闸保证：旧清单还在屏上时同一个动作不能被再点一次。
+			* 「重读也在这趟里」由 `runWrite` 的闸保证：旧清单还在屏上时同一个动作不能被再点一次——再点那一次
+			* 被同步挡回、整趟不跑（座位交回 `undefined`），这一行保持原样，等在飞那一趟的结论。
 			* 单条恢复走 `single` 读法，`already-gone` 不可能出现，座位里那条查找兜底在此不会命中。
 			* 座位的 refresh 仍按 `WriteOutcome` 给（那只信封里没有附件读数要转交）：这里只把它换成"重读"这一个动作，
-			* outcome 不再流向 query——孤儿重扫判据已不在面板（ADR-0021）。
+			* outcome 不再流向 query——孤儿重扫判据已不在面板（ADR-0021）。座位字段仍叫 `refreshAfterWrite`
+			* （`write-seats.ts` 的信封接口，写座位自己的名字），与清单重读已合一的旧双名无关。
 			*/
 			const restore = (0, react.useCallback)(async (entry) => {
-				setActionFailure((current) => {
-					const next = { ...current };
-					delete next[entry.id];
-					return next;
-				});
-				const failure = (await restoreFromPanel({
+				clearRowFailures([entry.id]);
+				const outcome = await restoreFromPanel({
 					deps,
 					ids: [entry.id],
 					single: true,
 					entries,
 					gate,
-					refreshAfterWrite: () => refreshAfterWrite(),
+					refreshAfterWrite: () => reload(),
 					clearDetailCache
-				})).failures.get(entry.id);
+				});
+				if (outcome === void 0) return;
+				const failure = outcome.failures.get(entry.id);
 				if (failure !== void 0) failRow(entry.id, failure);
 			}, [
 				clearDetailCache,
+				clearRowFailures,
 				deps,
 				entries,
 				failRow,
 				gate,
-				refreshAfterWrite
+				reload
 			]);
 			/**
 			* 批量彻底删除 / 批量恢复**共用这一条**：一次 `apply` 把整批交给 Node 半，逐条成败住在
@@ -26895,10 +27861,11 @@ window.__ModuleLoader__.load({
 			* 不能断言哪几条落地：原文保守地铺到每一个 id（别让清单看起来"删成功了"），清单照样重读。
 			*/
 			const confirmApply = (0, react.useCallback)(async (action, ids) => {
+				clearRowFailures(ids);
 				const settle = (outcome) => {
 					setPending(null);
 					if (action === "purge") noteAttachmentCleanup(outcome.ok ? outcome.summary.attachmentCleanup : void 0);
-					return refreshAfterWrite();
+					return reload();
 				};
 				const seat = {
 					deps,
@@ -26911,6 +27878,7 @@ window.__ModuleLoader__.load({
 					...seat,
 					entries
 				});
+				if (outcome === void 0) return;
 				if (outcome.failures.size === 0) return;
 				setActionFailure((current) => {
 					const next = { ...current };
@@ -26919,10 +27887,11 @@ window.__ModuleLoader__.load({
 				});
 			}, [
 				clearDetailCache,
+				clearRowFailures,
 				deps,
 				entries,
 				gate,
-				refreshAfterWrite,
+				reload,
 				noteAttachmentCleanup
 			]);
 			/**
@@ -26937,6 +27906,7 @@ window.__ModuleLoader__.load({
 				if (target.kind === "entries") return confirmApply("purge", target.ids);
 				if (target.kind === "restore") return confirmApply("restore", target.ids);
 				const emptied = await emptyTrash();
+				if (emptied === void 0) return;
 				setPending(null);
 				if (emptied) detailCache.current.clear();
 			}, [
@@ -26948,12 +27918,19 @@ window.__ModuleLoader__.load({
 				busy: gate.busy,
 				selected,
 				selectedId,
+				childView,
+				detailNav,
+				openChild,
+				closeChild,
 				drilled,
 				detail,
+				loadingOlder,
+				olderFailure,
 				pending,
 				pendingEntries,
 				actionFailure,
 				select,
+				loadOlder,
 				retry,
 				back,
 				request,
@@ -27091,6 +28068,9 @@ window.__ModuleLoader__.load({
 		const HANDLE_STEP = 20;
 		/** 详情正文的收口宽度：中央列再宽也不把文字拉成长线。 */
 		const DETAIL_TEXT_MAX_WIDTH = 860;
+		/** 清单 grid 的列数：条目行恒为两格（常态：内容 + 动作；多选态：勾选框占内容前的一格、动作列退场）；
+		*  组头只有一格，用 colspan 横跨整行——各行列数一致是 grid 的播报契约（ADR-0028）。 */
+		const LIST_COLUMN_COUNT = 2;
 		/**
 		* 页面骨架：撑满中央列（`height:100%` 落在 `.centerCol` 这个有定高的网格项上），自收滚动。
 		*
@@ -27177,6 +28157,15 @@ window.__ModuleLoader__.load({
 				unit: unitWord(unit, t)
 			});
 		}
+		/**
+		* 行的 DOM id。entry id 里可能带空白/引号（目录名只挡路径分隔符），直接拼进 HTML id 是非法值、
+		* `aria-activedescendant` 也会失配——所以**在 DOM 这一侧编码**（issue #8 第 7 条）：`data-entry-id`
+		* 仍留原始 id，焦点交还按属性值比对不受影响。entry id 本身不许改形：它是回收站目录名，
+		* 恢复要按它反推原目录名放回（`trash/entry.ts` 的往返契约）。
+		*/
+		function domRowId(entryId) {
+			return `sd-trash-${encodeURIComponent(entryId)}`;
+		}
 		function TrashPanel({ deps, t = zhTranslate }) {
 			/** 面板唯一的一枚全局闸（写动作在飞时按住一排按钮）：本体住 `busy-gate.ts`，查询侧的写动作也吃它。 */
 			const gate = useBusyGate();
@@ -27185,11 +28174,13 @@ window.__ModuleLoader__.load({
 				t,
 				gate
 			});
-			const { list: listState, refreshAll } = query;
+			const { list: listState, reload } = query;
 			const view = listView(listState);
 			const entries = view.rows;
 			const listRef = (0, react.useRef)(null);
 			const rootRef = (0, react.useRef)(null);
+			/** 详情栏的滚动容器：分页 prepend 后按高度差补偿滚动位置（归 `trash-detail.tsx` 消费）。 */
+			const detailScrollRef = (0, react.useRef)(null);
 			const width = usePanelWidth(rootRef);
 			/**
 			* 真走两栏的条件：盒子够宽 **且清单里有东西可看**。空态与读数失败时右栏不出现——那一栏既没有
@@ -27211,9 +28202,16 @@ window.__ModuleLoader__.load({
 				entries,
 				groups
 			});
-			/** 行的 DOM 查询留给面板；导航只拿"把焦点还给哪一行"这个动作（不认行选择器）。 */
+			/** 行的 DOM 查询留给面板；导航只拿"把焦点还给哪一行"这个动作（不认行选择器）。
+			*  按属性值自己比，不把 `entryId` 拼进选择器：id 只挡路径分隔符（`trash/entry.ts`），另一半是
+			*  宿主给的目录名，带引号时选择器直接抛。 */
 			const focusRow = (0, react.useCallback)((entryId) => {
-				(listRef.current?.querySelector(`[data-entry-id="${entryId}"]`))?.focus();
+				const rows = listRef.current?.querySelectorAll("[data-entry-id]");
+				if (rows === void 0) return;
+				for (const row of rows) if (row.getAttribute("data-entry-id") === entryId) {
+					row.focus();
+					return;
+				}
 			}, []);
 			/**
 			* 选中 / 详情缓存 / 清单换版清场 / 宽档自动选中 / 写动作与失败落点，整块住在
@@ -27240,7 +28238,7 @@ window.__ModuleLoader__.load({
 				drilled: controller.drilled,
 				select: controller.select,
 				toggleCheck,
-				exitDrill: controller.back,
+				back: controller.back,
 				focusRow
 			});
 			const pending = controller.pending;
@@ -27256,14 +28254,19 @@ window.__ModuleLoader__.load({
 			/**
 			* 清单容器（roving tabindex 的唯一 tab 巢）。`flex:'1 1 auto'` 撑起空态居中的父链；
 			* `min-height:auto` 让长清单保持内容高，滚动交给外层。
+			*
+			* ARIA 模式是 **grid** 而不是 listbox（为什么：裁决见 ADR-0028）。只有真有行时才挂 grid
+			* 与它的 aria：失败/加载/空态是一块普通内容，不是「空的 grid」，generic div 不背 aria 名字。
 			*/
+			const gridActive = view.failure === null && hasEntries;
 			const list = /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 				ref: listRef,
 				"data-dsh-session-delete": "trash-list",
-				role: "listbox",
-				"aria-label": t("detail.list.label"),
-				"aria-activedescendant": nav.activeDescendantId === null ? void 0 : `sd-trash-${nav.activeDescendantId}`,
-				"aria-multiselectable": selectMode ? true : void 0,
+				role: gridActive ? "grid" : void 0,
+				"aria-label": gridActive ? t("detail.list.label") : void 0,
+				"aria-colcount": gridActive ? LIST_COLUMN_COUNT : void 0,
+				"aria-activedescendant": gridActive && nav.activeDescendantId !== null ? domRowId(nav.activeDescendantId) : void 0,
+				"aria-multiselectable": gridActive && selectMode ? true : void 0,
 				tabIndex: -1,
 				onKeyDown: nav.onListKeyDown,
 				style: {
@@ -27320,7 +28323,7 @@ window.__ModuleLoader__.load({
 							variant: "outline",
 							size: "sm",
 							style: { flex: "none" },
-							onClick: () => void refreshAll(),
+							onClick: () => void reload(),
 							children: t("common.retry")
 						})
 					]
@@ -27376,6 +28379,7 @@ window.__ModuleLoader__.load({
 						})
 					]
 				}) : groups.map((group) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+					role: "rowgroup",
 					"data-dsh-session-delete": "trash-group",
 					"aria-label": group.label,
 					style: {
@@ -27384,7 +28388,8 @@ window.__ModuleLoader__.load({
 						gap: 8,
 						minWidth: 0
 					},
-					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						role: "row",
 						"data-dsh-session-delete": "trash-group-row",
 						style: {
 							display: "flex",
@@ -27392,71 +28397,82 @@ window.__ModuleLoader__.load({
 							gap: 6,
 							minWidth: 0
 						},
-						children: [selectMode ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Checkbox, {
-							checked: groupFullyChecked(group),
-							indeterminate: groupPartiallyChecked(group),
-							label: t("trash.select.group", {
-								project: group.label,
-								count: group.entries.length
-							}),
-							onChange: () => {
-								toggleGroupCheck(group);
-							}
-						}) : null, /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
-							type: "button",
-							className: "sd-disclosure-row",
-							"data-dsh-session-delete": "trash-group-head",
-							"data-expandable": "",
-							"aria-expanded": !isCollapsed(group.projectDir),
-							onClick: () => {
-								toggleGroup(group.projectDir);
-							},
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							role: "gridcell",
+							"aria-colspan": LIST_COLUMN_COUNT,
 							style: {
-								background: "none",
-								border: "none",
-								padding: 0,
-								font: "inherit",
-								textAlign: "start",
+								display: "flex",
+								alignItems: "center",
+								gap: 6,
 								flex: "1 1 auto",
-								gap: 6
+								minWidth: 0
 							},
-							children: [
-								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-									className: "sd-disclosure-leading",
-									"aria-hidden": "true",
-									children: isCollapsed(group.projectDir) ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconChevronRightOutlineRegular, { size: 14 }) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconChevronDownOutlineRegular, { size: 14 })
-								}),
-								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-									style: {
-										display: "inline-flex",
-										flex: "none",
-										color: "var(--dsw-alias-label-tertiary)"
-									},
-									"aria-hidden": "true",
-									children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconFolderOpenOutlineRegular, { size: 13 })
+							children: [selectMode ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Checkbox, {
+								checked: groupFullyChecked(group),
+								indeterminate: groupPartiallyChecked(group),
+								label: t("trash.select.group", {
+									project: group.label,
+									count: group.entries.length
 								}),
-								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-									className: "sd-disclosure-title",
-									style: {
-										...ELLIPSIS,
-										minWidth: 0,
-										flex: "1 1 auto",
-										fontWeight: 500
-									},
-									title: group.projectDir,
-									children: group.label
-								}),
-								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-									style: {
-										marginLeft: "auto",
-										flex: "none",
-										fontSize: 11.5,
-										color: "var(--dsw-alias-label-tertiary)"
-									},
-									children: t("trash.group.count", { count: group.entries.length })
-								})
-							]
-						})]
+								onChange: () => {
+									toggleGroupCheck(group);
+								}
+							}) : null, /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+								type: "button",
+								className: "sd-disclosure-row",
+								"data-dsh-session-delete": "trash-group-head",
+								"data-expandable": "",
+								"aria-expanded": !isCollapsed(group.projectDir),
+								onClick: () => {
+									toggleGroup(group.projectDir);
+								},
+								style: {
+									background: "none",
+									border: "none",
+									padding: 0,
+									font: "inherit",
+									textAlign: "start",
+									flex: "1 1 auto",
+									gap: 6
+								},
+								children: [
+									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										className: "sd-disclosure-leading",
+										"aria-hidden": "true",
+										children: isCollapsed(group.projectDir) ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconChevronRightOutlineRegular, { size: 14 }) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconChevronDownOutlineRegular, { size: 14 })
+									}),
+									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										style: {
+											display: "inline-flex",
+											flex: "none",
+											color: "var(--dsw-alias-label-tertiary)"
+										},
+										"aria-hidden": "true",
+										children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconFolderOpenOutlineRegular, { size: 13 })
+									}),
+									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										className: "sd-disclosure-title",
+										style: {
+											...ELLIPSIS,
+											minWidth: 0,
+											flex: "1 1 auto",
+											fontWeight: 500
+										},
+										title: group.projectDir,
+										children: group.label
+									}),
+									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										style: {
+											marginLeft: "auto",
+											flex: "none",
+											fontSize: 11.5,
+											color: "var(--dsw-alias-label-tertiary)"
+										},
+										children: t("trash.group.count", { count: group.entries.length })
+									})
+								]
+							})]
+						})
 					}), isCollapsed(group.projectDir) ? null : group.entries.map((entry) => {
 						const isSelected = entry.id === controller.selectedId;
 						const isChecked = checked.has(entry.id);
@@ -27464,8 +28480,8 @@ window.__ModuleLoader__.load({
 						const kids = entry.subagentCount ?? 0;
 						const stranded = entry.strandedSubagents ?? 0;
 						return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-							id: `sd-trash-${entry.id}`,
-							role: "option",
+							id: domRowId(entry.id),
+							role: "row",
 							"aria-selected": selectMode ? isChecked : isSelected,
 							tabIndex: entry.id === nav.tabStopId ? 0 : -1,
 							"data-dsh-session-delete": "trash-row",
@@ -27479,14 +28495,22 @@ window.__ModuleLoader__.load({
 								controller.select(entry, { drill: !split });
 							},
 							children: [
-								selectMode ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Checkbox, {
-									checked: isChecked,
-									label: t("trash.select.row", { title }),
-									onChange: () => {
-										toggleCheck(entry.id);
-									}
+								selectMode ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+									role: "gridcell",
+									style: {
+										display: "flex",
+										alignItems: "center"
+									},
+									children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Checkbox, {
+										checked: isChecked,
+										label: t("trash.select.row", { title }),
+										onChange: () => {
+											toggleCheck(entry.id);
+										}
+									})
 								}) : null,
 								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+									role: "gridcell",
 									style: {
 										display: "flex",
 										flexDirection: "column",
@@ -27551,6 +28575,7 @@ window.__ModuleLoader__.load({
 									]
 								}),
 								selectMode ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+									role: "gridcell",
 									style: {
 										display: "flex",
 										gap: 6,
@@ -27586,7 +28611,12 @@ window.__ModuleLoader__.load({
 					})]
 				}, group.projectDir))
 			});
+			/**
+			* 孩子视图的开与回（ADR-0029 单级判据）住控制器的 `detailNav`：这里只转交，不再自己拼
+			* openChild / parentContext 两个派生块——判据的第二个家会让视图与测试各自复述一遍语义。
+			*/
 			const detailPane = /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				ref: detailScrollRef,
 				"data-dsh-session-delete": "trash-detail",
 				style: DETAIL_COLUMN,
 				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
@@ -27597,6 +28627,15 @@ window.__ModuleLoader__.load({
 						wide: split,
 						onRetry: () => controller.retry(),
 						onBack: () => controller.back(),
+						detailNav: controller.detailNav,
+						pager: {
+							loadingOlder: controller.loadingOlder,
+							olderFailure: controller.olderFailure,
+							onLoadOlder: () => {
+								controller.loadOlder();
+							},
+							scrollRef: detailScrollRef
+						},
 						t
 					})
 				})
@@ -27840,6 +28879,7 @@ window.__ModuleLoader__.load({
 					children: [text, actions?.map((action) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 						type: "button",
 						className: "sd-toast-action",
+						disabled: action.disabled,
 						onClick: action.onClick,
 						children: action.label
 					}, action.label))]
@@ -27851,31 +28891,12 @@ window.__ModuleLoader__.load({
 		/**
 		* 撤销提示（docs/ui-spec.md 状态 ③）：删除成功后一条可撤销的横幅。
 		*
-		* 现场与发布住在 `undo-notices.ts`；本文件只做组件，并把通知台与外部恢复座位组合起来。
+		* 现场与发布住在 `undo-notices.ts`；本文件只做组件：画通知台已有的事实，「撤销」整趟按下交给
+		* `write-seats.ts` 的 `restoreFromUndo`（编排归恢复座位，见 ADR-0018 的边界）。
 		* 为什么组件要独立：宿主的菜单行随菜单**一起卸载**（真产物 Menu 的注释原文
 		* "the rows unmount with the list"），而提示要在菜单关掉之后还活着。宿主的官方配方同形——
 		* 会话行的动作把请求写进一个模块级 store，`shell.overlay` 里的 `workspace.row-toast` 读它。
 		*/
-		/** 撤销：单条与批量都走**一次** `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"）：没有待撤销的事时什么都不渲染。
@@ -27883,6 +28904,15 @@ window.__ModuleLoader__.load({
 		function UndoToast({ deps, t = zhTranslate }) {
 			const current = useUndoNotice();
 			if (current === null) return null;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NoticeToast, {
+				deps,
+				current,
+				t
+			}, current.seq);
+		}
+		/** 一条通知的躯体：busy 生命周期归 `useBusyGate`（连点的同步判重也在闸里），这里只组合呈现。 */
+		function NoticeToast({ deps, current, t }) {
+			const gate = useBusyGate();
 			const { seq, failure } = current;
 			if (failure !== void 0) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Toast, {
 				text: failure,
@@ -27897,7 +28927,10 @@ window.__ModuleLoader__.load({
 				holdMs: UNDO_HOLD_MS,
 				actions: canUndo ? [{
 					label: t("undo.undo"),
-					onClick: () => void undo(deps, current)
+					disabled: gate.busy,
+					onClick: () => {
+						gate.around(() => restoreFromUndo(deps, current, t));
+					}
 				}] : void 0,
 				onDone: clearUndoNotice
 			}, seq);
@@ -27977,10 +29010,13 @@ window.__ModuleLoader__.load({
 		}
 		/** 多选模式行首勾选框的宿主：槽位只投 `sessionId`，标题从 root hook 的 `byId[id].title` 读。 */
 		function PickLeadingRow({ sessionId, useSessions, t }) {
-			const title = (typeof useSessions === "function" ? useSessions : NEVER_SESSIONS)((state) => state?.byId?.[sessionId]?.title?.trim() ?? "");
+			const select = typeof useSessions === "function" ? useSessions : NEVER_SESSIONS;
+			const title = select((state) => state?.byId?.[sessionId]?.title?.trim() ?? "");
+			const live = select((state) => state?.byId?.[sessionId]?.running === true);
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(BatchPickCheckbox, {
 				sessionId,
 				title,
+				live,
 				t
 			});
 		}
@@ -28029,10 +29065,12 @@ window.__ModuleLoader__.load({
 		/**
 		* **探测 → 注册**：取数通道在不在，只有真发一次请求才知道。
 		*
-		* - 探测不过（打不通 / 回的不是信封）⇒ **早返回**：一个槽位贡献都不注册。页面上的表现是"本插件
-		*   不存在"，而不是点下去必然失败的入口——半吊子 UI 比没有 UI 更糟（docs/architecture.md §3「通道探测决定入口出现与否」）。
-		* - 探测过（哪怕 `ping` 回的是 `{ok:false,error}`）⇒ 注册：那次往返证明路由在、依赖接上了、
-		*   错误映射也生效了，失败该做的是把原文交给用户看。
+		* - 探测不过（打不通 / 回的不是信封 / 401·403 表示没有宿主身份 / 失败信封）⇒ **早返回**：
+		*   一个槽位贡献都不注册。页面上的表现是"本插件不存在"，而不是点下去必然失败的入口——半吊子 UI
+		*   比没有 UI 更糟（docs/architecture.md §3「通道探测决定入口出现与否」）。
+		* - 探测过（`ping` 回成功信封的 `pong`）⇒ 注册：那次往返证明路由在、依赖接上了、鉴权也过了。
+		*
+		* 支持面是 web UI 与桌面端，二者都从宿主 `/api` 取数（ADR-0033）；没有旧前缀可退回。
 		*
 		* 面板那两条是**一对座位**：行的 `selectPanel(id)` 要求 `main` 里有同字 key，缺了面板那一头，
 		* 用户点一下就是宿主自己的 `layout.selectPanel: main panel "…" is not registered`。