@xrn1997/dsh-session-delete 0.4.0 → 0.6.0

package/lib/types/api/attachment-orphans.d.ts

@@ -2,10 +2,16 @@
  * 孤儿附件的报告段：`GET /attachment-orphans`。
  *
  * 报告把扫描计划折成数量/字节 + 对象清单（`id`/`bytes`，供设置页预览缩略图；最多
- * `ORPHAN_PREVIEW_LIMIT` 条，清理不受预览条数限制）。扫描跳过（引用源或对象列表读不出）时
- * **报告必须失败**——回一份 0 会让界面说"没有孤儿"，而这类失败恰恰是"不知道"，不是"没有"。
+ * `src/config.ts` 的 `orphanPreviewLimit`（默认 200，ADR-0037），清理不受预览条数限制）。
+ * 扫描跳过（引用源或对象列表读不出）时**报告必须失败**——回一份 0 会让界面说"没有孤儿"，
+ * 而这类失败恰恰是"不知道"，不是"没有"。
  * 清理是 `POST /attachment-clean`，由路由直接接到 `cleanOrphanImageAttachments`。
  */
 import { type AttachmentReadDeps } from '../trash/attachments.js';
+import type { SessionDeleteConfig } from '../config.js';
 import type { AttachmentOrphanReportWire } from '../shared/wire.js';
-export declare function reportAttachmentOrphans(deps: AttachmentReadDeps): Promise<AttachmentOrphanReportWire>;
+/** 报告比扫描多读一只旋钮（预览条数）；扫描本体仍只认 `maxJsonRefBytes`。 */
+export interface AttachmentOrphanReportDeps extends AttachmentReadDeps {
+    config: AttachmentReadDeps['config'] & Pick<SessionDeleteConfig, 'orphanPreviewLimit'>;
+}
+export declare function reportAttachmentOrphans(deps: AttachmentOrphanReportDeps): Promise<AttachmentOrphanReportWire>;

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

@@ -2,22 +2,32 @@
  * 附件原始字节（`GET /attachment`，全仓唯一的二进制响应段）。
  *
  * 四条硬口径：
- * ① **寻址只认 sha256 id**：`id` 必须 `sha256:<64 位小写 hex>`，路径由 `attachmentPathOf(home, kind, id)`
- *    自己推导——请求里的任何一截都不参与路径拼接（`name` 只做下载名）。
+ * ① **寻址只认 sha256 id**：`id` 必须 `sha256:<64 位小写 hex>`，路径不来自请求里的任何一截
+ *    （`name` 只做下载名；媒体元数据只给宿主 `attachments` 服务做引用校验）。
  * ② **kind 只认 image / file**：分别对应宿主附件库的 `objects`（图片）与 `file-objects`（普通文件）；
  *    不认 v2、tmp、cache，也不给"读任意文件"留入口。
- * ③ **单文件 ≤ 20 MiB**：超过不读进内存，回 200 + JSON 失败信封。图片的 `onError` 会换成占位；
- *    普通文件走 `<a download>`，没有页面内失败面——浏览器可能把这份错误响应存成文件。
- * ④ 图片按**魔数**给类型（PNG / JPEG / GIF / WebP）；认不出就按下载处理（`application/octet-stream` +
- *    `attachment`），不猜、也不拿请求里的名字当类型来源。
+ * ③ **单文件 ≤ `maxAttachmentBytes`（默认 20 MiB，可配，ADR-0037）**：所有路径共用同一道
+ *    `assertWithinLimit`；服务路径先按引用字节拦一道、再按实际字节复核，流式读在累计处停下。
+ * ④ **直接 fs 路径**按**魔数**给图片类型（PNG / JPEG / GIF / WebP），认不出就按下载处理
+ *    （`application/octet-stream` + `attachment`），不猜、也不拿请求里的名字当类型来源；服务路径用
+ *    宿主归一化后的 `mediaType`（ADR-0035）。
+ *
+ * **读取优先走宿主 `attachments` 服务**（ADR-0035）：`readImage` / `readFileStream` 会按记录里的
+ * 引用校验字节；`attachments` 缺席或请求里没有足够的引用元数据时，才退回直接 fs（旧宿主）。
+ * 两种"接不了这次读"（服务缺席 / 元数据不够）在调用方看来是同一个 `undefined`，不各写一条 fallback。
+ * 直接 fs 的路径仍只由 `attachmentPathOf(home, kind, id)` 推导。
  *
  * 请求本身不对（id/kind 形状）⇒ 400；对象不在 / 超限 / 读失败 ⇒ 200 + 信封（与其余段同一条错误面）。
  */
 import type { FsPort } from '../ports/fs-port.js';
+import type { SessionDeleteConfig } from '../config.js';
+import type { AttachmentsPort } from '../ports/attachments-port.js';
 import type { BinaryResponse } from './route-table.js';
-/** 读附件只需要 stat + read：与 `AttachmentRemovalDeps` 同一条收窄纪律，执行面不给。 */
+/** 读附件只需要 stat + read、宿主 `attachments` 读面与响应上限；执行面（removeDir/removeFile）不给。 */
 export interface AttachmentReadPorts {
     fs: Pick<FsPort, 'statFile' | 'readFile'>;
     home: string;
+    attachments: AttachmentsPort;
+    config: Pick<SessionDeleteConfig, 'maxAttachmentBytes'>;
 }
 export declare function readAttachmentResponse(deps: AttachmentReadPorts, query: URLSearchParams): Promise<BinaryResponse>;

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

@@ -0,0 +1,23 @@
+import type { Dispatch } from './dispatch.js';
+/** 请求体字节上限：这条通道只收几个 id，1MiB 是"够用且不给自己开一条内存放大器"的量级。 */
+export declare const JSON_BODY_MAX_BYTES: number;
+/** 宿主 `connection.fetch.register` 的入参形状（只声明本适配器用到的成员）。 */
+export interface ConnectionFetchRouteLike {
+    readonly path: string;
+    readonly methods: readonly ('GET' | 'HEAD' | 'POST')[];
+    readonly requestBody: 'buffered' | 'streaming';
+    readonly fetch: (request: Request) => Promise<Response>;
+}
+/** 宿主 `connection` 服务的窄镜像：只要求 exact Fetch 注册点。 */
+export interface ConnectionFetchServiceLike {
+    readonly fetch?: {
+        register(route: ConnectionFetchRouteLike): () => Promise<void>;
+    };
+}
+/**
+ * 注册九段 exact Fetch 路由。返回一个组合 disposer；调用方把它挂在自己的 effect 上。
+ * `connection` 是插件的硬依赖（web UI / 桌面端都装 `client-connection`）；`fetch.register`
+ * 缺席属于宿主形状漂移，直接抛——静默返回空 disposer 会让插件「在但没有入口」。
+ * `dispatch` 与分发器同源。
+ */
+export declare function registerConnectionRoutes(service: ConnectionFetchServiceLike, dispatch: Dispatch): () => Promise<void>;

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

@@ -1,15 +1,26 @@
-/**
- * /dsh-session-delete-api 的前缀路由分发：只负责传输。
- *
- * 三件事：请求栅栏 → 查路由表 → 回信封。方法、纯度、body 预读与读面的判据都在
- * src/api/route-table.ts（这里只按判据执行）；行投影在 src/api/trash-rows.ts。
- *
- * - 请求本身不对用 4xx（400 请求体 / 405 方法 / 404 未知路由 / 403 栅栏拒绝）；
- *   操作失败回 200 + {ok:false,error}。浏览器半先解信封，再看状态。
- * - 请求栅栏（归属 / 身份）归 `src/api/request-trust.ts`，这里只按它的裁决写 403。
- * - purity 为 chained 的请求串行执行，避免读清册/动文件/写清册交错。
- */
-import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { DeleteDeps } from '../deps.js';
-import { type RequestTrustFacts } from './request-trust.js';
-export declare function createApiHandler(deps: DeleteDeps, trust: RequestTrustFacts): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+import { type BinaryResponse, type JsonBody, type RouteSpec, type SliceDeps } from './route-table.js';
+/** 适配器归一后的一次请求：`rest` 是插件前缀之后的段名（如 `/list`）。 */
+export interface ApiInput {
+    readonly method: string;
+    readonly rest: string;
+    readonly search: URLSearchParams;
+    readonly body: JsonBody;
+}
+/** 适配器归一后的一次响应：JSON 信封或二进制字节，状态码与头由适配器写。 */
+export type ApiResult = {
+    readonly kind: 'json';
+    readonly status: number;
+    readonly body: unknown;
+} | {
+    readonly kind: 'binary';
+    readonly body: BinaryResponse;
+};
+/** 段名的 404 与方法的 405 只在这里判一次；空段名按插件前缀显示，避免 404 原文出现一个空串。 */
+export declare function resolveRoute(method: string, rest: string): RouteSpec;
+/** 四格只建一次：收窄对象在 dispatcher 构造期固定，请求路径只做引用选择。 */
+export declare function slicesOf(full: DeleteDeps): SliceDeps;
+/** 分发函数：查段 → 方法闸 → 读面 → 处理。 */
+export type Dispatch = (input: ApiInput) => Promise<ApiResult>;
+/** 路由执行器：查段 → 方法闸 → 读面 → 处理；返回归一结果。组合根只建一次。 */
+export declare function createDispatcher(deps: DeleteDeps): Dispatch;

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

@@ -1,16 +1,19 @@
 /**
- * 路由表（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 { AttachmentsPort } from '../ports/attachments-port.js';
 import type { TrashEntry } from '../trash/entry.js';
 /** 请求体：`json` 才读下来（GET 一律不读；读两遍会把流消费掉）。 */
 export type BodyKind = 'none' | 'json';
@@ -31,19 +34,52 @@ export interface BinaryResponse {
 export interface RouteRead {
     rows(): Promise<readonly TrashEntry[]>;
 }
-export interface RouteSpec {
+/** deps 切片（ADR-0032）：每一段只声明自己要的那一面。读与探测五段拿基础面，`attachment` 段另多一条
+ *  宿主 `attachments` 读面，两个删盘段多删除能力，`/apply` 是唯一拿全量面的行——段的 run 里长出超面
+ *  调用就是编译错，dispatch 也只按这一格注入（运行期收窄住 `src/api/dispatch.ts` 的 `slicesOf`）。 */
+export type RouteSlice = 'core' | 'removal' | 'full' | 'attachment';
+/** 切片名 → 依赖面：{@link RouteSpec.run} 的 deps 参数类型与 `depsFor` 的返回类型都从这一格取。 */
+export type SliceDeps = {
+    core: CoreDeps;
+    removal: RemovalDeps;
+    full: DeleteDeps;
+    attachment: CoreDeps & {
+        readonly attachments: AttachmentsPort;
+    };
+};
+interface BaseRouteSpec<S extends 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>;
+    /** 同源取数闸（ADR-0033）：只有能被别的页面渲染消费的段需要；判据住 `src/api/connection-route.ts`。
+     *  缺省不设闸——JSON 响应跨源读不到（没有 CORS），不需要它。 */
+    readonly fetchGate?: 'same-origin';
 }
+/** JSON 段：处理函数拿请求体与读面；`query` 不在这里（九行里只有二进制段需要查询串）。 */
+export interface JsonRouteSpec<S extends RouteSlice = RouteSlice> extends BaseRouteSpec<S> {
+    readonly response: 'json';
+    /** 声明成函数属性而不是方法：方法签名是双变的，显式标注更宽的 deps 能绕过切片闸；属性按逆变校验。 */
+    readonly run: (deps: SliceDeps[S], body: JsonBody, read: RouteRead) => Promise<unknown>;
+}
+/** 二进制段：只有 `/attachment`；处理函数直接拿查询串，交回字节与安全头。 */
+export interface BinaryRouteSpec<S extends RouteSlice = RouteSlice> extends BaseRouteSpec<S> {
+    readonly response: 'binary';
+    readonly run: (deps: SliceDeps[S], query: URLSearchParams) => Promise<BinaryResponse>;
+}
+export type RouteSpec<S extends RouteSlice = RouteSlice> = JsonRouteSpec<S> | BinaryRouteSpec<S>;
+/** 九行的并集（表的值类型）：每行由自己的 `slice` 与 `response` 字面量定型，`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;
+export {};

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/batch-bar.d.ts

@@ -2,7 +2,7 @@
  * 批量删除的浮条：**多选模式内常驻**（0 条也渲染，既显示模式又给退出入口），
  * 汇总「已选 N 条」+（读得到时）「含 K 个子会话」；「查看已选」展开限高可滚动的标题清单
  * （逐条可移除），回答"到底选了哪些"——清单默认收起，不把底部输入区盖住。
- * 模式内的整行点击守卫也挂在这棵常驻宿主上（见 `host-rows.ts` 的 `useSelectionRowClickGuard`）。
+ * 模式内的整行点击守卫也挂在这棵常驻宿主上（见 `batch-pick.ts` 的 `useSelectionRowClickGuard`）。
  *
  * 为什么单独一个文件而不是并进 `batch-select.tsx`：那份是"行开关控件"，而浮条要点开确认框
  * （要 import 它的现场）——两个方向合到一个文件上就是一圈。浮条住在

package/lib/types/client/batch-pick.d.ts

@@ -0,0 +1,19 @@
+import { type PickItem } from './batch-selection-store.js';
+/** 全选：把当前可见可选行按登记序追加；已在名单里的由 `addPicks` 自己跳过，原有选中保持在前。 */
+export declare function selectAllVisible(): void;
+/**
+ * 同一个切换口该显示「全选」还是「取消全选」：
+ * - 有选中、且当前可见可选行全都选中 ⇒ 取消全选；
+ * - 有选中、但当前没有可见可选行（全折叠/过滤掉）⇒ 只能清空，也显示取消全选；
+ * - 其余（含 0 条）⇒ 全选。
+ */
+export declare function areAllVisibleRowsSelected(rows: readonly PickItem[], picks: readonly PickItem[]): boolean;
+/**
+ * 多选态内的整行点击守卫（document 捕获阶段）。
+ *
+ * 边界：行里的按钮 / 链接 / 输入 / 菜单项一律放行（否则 ⋯ 菜单、归档、置顶、单删都点不动）；
+ * 双击的第二下与 dblclick 不翻转（第一下已经选中，第二下不能又反掉，也不能打开宿主的重命名）。
+ * 认行靠 `data-row-key="session:…"`——**这是本文件唯一一处 DOM 读**（ADR-0034）：宿主将来改掉这个
+ * 属性，最差是模式内点行不生效，勾选框本身仍在。模式外不挂监听：这时点行必须还是宿主的"打开会话"。
+ */
+export declare function useSelectionRowClickGuard(): void;

package/lib/types/client/batch-select.d.ts

@@ -4,16 +4,16 @@
  *
  * 入口在每行的「⋯」菜单里（`batch-menu-item.tsx`）：**按下才进入多选模式**，模式内才渲染勾选框、
  * 才把整行点击变成"勾/取消"；退出模式清空名单。选中集只住 `batch-selection-store.ts`（模式 + 名单一份
- * 合并快照）；"哪些行现在可见、点行算不算选中"只住 `host-rows.ts`。四处隔着槽位边界，只有模块级
- * store 能让他们看见同一份名单；本文件不再持有任何现场。
+ * 合并快照）；"哪些行现在可见"住 `host-rows.ts`，"点行算不算选中"住 `batch-pick.ts`。四处隔着
+ * 槽位边界，只有模块级 store 能让他们看见同一份名单；本文件不持有任何现场。
  *
  * **为什么主勾选在行首**：宿主对行尾 `.rowActions` 是 `display:none`，只有 `row:hover` / 菜单打开
  * 才出现（app.asar 0.2.0-rc.2 的 Rows 渲染）；行首 16px 格在无状态点时是空的，模式内可见。
  * 宿主在「有状态点（运行中/待确认/未读完成）」与归档行不渲染行首格 ⇒ 这些行走行尾悬停兜底，
- * 但模式内**点整行**也能选（`host-rows.ts` 的 `useSelectionRowClickGuard`），所以不依赖那颗小框。
+ * 但模式内**点整行**也能选（`batch-pick.ts` 的 `useSelectionRowClickGuard`），所以不依赖那颗小框。
  * 两条勾选不会同时出现（`ui.css` 的 `:has` 兜底隐藏规则，靠宿主行的 `data-row-key`）。
  */
-import { type ReactElement } from 'react';
+import type { ReactElement } from 'react';
 import { type Translate } from './copy.js';
 import { type SessionDeleteRemote } from './remote.js';
 /**
@@ -27,6 +27,8 @@ export interface BatchPickCheckboxProps {
     sessionId: string;
     /** 槽位只投 `sessionId`；标题由宿主侧的 root hook 读出来再传进来（见 `index.tsx` 的 `PickLeadingRow`）。 */
     title: string;
+    /** 运行态同样由 root hook 读：登记表里的 `live` 与行尾兜底保持同一口径。 */
+    live?: boolean;
     /** 文案（缺省 = 内置 zh，见 `copy.ts`）。 */
     t?: Translate;
 }
@@ -37,7 +39,7 @@ export interface BatchPickCheckboxProps {
  * （行首格在宿主行那条 `onClick` 里面）。宿主对「有状态点」和归档行不渲染这一格，
  * 那些行走 `BatchPickButton` 兜底；两条不会同时出现（见 `ui.css` 的兜底隐藏规则）。
  */
-export declare function BatchPickCheckbox({ sessionId, title, t, }: BatchPickCheckboxProps): ReactElement | null;
+export declare function BatchPickCheckbox({ sessionId, title, live, t, }: BatchPickCheckboxProps): ReactElement | null;
 export interface BatchPickButtonProps {
     sessionId: string;
     title: string;

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

@@ -1,50 +1,49 @@
-import { type PickItem } from './batch-selection-store.js';
+import type { PickItem } from './batch-selection-store.js';
 export interface HostRowInfo {
-    /** 槽位投影的 `displayTitle`（行首槽只投 id，所以守卫靠行尾那颗常驻登记）。 */
+    /** 槽位宿主投影的标题（`PickLeadingRow` / `PickRow` 从 root hook 读）；守卫只读登记，不读 DOM 文本。 */
     readonly title: string;
     /** 在跑的行点整行也不选：与置灰的勾选框同口径（级联遇在跑成员整组拒绝）。 */
     readonly live: boolean;
 }
 /**
- * 行尾兜底勾选开关登记一行：模式内与模式外都要登记（守卫进模式的那一帧就得有标题）。
- * 只有标题／运行态**真的变了**才标脏：重渲染时的同值登记不该把快照翻新一遍。
+ * 行槽位开关登记一行：模式内与模式外都要登记（守卫进模式的那一帧就得有标题）。
+ * 每次登记算**多一个挂载实例**；不给 info 时只占位，随后由 {@link updateHostRowInfo} 填值。
  */
-export declare function registerHostRowInfo(sessionId: string, info: HostRowInfo): void;
+export declare function registerHostRowInfo(sessionId: string, info?: HostRowInfo): void;
 /**
- * 「当前可见」的可选行：侧栏里**已渲染**的会话行（`data-row-key="session:…"`）——折叠组、
- * 归档过滤外的行不在 DOM 里，宿主隐藏的 subagent 也不在；在跑的行跳过（与置灰勾选框同口径）。
- * 标题/运行态来自行尾兜底登记的 `rowInfo`（模式内它对每个非空行都渲染）；DOM 序就是侧栏顺序。
+ * 标题/运行态变了就地更新：**不注销、不重登记**，否则这一行会被挪到登记序末尾（ADR-0034 决定 2）。
+ */
+export declare function updateHostRowInfo(sessionId: string, info: HostRowInfo): void;
+/**
+ * 槽位组件共用的登记生命周期：挂载登记、卸载注销；标题/运行态变化只走更新口。
+ * 两次 effect 分工是顺序契约：先占住首次登记序，再填值。
+ */
+export declare function useHostRowRegistration(sessionId: string, info: HostRowInfo): void;
+/** 行槽位开关卸载时调用：那一行已经离开渲染树，登记跟着走。
+ *  还有别的挂载实例在用同一行（重复行）就只减计数，不摘登记。 */
+export declare function unregisterHostRowInfo(sessionId: string): void;
+/**
+ * 守卫与全选共用的一行读数：这一行此刻可勾选时交回登记（含标题）；未登记或在跑回 `undefined`。
+ * 登记表是可见行的事实源，所以"没登记"就是"这一行此刻不在可见集合里"。
+ */
+export declare function pickableRowOf(sessionId: string): HostRowInfo | undefined;
+/**
+ * 「当前可见」的可选行：**已登记**的会话行（槽位开关还挂在渲染树上）——折叠组、归档过滤外的行
+ * 没有挂载，因此没有登记；在跑的行跳过（与置灰勾选框同口径）。标题/运行态来自登记值；
+ * 顺序是登记顺序（宿主按列表顺序挂载行）。
  *
  * 这是**当场读**：事件路径（点「全选」那一刻的页面）与测试用它；渲染侧读下面的快照。
  */
 export declare function readVisibleSelectableRows(): PickItem[];
 /**
- * 渲染侧的快照：脏了才查 DOM；干净时回同一个引用（React 的 `useSyncExternalStore` 契约）。
+ * 渲染侧的快照：脏了才重读登记；干净时回同一个引用（React 的 `useSyncExternalStore` 契约）。
  * 没变化时连续两次调用必须同引用，否则订阅方会被自己的快照更新推成死循环。
  */
 export declare function getVisibleSelectableRowsSnapshot(): readonly PickItem[];
 /**
- * 渲染侧只读快照 + DOM 观察订阅；首个订阅者起开始观察，最后一个走了断开。
- * `enabled === false` 不订阅也不读 DOM——行列表只随多选态存在，模式外不必付观察的成本。
+ * 渲染侧只读快照 + 登记订阅；`enabled === false` 不订阅也不读登记——行列表只随多选态存在，
+ * 模式外不必付订阅的成本。
  */
 export declare function useVisibleSelectableRows(enabled: boolean): readonly PickItem[];
-/** 全选：把当前可见可选行按 DOM 序追加；已在名单里的由 `addPicks` 自己跳过，原有选中保持在前。 */
-export declare function selectAllVisible(): void;
-/**
- * 同一个切换口该显示「全选」还是「取消全选」：
- * - 有选中、且当前可见可选行全都选中 ⇒ 取消全选；
- * - 有选中、但当前没有可见可选行（全折叠/过滤掉）⇒ 只能清空，也显示取消全选；
- * - 其余（含 0 条）⇒ 全选。
- */
-export declare function areAllVisibleRowsSelected(rows: readonly PickItem[], picks: readonly PickItem[]): boolean;
-/**
- * 多选态内的整行点击守卫（document 捕获阶段）。
- *
- * 边界：行里的按钮 / 链接 / 输入 / 菜单项一律放行（否则 ⋯ 菜单、归档、置顶、单删都点不动）；
- * 双击的第二下与 dblclick 不翻转（第一下已经选中，第二下不能又反掉，也不能打开宿主的重命名）。
- * 认行靠 `data-row-key="session:…"`——宿主将来改掉这个属性，最差是模式内点行不生效，
- * 勾选框本身仍在。模式外不挂监听：这时点行必须还是宿主的"打开会话"。
- */
-export declare function useSelectionRowClickGuard(): void;
-/** 测试专用：登记表清空并标脏（会话 id 不跨用例复用，名字/运行态别串味）；观察者归订阅者管。 */
+/** 测试专用：登记表清空并标脏（会话 id 不跨用例复用，名字/运行态别串味）。 */
 export declare function resetHostRows(): void;

package/lib/types/client/main-view.d.ts

@@ -11,7 +11,8 @@
  * 所以关闭/重开是**一段生命周期**，不是一个 id：删除成功后 `afterDelete` 关掉当前
  * 主视图并记下"这一条是我们关掉的"；撤销成功后 `afterRestore` 只重开自己记过的那些。调用方不再
  * 各自判定该不该关、也不再把会话 id 塞进撤销提示传一圈——判据全在这一处。两次重开排队时只有最新
- * 那条会打开（最新票守卫），`resetMainView()` 清掉这份记忆并让在等的重开作废。
+ * 那条会打开（等待本身住 `src/client/pending-open.ts` 的票与订阅），`resetMainView()` 清掉这份记忆
+ * 并取消在等的重开。
  *
  * **不 import 宿主客户端包**（AGENTS.md 红线）：只通过 `ctx.get('uiWorkspace')` 可选读服务，
  * 形状不符/服务缺席都安静退回，绝不影响插件激活。字段与方法名来自上面两个包的产物原文；

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;
 }>;