@xrn1997/dsh-session-delete 0.4.0 → 0.5.0

package/lib/types/api/dispatch.d.ts

@@ -1,8 +1,9 @@
 /**
  * /dsh-session-delete-api 的前缀路由分发：只负责传输。
  *
- * 三件事：请求栅栏 → 查路由表 → 回信封。方法、纯度、body 预读与读面的判据都在
- * src/api/route-table.ts（这里只按判据执行）；行投影在 src/api/trash-rows.ts。
+ * 四件事：请求栅栏 → 查路由表 → 按段注入窄面 → 回信封。纯度、body 预读与读面的判据都在
+ * src/api/route-table.ts（方法也从那张表读，字面量家在 `shared/wire.ts` 的段名表；这里只按判据执行）；
+ * 行投影在 src/api/trash-rows.ts。
  *
  * - 请求本身不对用 4xx（400 请求体 / 405 方法 / 404 未知路由 / 403 栅栏拒绝）；
  *   操作失败回 200 + {ok:false,error}。浏览器半先解信封，再看状态。
@@ -12,4 +13,7 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { DeleteDeps } from '../deps.js';
 import { type RequestTrustFacts } from './request-trust.js';
+import { type SliceDeps } from './route-table.js';
+/** 三格只建一次：收窄对象在 handler 构造期固定，请求路径只做引用选择。 */
+export declare function slicesOf(full: DeleteDeps): SliceDeps;
 export declare function createApiHandler(deps: DeleteDeps, trust: RequestTrustFacts): (req: IncomingMessage, res: ServerResponse) => Promise<void>;

package/lib/types/api/route-table.d.ts

@@ -1,16 +1,18 @@
 /**
- * 路由表（ADR-0004）：段名 → { 方法, 纯度, 读面, body, 处理 }。一条记录，两个消费者。
+ * 路由表（ADR-0004；deps 切片见 ADR-0032）：段名 → { 方法, 纯度, 读面, body, deps 切片, 处理 }。一条记录，两个消费者。
  *
  * 一致性要求：
  * - 该纯的判成写 ⇒ 探测/正文读/扫描被堵在串行链后；
  * - 该写的判成纯 ⇒ 写动作绕开到达序链，与对账交错；
- * - body 该读没读 ⇒ 下游拿到 null；读两遍 ⇒ 流已被消费。
+ * - body 该读没读 ⇒ 下游拿到 null；读两遍 ⇒ 流已被消费；
+ * - 切片声明宽了 ⇒ 危险能力（删目录 / 时钟）漏进读段的 run；窄了 ⇒ 写段的处理编译不过。
  *
  * 这张表不放 shared/wire.ts：处理函数会 import 动词与 node:fs，而浏览器半要 import wire.ts。
- * 段名与动作仍住 wire.ts；这张表只回答“怎么处理”。
+ * 段名、方法与动作仍住 wire.ts（`ROUTES` 每项 `{ path, method }`，本表的 method 只投影、不写第二份字面量）；
+ * 这张表只回答“怎么处理”。
  */
-import { ROUTES, type ApplyAction } from '../shared/wire.js';
-import type { DeleteDeps } from '../deps.js';
+import { type ApplyAction, type RouteName } from '../shared/wire.js';
+import type { CoreDeps, DeleteDeps, RemovalDeps } from '../deps.js';
 import type { TrashEntry } from '../trash/entry.js';
 /** 请求体：`json` 才读下来（GET 一律不读；读两遍会把流消费掉）。 */
 export type BodyKind = 'none' | 'json';
@@ -31,19 +33,37 @@ export interface BinaryResponse {
 export interface RouteRead {
     rows(): Promise<readonly TrashEntry[]>;
 }
-export interface RouteSpec {
+/** deps 切片（ADR-0032）：每一段只声明自己要的那一面。读与探测六段拿基础面，两个删盘段多删除能力，
+ *  `/apply` 是唯一拿全量面的行——段的 run 里长出超面调用就是编译错，dispatch 也只按这一格注入
+ *  （运行期收窄住 `src/api/dispatch.ts` 的 `slicesOf`）。 */
+export type RouteSlice = 'core' | 'removal' | 'full';
+/** 切片名 → 依赖面：{@link RouteSpec.run} 的 deps 参数类型与 `depsFor` 的返回类型都从这一格取。 */
+export type SliceDeps = {
+    core: CoreDeps;
+    removal: RemovalDeps;
+    full: DeleteDeps;
+};
+export interface RouteSpec<S extends RouteSlice = RouteSlice> {
+    /** 这一行吃哪一格 deps：dispatch 按它注入，`run` 的 deps 参数类型也跟着它走。 */
+    readonly slice: S;
     readonly method: 'GET' | 'POST';
     readonly body: BodyKind;
     readonly purity: Purity;
     readonly read: ReadKind;
     /** 响应形态：`json` 走信封（`{ok:true,value}`）；`binary` 直接把处理函数的 `BinaryResponse` 写出去。 */
     readonly response: 'json' | 'binary';
-    run(deps: DeleteDeps, body: JsonBody, read: RouteRead, query: URLSearchParams): Promise<unknown>;
+    /** 声明成函数属性而不是方法：方法签名是双变的，显式标注更宽的 deps 能绕过切片闸；属性按逆变校验。 */
+    readonly run: (deps: SliceDeps[S], body: JsonBody, read: RouteRead, query: URLSearchParams) => Promise<unknown>;
 }
+/** 九行的并集（表的值类型）：每行由自己的 `slice` 字面量定型，`run` 的 deps 面随之收窄。 */
+export type AnyRouteSpec = {
+    [S in RouteSlice]: RouteSpec<S>;
+}[RouteSlice];
 export declare const APPLY_ACTIONS: readonly ApplyAction[];
 /**
- * 九个段名各一行。`Record<段名, RouteSpec>` 是闸：`wire.ts` 加了段名而这里没加，编译不过。
+ * 九个段名各一行。`Record<段名, AnyRouteSpec>` 是闸：`wire.ts` 加了段名而这里没加，编译不过；
+ * 每行的 `slice` 又把该行的 `run` 钉在自己那一格 deps 上（ADR-0032）。
  */
-export declare const ROUTE_TABLE: Record<(typeof ROUTES)[keyof typeof ROUTES], RouteSpec>;
+export declare const ROUTE_TABLE: Record<RouteName, AnyRouteSpec>;
 /** 段名 → 那一行；不认识的段名回 `undefined`（调用方抛 404，并带出原路径）。 */
 export declare function routeOf(rest: string): RouteSpec | undefined;

package/lib/types/api/trash-rows.d.ts

@@ -6,7 +6,7 @@
  * 归 `verbs/permanent-removal.ts` 的只读计划 —— 这里只做装配，不再自己枚举盘上后代。
  */
 import type { CoreDeps } from '../deps.js';
-import type { TrashEntry } from '../trash/entry.js';
+import { type TrashEntry } from '../trash/entry.js';
 import type { TrashRowWire } from '../shared/wire.js';
 /** 组视图那几个只读数的容器（行投影的第二个入参）。`releaseBytes` 必填（计划里实测好的那一格）；
  *  其余缺席 = 这次没算，不是 0。 */
@@ -14,8 +14,8 @@ type TrashRowReadouts = {
     readonly releaseBytes: number;
 } & Partial<Pick<TrashRowWire, 'subagentCount' | 'subagentBytes' | 'strandedSubagents' | 'strandedBytes' | 'workspaceMissing'>>;
 /**
- * 清册那一行 → 线上那一行。**显式字面量、不用 `...row`**：线上形状多一个必填字段时，这里编译不过，
- * 于是"线上多了一格却没人填"不可能悄悄发生（`...row` 会把它带过去，看上去一切正常）。
+ * 清册那一行 → 线上那一行。清册字段走 `entryWire` 那份显式字面量（线上形状多一个必填字段时编译不过，
+ * `...row` 会把它带过去），这里只补 `/list` 的只读数。
  */
 export declare function toWire(row: TrashEntry, readouts: TrashRowReadouts): TrashRowWire;
 /**

package/lib/types/client/busy-gate.d.ts

@@ -1,6 +1,10 @@
 export interface BusyGate {
     readonly busy: boolean;
-    /** 把一次任务整个包进「这一趟还算忙」；落地与抛错都放回 false。 */
-    around<T>(task: () => Promise<T>): Promise<T>;
+    /** 把一次任务整个包进「这一趟还算忙」；落地与抛错都放回 false。
+     *  同一枚闸已有任务在飞时这一次**不执行**（同步判重），立即回 `undefined`。类型里带上 `undefined`
+     *  不是将就，是判据：挡回的那一趟什么都没跑，把它伪装成一枚 `T` 就是把「没跑」当成「跑完且结果是
+     *  那个值」——消费返回值的调用方（写入座位、清空）会照着编出失败原文或宣布成功。怎么收尾由调用方
+     *  定：这一趟的界面后果归在飞的那一趟，挡回来的那一份什么都不该改。 */
+    around: <T>(task: () => Promise<T>) => Promise<T | undefined>;
 }
 export declare function useBusyGate(): BusyGate;

package/lib/types/client/confirm-close.d.ts

@@ -5,7 +5,10 @@
  *  返回的 `closeDisabled` 与 `close` 同源：取消键的置灰读数也从这里取，各组件不再各写一遍
  *  `disabled={busy}`——否则"拦住"这件事会有两个判据。 */
 export interface IdleClose {
-    close(): void;
+    /** 属性声明而不是方法简写：实现体不读 `this`，调用方会把 `close` 摘下来直接交给 `Modal`/
+     *  `Button`（`onClose={close}`）；方法简写会给它隐式 `this: IdleClose`，`unbound-method`
+     *  就会把这种正常交接报成可疑。形状仍是同一个函数，零运行时改动。 */
+    close: () => void;
     readonly closeDisabled: boolean;
 }
 export declare function useIdleClose(busy: boolean, onClose: () => void): IdleClose;

package/lib/types/client/context.d.ts

@@ -26,6 +26,7 @@ export interface ClientContextLike {
     slots: SlotsLike;
     /** 可选服务的读面（宿主自己的写法：`ctx.get('…')?.…`）。**缺省调用**：老宿主上没有这个方法。 */
     get?(name: string): unknown;
-    /** 挂一个随本插件卸载而撤销的副作用（返回的清理函数由框架接管）。 */
-    effect(execute: () => unknown, label?: string): unknown;
+    /** 挂一个随本插件卸载而撤销的副作用（返回的清理函数由框架接管）。
+     *  属性声明：测试会把它当成员读（`expect(ctx.effect).not.toHaveBeenCalled()`），实现不读 `this`。 */
+    effect: (execute: () => unknown, label?: string) => unknown;
 }

package/lib/types/client/copy.d.ts

@@ -102,7 +102,7 @@ declare const ZH: {
     readonly 'detail.notSelected': "选中一条会话，看它讲了什么";
     readonly 'detail.loading': "正在读这条会话…";
     readonly 'detail.readFailed': "这条会话的正文读不出来";
-    readonly 'detail.noBody': "这条会话没有可显示的文字";
+    readonly 'detail.noBody': "这条会话没有可显示的内容";
     readonly 'detail.field.created': "创建";
     readonly 'detail.field.lastActivity': "最后活动";
     readonly 'detail.field.deletedAt': "删除于";
@@ -111,8 +111,9 @@ declare const ZH: {
     readonly 'detail.field.size': "大小";
     readonly 'detail.field.turns': "轮数";
     readonly 'detail.field.userMessages': "提问";
-    readonly 'detail.field.assistantMessages': "回复";
+    readonly 'detail.field.assistantMessages': "助手消息";
     readonly 'detail.field.toolCalls': "工具调用";
+    readonly 'detail.field.injections': "注入上下文";
     readonly 'detail.field.models': "模型";
     readonly 'detail.field.project': "项目";
     readonly 'detail.field.sessionId': "会话 id";
@@ -120,10 +121,36 @@ declare const ZH: {
     readonly 'detail.field.wasArchived': "原本归档";
     readonly 'detail.value.yes': "是";
     readonly 'detail.value.no': "否";
+    readonly 'detail.value.spanLessThanHour': "不足 1 小时";
     readonly 'detail.value.spanHours': "{n} 小时";
     readonly 'detail.value.spanDays': "{n} 天";
-    readonly 'detail.messages.hidden': "另有 {count} 条宿主注入的上下文未显示";
-    readonly 'detail.messages.omitted': "还有 {count} 条未显示";
+    readonly 'detail.block.reasoning': "思考";
+    readonly 'detail.block.tool': "工具调用";
+    readonly 'detail.block.injection': "上下文注入";
+    readonly 'detail.block.system': "系统消息";
+    readonly 'detail.block.compaction': "上下文已压缩";
+    readonly 'detail.block.args': "参数";
+    readonly 'detail.block.result': "结果";
+    readonly 'detail.block.noResult': "日志在调用结束前结束，没有结果";
+    readonly 'detail.block.status.ok': "成功";
+    readonly 'detail.block.status.error': "失败";
+    readonly 'detail.block.status.unfinished': "未完成";
+    readonly 'detail.block.truncated': "已截断";
+    readonly 'detail.loadOlder': "加载更早";
+    readonly 'detail.loadOlder.loading': "正在加载更早…";
+    readonly 'detail.expandAll': "全部展开";
+    readonly 'detail.collapseAll': "全部折叠";
+    readonly 'detail.injection.runtimeContext': "运行上下文";
+    readonly 'detail.injection.timeContext': "时间上下文";
+    readonly 'detail.injection.agentInstructions': "Agent 指令";
+    readonly 'detail.injection.skillCatalog': "技能目录";
+    readonly 'detail.injection.agentMessage': "子会话消息";
+    readonly 'detail.injection.subagentSettled': "子会话结束";
+    readonly 'detail.injection.toolJobs': "后台任务";
+    readonly 'detail.injection.skillInvocation': "技能调用";
+    readonly 'detail.injection.userApproval': "用户批准";
+    readonly 'detail.injection.goal': "目标";
+    readonly 'detail.injection.other': "其他上下文";
     readonly 'detail.image': "[图片]";
     readonly 'detail.image.alt': "[图片 · {alt}]";
     readonly 'detail.attachment.file': "文件";
@@ -135,6 +162,9 @@ declare const ZH: {
     readonly 'detail.attachment.saving': "保存中…";
     readonly 'detail.attachment.saveFailed': "保存失败：{message}";
     readonly 'detail.back': "← 返回清单";
+    readonly 'detail.subagents.header': "子会话（{n}） · {size}";
+    readonly 'detail.subagents.truncated': "仅列出前 {shown} 条，共 {total} 条";
+    readonly 'detail.backToParent': "← 返回父会话";
     readonly 'detail.list.label': "回收站清单";
     readonly 'detail.role.user': "你";
     readonly 'detail.role.assistant': "助手";
@@ -160,6 +190,7 @@ declare const ZH: {
     readonly 'undo.moved': "{title} 已移入回收站";
     readonly 'undo.session': "会话";
     readonly 'undo.undo': "撤销";
+    readonly 'undo.failedBatch': "{n} 条会话未能撤销：{reasons}";
 };
 export type CopyKey = keyof typeof ZH;
 export type CopyParams = Readonly<Record<string, string | number>>;
@@ -174,6 +205,25 @@ export declare const zhTranslate: Translate;
  * 而且同一命名空间的同一语言**只能注册一次**——effect 没挂，HMR 重挂就撞 "already has locale"。
  */
 export declare function createTranslate(ctx: ClientContextLike): Translate;
+/**
+ * `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` 的换语言用例兜住；换借句或改那句译文时先看它红不红。
+ */
+export declare function localeProbe(t: Translate): string;
 /**
  * 把一句话里内嵌的那一段拆出来：`'…文件，之后没有任何副本可以恢复。'` 交给调用面用 `<b>` 包中间那段。
  *

package/lib/types/client/delete-confirm.d.ts

@@ -16,7 +16,7 @@ export declare const TARGET_CARD: {
 export interface DeleteRequest {
     /** 每次发布递增：换一个会话就重挂载确认框，busy / failure 不带着上一条请求的记忆。 */
     seq: number;
-    /** 要删的会话 id——原样透给 `sessiondelete/delete`。 */
+    /** 要删的会话 id——原样透给删除写入（`apply` 的 `delete` 动作；段名与动作住 `shared/wire.ts`）。 */
     sessionId: string;
     /** 删除那一刻的会话名（槽位投影的 `displayTitle`）：只用于确认框文案与撤销提示。 */
     title: string;

package/lib/types/client/delete-menu-item.d.ts

@@ -1,6 +1,6 @@
 import { type Translate } from './copy.js';
 export interface DeleteMenuItemProps {
-    /** 宿主菜单槽投影的会话 id，原样透给 `sessiondelete/delete`（浏览器半不自己拼 id）。 */
+    /** 宿主菜单槽投影的会话 id，原样透给删除写入（`apply` 的 `delete` 动作；段名与动作住 `shared/wire.ts`，浏览器半不自己拼 id）。 */
     sessionId: string;
     /** 宿主菜单槽投影的 `displayTitle`：只用于确认框与提示文案，不参与任何请求。 */
     title: string;

package/lib/types/client/host-rows.d.ts

@@ -7,9 +7,13 @@ export interface HostRowInfo {
 }
 /**
  * 行尾兜底勾选开关登记一行：模式内与模式外都要登记（守卫进模式的那一帧就得有标题）。
- * 只有标题／运行态**真的变了**才标脏：重渲染时的同值登记不该把快照翻新一遍。
+ * 每次登记算**多一个挂载实例**；只有标题／运行态**真的变了**才标脏：重渲染时的同值登记
+ * 不该把快照翻新一遍。
  */
 export declare function registerHostRowInfo(sessionId: string, info: HostRowInfo): void;
+/** 行尾开关卸载时调用：那一行已经离开渲染树，登记跟着走。
+ *  还有别的挂载实例在用同一行（重复行）就只减计数，不摘登记。 */
+export declare function unregisterHostRowInfo(sessionId: string): void;
 /**
  * 「当前可见」的可选行：侧栏里**已渲染**的会话行（`data-row-key="session:…"`）——折叠组、
  * 归档过滤外的行不在 DOM 里，宿主隐藏的 subagent 也不在；在跑的行跳过（与置灰勾选框同口径）。

package/lib/types/client/markdown.d.ts

@@ -2,18 +2,17 @@ import type { Translate } from './copy.js';
 import './ui/styles.js';
 /**
  * `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`）⇒ 重解析。
  */
 export declare const MarkdownBody: import("react").NamedExoticComponent<{
     text: string;
     t: Translate;
-    localeKey: string;
+    probe: string;
 }>;

package/lib/types/client/orphan-maintenance.d.ts

@@ -3,8 +3,9 @@
  *
  * 它先是回收站面板上的一块，2026-10-27 起搬进插件设置页的「维护」卡（面板不再自动扫孤儿，ADR-0021）。
  * 之所以仍收成一个 module：这三段与任何一面的清单渲染、选择、键盘、拖栏都毫无关系；改维护块的文案或
- * 确认框时，diff 不该与布局改动互相踩。它只吃一个窄接口 `OrphanMaintenanceQuery`——报告、三条提示与
- * 四个动作，实现方是设置页的 `use-maintenance.ts`。
+ * 确认框时，diff 不该与布局改动互相踩。它只吃泛型段 module 的一张视图 `MaintenanceSectionView`——
+ * 报告、三条提示、确认框与四个动作；实现方是 `use-maintenance-section.ts` 的状态机
+ * （设置页的 `use-maintenance.ts` 为孤儿会话段实例化它）。
  *
  * 三条界面规则（现状住 `docs/ui-spec.md`）：
  * - **报告非空才出警告条**：空报告与 `null` 都不出现——"检查过了，什么都没有"不是要给用户看的东西，
@@ -13,33 +14,17 @@
  *   （"没能回答有多少残留"与"没有残留"是两件事，不许折成空报告）。
  * - **「已经不在」不是失败**：别处清掉或父已回到清册时单独一条中性提示，不计入失败，下次检查时自然消失。
  *
- * 四个动作都由实现方给：警告条开预览（`openOrphanPreview`）、失败块重试（`scanOrphans`）、
- * 确认框清理（`cleanOrphans`）、取消（`setOrphanConfirm`）。`busy` 不归本 module 管——它是实现方
- * 那一段自己的忙碌读数，通过 props 传进来。
+ * 四个动作都从段上取：警告条开预览（`openPreview`，唯一开门、先清旧提示）、失败块重试（`scan`）、
+ * 确认框清理（`clean`）、取消（`cancel`，只收框）。`busy` 也不再是 prop——段自己给（在飞即忙），
+ * 本块只读它按住按钮。
  */
 import type { ReactElement } from 'react';
 import type { Translate } from './copy.js';
 import type { OrphanReportWire } from './remote.js';
-/**
- * 本块消费的那一面：一份报告、三条提示、四个动作。窄到只列它真读的成员——实现方多给（阶段、忙碌、
- * 附件回执…）都与本块无关，也不许本块去读。设置页的 `Maintenance` 结构上满足它。
- */
-export interface OrphanMaintenanceQuery {
-    /** `null` = 还没检查/读不到；本块只认"非空报告"那一档。 */
-    readonly orphanReport: OrphanReportWire | null;
-    readonly orphanFailure: string | null;
-    readonly orphanNotice: string | null;
-    readonly orphanConfirm: boolean;
-    setOrphanConfirm(open: boolean): void;
-    openOrphanPreview(): void;
-    cleanOrphans(): Promise<void>;
-    /** 检查（也是失败块那颗「重试」）：维护面上没有第二份扫描入口。 */
-    scanOrphans(): Promise<void>;
-}
+import type { MaintenanceSectionView } from './use-maintenance-section.js';
 export interface OrphanMaintenanceProps {
-    query: OrphanMaintenanceQuery;
-    /** 这一段自己的忙碌读数：在飞时按住本块里的每一颗按钮。 */
-    busy: boolean;
+    /** 段视图：读数、提示、确认框、忙碌与四个动作都在它上面，本块不多要也不少读。 */
+    section: MaintenanceSectionView<OrphanReportWire>;
     t: Translate;
 }
-export declare function OrphanMaintenance({ query, busy, t }: OrphanMaintenanceProps): ReactElement | null;
+export declare function OrphanMaintenance({ section, t }: OrphanMaintenanceProps): ReactElement | null;

package/lib/types/client/receipt.d.ts

@@ -68,11 +68,13 @@ export declare function readSingleReceipt<A extends ApplyAction>(action: A, id:
 export interface ReceiptSummary {
     readonly successIds: readonly string[];
     readonly neutralIds: readonly string[];
-    /** failed + missing（通道没回）；neutral 单独在 `neutralIds`，部分计数只从 failed 的 details 取。 */
+    /** failed + missing（通道没回）；neutral 单独在 `neutralIds`。 */
     readonly failed: readonly {
         readonly id: string;
         readonly error: RemoteFailure;
     }[];
+    /** 部分计数的累加语义只住这里：只从 failed 的 `details` 取 `removed`/`freedBytes` 并按批相加
+     *  （"删了一半才炸"的那部分释放量）；neutral / missing 不带 details，不参与累加。 */
     readonly partial: {
         readonly removed: number;
         readonly freedBytes: number;

package/lib/types/client/remote.d.ts

@@ -3,7 +3,9 @@
  *
  * - 路由是宿主 web server 上的插件前缀；官方 remote.<namespace> 需要生成的 Typert 描述符，
  *   第三方无法动态挂载，因此走这条薄线（ADR-0009）。
- * - 九段：list / ping / orphans / detail / apply / empty / attachment / attachment-orphans / attachment-clean；
+ * - 九段的**段名与方法**住 `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；
@@ -25,6 +27,8 @@ export type PurgeResultLike = PurgeStatsWire;
  * **线上只有"日志里读出来的那几件"**：`deletedAt` / `sizeBytes` / `wasArchived` / 清册 `title` 这些
  * 清册已有的字段一律不过线——组件按 `entryId` 与自己手上那份清单配对，这样"清单里的大小"和
  * "详情里的大小"永远是同一个数，不会因为两次读数不同而各说各话。
+ * 例外只有一格：`subagents`（孩子摘要）。孩子不在客户端清单里、无从配对，
+ * 它们的清册事实只能随详情过线（issue #7，ADR-0029）。
  */
 export type TrashDetailLike = TrashDetailWire;
 /** 任意异常 → 失败面。非带标记的失败（网络层、TypeError…）也保留原文，绝不吞；带标记的失败把
@@ -63,7 +67,7 @@ export interface RawSessionDeleteRemote {
     attachmentOrphans(): Promise<RemoteResult<AttachmentOrphanReportWire>>;
     /** 聚合写：只删上一条报告那一刻无引用的图片对象，回 `AttachmentCleanupWire`。 */
     attachmentClean(): Promise<RemoteResult<AttachmentCleanupWire>>;
-    detail(entryId: string): Promise<RemoteResult<TrashDetailLike>>;
+    detail(entryId: string, before?: number): Promise<RemoteResult<TrashDetailLike>>;
     /** 一组 id 上的同一个动作。顶层信封的 `ok:false` 只表示**整次调用**没办成（路由自检、栅栏之外）；
      *  单条动作的成败住在 `ApplyOutcome` 里——这是批量接口的判据，别在信封层找它。 */
     apply(action: ApplyAction, ids: readonly string[]): Promise<RemoteResult<ApplyOutcome[]>>;
@@ -117,7 +121,7 @@ export interface SessionDeleteRemote {
     scanAttachmentOrphans(): Promise<AttachmentOrphanReportWire>;
     /** 清掉报告那一刻无引用的图片副本（聚合回执）。 */
     cleanAttachmentOrphans(): Promise<AttachmentCleanupWire>;
-    detail(entryId: string): Promise<TrashDetailLike>;
+    detail(entryId: string, before?: number): Promise<TrashDetailLike>;
     /** 一段管所有写动作：一次调用把整批办完，逐条结果原样交回组件。 */
     applyOutcomes(action: ApplyAction, ids: readonly string[]): Promise<ApplyOutcome[]>;
     /** 清空回收站（聚合回执）。 */

package/lib/types/client/store.d.ts

@@ -17,10 +17,12 @@ export interface ClientStore<T> {
 export declare function createStore<T>(initial: T): ClientStore<T>;
 /** 懒读快照：`get()` 只在脏了时调用 `read()`，干净时回同一个引用（React snapshot 契约）。 */
 export interface LazyStore<T> {
-    get(): T;
+    /** 属性声明：`get` / `subscribe` 会被摘下来直接交给 `useSyncExternalStore`（宿主行快照），
+     *  实现不读 `this`。方法简写会给它隐式 `this: LazyStore<T>`，触发 `unbound-method` 误报。 */
+    get: () => T;
     /** 标脏并通告；下一次 `get()` 重读。 */
-    invalidate(): void;
-    subscribe(listener: () => void): () => void;
+    invalidate: () => void;
+    subscribe: (listener: () => void) => () => void;
 }
 export interface LazyStoreLifecycle {
     /** 第一个订阅者到来时跑（观察者在这里接上）。 */
@@ -46,3 +48,12 @@ export interface LatestWins {
     invalidate(): void;
 }
 export declare function createLatestWins(): LatestWins;
+/**
+ * 引用归一：输入允许调用方逐渲染换新对象，回调只经这份 ref 读**最新**那一份，于是依赖它的回调
+ * 身份恒稳、调用方的 effect 可以放心把它们当依赖——「输入必须是稳定引用」的隐式契约就此不存在
+ * （issue #8 第 3 条）。写回在 effect 里（提交后），与 React 的渲染期只读约定一致。
+ * 这一形状的唯一实现：别在调用方再手写一份「useRef + 每渲染写回」。
+ */
+export declare function useLatest<T>(value: T): {
+    readonly current: T;
+};

package/lib/types/client/trash-detail.d.ts

@@ -1,27 +1,69 @@
+/**
+ * 回收站详情块：只画状态，不取数。选中、缓存、失败与重读都在面板控制器里。
+ *
+ * 三条界面约束：
+ * - 动作（恢复/彻底删除）留在清单行右侧；详情只负责看。
+ * - 标题优先用清册标题，空串才回落到日志的 session/title。
+ * - 正文是**块**：用户/助手文字常显；思考、工具、注入、系统消息、压缩摘要默认折叠，折叠头给
+ *   标签 + 首行摘要（工具另给状态）。注入也铺进正文——这是对宿主 Chat 的有意偏离（它隐藏普通注入，
+ *   而这里的目标是「删之前看全」）；条数另进元信息表。
+ *
+ * 助手正文与思考走 Markdown，用户提问保持原话；工具参数/结果走等宽纯文本（限高可滚）。
+ * 附件随块位置渲染：用户气泡之上、助手正文之后、工具展开体末尾。
+ */
+import { type RefObject } from 'react';
 import { type Translate } from './copy.js';
-import type { TrashDetailLike, TrashEntryLike } from './remote.js';
+import type { TrashEntryWire } from '../shared/wire.js';
+import type { TrashDetailLike } from './remote.js';
+/** 详情主体只承诺清册那一行：孩子视图看的那条不在客户端清单里，没有只读数可配对
+ *  （孩子摘要随父详情过线，那一格的判据住 `src/client/remote.ts` 的 `TrashDetailLike`）。 */
 export type TrashDetailState = {
     kind: 'idle';
 } | {
     kind: 'loading';
-    entry: TrashEntryLike;
+    entry: TrashEntryWire;
 } | {
     kind: 'failed';
-    entry: TrashEntryLike;
+    entry: TrashEntryWire;
     message: string;
 } | {
     kind: 'ready';
-    entry: TrashEntryLike;
+    entry: TrashEntryWire;
     detail: TrashDetailLike;
 };
+/** 「加载更早」这一块（在飞/失败 + 滚动容器）整体过手：`TrashDetail` 只转交，谁画正文谁拆开用。
+ *  四样东西是一个概念（分页读面）的四个格子，打包走一个名字，不再逐样穿透组件边界。 */
+export interface DetailPager {
+    /** 更早一页正在读。 */
+    loadingOlder: boolean;
+    /** 更早一页读失败的原文；正文本身仍是 ready。 */
+    olderFailure: string | null;
+    onLoadOlder: () => void;
+    /** 详情栏的滚动容器；prepend 更早一页后按高度差补偿滚动位置。 */
+    scrollRef?: RefObject<HTMLDivElement | null>;
+}
+/** 详情的导航面（孩子视图的开与回）：类型定义住在这里（视图定 prop 形状），
+ *  控制器 `import type` 它避免环。判据（谁在场、title 给什么）住控制器的 `detailNav` 派生。 */
+export interface DetailNav {
+    /** 只在主体是清单选中那条时交出（ADR-0029 单级判据的唯一实现）。 */
+    readonly onOpenChild?: (child: TrashEntryWire) => void;
+    /** 孩子视图的返回目标；title 是原文（未命名兜底由视图按 t 处理）。 */
+    readonly parentContext?: {
+        readonly title: string;
+        readonly onBack: () => void;
+    };
+}
 export interface TrashDetailProps {
     state: TrashDetailState;
     /** 有写操作在飞（动作按钮住在清单行里，这里只用来把「重试」按住）。 */
     busy: boolean;
-    /** 宽档不画返回——同屏就有清单，返回是多余的一步。 */
+    /** 宽档不画「返回清单」——同屏就有清单，那一步多余。孩子视图另有一颗返回，见 `detailNav.parentContext`。 */
     wide: boolean;
     onRetry: () => void;
     onBack: () => void;
+    /** 孩子视图的开与回（控制器派生，判据见 `DetailNav`）：缺席 = 不画入口/返回，组件只画状态，不自己造动作。 */
+    detailNav: DetailNav;
+    pager: DetailPager;
     t: Translate;
 }
-export declare function TrashDetail({ state, busy, wide, onRetry, onBack, t }: TrashDetailProps): import("react").JSX.Element;
+export declare function TrashDetail({ state, busy, wide, onRetry, onBack, detailNav, pager, t, }: TrashDetailProps): import("react").JSX.Element;

package/lib/types/client/trash-entry.d.ts

@@ -1,6 +1,6 @@
 /** 宿主 `SidebarPanelIconOwnerProps`：请求的方形边长；`active` 收了但不用（见头注）。 */
 export interface TrashPanelIconProps {
-    size?: number;
+    size?: number | undefined;
     active?: boolean;
 }
 export declare function TrashPanelIcon({ size }: TrashPanelIconProps): import("react").JSX.Element;

package/lib/types/client/trash-nav.d.ts

@@ -4,8 +4,8 @@ import type { TrashEntryLike } from './remote.js';
  * 导航要的面。`ordered` 是**屏幕上的顺序**（只含展开的组），由面板/选择面算好传进来——
  * 布局常量与本 module 无关。`drillEnabled` 是这一档支不支持整行下钻（窄档为真；宽档 Enter/Space
  * 只移动选中，与整行点击的 `{ drill: !split }` 同一条判据）。四个动作都由调用方注入：
- * `select` 只移动选中（带 `drill` 才下钻），`exitDrill` 是控制器那条「← 返回清单」的同一动作，
- * `focusRow` 把焦点交给某一行。
+ * `select` 只移动选中（带 `drill` 才下钻），`back` 是控制器的回退动作（两程：先收孩子视图、
+ * 再退下钻），`focusRow` 把焦点交给某一行。
  */
 export interface TrashNavInput {
     ordered: readonly TrashEntryLike[];
@@ -13,18 +13,22 @@ export interface TrashNavInput {
     selectMode: boolean;
     drillEnabled: boolean;
     drilled: boolean;
-    select(entry: TrashEntryLike, options?: {
+    /** 四个动作都是**属性声明**：它们被摘下来放进 `useTrashNav` 的输入或直接挂成事件处理器，
+     *  实现体一个都不读 `this`。方法简写会带上隐式 `this: TrashNavInput`，`unbound-method`
+     *  会把这种交接报成可疑；改属性只是让类型面说真话。 */
+    select: (entry: TrashEntryLike, options?: {
         drill?: boolean;
-    }): Promise<void>;
-    toggleCheck(entryId: string): void;
-    exitDrill(): void;
-    focusRow(entryId: string): void;
+    }) => Promise<void>;
+    toggleCheck: (entryId: string) => void;
+    back: () => void;
+    focusRow: (entryId: string) => void;
 }
 export interface TrashNav {
     /** `aria-activedescendant` 的那条 id：选中行不在 DOM 里时是 `null`。 */
     readonly activeDescendantId: string | null;
     /** 清单里唯一拿着 `tabIndex=0` 的那一行；清单空时是 `null`。 */
     readonly tabStopId: string | null;
-    onListKeyDown(event: ReactKeyboardEvent<HTMLElement>): void;
+    /** 直接挂到清单容器的 `onKeyDown`：属性声明（见上）让「摘下来挂事件」不被误报。 */
+    onListKeyDown: (event: ReactKeyboardEvent<HTMLElement>) => void;
 }
 export declare function useTrashNav(input: TrashNavInput): TrashNav;

package/lib/types/client/ui/Toast.d.ts

@@ -19,6 +19,8 @@ import './styles.js';
 export interface ToastAction {
     label: string;
     onClick: () => void;
+    /** 在飞/不可用时按灰并挡住点击（Toast 是本地配方，动作面按调用点的需要长）。 */
+    disabled?: boolean;
 }
 export interface ToastProps {
     /** 已解析好的横幅文案（本地化由调用面负责）。 */
@@ -29,7 +31,7 @@ export interface ToastProps {
     /** 全不透明停留时长；缺省 3000。 */
     holdMs?: number;
     /** 句尾的行内动作（照着句子的顺序排）。 */
-    actions?: readonly ToastAction[];
+    actions?: readonly ToastAction[] | undefined;
     /** 淡出完成时调用一次：在这里卸载。 */
     onDone: () => void;
 }

package/lib/types/client/ui/icons.d.ts

@@ -12,7 +12,7 @@
 import type { ReactElement } from 'react';
 /** 宿主图标组件的实际使用面：一个方形边长，色走 `currentColor`。 */
 export interface IconProps {
-    size?: number;
+    size?: number | undefined;
 }
 export declare function IconTrashOutlineRegular({ size }: IconProps): ReactElement;
 export declare function IconWarningOutlineRegular({ size }: IconProps): ReactElement;

package/lib/types/client/undo-toast.d.ts

@@ -1,7 +1,8 @@
 /**
  * 撤销提示（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` 读它。