From 629f1cd74e47160513653be3aa810c0e72d55c2d Mon Sep 17 00:00:00 2001
From: xiaosheng <73678111+xiaoshengbao@users.noreply.github.com>
Date: Tue, 15 Sep 2026 16:49:41 +0800
Subject: [PATCH 1/2] =?UTF-8?q?feat:=20=E5=9B=BA=E5=AE=9A=E8=AF=AD?=
 =?UTF-8?q?=E4=B9=89=E6=A3=80=E7=B4=A2=E6=B6=88=E6=81=AF=E6=80=BB=E9=87=8F?=
 =?UTF-8?q?=E5=B9=B6=E5=AE=8C=E5=96=84=20AI=20=E8=BF=87=E7=A8=8B=E5=B1=95?=
 =?UTF-8?q?=E7=A4=BA?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 design-qa.md                                  | 137 ++++++++++++
 docs/local-semantic-search.md                 |   4 +
 frontend/assets/css/agent.css                 |  41 ++--
 frontend/components/LocalSearchSettings.vue   | 107 +++++++--
 frontend/components/chat/AgentRun.vue         |  48 +----
 frontend/components/chat/AgentSubtasks.vue    |   4 +-
 frontend/components/chat/AgentToolCall.vue    |  37 +++-
 frontend/components/chat/ChatAgentPanel.vue   |  10 +-
 frontend/tests/agent-timeline.test.js         |  45 ++--
 frontend/tests/agent-tool-errors.test.js      |  27 +++
 frontend/tests/chat-agent.test.js             |  36 ++++
 .../fixtures/AgentModelPickerPreview.vue      |   2 +-
 .../tests/fixtures/AgentProgressPreview.vue   |  12 ++
 .../tests/fixtures/LocalSearchPreview.vue     |  11 +-
 frontend/tests/fixtures/local-search.js       |  18 +-
 frontend/tests/local-search.test.js           | 119 +++++++++-
 src/wechat_decrypt_tool/ai/deep_runtime.py    |   9 +-
 .../local_search/frozen.py                    | 109 ++++++++++
 .../local_search/progressive.py               |   4 +-
 .../local_search/service.py                   |  44 +++-
 .../local_search/totals.py                    |  75 +++++++
 tests/test_ai_deepagents.py                   |   8 +-
 tests/test_local_search.py                    |   9 +-
 tests/test_local_search_totals.py             | 203 ++++++++++++++++++
 24 files changed, 962 insertions(+), 157 deletions(-)
 create mode 100644 src/wechat_decrypt_tool/local_search/frozen.py
 create mode 100644 src/wechat_decrypt_tool/local_search/totals.py
 create mode 100644 tests/test_local_search_totals.py

diff --git a/design-qa.md b/design-qa.md
index ff280245..fc8b41d1 100644
--- a/design-qa.md
+++ b/design-qa.md
@@ -1,3 +1,110 @@
+# 本地检索固定总量验收 · 2026-09-15
+
+- final result: passed
+- 本节为最新验收；下方记录保留历史方案，原「预计总量、完成校准」已由固定本轮清单取代。
+- source visual truth path: `output/local-search-progress/total-desktop.png`（上一版面板）。
+- implementation screenshot path: `output/local-search-progress/fixed-total.png`、`fixed-counting.png`、`fixed-narrow-dark.png`（均在同目录）。
+- viewport: 1280×720 CSS px；比较截图均为 1280×720 像素，未额外缩放。宽容器 1000px，窄容器 480px。
+- state: 整理中、统计中；浅色宽屏、深色窄屏；正式组件使用明确标注的虚构数据。
+- full-view comparison evidence: 在同一输入中查看上一版总量面板、新固定总量面板和统计阶段截图；保留阶段、进度条、四项数字与处理详情的层级。
+- focused region comparison evidence: 完整截图中统计区域清晰可读，无需裁切；窄屏另行检查两列数字、分母和提示文字，无截断。
+
+## 五项核验
+
+- 字体：主数字和次要分母维持原有字号、字重；「本轮总量」取代「预计总量」。
+- 间距：宽屏四列、窄屏两列；保存进度与固定分母同组，长提示自然换行。
+- 颜色：沿用绿色保存进度和蓝色累计索引，深色数字清晰。
+- 图像：无新增位图，沿用现有状态图标和原生进度条。
+- 文案：统计时明确说明统计完成后开始整理；不显示中途增长的统计值或虚假百分比。整理时说明本轮固定、新消息下一轮。
+
+## 行为与验证
+
+- 先分页准备完整消息清单、去重并确定总量，然后开始模型整理；进度条按已保存消息 / 固定总量计算。
+- 暂停、重启沿用同一清单；源消息删除、新增或补入旧消息不会改变已冻结的总量。未完成任务不因后台发现新会话而扩大范围。
+- 清单暂存在本地 SQLite，完成后清理；首次统计增加等待时间和临时磁盘占用。清单丢失时明确报错，保留已有索引，不静默重算分母。
+- 83 项后端测试、54 项前端测试通过；覆盖完整准备先于编码、固定总量、源数据变动、暂停续接、统计失败重试、零值及旧任务兼容。
+- 浏览器 console error 为空；机械扫描无发现；目标文件 diff 检查通过。最终无 P0/P1/P2 视觉问题。
+- 当前桌面后端尚未重启，新后端逻辑需重启项目后加载。验收使用测试与隔离预览，未对真实聊天触发额外整理。
+
+final result: passed
+
+---
+
+# 本地检索消息总量补充验收 · 2026-09-15
+
+- final result: passed
+- source visual truth path: `output/local-search-progress/desktop.png`（已接受的面板），本轮要求在已读取消息旁增加总量。
+- implementation screenshot path: `output/local-search-progress/total-desktop.png`、`output/local-search-progress/total-narrow.png`。
+- viewport: 1280×720 CSS px；源与实现截图均为 1280×720 像素，工具已归一为 CSS 像素，未额外缩放。
+- state: 浅色、整理中、虚构数据；宽容器 1000px，窄容器 480px。
+- full-view comparison evidence: 同一输入并列查看原面板、新宽屏、新窄屏三张截图。所有主体布局保留，首项增加小字号分母 58,735，显示为 26,286 / 58,735。
+- focused region comparison evidence: 数字、标签与分母在完整截图中均可读，未额外裁切。
+
+## 五项核验
+
+- 字体：现有 24px 主数字保留；分母 14px、普通字重，清晰区分当前数与总量。
+- 间距：分母同行基线对齐，宽度不足可换行；窄窗口各统计项 clientWidth / scrollWidth 均为 182px，无溢出。
+- 颜色：分母使用现有次要文字令牌，继承深色主题；绿色与蓝色统计保持原样。
+- 图像：未新增图片或替换图标。
+- 文案：标明「预计总量」，本轮范围与去重校准规则放在处理详情；未知值不伪造分母。
+
+## 证据与边界
+
+- 浏览器无 console error；宽窄截图无 P0/P1/P2 问题，无需视觉修正。
+- 52 项前端测试通过；77 项后端测试通过。覆盖当前任务绑定、零值、未知/失效总量、范围合并、取消、失败降级、完成校准和禁止正文回退扫描。
+- 机械扫描无发现，修改文件 diff 检查通过。
+- 后端统计为新代码；现有运行服务需重启后加载。本轮未重启正在运行的桌面服务，也未对真实聊天触发额外索引。
+
+final result: passed
+
+---
+
+# 本地语义检索进度面板验收 · 2026-09-15
+
+- final result: passed
+- source visual truth path: `C:/Users/123/AppData/Local/Temp/codex-clipboard-6525eb58-700d-4983-a2a4-2eb62d433f8a.png`
+- 改造对象参考：`C:/Users/123/AppData/Local/Temp/codex-clipboard-271309b8-7457-4ccd-8051-81f66f0c1b58.png`
+- implementation screenshot path: `output/local-search-progress/desktop.png`
+- 补充截图：`output/local-search-progress/narrow-dark.png`、`initial.png`、`error.png`（均在同目录）。
+- 本地预览：`http://127.0.0.1:4173/tests/fixtures/local-search.html?progress=running`
+- 预览挂载正式 LocalSearchSettings 组件，数据为明确标注的虚构快照；未操作真实索引。
+
+## 对比依据与范围
+
+图一是语音任务的样式参考，图二是语义检索的改造对象，并非要求复制语音转换页面。参考图一 1800×1200、图二 1474×1104；最终浏览器截图 1280×720（工具输出按 CSS 像素归一）。浏览器视口 1280×720 CSS px；宽容器约 1000px，窄窗口容器 480px，状态卡约 417px。未拉伸图像，未把原图系统缩放或不同内容产生的尺寸差认定为视觉缺陷。
+
+已在同一图像比较输入中打开图一和 desktop.png，重点对比进度区的结构：阶段与状态标签、通栏绿色进度条、数字优先的四列统计、下方辅助说明。两张完整截图中的进度区均能直接读清，不需要额外裁切。语义检索继续使用自己的消息/片段/索引统计，未引入语音任务的失败数或成功数。
+
+## 五项视觉核验
+
+- 字体：保留现有系统中文字体；阶段 14px，主要数字最高 24px、600 字重，启用等宽数字。标签与说明降低层级，数字不再混在整句中。
+- 布局：白色面板、12px 圆角、20px 内边距；四列统计平铺，累计索引有细分隔线。容器小于 520px 改为两列，DOM 检查各项 scrollWidth 等于 clientWidth，无横向溢出。
+- 颜色：沿用产品绿色。绿色表示已保存，蓝色区分累计索引，错误用明确图标与文字表达。深色数字使用 #64d49c 和 #9aafd7。
+- 图标与图像：使用项目已有 Font Awesome 图标，无新增位图或占位图。参考中的纯 UI 元素用原生 progress 和组件样式实现。
+- 内容：百分比按任务已完成会话时间段计算，未知总数为不定进度。实时生成与事务保存数量分开；运行中可见暂停入口；批量、复用、索引模式移至处理详情，错误和警告保持展开。
+
+## 检查历史
+
+1. 首轮宽屏对比通过；窄窗口深色截图发现 [P2] 统计绿色/蓝色过暗，scoped CSS 的全局主题选择器未命中状态卡。
+2. 修正完整全局选择器；再次截图 `narrow-dark.png`，确认绿色变量为 #64d49c，绿色/蓝色数字清晰；两列无截断。无其他 P0/P1/P2 问题。
+
+## 交互与验证
+
+- 浏览器检查详情展开/收起、暂停、首次零进度、错误提示、深浅色、窄窗口。
+- 暂停后实际显示已保存片段 4,180，替换生成中片段 4,260；保留 43% 进度并提供继续整理入口。
+- 浏览器 console error 列表为空。
+- `vitest run tests/local-search.test.js --root frontend`：46 项通过，覆盖进度口径、未知/空范围、零值到完成、错误外显和原有事件/暂停语义。
+- Impeccable 机械扫描无发现；目标文件 `git diff --check` 通过。
+- 验证边界：组件与虚构任务状态验证；未重新运行真实模型或索引流程，后端未修改。
+
+## 结论
+
+final result: passed
+
+---
+
+以下保留此前任务的验收记录：
+
 # AI 助手改版验收
 
 - 日期：2026-09-08
@@ -471,3 +578,33 @@ final result: passed
 - 浏览器已检查强度和列表两态，回到强度态保留预览。10 项既有组件回归通过，git diff --check 通过。前端热更新已生效，无后端改动。
 
 final result: passed
+
+## 2026-09-15 读取小节点详情面板
+
+- 范围：AgentToolCall 的逐次读取节点；保留独立运行详情入口和已有执行过程结构。
+- 视觉来源：C:/Users/123/AppData/Local/Temp/codex-clipboard-1a0a8fe1-af94-4454-999b-6998fb7bc653.png（979×270），C:/Users/123/AppData/Local/Temp/codex-clipboard-54baee6a-21f0-4a21-888f-5a96545bed0a.png（735×1048）。前者定义展开面板，后者定义挂载位置。
+- 实现截图：tmp/agent-node-details-20260915/light-expanded.png、dark-expanded.png。
+- 预览：http://127.0.0.1:3057/tests/fixtures/agent-progress.html?nodes=1；仅合成数据。
+- 视口：1280×720 CSS px，浏览器 DPR 1.75，截图工具输出 1265×712 px。参考图未提供缩放比例；按节点与面板内容区域比较结构与效果，不以原图字号像素推断应用字号。
+- 状态：10 次读取，首节点展开，其余折叠；另测第二节点键盘展开、运行态、浅色和深色主题。
+- 对比证据：命令详情参考与实现截图在同批图像输入中展示，随后将节点列表参考与同张实现截图同批展示；聚焦首节点、浅灰面板、输入参数、结果和右下角状态，宽面板及窄侧栏均清晰可读。
+
+### Findings
+
+无待处理 P0/P1/P2。一次视觉比较通过；修复过一项旧测试对保存节点提示文字的断言，保留其原有提示。没有据截图追加视觉调整。
+
+- 字体：沿用现有系统字体、12px 详情与 11px 状态；参数使用现有等宽字体回退。保持应用密度，不复制参考截图的放大比例。
+- 间距：每个小节点独立箭头，展开区域紧随该节点；6px 圆角、10px/12px 内边距，竖线随面板高度延伸。窄面板约 231 CSS px，无横向溢出，日期自动换行。
+- 颜色：复用 ag-soft、ag-muted 等明暗主题变量；浅灰背景，完成状态右对齐；失败状态保留文字和图标，运行态使用既有 shimmer。
+- 图片与图标：无新增位图需求，全部使用现有 Font Awesome 图标，未将参考中的命令内容或批注复制为图片。
+- 文案与数据：本次会话、查询条件、分页位置、返回数量和状态来自已有节点数据；显示零分页位置，不伪造 Shell 命令。运行详情结构保持不变。
+
+### Implementation Checklist
+
+- 鼠标和 Enter 均可展开单个节点；节点互不干扰。
+- 进度更新保留展开选择；组件测试覆盖外部保存状态与本地状态，以及重新挂载。
+- 81 项相关测试已通过（22 项工具详情、26 项时间线、33 项聊天面板）。
+- 浏览器错误日志为空；改动文件 diff --check 通过。
+- 限制：浏览器使用合成数据，未调用真实模型。沿用现有全部结果文案与错误分支，未更改后端。
+
+final result: passed
diff --git a/docs/local-semantic-search.md b/docs/local-semantic-search.md
index 852f48f6..b190a497 100644
--- a/docs/local-semantic-search.md
+++ b/docs/local-semantic-search.md
@@ -90,6 +90,10 @@ GPU 进程故障、超时、缺库或显存不足时销毁故障进程，在独
 - 默认自动批量（`read_batch_size=0`）。总内存不超过 4 GiB 或可用内存不足 1 GiB 时最多 100 条；总内存不超过 8 GiB 或可用内存不足 3 GiB 时最多 500 条；其余情况自动使用 1,000 条。高级设置可选 100／500／1,000／2,000 条，手动选择仍受内存保护，每批重新检查。不依赖 NVIDIA 显卡是否存在。
 - 单批累计文本达到 128,000 字符时提前处理，避免少量长文本积累过多片段；保留完整单条消息，因此此阈值不是进程内存的硬上限。推理仍按最多 8 个片段执行，不随读取批量扩大显存需求。低内存策略通过模拟测试，其他硬件、系统和磁盘速度仍需实机验证。
 - 读取数量约每 250 ms（有新消息时）上报一次，页尾立即上报；SSE 每秒传递事件，1.5 秒轮询兜底。界面直接更新读取数、片段数、实际批量和已保存进度，较旧事件或轮询响应不得让进度倒退。设备状态不变时不重复写入相同事件。
+- 整理采用固定轮次：先显示「正在统计消息总量」，按任务开始时的聊天目录、截止时间和本轮范围准备完整清单并去重，再显示「已读取 / 本轮总量」。统计中的临时数量不会作为分母展示；统计失败则保留断点并等待重试，不提前进入推理。
+- 本轮总量发布后不再增长、隐藏或在完成时校准，进度条按「已保存消息数 / 本轮总量」计算。后台发现的新会话不会打断未完成轮次；统计完成后收到或补入的消息留到下一轮。
+- 为避免统计与实际读取之间的数据变化，准备清单时会分页暂存本轮消息，之后直接从本地暂存数据整理，不再第二次读取微信正文。内存按分页条数和字符数限制；首次整理需等待全部统计完成，并临时占用额外磁盘空间。暂存文件位于本地检索数据目录的 `plans/` 下，按账号与任务隔离。
+- 暂停或重启保留统计断点及已固定的消息清单；旧任务迁移时将已保存数量纳入本轮总量。完成后自动清理临时清单，调整配置、清理索引或删除账号时也会清理。已固定清单丢失时提示从头整理，不静默重新统计成另一个总量。
 - 最小化继续处理；退出停止。重启恢复此前运行任务，主动暂停保持暂停。数据和断点仍在同一事务提交，读取中的数量不用于恢复；失败或暂停只保留已提交批次，大批写入期间每 100 条检查取消。恢复时会重读尚未保存的一批。
 - `members(source,chunk)` 索引保证按原消息查找关联片段时不扫描整张关联表，适用于新建及已有索引。批量去重和关联查询在后台线程执行。
 - 关键词及向量分别最多召回 200 条，按来源去重、RRF（常数 60）融合。查询票据固定账号、权限版本、范围及候选顺序，有效十分钟，最多缓存 32 次查询。检索文本返回前再次按原消息权限和过滤条件约束，不返回片段内越权相邻原文。
diff --git a/frontend/assets/css/agent.css b/frontend/assets/css/agent.css
index 1c3bb7d5..b9466838 100644
--- a/frontend/assets/css/agent.css
+++ b/frontend/assets/css/agent.css
@@ -166,11 +166,25 @@ html[data-theme="dark"] .agent-thread-management .is-destructive, html[data-them
 .agent-tool-timeline .agent-tool-attempt { position:relative; padding:0 0 8px 20px; margin:0; }
 .agent-tool-timeline .agent-tool-attempt:not(:last-child)::before { content:''; position:absolute; left:0; top:10px; bottom:-10px; width:1px; background:color-mix(in srgb,var(--ag-muted) 30%,transparent); }
 .agent-tool-timeline .agent-tool-attempt:last-child { padding-bottom:0; }
-.agent-tool-attempt-row { display:flex; align-items:baseline; flex-wrap:wrap; gap:2px 18px; list-style:none; cursor:pointer; min-height:24px; line-height:1.8; }
+.agent-tool-attempt-row { display:flex; align-items:baseline; flex-wrap:wrap; gap:2px 12px; list-style:none; cursor:pointer; min-height:28px; line-height:1.8; border-radius:4px; }
 .agent-tool-attempt-row strong { font-weight:400; min-width:72px; }
 .agent-tool-attempt-row .agent-tool-node { position:absolute; top:8px; left:-4px; font-size:6px; color:color-mix(in srgb,var(--ag-muted) 55%,var(--ag-bg)); }
 .agent-tool-inspection[open] > summary { margin-bottom:8px; }
 .agent-tool-inspection[open] { padding-bottom:4px; }
+/* 小节点下方展示本次操作，浅色面板与右下角状态呼应命令详情的阅读方式。 */
+.agent-tool-attempt-row:hover { color:var(--app-text-primary); }
+.agent-attempt-chevron { margin-left:auto; flex:none; font-size:10px; align-self:center; transition:transform .15s ease; }
+.agent-tool-inspection[open] > .agent-tool-attempt-row .agent-attempt-chevron { transform:rotate(90deg); }
+.agent-tool-inspection-panel { min-width:0; padding:10px 12px; border-radius:6px; background:var(--ag-soft); color:var(--ag-muted); line-height:1.75; }
+.agent-tool-inspection-panel > header { margin:0 0 8px; }
+.agent-tool-inspection-panel > header strong { color:inherit; font-weight:400; }
+.agent-tool-request { font-family:var(--font-mono,ui-monospace,SFMono-Regular,Consolas,monospace); font-size:12px; }
+.agent-tool-request:empty,.agent-tool-response:empty { display:none; }
+.agent-tool-request + .agent-tool-response:not(:empty) { margin-top:10px; }
+.agent-tool-inspection-status { display:flex; align-items:center; justify-content:space-between; gap:12px; margin-top:12px; font-size:11px; font-variant-numeric:tabular-nums; }
+.agent-tool-inspection-status > span:last-child { display:inline-flex; align-items:center; gap:5px; }
+.agent-tool-inspection-panel.is-failed .agent-tool-inspection-status > span:last-child { color:var(--danger-color,#b95039); }
+@media(prefers-reduced-motion:reduce) { .agent-attempt-chevron { transition:none; } }
 .agent-progress-note { line-height:1.7; margin:16px 0 8px; color:var(--app-text-primary,#25352d); }
 .agent-progress-note p { margin:0; }
 .agent-progress-note small, .agent-progress-note.is-superseded { color:var(--ag-muted); font-size:10px; }
@@ -194,8 +208,8 @@ html[data-theme="dark"] .agent-thread-management .is-destructive, html[data-them
 .agent-error { font-size:11px; color:#b95039; background:#b9503910; padding:9px 12px; border-radius:7px; margin:10px 16px; }
 .agent-run .agent-error { margin:10px 0; }
 .agent-composer { position:relative; flex-shrink:0; padding:6px 16px 10px; }
-.agent-input-box { border:1px solid var(--ag-border); border-radius:24px; padding:10px; background:var(--ag-bg); box-shadow:0 2px 8px #00000003; }
-.agent-input-box:focus-within { border-color:var(--ag-muted); box-shadow:0 0 0 1px var(--ag-border); }
+.agent-input-box { border:1px solid var(--ag-border); border-radius:12px; padding:10px; background:var(--ag-bg); box-shadow:0 2px 8px #00000003; }
+.agent-input-box:focus-within { border-color:color-mix(in srgb,var(--ag-muted) 45%,var(--ag-border)); }
 .agent-input-box textarea { display:block; width:100%; min-height:28px; max-height:144px; resize:none; overflow-y:auto; border:0; outline:0; font:inherit; font-size:13px; line-height:1.6; background:transparent; color:inherit; padding:0; box-sizing:border-box; }
 .agent-input-box textarea::placeholder { color:var(--ag-muted); }
 .agent-input-actions { display:flex; gap:4px; align-items:center; margin-top:10px; min-width:0; }
@@ -205,7 +219,6 @@ html[data-theme="dark"] .agent-thread-management .is-destructive, html[data-them
 .agent-input-actions > button { flex-shrink:0; width:28px; height:28px; padding:0; color:var(--ag-muted); font-size:12px; }
 .agent-input-actions .agent-send { margin-left:auto; color:#fff; background:#171717; width:28px; height:28px; border-radius:50%; padding:3px; font-size:14px; }
 .agent-input-actions .agent-send:hover { background:var(--app-text-secondary,#5f5f5f); }
-.agent-disclaimer { display:block; text-align:center; color:var(--ag-muted); font-size:10px; margin-top:6px; }
 .agent-composer-settings { position:absolute; bottom:calc(100% - 4px); left:12px; right:12px; padding:12px; background:var(--ag-bg); border:1px solid var(--ag-border); border-radius:10px; box-shadow:0 -6px 28px #0001; z-index:5; font-size:12px; }
 .agent-composer-settings header { display:flex; align-items:center; justify-content:space-between; margin-bottom:10px; }
 .agent-composer-settings label { display:block; color:var(--ag-muted); }
@@ -274,7 +287,10 @@ html[data-theme=dark] .agent-panel .agent-composer-settings > button { color:#70
 html[data-theme=dark] .agent-panel .agent-markdown .agent-ref[aria-expanded=true] { color:#fff; background:#087c44; }
 
 /* 执行记录沿用正文阅读轴；当前状态独立显示，折叠历史时也能看到进展。 */
-.agent-process-toggle .agent-shimmer { animation:none; background:none; color:inherit; -webkit-text-fill-color:currentColor; }
+/* 用文字扫光表示 AI 正在处理，减少持续旋转图标的干扰。 */
+.agent-shimmer { background:linear-gradient(100deg,currentColor 35%,color-mix(in srgb,currentColor 25%,var(--ag-bg)) 50%,currentColor 65%); background-size:250% 100%; background-clip:text; -webkit-background-clip:text; -webkit-text-fill-color:transparent; animation:agent-shimmer 2s linear infinite; }
+@keyframes agent-shimmer { from { background-position:100% 0; } to { background-position:0 0; } }
+@media(prefers-reduced-motion:reduce), (forced-colors:active) { .agent-shimmer { animation:none; background:none; -webkit-text-fill-color:currentColor; } }
 .agent-stream-status { display:flex; align-items:center; gap:8px; margin:14px 0 18px; color:var(--ag-muted); font-size:13px; }
 .agent-stream-status time { font-size:10px; opacity:.7; font-variant-numeric:tabular-nums; }
 .agent-status-dot { width:6px; height:6px; flex:none; border-radius:50%; background:currentColor; animation:agent-status-pulse 1.6s ease-in-out infinite; }
@@ -325,13 +341,11 @@ html[data-theme=dark] .agent-panel .agent-markdown .agent-ref[aria-expanded=true
 .agent-process-body { margin:6px 0 0 7px; border-left:1px solid var(--ag-border); padding:2px 0 4px 10px; background:transparent; }
 .agent-process-body.is-collapsed { margin:2px 0 0; padding:0; border:0; }
 .agent-live-step { display:flex; align-items:baseline; gap:10px; margin:6px 8px; padding:5px 0; color:var(--ag-muted); font-size:12px; line-height:1.65; }
-.agent-live-step > i { width:14px; flex:none; color:#079b57; }
 .agent-live-step > div { min-width:0; }
 .agent-live-caption { font-size:11px; margin-right:8px; color:var(--ag-muted); }
 .agent-live-step .agent-stream-status { display:inline; margin:0; color:var(--app-text-primary); font-size:13px; overflow-wrap:anywhere; }
 .agent-live-hint { margin:3px 0 0; font-size:12px; }
 .agent-live-step > time { flex:none; font-size:11px; font-variant-numeric:tabular-nums; }
-html[data-theme=dark] .agent-live-step > i { color:#63d99a; }
 .agent-process-body .agent-tool { margin:2px 0; padding:0 8px; font-size:13px; }
 .agent-process-body .agent-tool-title { color:var(--ag-muted); }
 .agent-process-body .agent-tool[open] { background:var(--ag-bg); }
@@ -348,26 +362,17 @@ html[data-theme=dark] .agent-live-step > i { color:#63d99a; }
 .agent-stage-row > span { overflow-wrap:anywhere; }
 .agent-stage-row > small { font-size:11px; font-variant-numeric:tabular-nums; }
 .agent-stage-row .sr-only { position:absolute; width:1px; height:1px; padding:0; margin:-1px; overflow:hidden; clip:rect(0,0,0,0); white-space:nowrap; border:0; }
-.agent-stage-row.is-running > i { color:#079b57; }
 .agent-process-body .agent-process:empty { display:none; }
 .agent-process-body:has(.agent-process:empty) .agent-run-metadata { margin-top:0; padding-top:0; border-top:0; }
 .agent-process-body .agent-run-metadata { margin:12px 8px 0; padding-top:10px; border-top:1px solid var(--ag-border); }
-/* 摘要入口与实时进度分层，诊断信息按需展开。 */
+/* 执行过程底部直接显示 Token 用量，来源结果仍按需展开。 */
 .agent-metadata-actions { display:flex; flex-wrap:wrap; align-items:center; gap:4px 20px; }
 .agent-metadata-actions > button { display:inline-flex; align-items:center; gap:8px; min-height:32px; padding:4px 0; margin:0; font-size:12px; color:var(--ag-muted); text-decoration:none; }
 .agent-metadata-actions > button i { flex:none; width:10px; text-align:center; font-size:10px; }
 .agent-metadata-actions > button:hover { color:var(--app-text-primary); }
 .agent-run-metadata button:focus-visible { outline:2px solid var(--ag-muted); outline-offset:3px; border-radius:4px; }
 .agent-coverage-summary { margin:0 0 4px; line-height:1.7; }
-.agent-run-details { padding:12px 0 4px; line-height:1.7; overflow-wrap:anywhere; }
-.agent-detail-facts { display:grid; gap:8px; margin:0; }
-.agent-detail-facts > div { display:grid; grid-template-columns:5em minmax(0,1fr); gap:12px; align-items:baseline; }
-.agent-detail-facts dt, .agent-detail-facts dd { margin:0; }
-.agent-detail-facts dd { color:var(--app-text-primary); font-variant-numeric:tabular-nums; }
-.agent-run-details .agent-usage { margin:12px 0 0; font-size:12px; }
-.agent-run-details .agent-coverage-note { margin-top:8px; }
-.agent-run-details .agent-index-note { margin-top:12px; }
-.agent-run-details button { min-height:32px; padding:4px 6px; font-size:12px; text-decoration:underline; text-underline-offset:3px; }
+.agent-run-metadata > .agent-usage { margin:6px 0; font-size:12px; font-variant-numeric:tabular-nums; }
 .agent-answer-heading { margin:0 0 12px; font-size:14px; line-height:1.5; font-weight:600; color:var(--app-text-primary); }
 .agent-panel .agent-final-answer .agent-markdown { font-size:15px; line-height:1.85; }
 @container (max-width:480px) {
diff --git a/frontend/components/LocalSearchSettings.vue b/frontend/components/LocalSearchSettings.vue
index 1885dd5c..19d3f6b3 100644
--- a/frontend/components/LocalSearchSettings.vue
+++ b/frontend/components/LocalSearchSettings.vue
@@ -7,23 +7,40 @@
       </header>
 
       <div v-if="!account" class="lss-feedback">请先在聊天页面选择账号。现在也可以下载模型，之后再开始整理。</div>
-      <div v-if="job && (form.enabled || job.status==='error')" ref="statusRef" class="lss-status" tabindex="-1" :class="{ 'is-error': job.status==='error' }" aria-live="polite">
-        <div class="lss-row">
-          <div class="lss-status-title"><i class="fa-solid" :class="running ? 'fa-circle-notch fa-spin' : job.status==='done' ? (hasSearchData ? 'fa-circle-check' : 'fa-circle-info') : 'fa-circle-pause'" aria-hidden="true"></i><strong>{{ job.status==='done' ? completedTitle : stage(job) }}</strong></div>
-          <span class="lss-note">用时 {{ elapsed(job) }}</span>
+      <div v-if="job && (form.enabled || job.status==='error')" ref="statusRef" class="lss-status" tabindex="-1" :class="{ 'is-error': job.status==='error', 'is-paused': job.status==='paused' }">
+        <div class="lss-status-heading">
+          <div class="lss-status-title" role="status"><i class="fa-solid" :class="running ? 'fa-circle-notch fa-spin' : job.status==='error' ? 'fa-circle-exclamation' : job.status==='done' ? (hasSearchData ? 'fa-circle-check' : 'fa-circle-info') : 'fa-circle-pause'" aria-hidden="true"></i><strong>{{ job.status==='done' ? completedTitle : stage(job) }}</strong></div>
+          <div class="lss-status-meta"><span class="lss-device-badge"><i class="fa-solid fa-microchip" aria-hidden="true"></i>{{ actualDevice }}</span><span class="lss-note">用时 {{ elapsed(job) }}</span></div>
         </div>
-        <p class="lss-live-count">{{ job.status==='done' ? '本次检查' : '已读取' }} {{ job.read_count ?? job.processed ?? 0 }} 条消息 · {{ running ? '本次生成' : '本次已保存' }} {{ running ? (job.embedded_count ?? job.embedded ?? 0) : (job.embedded ?? 0) }} 个片段 · {{ actualDevice }}</p>
-        <p v-if="indexStats" class="lss-index-total">当前索引：{{ indexStats.messages }} 条消息 · {{ indexStats.chunks }} 个片段</p>
-        <p v-if="job.mode" class="lss-note">{{ indexMode(job.mode) }}</p>
-        <p v-if="job.unchanged" class="lss-note">已复用 {{ job.unchanged }} 条未变化消息，无需重复生成片段。</p>
-        <p v-if="job.status==='done' && !job.embedded && hasSearchData" class="lss-note">内容没有变化，已复用现有搜索数据，无需重复生成片段。</p>
-        <p v-if="running || job.status==='paused' || job.status==='error'" class="lss-note">已保存 {{ job.processed || 0 }} 条消息的进度<template v-if="running"> · {{ job.chat_index || 0 }} / {{ job.segments?.length || job.config?.usernames?.length || form.usernames.length }} 个{{ job.segments ? '会话时间段' : '聊天' }}已完成</template></p>
-        <p v-if="running && job.read_batch_size_effective" class="lss-note">当前每批最多 {{ job.read_batch_size_effective }} 条 · 根据可用内存调整</p>
-        <p v-if="running" class="lss-note">可以离开这个页面，整理会在后台继续。</p>
-        <p v-else-if="job.status==='done' && hasSearchData" class="lss-note">在聊天搜索中切换到「智能搜索」，或直接向 AI 助手提问。</p>
-        <p v-else-if="job.status==='done' && indexStats && !hasSearchData" class="lss-note">请调整聊天或时间范围；只有图片等尚未提取文字的内容无法生成搜索片段。</p>
-        <p v-if="job.warning" class="lss-note">{{ job.warning }}</p><p v-if="job.error" :class="job.status==='paused' ? 'lss-note' : 'lss-error'">{{ job.error }}</p>
-        <div class="lss-actions" v-if="running"><button type="button" :disabled="busy" @click="act(()=>request('/index/pause',{method:'POST'},true))">暂停整理</button></div>
+        <div class="lss-progress-heading">
+          <span>{{ progress.total ? (progress.unit==='消息' ? '已保存消息进度' : `${progress.unit}进度`) : job.status==='done' ? '本轮整理进度' : job.stage==='counting' ? '统计完成后显示总量' : '正在确认整理范围' }}<span v-if="progress.total" class="lss-progress-count">{{ number(progress.completed) }} / {{ number(progress.total) }} 已完成</span></span>
+          <strong>{{ progress.percent === null ? '—' : `${progress.percent}%` }}</strong>
+        </div>
+        <progress class="lss-index-progress" :value="progress.percent ?? undefined" max="100" :aria-label="`${progress.unit}整理进度`" />
+        <dl class="lss-metrics">
+          <div class="lss-metric" data-metric="read"><dt>{{ job.status==='done' ? '本次检查消息' : '已读取消息' }}<template v-if="messageTotal.value !== null"> / 本轮总量</template></dt><dd><strong class="lss-read-total">{{ number(job.read_count ?? job.processed ?? 0) }}<span v-if="messageTotal.value !== null" class="lss-total-denominator">/ {{ number(messageTotal.value) }}</span></strong><span>{{ messageTotal.value !== null ? '条消息' : messageTotal.hint }}</span></dd></div>
+          <div class="lss-metric lss-metric-saved" data-metric="saved"><dt>已保存进度</dt><dd><strong>{{ number(job.processed ?? 0) }}</strong><span>条消息</span></dd></div>
+          <div class="lss-metric" data-metric="generated"><dt>{{ running ? '本次生成片段' : '本次已保存片段' }}</dt><dd><strong>{{ number(running ? (job.embedded_count ?? job.embedded ?? 0) : (job.embedded ?? 0)) }}</strong><span>个片段</span></dd></div>
+          <div class="lss-metric lss-metric-index" data-metric="indexed"><dt>当前索引片段</dt><dd><strong>{{ indexStats ? number(indexStats.chunks) : '—' }}</strong><span>{{ indexStats ? `覆盖 ${number(indexStats.messages)} 条消息` : '等待索引统计' }}</span></dd></div>
+        </dl>
+        <p v-if="job.warning" class="lss-status-warning" role="status"><i class="fa-solid fa-circle-info" aria-hidden="true"></i>{{ job.warning }}</p>
+        <p v-if="job.error" :class="job.status==='paused' ? 'lss-note' : 'lss-error'" :role="job.status==='paused' ? 'status' : 'alert'">{{ job.error }}</p>
+        <div class="lss-status-footer">
+          <p class="lss-note">{{ statusHint }}</p>
+          <button v-if="running" type="button" :disabled="busy" @click="act(()=>request('/index/pause',{method:'POST'},true))"><i class="fa-solid fa-pause" aria-hidden="true"></i>暂停整理</button>
+        </div>
+        <details class="lss-status-details">
+          <summary>处理详情<i class="fa-solid fa-chevron-down" aria-hidden="true"></i></summary>
+          <div>
+            <p v-if="job.mode" class="lss-note">{{ indexMode(job.mode) }}</p>
+            <p v-if="job.unchanged" class="lss-note">已复用 {{ number(job.unchanged) }} 条未变化消息，无需重复生成片段。</p>
+            <p v-if="job.status==='done' && !job.embedded && hasSearchData" class="lss-note">内容没有变化，已复用现有搜索数据，无需重复生成片段。</p>
+            <p class="lss-note">已读取 {{ number(job.read_count ?? job.processed ?? 0) }} 条消息，已保存 {{ number(job.processed ?? 0) }} 条消息的进度。生成中的片段以保存后结果为准。</p>
+            <p class="lss-note">开始整理前先统计完整消息总量，本轮总量固定不变；新增消息留到下一轮。暂停或重启后继续使用同一总量。</p>
+            <p v-if="running && job.read_batch_size_effective" class="lss-note">当前每批最多 {{ number(job.read_batch_size_effective) }} 条 · 根据可用内存调整</p>
+            <p class="lss-note">进度按已保存的{{ progress.unit }}计算，不代表剩余用时。</p>
+          </div>
+        </details>
       </div>
 
       <div class="lss-setup">
@@ -217,6 +234,38 @@ const selectedModel=computed(()=>state.value.models?.find(m=>m.id===form.model))
 const displayModel=computed(()=>selectedModel.value || state.value.models?.find(m=>m.recommended) || state.value.models?.[0])
 const modelReady=computed(()=>!!selectedModel.value?.downloaded)
 const running=computed(()=>['running','queued'].includes(job.value?.status))
+const number=value=>Number(value ?? 0).toLocaleString('zh-CN')
+const messageTotal=computed(()=>{
+  const current=job.value, total=state.value.message_total
+  // 固定总量从统计快照读取，完成、暂停和实时读取事件都不能改写分母。
+  if(total?.job_id===current?.id && total?.status==='ready' && total.fixed===true && typeof total.value==='number' && Number.isFinite(total.value) && total.value>=0){
+    return {value:total.value}
+  }
+  if(current?.status==='done')return {value:current.processed ?? 0}
+  const status=total?.job_id===current?.id ? total?.status : null
+  return {value:null,hint:status==='unavailable' ? '总量统计未完成' : !running.value ? '总量未统计完' : '总量统计中…'}
+})
+const progress=computed(()=>{
+  const current=job.value, total=messageTotal.value.value
+  if(total!==null){
+    const completed=Math.min(total,Math.max(0,Number(current?.processed) || 0))
+    return {total,completed,unit:'消息',percent:total ? Math.floor(completed/total*100) : current?.status==='done' ? 100 : 0}
+  }
+  if(current?.stage==='counting')return {total:0,completed:0,unit:'消息',percent:null}
+  // 旧任务尚未迁移固定消息清单时，继续展示原来已有的会话进度。
+  const segments=current?.segments?.length ?? current?.config?.usernames?.length ?? 0
+  const completed=Math.min(segments,Math.max(0,Number(current?.chat_index) || 0))
+  return {total:segments,completed,unit:current?.segments ? '会话时间段' : '聊天',percent:segments ? Math.floor(completed/segments*100) : null}
+})
+const statusHint=computed(()=>{
+  if(running.value && job.value?.stage==='counting')return '正在统计本轮消息总量，统计完成后开始整理。'
+  if(running.value)return '本轮范围已固定，新增消息留到下一轮；可以离开此页面。'
+  if(job.value?.status==='paused')return '进度已保存，可继续整理。'
+  if(job.value?.status==='error')return '已保存的进度会保留，可在下方重试整理。'
+  if(job.value?.status==='done' && hasSearchData.value)return '本轮整理已完成。在聊天搜索中切换到「智能搜索」，或直接向 AI 助手提问。'
+  if(job.value?.status==='done' && indexStats.value)return '请调整聊天或时间范围；只有图片等尚未提取文字的内容无法生成搜索片段。'
+  return '本轮整理已结束。'
+})
 const selectedChatNames=computed(()=>form.usernames.map(id=>chats.value.find(c=>c.username===id)?.name).filter(Boolean).slice(0,3).join('、')+(form.usernames.length>3?' 等':''))
 const dialogTitle=computed(()=>({models:'选择检索模型',scope:'选择聊天',import:'离线导入'}[dialog.value] || ''))
 const invalidDates=computed(()=>period.value==='custom' && (!startDate.value || !endDate.value || startDate.value>endDate.value))
@@ -230,7 +279,7 @@ const actualDevice=computed(()=>state.value.device?.actual_device==='cuda' ? (st
 const bytes=n=>!n ? '0 B' : n<1024**2 ? `${(n/1024).toFixed(0)} KB` : n<1024**3 ? `${(n/1024**2).toFixed(1)} MB` : `${(n/1024**3).toFixed(2)} GB`
 const date=n=>n ? new Date(n*1000).toLocaleString() : '—'
 const elapsed=j=>`${Math.max(0,Math.floor((j.finished || (['paused','done','error'].includes(j.status) ? j.updated : now.value) || now.value)-j.started))} 秒`
-const stage=j=>!j ? '未下载' : ({importing:'导入中',pausing:'正在暂停',queued:'等待整理',connecting:'连接中',downloading:'下载中',retry_wait:'等待重试',paused:'已暂停',verifying:'校验中',verified:'校验完成',loading:'测试模型',done:'已完成',error:'处理失败',reading:'读取聊天记录',organizing:'整理消息片段',embedding:'正在理解聊天内容',saving:'正在保存搜索数据',installing:'安装加速组件'}[j.status==='error' || j.status==='paused' ? j.status : j.stage] || '处理中')
+const stage=j=>!j ? '未下载' : ({counting:'正在统计消息总量',importing:'导入中',pausing:'正在暂停',queued:'等待整理',connecting:'连接中',downloading:'下载中',retry_wait:'等待重试',paused:'已暂停',verifying:'校验中',verified:'校验完成',loading:'测试模型',done:'已完成',error:'处理失败',reading:'读取聊天记录',organizing:'整理消息片段',embedding:'正在理解聊天内容',saving:'正在保存搜索数据',installing:'安装加速组件'}[j.status==='error' || j.status==='paused' ? j.status : j.stage] || '处理中')
 const request=(path,options={},scoped=false)=>api.request(`/local-search${path}${scoped && account.value ? `${path.includes('?')?'&':'?'}account=${encodeURIComponent(account.value)}`:''}`,options)
 let refreshDone=Promise.resolve()
 let timer, loading=false, version=0, gpuVersion=0, needsReset=false, previousFocus, stopEvents
@@ -381,10 +430,28 @@ onBeforeUnmount(()=>{clearInterval(timer);stopEvents?.()})
 .lss-start p{font-size:11px}.lss-start strong{font-size:12px}
 .lss-start-actions{display:flex;gap:8px;flex-wrap:wrap;flex-shrink:0}
 @container (max-width:600px){.lss-start-actions button{flex:1}}
-.lss-status{border:1px solid var(--app-border,#e7e9ed);border-radius:8px;background:var(--app-surface-soft,#f7f8fa);padding:14px 16px;margin-bottom:14px}
-.lss-status-title{display:flex;align-items:center;gap:8px}.lss-status-title>i{color:#079b57}
-.lss-live-count{font-variant-numeric:tabular-nums}
+.lss-status{--lss-green:#07834b;--lss-blue:#526d9e;border:1px solid color-mix(in srgb,var(--app-border,#e7e9ed),#079b57 20%);border-radius:12px;background:var(--app-surface-bg,#fff);padding:20px;margin-bottom:16px;container-type:inline-size;font-variant-numeric:tabular-nums}
+.lss-status-heading{display:flex;align-items:center;justify-content:space-between;gap:12px;flex-wrap:wrap}
+.lss-status-title{display:flex;align-items:center;gap:8px;font-size:14px;min-width:0}.lss-status-title>i{color:var(--lss-green);flex-shrink:0}
+.lss-status-meta{display:flex;align-items:center;gap:12px;min-width:0;margin-left:auto}.lss-status-meta>.lss-note{white-space:nowrap}
+.lss-device-badge{display:inline-flex;align-items:center;gap:6px;min-width:0;font-size:11px;padding:4px 9px;border-radius:6px;background:var(--app-accent-soft,#edf8f1);color:var(--lss-green);overflow-wrap:anywhere}
+.lss-progress-heading{display:flex;align-items:center;justify-content:space-between;gap:12px;margin:20px 0 8px;color:var(--app-text-secondary,#687582);font-size:11px}
+.lss-progress-heading strong{color:var(--lss-blue);font-size:16px;flex-shrink:0}.lss-progress-count{margin-left:10px}
+.local-search-settings .lss-index-progress{display:block;width:100%;height:8px;appearance:none;border:0;border-radius:8px;overflow:hidden;background:var(--app-accent-soft,#e6f0eb);accent-color:#07bf63}
+.lss-index-progress::-webkit-progress-bar{background:var(--app-accent-soft,#e6f0eb)}.lss-index-progress::-webkit-progress-value{background:#07bf63;border-radius:8px}.lss-index-progress::-moz-progress-bar{background:#07bf63;border-radius:8px}
+.lss-index-progress:indeterminate{opacity:.6}.is-paused .lss-index-progress{accent-color:var(--app-text-secondary,#687582)}.is-paused .lss-index-progress::-webkit-progress-value{background:var(--app-text-secondary,#687582)}.is-paused .lss-index-progress::-moz-progress-bar{background:var(--app-text-secondary,#687582)}
+.lss-metrics{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:16px;margin:24px 0}
+.lss-metric{display:flex;flex-direction:column;align-items:center;text-align:center;min-width:0}.lss-metric dt{order:2;margin-top:5px;font-size:11px;font-weight:400;color:var(--app-text-secondary,#687582)}
+.lss-metric dd{display:contents;margin:0}.lss-metric dd>strong{font-size:clamp(18px,3.4cqw,24px);font-weight:600;overflow-wrap:anywhere;max-width:100%}.lss-metric{font-size:24px;font-weight:600;line-height:1.3}.lss-metric dd>span{order:3;margin-top:5px;font-size:10px;font-weight:400;color:var(--app-text-secondary,#687582)}
+.lss-metric-saved{color:var(--lss-green)}.lss-metric-index{color:var(--lss-blue);border-left:1px solid var(--app-border,#e7e9ed)}
+.lss-read-total{display:flex;align-items:baseline;justify-content:center;flex-wrap:wrap;gap:4px}.lss-total-denominator{font-size:14px;font-weight:400;white-space:nowrap;color:var(--app-text-secondary,#687582)}
+.lss-status-footer{display:flex;align-items:center;justify-content:space-between;gap:16px}.lss-status-footer>.lss-note{margin:0;font-size:11px}.lss-status-footer button{flex-shrink:0}
+.lss-status-details{border-top:1px solid var(--app-border,#e7e9ed);margin-top:16px;padding-top:12px}.lss-status-details summary{display:flex;align-items:center;gap:8px;width:fit-content;min-height:28px;font-size:11px;color:var(--app-text-secondary,#687582);list-style:none}.lss-status-details summary::-webkit-details-marker{display:none}.lss-status-details summary>i{font-size:9px}.lss-status-details[open] summary>i{transform:rotate(180deg)}.lss-status-details summary:hover{color:var(--lss-green)}.lss-status-details>div{padding-top:4px}
+.lss-status :is(.lss-error,.lss-status-warning){overflow-wrap:anywhere;margin-bottom:12px}.lss-status-warning{display:flex;align-items:baseline;gap:7px}
 .lss-status.is-error{border-color:var(--danger-color,#cb4b43)}
+.lss-status.is-error .lss-status-title>i{color:var(--danger-color,#cb4b43)}
+:global([data-theme=dark] .lss-status){--lss-green:#64d49c;--lss-blue:#9aafd7}
+@container(max-width:520px){.lss-metrics{grid-template-columns:repeat(2,minmax(0,1fr));gap:20px 12px}.lss-metric-index{border-left:0}.lss-progress-count{display:block;margin:4px 0 0}.lss-status-footer{align-items:flex-start;flex-wrap:wrap}.lss-status-footer button{margin-left:auto}.lss-metric{font-size:22px}}
 .lss-bottom-note{display:flex;align-items:flex-start;gap:7px;font-size:10px;color:var(--app-text-secondary,#687582);padding:12px 1px;line-height:1.7}
 .lss-bottom-note>i{margin-top:3px}
 .lss-advanced{border:1px solid var(--app-border,#e7e9ed);border-radius:9px;margin-top:14px;background:var(--app-surface-soft,#f7f7f7);overflow:hidden}
diff --git a/frontend/components/chat/AgentRun.vue b/frontend/components/chat/AgentRun.vue
index dd7ac4d5..984b39f7 100644
--- a/frontend/components/chat/AgentRun.vue
+++ b/frontend/components/chat/AgentRun.vue
@@ -18,42 +18,22 @@
         <p v-else-if="item.kind === 'notice'" class="agent-process-notice" role="status">{{ item.text }}<small v-if="item.attempt"> · 第 {{ item.attempt }} 次尝试</small></p>
         <div v-else-if="item.kind === 'answer' && item.status === 'superseded'" class="agent-progress-note is-superseded"><small>旧答案已根据补充要求调整</small></div>
         <div v-else-if="item.kind === 'status'" class="agent-stage-row" :class="`is-${item.status}`">
-          <i :class="item.status === 'running' ? 'fa-solid fa-spinner fa-spin' : item.status === 'completed' ? 'fa-solid fa-check' : 'fa-regular fa-circle-pause'" aria-hidden="true" />
-          <span>{{ item.text.replace(/^正在/, '') }}</span>
+          <i v-if="item.status !== 'running'" :class="item.status === 'completed' ? 'fa-solid fa-check' : 'fa-regular fa-circle-pause'" aria-hidden="true" />
+          <span :class="{ 'agent-shimmer': item.status === 'running' }">{{ item.text.replace(/^正在/, '') }}</span>
           <small><span class="sr-only">{{ stageOutcome(item.status) }} · </span>{{ duration((item.finished_at ?? now / 1000) - item.started_at) }}</small>
         </div>
       </template>
     </div>
       <div v-if="running && !(open && compacting) && !(open && run.subtasks?.running && run.stage === '执行独立子任务')" class="agent-live-step" role="status" aria-live="polite" aria-atomic="true">
-        <i class="fa-solid fa-spinner fa-spin" aria-hidden="true" />
-        <div><span class="agent-live-caption">AI 助手</span><span class="agent-stream-status">{{ run.stage || (run.status === 'queued' ? '等待开始处理' : '正在查找与分析') }}</span><p v-if="liveHint" class="agent-live-hint">{{ liveHint }}</p><p v-if="stageElapsed >= 30" class="agent-wait-note">这一步仍在处理中，可随时补充要求或停止。</p></div>
+        <div><span class="agent-live-caption">AI 助手</span><span class="agent-stream-status agent-shimmer">{{ run.stage || (run.status === 'queued' ? '等待开始处理' : '正在查找与分析') }}</span><p v-if="liveHint" class="agent-live-hint">{{ liveHint }}</p><p v-if="stageElapsed >= 30" class="agent-wait-note">这一步仍在处理中，可随时补充要求或停止。</p></div>
         <time aria-hidden="true">{{ duration(stageElapsed) }}</time>
       </div>
       <div v-show="open" class="agent-run-metadata">
         <p v-if="!running && run.analysis?.known && run.coverage_state !== 'not_applicable'" class="agent-coverage-summary">已读取 {{ run.read_count || 0 }} 条<template v-if="run.analysis.tracked !== false"> · 已提交分析 {{ run.analysis.analyzed || 0 }} 条 · {{ run.analysis.complete ? '范围处理完成' : '范围尚未处理完成' }}</template><template v-else> · 按需检索</template></p>
         <p v-else-if="!running && run.coverage_state !== 'not_applicable'" class="agent-coverage">此轮未记录完整遍历进度，范围覆盖情况未知。</p>
-        <div class="agent-metadata-actions">
-          <button type="button" :aria-expanded="detailsOpen" :aria-controls="`run-details-${run.id}`" @click="detailsOpen = !detailsOpen"><i :class="detailsOpen ? 'fa-solid fa-chevron-down' : 'fa-solid fa-chevron-right'" aria-hidden="true" />运行详情</button>
-          <button v-if="run.coverage_state !== 'not_applicable' && (run.source_count || run.analysis?.known)" type="button" class="agent-materials-link" :aria-expanded="materialsOpen" :aria-controls="`materials-${run.id}`" @click="materialsOpen = !materialsOpen">{{ materialsOpen ? '收起来源与结果' : '来源与结果' }}<i :class="materialsOpen ? 'fa-solid fa-chevron-down' : 'fa-solid fa-chevron-right'" aria-hidden="true" /></button>
-        </div>
-        <div v-show="detailsOpen" :id="`run-details-${run.id}`" class="agent-run-details" role="region" aria-label="运行详情">
-        <dl class="agent-detail-facts">
-          <div><dt>执行统计</dt><dd>{{ toolCount }} 项操作<span v-if="run.usage || modelCalls"> · {{ modelCalls }} 次模型调用</span><span v-if="run.used?.media"> · {{ run.used.media }} 个媒体</span></dd></div>
-          <div v-if="run.query_filters"><dt>聊天范围</dt><dd>{{ run.query_filters.conversations?.length || 0 }} 个聊天<span v-if="run.query_filters.sender"> · 发言人 {{ nameFor(run.query_filters.sender) }}</span></dd></div>
-          <div v-if="run.time_range && (run.time_range.start != null || run.time_range.end != null)"><dt>查询时间</dt><dd>{{ date(run.time_range.start) }} — {{ date(run.time_range.end) }}</dd></div>
-          <div v-if="run.intent?.message_count"><dt>读取范围</dt><dd>最近 {{ run.intent.message_count }} 条消息；不足时按实际数量。</dd></div>
-          <div v-if="running && run.analysis?.known && run.coverage_state !== 'not_applicable'"><dt>范围进度</dt><dd>{{ run.analysis.tracked === false ? '按需检索' : run.analysis.complete ? '范围处理完成' : '范围尚未处理完成' }}</dd></div>
-          <div v-if="run.analysis?.segments || run.analysis?.findings"><dt>分析产出</dt><dd>{{ run.analysis.segments || 0 }} 个分段结果 · {{ run.analysis.findings || 0 }} 条分析发现</dd></div>
-        </dl>
-        <div v-if="run.analysis?.known && run.coverage_state !== 'not_applicable'" class="agent-coverage-note">
-          <button v-if="readingCoverage.length" type="button" :aria-expanded="readingCoverageOpen" :aria-controls="`reading-coverage-${run.id}`" @click="readingCoverageOpen = !readingCoverageOpen">{{ readingCoverageOpen ? '收起逐聊天覆盖' : '查看逐聊天覆盖' }}（{{ readingCoverage.length }} 个聊天）</button>
-          <div v-if="readingCoverageOpen" :id="`reading-coverage-${run.id}`" role="region" aria-label="逐聊天读取覆盖">
-            <p v-for="c in visibleCoverage" :key="c.username">{{ nameFor(c.username) }}：读取 {{ c.read }} 条<template v-if="run.analysis.tracked !== false">，分析 {{ c.analyzed }} 条 · {{ c.complete ? '已处理完成' : '待继续' }}</template><template v-else> · 按需检索</template><span v-if="c.warning"> · {{ c.warning }}</span></p>
-            <div v-if="coveragePages > 1"><button type="button" :disabled="coveragePage === 0" @click="coveragePage--">上一页覆盖</button><span>第 {{ coveragePage + 1 }} / {{ coveragePages }} 页</span><button type="button" :disabled="coveragePage + 1 >= coveragePages" @click="coveragePage++">下一页覆盖</button></div>
-          </div>
-        </div>
-        <p v-if="run.index_status && run.coverage_state !== 'not_applicable'" class="agent-index-note">{{ run.index_status.message }}<button v-if="!run.index_status.enabled" type="button" @click="$emit('settings')">启用本地模型</button></p>
-        <div v-if="run.usage" class="agent-usage"><p v-if="running && modelCalls > run.usage.calls">Token 用量将在本轮结束后汇总。</p><p v-else>输入 {{ run.usage.input_tokens }} · 输出 {{ run.usage.output_tokens }} Token</p><p v-if="run.usage.unknown">{{ run.usage.unknown }} 次调用未返回完整用量，以上为已知部分。</p><button type="button" @click="$emit('settings')">查看用量审计</button></div>
+        <p v-if="run.usage" class="agent-usage" :title="run.usage.unknown ? '部分调用未返回完整用量，当前显示已知部分。' : undefined">输入 {{ usagePending ? '待汇总' : (run.usage.input_tokens ?? '未知') }} · 输出 {{ usagePending ? '待汇总' : (run.usage.output_tokens ?? '未知') }} Token</p>
+        <div v-if="run.coverage_state !== 'not_applicable' && (run.source_count || run.analysis?.known)" class="agent-metadata-actions">
+          <button type="button" class="agent-materials-link" :aria-expanded="materialsOpen" :aria-controls="`materials-${run.id}`" @click="materialsOpen = !materialsOpen">{{ materialsOpen ? '收起来源与结果' : '来源与结果' }}<i :class="materialsOpen ? 'fa-solid fa-chevron-down' : 'fa-solid fa-chevron-right'" aria-hidden="true" /></button>
         </div>
       </div>
     <AgentMaterials v-if="materialsOpen" v-show="open" :id="`materials-${run.id}`" :run="run" :name-for="nameFor" @close="materialsOpen = false" @locate="$emit('locate', $event)" />
@@ -96,17 +76,6 @@ defineEmits(['locate','choose','continue','restart','settings'])
 // 阅读页在切回窗口或重新挂载时复用同一份展开状态。
 const disclosure = name => computed({get:()=>!!props.viewState[`${props.run.id}:${name}`],set:value=>{props.viewState[`${props.run.id}:${name}`]=value}})
 const evidenceOpen = disclosure('evidence'), materialsOpen = disclosure('materials'), coverageOpen = disclosure('coverage')
-const readingCoverageOpen = disclosure('readingCoverage')
-// 运行详情默认折叠，并在进度刷新或切回对话时保留用户选择。
-const detailsOpen = disclosure('details')
-const readingCoverage = computed(() => props.run.analysis?.coverage || [])
-const coveragePages = computed(() => Math.max(1, Math.ceil(readingCoverage.value.length / 20)))
-// 分页和展开状态随原有对话视图保存，刷新进度不重置用户的阅读页。
-const coveragePage = computed({
-  get: () => Math.max(0, Math.min(coveragePages.value - 1, props.viewState[`${props.run.id}:coveragePage`] || 0)),
-  set: value => { props.viewState[`${props.run.id}:coveragePage`] = value },
-})
-const visibleCoverage = computed(() => readingCoverage.value.slice(coveragePage.value * 20, (coveragePage.value + 1) * 20))
 const running = computed(() => ['queued','running'].includes(props.run.status))
 // 有过程就默认展开，完成后不自动收起；仍保留用户手动收起的选择。
 const open = computed({get:()=>props.viewState[props.run.id] ?? !(running.value && !records.value.length),set:v=>{props.viewState[props.run.id]=v}})
@@ -117,9 +86,9 @@ const isCompaction = item => item.kind === 'notice' && item.context_job?.id && N
 const compactions = computed(() => records.value.filter(isCompaction))
 const compacting = computed(() => compactions.value.some(item => item.context_job.status === 'running' && (item.input_version ?? props.run.version) === props.run.version))
 const firstTaskRecord = computed(() => groupedRecords.value.find(item => item.kind === 'tool' && item.action === 'task')?.id)
-const toolCount = computed(() => records.value.filter(x=>x.kind==='tool').length)
-// SSE 已推送实际调用次数，不能继续显示首次快照里尚未汇总的零值。
+// 尚未汇总的模型调用不显示成零 Token。
 const modelCalls = computed(() => Math.max(props.run.used?.models || 0, props.run.usage?.calls || 0))
+const usagePending = computed(() => running.value && modelCalls.value > (props.run.usage?.calls || 0))
 const elapsed = computed(() => (props.run.elapsed_seconds || 0) + (running.value ? Math.max(0,props.now / 1000 - props.run.segment_started) : 0))
 const stageElapsed = computed(() => Math.max(0,props.now / 1000 - (props.run.stage_started_at ?? props.run.segment_started ?? props.now / 1000)))
 // 提示只来自已返回的进度，不编造模型思考或尚未完成的动作。
@@ -134,6 +103,5 @@ const liveHint = computed(() => {
 })
 const duration = value => { const n=Math.max(0,Math.floor(value || 0)); return n>=60 ? `${Math.floor(n/60)}分${n%60}秒` : `${n}秒` }
 const stageOutcome = status => ({running:'进行中',completed:'已完成',failed:'未完成',superseded:'已调整',cancelled:'已停止',paused:'已暂停',incomplete:'未完成'}[status] || '已结束')
-const date = value => value ? new Date(value*1000).toLocaleString() : '不限'
 const toggle = () => { open.value = !open.value }
 </script>
diff --git a/frontend/components/chat/AgentSubtasks.vue b/frontend/components/chat/AgentSubtasks.vue
index 31aba9a7..a97f4b61 100644
--- a/frontend/components/chat/AgentSubtasks.vue
+++ b/frontend/components/chat/AgentSubtasks.vue
@@ -20,7 +20,7 @@
       <li v-for="item in items" :key="item.id" class="subtask-item">
         <div class="subtask-heading">
           <strong>{{ item.name }}</strong>
-          <span class="subtask-status" :class="`is-${item.status}`"><i class="fa-solid" :class="statusIcons[item.status] || 'fa-circle-info'" aria-hidden="true" />{{ labels[item.status] || item.status }}</span>
+          <span class="subtask-status" :class="[`is-${item.status}`, { 'agent-shimmer': item.status === 'running' }]"><i v-if="item.status !== 'running'" class="fa-solid" :class="statusIcons[item.status] || 'fa-circle-info'" aria-hidden="true" />{{ labels[item.status] || item.status }}</span>
           <small class="subtask-elapsed">用时 {{ elapsed(item) }}</small>
         </div>
         <p v-if="item.scope_names?.length" class="subtask-range">{{ item.scope_names.join('、') }}</p>
@@ -87,7 +87,7 @@ const rangeLabel = range => {
 }
 const loading = ref(false), error = ref(''), hasMore = ref(false), opened = ref(['queued', 'running'].includes(props.run.status)), locating = ref(false)
 const labels = { queued:'等待执行', running:'分析中', completed:'已完成', failed:'未完成', interrupted:'已暂停', cancelled:'已停止', superseded:'已更新范围' }
-const statusIcons = { queued:'fa-clock', running:'fa-spinner fa-spin', completed:'fa-check', failed:'fa-circle-exclamation', interrupted:'fa-pause', superseded:'fa-rotate' }
+const statusIcons = { queued:'fa-clock', completed:'fa-check', failed:'fa-circle-exclamation', interrupted:'fa-pause', superseded:'fa-rotate' }
 // 只限制默认摘要的篇幅，原始进展始终可以展开查看。
 const progressText = item => String(item.latest_progress?.text || '')
 const objectivePreview = item => { const first = String(item.objective || '').split('\n')[0]; return first.length > 72 ? `${first.slice(0, 72)}…` : first }
diff --git a/frontend/components/chat/AgentToolCall.vue b/frontend/components/chat/AgentToolCall.vue
index 86c412f6..665b2891 100644
--- a/frontend/components/chat/AgentToolCall.vue
+++ b/frontend/components/chat/AgentToolCall.vue
@@ -1,25 +1,30 @@
 <template>
   <details class="agent-tool" :class="[`is-${status}`, { 'is-grouped': grouped }]" :open="expanded" @toggle="expanded = $event.target.open">
     <summary>
-      <i :class="icon" aria-hidden="true" />
-      <span class="agent-tool-title"><span class="agent-tool-label">{{ label }}</span><small v-if="first.query" class="agent-tool-query" :title="first.query">{{ first.query }}</small><small v-if="grouped" class="agent-tool-count">{{ items.length }} 次</small></span>
+      <i v-if="status !== 'running'" :class="icon" aria-hidden="true" />
+      <span class="agent-tool-title"><span class="agent-tool-label" :class="{ 'agent-shimmer': status === 'running' }">{{ label }}</span><small v-if="first.query" class="agent-tool-query" :title="first.query">{{ first.query }}</small><small v-if="grouped" class="agent-tool-count">{{ items.length }} 次</small></span>
       <span v-if="status !== 'completed'" class="agent-tool-outcome">{{ groupOutcome }}</span>
       <span v-else class="agent-tool-summary">{{ summary }}</span>
       <i class="fa-solid fa-chevron-right agent-tool-chevron" aria-hidden="true" />
     </summary>
     <div class="agent-tool-detail" :class="{ 'agent-tool-timeline': grouped }">
       <section v-for="(item, index) in items" :key="item.id" class="agent-tool-attempt">
-        <component :is="grouped ? 'details' : 'div'" class="agent-tool-inspection" :open="grouped && viewState?.[`tool-detail:${item.id}`]" @toggle="viewState && (viewState[`tool-detail:${item.id}`] = $event.target.open)">
-        <summary v-if="grouped" class="agent-tool-attempt-row" :title="item.action === 'commit_findings' ? '展开本次保存详情' : '展开本次读取详情'">
+        <component :is="grouped ? 'details' : 'div'" class="agent-tool-inspection" :open="grouped && inspectionOpen(item.id)" @toggle.stop="setInspectionOpen(item.id, $event.target.open)">
+        <summary v-if="grouped" class="agent-tool-attempt-row" :title="item.action === 'commit_findings' ? '展开本次保存详情' : '展开本次读取详情'" :aria-controls="`tool-inspection-${item.id}`">
           <i class="fa-solid fa-circle agent-tool-node" aria-hidden="true" />
           <strong>{{ item.action === 'commit_findings' ? (index === 0 ? '首次保存' : `第 ${index + 1} 次保存`) : item.action === 'compact_context' ? `第 ${index + 1} 次整理` : item.cached ? '复用已读结果' : index === 0 ? '首次读取' : `第 ${index + 1} 次读取` }}</strong>
           <span>{{ item.status !== 'completed' ? outcome(item.status) : item.cached ? '无需重复读取' : callSummary(item) }}</span>
+          <i class="fa-solid fa-chevron-right agent-attempt-chevron" aria-hidden="true" />
         </summary>
-          <header v-if="!grouped"><strong>{{ toolLabel(item.action) }}</strong><span>{{ outcome(item.status) }} · {{ duration(elapsed(item)) }}</span></header>
-        <p v-if="item.username">会话：{{ nameFor(item.username) }}</p>
+        <div :id="`tool-inspection-${item.id}`" class="agent-tool-inspection-panel" :class="`is-${item.status}`">
+          <header><strong>{{ toolLabel(item.action) }}</strong></header>
+        <div class="agent-tool-request">
+        <p v-if="item.username">会话：{{ nameFor(item.username) || item.username }}</p>
         <p v-if="item.query">搜索：{{ item.query }}</p>
-        <p v-if="item.start || item.end">范围：{{ date(item.start) }} — {{ date(item.end) }}</p>
-        <p v-if="item.offset">分页位置：{{ item.offset }}</p>
+        <p v-if="item.start != null || item.end != null">范围：{{ date(item.start) }} — {{ date(item.end) }}</p>
+        <p v-if="item.offset != null">分页位置：{{ item.offset }}</p>
+        </div>
+        <div class="agent-tool-response">
         <p v-if="item.detail && item.status === 'running'">{{ item.detail }}</p>
         <p v-if="item.action === 'compact_context' && item.result?.saved">笔记已保存 · 上下文 {{ item.result.before }} → {{ item.result.after }} 预算单位 · {{ item.result.covered_fragments }} 个原文片段</p>
         <p v-else-if="item.action === 'commit_findings' && item.status === 'completed'">{{ saveSummary(item) }}</p>
@@ -32,6 +37,12 @@
         <p v-if="item.result?.warning" class="agent-coverage">{{ item.result.warning }}</p>
         <p v-if="item.result?.note && item.result.note !== item.result.error">{{ item.result.note }}</p>
         <p v-if="['failed','paused','superseded'].includes(item.status)">{{ recovered.has(item.id) ? '本次保存失败，后续已重试并保存成功。' : item.status === 'failed' ? '这一步未完成，已读取资料会保留。' : item.status === 'superseded' ? '已根据补充要求调整。' : '这一步已暂停。' }}</p>
+        </div>
+        <footer class="agent-tool-inspection-status">
+          <span>{{ duration(elapsed(item)) }}</span>
+          <span :class="{ 'agent-shimmer': item.status === 'running' }"><i v-if="item.status !== 'running'" :class="item.status === 'completed' ? 'fa-solid fa-check' : item.status === 'failed' ? 'fa-solid fa-circle-exclamation' : 'fa-regular fa-circle-pause'" aria-hidden="true" />{{ outcome(item.status) || '状态未知' }}</span>
+        </footer>
+        </div>
         </component>
       </section>
     </div>
@@ -46,6 +57,10 @@ const grouped = computed(() => props.items.length > 1)
 // 过程面板展开时先显示操作摘要，逐次读取明细由用户按需展开。
 const localExpanded = ref(false)
 const expanded = computed({get:()=>props.viewState?.[`tool:${first.value.id}`] ?? localExpanded.value,set:value=>{if(props.viewState) props.viewState[`tool:${first.value.id}`]=value; else localExpanded.value=value}})
+// 每个读取节点独立展开，刷新进度与收起外层时保留用户的阅读位置。
+const localInspections = ref({})
+const inspectionOpen = id => !!(props.viewState || localInspections.value)[`tool-detail:${id}`]
+const setInspectionOpen = (id, value) => { (props.viewState || localInspections.value)[`tool-detail:${id}`] = value }
 // 只有同一范围、页面和输入版本的后续明确保存成功，才能解除历史失败提示。
 // 旧记录缺少标识时保留原状态，不能根据相邻顺序猜测已恢复。
 const pageKey = item => item.action === 'commit_findings' && item.scope_handle && item.page_id && item.input_version != null
@@ -64,8 +79,8 @@ const recovered = computed(() => {
 const effectiveItems = computed(() => props.items.filter(item => !recovered.value.has(item.id)))
 // 未恢复的失败、运行或暂停仍显露，不能被另一页的成功掩盖。
 const status = computed(() => ['running', 'failed', 'paused', 'cancelled', 'interrupted', 'superseded'].find(status => effectiveItems.value.some(item => item.status === status)) || effectiveItems.value[0]?.status)
-const icon = computed(() => status.value === 'running' ? 'fa-solid fa-spinner fa-spin' : status.value === 'failed' ? 'fa-solid fa-circle-exclamation' : status.value !== 'completed' ? 'fa-regular fa-circle-pause' : first.value.action?.includes('search') ? 'fa-solid fa-magnifying-glass' : first.value.action === 'analyze_media' ? 'fa-regular fa-images' : 'fa-regular fa-file-lines')
-const toolLabel = action => ({ commit_findings: '保存分析发现', search_messages: '搜索聊天记录', read_messages: '读取消息', read_context: '读取消息上下文', analyze_media: '分析媒体', find_conversations: '查找会话', search_material: '搜索附件内容', read_material: '读取附件', read_results: '读取分析结果' }[action] || '工具调用')
+const icon = computed(() => status.value === 'failed' ? 'fa-solid fa-circle-exclamation' : status.value !== 'completed' ? 'fa-regular fa-circle-pause' : first.value.action?.includes('search') ? 'fa-solid fa-magnifying-glass' : first.value.action === 'analyze_media' ? 'fa-regular fa-images' : 'fa-regular fa-file-lines')
+const toolLabel = action => ({ compact_context: '整理上下文', select_chat_scope: '确定查询范围', commit_findings: '保存分析发现', search_messages: '搜索聊天记录', read_messages: '读取聊天记录', read_context: '读取消息上下文', analyze_media: '分析媒体', find_conversations: '查找会话', search_material: '搜索附件内容', read_material: '读取附件', read_results: '读取分析结果' }[action] || '工具调用')
 const label = computed(() => first.value.action === 'compact_context' ? '整理上下文' : ['search_messages', 'read_context'].includes(first.value.action) ? toolLabel(first.value.action) : (first.value.text || toolLabel(first.value.action)).replace(/^(核对|读取)了/, '$1'))
 const outcome = status => ({ completed: '已完成', running: '进行中', failed: '失败', paused: '已暂停', cancelled: '已停止', interrupted: '已中断', superseded: '已调整' }[status] || '')
 const groupOutcome = computed(() => status.value !== 'running' && grouped.value && props.items.some(item => item.status === 'completed') && props.items.some(item => item.status !== 'completed') ? '部分完成' : outcome(status.value))
@@ -94,6 +109,6 @@ const summary = computed(() => {
   const reused = props.items.filter(item => item.cached).length
   return [fresh.length ? `${fresh.reduce((sum, item) => sum + returned(item), 0)} 条消息` : '', reused ? `含 ${reused} 次复用` : ''].filter(Boolean).join(' · ')
 })
-const date = value => value ? new Date(value * 1000).toLocaleString() : '不限'
+const date = value => value != null ? new Date(value * 1000).toLocaleString() : '不限'
 const retrievalLabel = item => item.result?.data_source === 'realtime_keyword' ? '实时关键词回查 · 无关原文仅在本机过滤' : item.result?.retrieval_mode === 'hybrid' ? '智能检索：关键词＋语义（按意思查找）' : item.result?.retrieval_mode === 'keyword' ? '已退回关键词检索 · 展开查看原因' : item.status === 'running' ? '正在确认检索方式' : '此步骤未记录实际检索方式'
 </script>
diff --git a/frontend/components/chat/ChatAgentPanel.vue b/frontend/components/chat/ChatAgentPanel.vue
index 9aea8993..ceb74107 100644
--- a/frontend/components/chat/ChatAgentPanel.vue
+++ b/frontend/components/chat/ChatAgentPanel.vue
@@ -30,7 +30,7 @@
       <p v-if="threadLoading" class="agent-loading" role="status">正在打开对话…</p>
       <AssistantThread :key="thread?.id || selectionKey" :messages="assistantMessages" :running="running" @scroll="onScroll" @ready="onThreadReady">
         <template #welcome>
-        <div v-if="!thread?.messages?.length && !threadLoading" class="agent-welcome"><span class="agent-welcome-symbol"><i class="fa-regular fa-comment-dots" aria-hidden="true" /></span><h3>想从聊天里了解什么？</h3><p>查找消息、梳理进展，或继续追问。<br>从当前聊天开始，可按需查找其他聊天，回答附上原文出处。</p><button v-for="q in suggestions" :key="q" type="button" @click="draft = q">{{ q }}<i class="fa-solid fa-arrow-up" aria-hidden="true"></i></button></div>
+        <div v-if="!thread?.messages?.length && !threadLoading" class="agent-welcome"><span class="agent-welcome-symbol"><i class="fa-regular fa-comment-dots" aria-hidden="true" /></span><h3>想从聊天里了解什么？</h3><p>查找消息、梳理进展，或继续追问。<br>从当前聊天开始，可按需查找其他聊天，回答附上原文出处。</p><button v-for="q in suggestions" :key="q" type="button" :disabled="sending || running || !account || (!contact?.username && !legacyView)" @click="sendSuggestion(q)">{{ q }}<i class="fa-solid fa-arrow-up" aria-hidden="true"></i></button></div>
         </template>
         <template #message="{ message }">
           <div v-if="message.role === 'user'" class="agent-user"><p>{{ message.text }}</p></div>
@@ -54,7 +54,6 @@
           </div>
         </div>
         <small v-if="modelSelection.state.notice" class="agent-error" role="status">{{ modelSelection.state.notice }} <button v-if="modelSelection.state.dirty" type="button" @click="modelSelection.choose(modelChoice)">重试保存</button></small>
-        <small class="agent-disclaimer" role="status">{{ running ? (stopping ? '正在停止…' : 'Enter 补充要求 · 模型设置下轮生效') : '围绕当前聊天 · 可按需查找其他聊天' }}</small>
       </footer>
       </div>
       <AgentSourceInspector v-if="inspectedSource" :source="inspectedSource.source" :number="inspectedSource.number" :prepare="prepareSource" :locate="locateSource" @close="closeInspector(true)" />
@@ -280,7 +279,7 @@ const ensureThread = async () => {
   saved.value.selected[key] = created.id; thread.value = created; saved.value.drafts[draftKey.value] = oldDraft; void loadHistory(); return created
 }
 const send = async () => {
-  if (threadLoading.value || sending.value || !draft.value.trim() || (!props.contact?.username && !legacyView.value)) return
+  if (threadLoading.value || sending.value || !props.account || !draft.value.trim() || (!props.contact?.username && !legacyView.value)) return
   if (new TextEncoder().encode(draft.value.trim()).length > 1048576) { error.value = '输入超过 1 MiB，请分次发送。'; return }
   const text = draft.value.trim(), oldKey = draftKey.value, sendKey = selectionKey.value
   sending.value = true
@@ -309,6 +308,11 @@ const send = async () => {
   })
   if (sendKey === selectionKey.value) sending.value = false
 }
+const sendSuggestion = async question => {
+  if (threadLoading.value || sending.value || running.value || !props.account || (!props.contact?.username && !legacyView.value)) return
+  draft.value = question
+  await send()
+}
 const primaryAction = async () => {
   if (!running.value) return send()
   if (stopping.value) return
diff --git a/frontend/tests/agent-timeline.test.js b/frontend/tests/agent-timeline.test.js
index f40c0648..980ba3bc 100644
--- a/frontend/tests/agent-timeline.test.js
+++ b/frontend/tests/agent-timeline.test.js
@@ -76,36 +76,23 @@ it('旧任务只提供新引擎重新运行入口', async () => {
 describe('Agent 执行对话流',()=>{
   it('运行中的模型调用次数使用 SSE 增量，不把尚未汇总的用量显示为零', async () => {
     const w = setup({run:{...base(),used:{models:5},usage:{calls:0,input_tokens:0,output_tokens:0}}})
-    expect(w.find('.agent-run-metadata').text()).toContain('5 次模型调用')
     expect(w.find('.agent-usage').text()).not.toContain('输入 0')
-    expect(w.find('.agent-usage').text()).toContain('本轮结束后汇总')
+    expect(w.find('.agent-usage').text()).toBe('输入 待汇总 · 输出 待汇总 Token')
     await w.setProps({run:{...base(),status:'completed',used:{models:5},usage:{calls:5,input_tokens:1200,output_tokens:300}}})
     expect(w.find('.agent-usage').text()).toContain('输入 1200 · 输出 300 Token')
     w.unmount()
   })
-  it('全账号覆盖按需分页，进度刷新和重新挂载保留展开状态及页码', async () => {
-    const coverage = Array.from({length:779}, (_,i) => ({username:`聊天${i}`,read:i===400?5:0,analyzed:0,complete:false,warning:i===400?'读取尚未完成':''}))
-    const viewState = reactive({run1:true})
-    const r = {...base(),analysis:{known:true,coverage,complete:false}}
-    const props = {run:r,viewState,nameFor:value=>value}
-    let w = setup(props)
-    await w.find('[aria-controls="run-details-run1"]').trigger('click')
-    expect(w.find('[aria-label="逐聊天读取覆盖"]').exists()).toBe(false)
-    await w.find('[aria-controls="reading-coverage-run1"]').trigger('click')
-    const region = () => w.find('[aria-label="逐聊天读取覆盖"]')
-    expect(region().findAll('p')).toHaveLength(20)
-    expect(region().text()).toContain('第 1 / 39 页')
-    const next = () => region().findAll('button').find(b=>b.text()==='下一页覆盖')
-    for(let i=0;i<20;i++) await next().trigger('click')
-    expect(region().text()).toContain('聊天400：读取 5 条，分析 0 条 · 待继续 · 读取尚未完成')
-    await w.setProps({run:{...r,updated_at:200}})
-    expect(region().text()).toContain('第 21 / 39 页')
-    w.unmount(); w=setup(props)
-    expect(region().text()).toContain('第 21 / 39 页')
-    viewState['run1:coveragePage']=38
-    await w.setProps({now:201000})
-    expect(region().findAll('p')).toHaveLength(19)
-    expect(next().attributes('disabled')).toBeDefined()
+  it('用量直接显示，旧详情展开状态不会恢复已移除的统计和入口', () => {
+    const w = setup({run:{...base(),status:'completed',usage:{calls:6,input_tokens:100,output_tokens:20,unknown:1},
+      query_filters:{conversations:['friend']},time_range:{start:100,end:200},
+      analysis:{known:true,coverage:[{username:'friend',read:50}],segments:2},
+      index_status:{enabled:true,message:'语义索引已暂停'}},viewState:reactive({'run1:details':true,'run1:readingCoverage':true})})
+    expect(w.find('.agent-usage').isVisible()).toBe(true)
+    expect(w.find('.agent-usage').text()).toBe('输入 100 · 输出 20 Token')
+    expect(w.find('.agent-usage').attributes('title')).toContain('已知部分')
+    expect(w.find('.agent-run-details').exists()).toBe(false)
+    for (const label of ['运行详情','执行统计','聊天范围','查询时间','逐聊天覆盖','语义索引已暂停','查看用量审计']) expect(w.text()).not.toContain(label)
+    expect(w.find('.agent-materials-link').exists()).toBe(true)
     w.unmount()
   })
   it('Agent 小提示使用实际分析进度，长时间等待说明也留在过程区域', async () => {
@@ -151,7 +138,8 @@ describe('Agent 执行对话流',()=>{
     expect(w.find('.agent-process').isVisible()).toBe(false)
     expect(w.find('.agent-live-step').isVisible()).toBe(true)
     expect(w.find('.agent-live-caption').text()).toBe('AI 助手')
-    expect(w.find('.agent-live-step .fa-spin').exists()).toBe(true)
+    expect(w.find('.agent-live-step .fa-spin').exists()).toBe(false)
+    expect(w.find('.agent-live-step .agent-shimmer').text()).toBe(w.find('.agent-stream-status').text())
     expect(w.find('.agent-stream-status').text()).toBe('理解问题与读取范围')
     expect(w.find('.agent-process-title').text()).toBe('执行中')
     expect(w.find('.agent-process-meta').text()).toBe('0分5秒')
@@ -207,9 +195,8 @@ describe('Agent 执行对话流',()=>{
     expect(text.indexOf('2分21秒')).toBeLessThan(text.indexOf('搜索报价'))
     expect(text).not.toContain('用量与读取范围')
     expect(w.find('.agent-run-metadata > summary').exists()).toBe(false)
-    expect(w.find('.agent-run-metadata').text()).toContain('6 次模型调用')
-    expect(w.find('.agent-run-details').isVisible()).toBe(false)
-    await w.find('[aria-controls="run-details-run1"]').trigger('click')
+    expect(w.find('.agent-run-details').exists()).toBe(false)
+    expect(w.find('.agent-usage').text()).toBe('输入 100 · 输出 20 Token')
     expect(w.find('.agent-usage').isVisible()).toBe(true)
     await w.find('.agent-process-toggle').trigger('click')
     expect(w.find('.agent-final-answer').isVisible()).toBe(true)
diff --git a/frontend/tests/agent-tool-errors.test.js b/frontend/tests/agent-tool-errors.test.js
index 5e9d39e5..a6d00c0b 100644
--- a/frontend/tests/agent-tool-errors.test.js
+++ b/frontend/tests/agent-tool-errors.test.js
@@ -1,7 +1,34 @@
 import { mount } from '@vue/test-utils'
+import { reactive } from 'vue'
 import { expect, it } from 'vitest'
 import AgentToolCall from '../components/chat/AgentToolCall.vue'
 
+it.each([true, false])('读取节点独立展开并在进度更新后保留选择（外部状态：%s）', async external => {
+  const items = [0, 1].map(index => ({ id:`read-${index}`,action:'read_messages',status:'completed',username:'sample',offset:index*200,started_at:100,finished_at:105,result:{returned:176-index*2} }))
+  const viewState = external ? reactive({}) : undefined
+  const props = {items,viewState,now:105000,nameFor:()=> '测试聊天'}
+  let view = mount(AgentToolCall, {props})
+  const group = view.find('.agent-tool')
+  group.element.open = true; await group.trigger('toggle')
+  const nodes = view.findAll('.agent-tool-inspection')
+  expect(nodes.every(node => !node.element.open)).toBe(true)
+  nodes[0].element.open = true; await nodes[0].trigger('toggle')
+  expect(nodes[1].element.open).toBe(false)
+  const panel = nodes[0].find('.agent-tool-inspection-panel')
+  expect(panel.find('header').text()).toBe('读取聊天记录')
+  expect(panel.find('.agent-tool-request').text()).toContain('分页位置：0')
+  expect(panel.find('.agent-tool-response').text()).toContain('176 条结果')
+  expect(panel.find('footer').text()).toContain('已完成')
+  await view.setProps({items:items.map(item=>({...item})),now:110000})
+  expect(view.findAll('.agent-tool-inspection')[0].element.open).toBe(true)
+  expect(view.findAll('.agent-tool-inspection')[1].element.open).toBe(false)
+  if (external) {
+    view.unmount(); view = mount(AgentToolCall, {props})
+    expect(view.findAll('.agent-tool-inspection')[0].element.open).toBe(true)
+  }
+  view.unmount()
+})
+
 const failed = { id: 'failed', action: 'search_messages', text: '搜索聊天记录', status: 'failed',
   result: { error: '本轮尚未选择查询范围，请先调用 select_chat_scope', error_code: 'scope_required' } }
 
diff --git a/frontend/tests/chat-agent.test.js b/frontend/tests/chat-agent.test.js
index c82e092f..5347951f 100644
--- a/frontend/tests/chat-agent.test.js
+++ b/frontend/tests/chat-agent.test.js
@@ -43,6 +43,42 @@ const mountPanel = () => mount(ChatAgentPanel, {attachTo:document.body,props:{ac
 const send = async (wrapper,text) => { await wrapper.find('textarea').setValue(text); await wrapper.find('textarea').trigger('keydown',{key:'Enter'}); await flushPromises() }
 
 describe('聊天 Agent', () => {
+  it('点击推荐问题直接发送，提交期间重复点击不会重复请求', async () => {
+    const original = request.getMockImplementation()
+    let release
+    request.mockImplementation(async (path, options) => {
+      if (path.endsWith('/messages')) await new Promise(resolve => { release = resolve })
+      return original(path, options)
+    })
+    const w = mountPanel(); await flushPromises()
+    const suggestion = w.find('.agent-welcome > button')
+    const question = suggestion.text()
+    await suggestion.trigger('click'); await flushPromises()
+    expect(suggestion.attributes('disabled')).toBeDefined()
+    await suggestion.trigger('click'); await flushPromises()
+    const sends = request.mock.calls.filter(([path]) => path.endsWith('/messages'))
+    expect(sends).toHaveLength(1)
+    expect(sends[0][1].body.text).toBe(question)
+    release(); await flushPromises()
+    expect(w.find('.agent-user').text()).toBe(question)
+    expect(w.find('textarea').element.value).toBe('')
+    expect(w.find('.agent-live-step .agent-shimmer').exists()).toBe(true)
+    w.unmount()
+  })
+  it('推荐问题发送失败后保留问题供重试', async () => {
+    const original = request.getMockImplementation()
+    request.mockImplementation((path, options) => {
+      if (path.endsWith('/messages')) return Promise.reject(new Error('发送失败，请重试'))
+      return original(path, options)
+    })
+    const w = mountPanel(); await flushPromises()
+    const suggestion = w.find('.agent-welcome > button'), question = suggestion.text()
+    await suggestion.trigger('click'); await flushPromises()
+    expect(w.find('textarea').element.value).toBe(question)
+    expect(w.find('[role="alert"]').text()).toBe('发送失败，请重试')
+    expect(w.find('.agent-send').attributes('disabled')).toBeUndefined()
+    w.unmount()
+  })
   it('未发送时切换即保存，跨账号、新对话和重新挂载沿用最后模型', async () => {
     const original = request.getMockImplementation()
     let choice = { profile_id: 'model', model_id: 'fixture' }
diff --git a/frontend/tests/fixtures/AgentModelPickerPreview.vue b/frontend/tests/fixtures/AgentModelPickerPreview.vue
index 7a21a305..2403276b 100644
--- a/frontend/tests/fixtures/AgentModelPickerPreview.vue
+++ b/frontend/tests/fixtures/AgentModelPickerPreview.vue
@@ -18,7 +18,7 @@ onMounted(() => { document.querySelectorAll('.agent-model-menu').forEach(menu =>
     <section v-for="width in [440, 320]" :key="width" class="agent-panel preview-panel" :style="{ width: `${width}px` }">
       <header class="agent-header"><strong>AI 助手</strong><span>{{ width }}px</span></header>
       <div class="preview-conversation"><p>模型和思考强度，放在同一个入口。</p><p>点击浮层中间选择模型，选好后回到滑杆。</p></div>
-      <footer class="agent-composer"><div class="agent-input-box"><textarea aria-label="示例问题" placeholder="向当前聊天提问…" rows="1" /><div class="agent-input-actions"><AgentContextRing /><AgentModelPicker v-model="choices[width]" :profiles="profiles" /><button type="button" class="agent-send" aria-label="发送示例问题" disabled><i class="fa-solid fa-arrow-up" /></button></div></div><small class="agent-disclaimer">围绕当前聊天 · 可按需查找其他聊天</small></footer>
+      <footer class="agent-composer"><div class="agent-input-box"><textarea aria-label="示例问题" placeholder="向当前聊天提问…" rows="1" /><div class="agent-input-actions"><AgentContextRing /><AgentModelPicker v-model="choices[width]" :profiles="profiles" /><button type="button" class="agent-send" aria-label="发送示例问题" disabled><i class="fa-solid fa-arrow-up" /></button></div></div></footer>
     </section>
   </main>
   <output class="preview-state">{{ choices }}</output>
diff --git a/frontend/tests/fixtures/AgentProgressPreview.vue b/frontend/tests/fixtures/AgentProgressPreview.vue
index 3caea802..caab85a6 100644
--- a/frontend/tests/fixtures/AgentProgressPreview.vue
+++ b/frontend/tests/fixtures/AgentProgressPreview.vue
@@ -12,6 +12,7 @@ import { computed, reactive, ref, watchEffect } from 'vue'
 import AgentRun from '../../components/chat/AgentRun.vue'
 const showSubtasks = ref(new URLSearchParams(location.search).has('subtasks'))
 const metadataPreview = new URLSearchParams(location.search).has('metadata')
+const nodesPreview = new URLSearchParams(location.search).has('nodes')
 const now = Date.now(), start = now / 1000 - (showSubtasks.value ? 570 : 42)
 const complete = ref(!showSubtasks.value && !metadataPreview), dark = ref(false), views = reactive({'大视图':{},'窄侧栏':{}})
 watchEffect(() => { document.documentElement.dataset.theme = dark.value ? 'dark' : 'light'; globalThis.progressPreviewCompleted = complete.value })
@@ -31,6 +32,17 @@ const run = computed(() => ({
   ],
   answer:complete.value?'主要讨论了三件事：\n\n- **工作安排**：聊到了接下来的打算，以及还有哪些事项待确认。\n- **电脑配件**：比较了升级成本，也讨论了继续使用现有配置。\n- **约饭与费用**：更新了碰面安排和费用处理方式。':'',
   citations:[],usage:{calls:4,input_tokens:2400,output_tokens:620},
+  // 节点详情使用合成分页数据，核对长列表与窄侧栏中的展开效果。
+  ...(nodesPreview ? {
+    read_count:1554,elapsed_seconds:212,answer:'最近主要讨论了工作安排、电脑配件和约饭。',
+    timeline:[{id:'scope',seq:1,kind:'tool',action:'select_chat_scope',text:'确定查询范围',status:'completed',started_at:start,finished_at:start+7},
+      ...[176,174,168,172,174,136,176,174,174,30].map((returned,index)=>({
+        id:`read-${index}`,seq:index+2,kind:'tool',action:'read_messages',text:'读取聊天记录',username:'sample',
+        status:complete.value || index!==1?'completed':'running',started_at:start+7+index*5,
+        ...(complete.value || index!==1?{finished_at:start+12+index*5}:{}),
+        start:1789142400,end:1789401600,offset:index*200,result:{returned,has_more:index<9},
+      }))],
+  } : {}),
   // 复现长状态区的示例，验证折叠后在大视图与窄侧栏中的信息密度。
   ...(metadataPreview ? {
     read_count:1000,source_count:1000,used:{models:8,media:0},
diff --git a/frontend/tests/fixtures/LocalSearchPreview.vue b/frontend/tests/fixtures/LocalSearchPreview.vue
index 5ba281a8..b0eb3478 100644
--- a/frontend/tests/fixtures/LocalSearchPreview.vue
+++ b/frontend/tests/fixtures/LocalSearchPreview.vue
@@ -1,14 +1,16 @@
 <template>
-  <div class="qa-toolbar">交互验收 · 虚构数据<button @click="dark=!dark">切换深浅色</button><button @click="narrow=!narrow">切换窄窗口</button></div>
-  <main :class="{dark,narrow}">
-    <aside><strong><i class="fa-solid fa-gear"></i> 设置</strong><span>桌面行为</span><span class="selected">AI 服务</span><span>语音转文字</span><span>MCP 接入</span><span>数据库与密钥</span><span>启动偏好</span><span>聊天与媒体</span></aside>
-    <div class="qa-content"><header>AI 服务</header><div class="qa-scroll"><AiSettings /></div></div>
+  <div class="qa-toolbar">交互验收 · 虚构数据<button @click="dark=!dark">切换深浅色</button><button @click="narrow=!narrow">切换窄窗口</button><select v-if="progressPreview" aria-label="整理状态" :value="progressPreview" @change="changeProgress"><option value="running">整理中</option><option value="initial">首次整理</option><option value="paused">已暂停</option><option value="error">失败</option><option value="done">已完成</option></select></div>
+  <main :class="{dark,narrow,'progress-preview':progressPreview}">
+    <aside v-if="!progressPreview"><strong><i class="fa-solid fa-gear"></i> 设置</strong><span>桌面行为</span><span class="selected">AI 服务</span><span>语音转文字</span><span>MCP 接入</span><span>数据库与密钥</span><span>启动偏好</span><span>聊天与媒体</span></aside>
+    <div class="qa-content"><header>AI 服务</header><div class="qa-scroll"><LocalSearchSettings v-if="progressPreview" account-wide /><AiSettings v-else /></div></div>
   </main>
 </template>
 <script setup>
 import { ref, watch } from 'vue'
 import AiSettings from '../../components/AiSettings.vue'
 const dark=ref(false),narrow=ref(false)
+const progressPreview=new URLSearchParams(location.search).get('progress')
+function changeProgress(event){location.search=`?progress=${event.target.value}`}
 watch(dark,value=>{document.documentElement.dataset.theme=value?'dark':'light'})
 </script>
 <style>
@@ -18,6 +20,7 @@ watch(dark,value=>{document.documentElement.dataset.theme=value?'dark':'light'})
 main{--app-surface-bg:#fff;--app-surface-soft:#f7f7f7;--app-text-primary:#191919;--app-text-secondary:#5f5f5f;--app-text-muted:#909090;--app-border:#e7e7e7;--app-accent:#079b57;display:flex;width:min(1100px,94vw);height:90vh;margin:0 auto;border-radius:12px;overflow:hidden;background:var(--app-surface-bg);color:var(--app-text-primary);box-shadow:0 20px 55px #0003}
 body:has(main.dark),main.dark{--app-surface-bg:#242424;--app-surface-soft:#2b2b2b;--app-text-primary:#f5f5f5;--app-text-secondary:#b8b8b8;--app-text-muted:#a0a0a0;--app-border:#3e3e3e;--app-accent-soft:#193c2c}
 main.narrow{width:700px;max-width:94vw}
+main.progress-preview{width:min(1000px,94vw)}main.progress-preview.narrow{width:480px}.progress-preview .qa-scroll{container-type:inline-size}
 aside{width:160px;flex-shrink:0;border-right:1px solid var(--app-border);padding:20px 12px;background:var(--app-surface-soft)}
 aside strong{display:block;margin:0 8px 24px;font-size:16px}aside strong i{color:#079b57;margin-right:8px}
 aside span{display:block;padding:9px 12px;margin-bottom:4px;color:var(--app-text-secondary)}
diff --git a/frontend/tests/fixtures/local-search.js b/frontend/tests/fixtures/local-search.js
index d5f4e84c..3820082b 100644
--- a/frontend/tests/fixtures/local-search.js
+++ b/frontend/tests/fixtures/local-search.js
@@ -14,6 +14,22 @@ const models=[
 {id:'multilingual-e5-small',name:'Multilingual E5 Small',description:'适合中英文及多语言聊天',repo:'intfloat/multilingual-e5-small',revision:'614241f622f53c4eeff9890bdc4f31cfecc418b3',license:'MIT',size:492421556,downloaded:false},
 ]
 let config={enabled:false,model:'bge-small-zh',usernames:[],days:90,start:null,end:null,device:'auto',device_id:0,auto_update:true,revision:1},jobs=[]
+// 固定的整理快照用于视觉与交互检查，不会读取真实聊天或启动索引。
+const progressPreview=new URLSearchParams(location.search).get('progress')
+let indexStats,messageTotal
+if(progressPreview){
+  config={...config,enabled:true,agent_global:true,days:0,start:0,read_batch_size:0}
+  const initial=progressPreview==='initial',done=progressPreview==='done'
+  const started=Date.now()/1000-(initial?1:86)
+  jobs=[{id:'progress-preview',status:initial?'running':progressPreview,stage:initial?'counting':done?'done':'embedding',mode:'initial',started,updated:Date.now()/1000,
+    ...(['paused','error','done'].includes(progressPreview)?{finished:Date.now()/1000}:{}),
+    read_count:initial?0:26286,processed:initial?0:25833,embedded:initial?0:4180,embedded_count:initial?0:4260,
+    chat_index:initial?0:done?1560:686,segments:Array.from({length:1560},()=>({})),read_batch_size_effective:1000,config:{...config},
+    ...(progressPreview==='error'?{error:'模型运行中断，请检查运行设备后重试。'}:{})}]
+  indexStats={messages:initial?0:25833,chunks:initial?0:4180}
+  messageTotal={job_id:'progress-preview',status:initial?'counting':'ready',value:58735,fixed:true,estimated:false}
+  if(done){jobs[0].read_count=58735;jobs[0].processed=58735}
+}
 // 分类弹窗验收使用与设计稿一致的虚构数据，覆盖长列表与部分选择。
 const scopePreview=new URLSearchParams(location.search).has('scope')
 const groupNames=['周末羽毛球群','产品讨论群','同学交流群','摄影分享群','城市徒步群','读书交流群']
@@ -27,7 +43,7 @@ const mac=navigator.userAgent.includes('Mac')
 const gpu={supported:!mac,platform:mac?'darwin':'win32',size:1671874915,installed:false,job:null}
 let gpuTimer
 globalThis.useAiApi=()=>({request:async(path,options={})=>{
-  if(path.startsWith('/local-search/status'))return JSON.parse(JSON.stringify({config,models,jobs,device:{actual_device:'cpu'},gpu,audit:[]}))
+  if(path.startsWith('/local-search/status'))return JSON.parse(JSON.stringify({config,models,jobs,index_stats:indexStats,message_total:messageTotal,device:{actual_device:'cpu'},gpu,audit:[]}))
   // 模拟组件状态，供按钮交互验收；不会下载真实文件。
   if(path==='/local-search/gpu/download'){
     if(!['queued','running'].includes(gpu.job?.status)){
diff --git a/frontend/tests/local-search.test.js b/frontend/tests/local-search.test.js
index 27be2d65..2a2b71ba 100644
--- a/frontend/tests/local-search.test.js
+++ b/frontend/tests/local-search.test.js
@@ -5,17 +5,18 @@ import LocalSearchSettings from '../components/LocalSearchSettings.vue'
 
 const account=ref('test-account'),request=vi.fn()
 vi.mock('~/stores/chatAccounts',()=>({useChatAccountsStore:()=>({selectedAccount:account})}))
-let wrapper,config,models,jobs,gpu,onEvent,indexStats,conversations
+let wrapper,config,models,jobs,gpu,onEvent,indexStats,conversations,messageTotal
 beforeEach(()=>{
   account.value='test-account'
   models=[{id:'bge-small-zh',name:'BGE Small 中文',description:'适合中文聊天',recommended:true,repo:'Xenova/bge-small-zh-v1.5',revision:'a'.repeat(40),license:'MIT',downloaded:false,size:95000000}]
   jobs=[]
   indexStats=undefined
+  messageTotal=undefined
   conversations=[{username:'current',name:'当前聊天'},{username:'other',name:'其他聊天'}]
   gpu={supported:true,size:1000}
   config={enabled:false,model:null,usernames:[],days:90,start:null,end:null,device:'auto',device_id:0,auto_update:true,revision:1}
   request.mockReset().mockImplementation(async(path,options)=>{
-    if(path.includes('/status'))return {config:{...config},models,device:{actual_device:null},jobs,gpu,index_stats:indexStats}
+    if(path.includes('/status'))return {config:{...config},models,device:{actual_device:null},jobs,gpu,index_stats:indexStats,message_total:messageTotal}
     if(path.includes('/conversations'))return conversations
     if(path.includes('/settings')){config={...options.body,revision:config.revision+1};return config}
     return []
@@ -148,9 +149,9 @@ it('重复检查零新增时展示现有索引总数，说明复用',async()=>{
   jobs=[{id:'done',status:'done',processed:6601,embedded:0,started:1,finished:13}]
   await open()
   expect(wrapper.find('.lss-status-title').text()).toContain('搜索数据已是最新')
-  expect(wrapper.find('.lss-index-total').text()).toContain('6601 条消息 · 601 个片段')
+  expect(wrapper.find('[data-metric=indexed]').text()).toContain('601覆盖 6,601 条消息')
   expect(wrapper.find('.lss-status').text()).toContain('已复用现有搜索数据')
-  expect(wrapper.find('.lss-live-count').text()).toContain('本次已保存 0 个片段')
+  expect(wrapper.find('[data-metric=generated]').text()).toBe('本次已保存片段0个片段')
 })
 it('没有可用片段时不能显示智能搜索已准备好',async()=>{
   ready();config.enabled=true;indexStats={messages:10,chunks:0}
@@ -160,16 +161,57 @@ it('没有可用片段时不能显示智能搜索已准备好',async()=>{
   expect(wrapper.find('.lss-status').text()).not.toContain('可以智能搜索了')
   expect(wrapper.find('.lss-status').text()).toContain('请调整聊天或时间范围')
 })
+it('进度按任务时间段计算，实时读取量不冒充已保存进度',async()=>{
+  ready();config.enabled=true
+  jobs=[{id:'run',status:'running',stage:'reading',chat_index:1,segments:[{},{},{},{}],read_count:1680,processed:1000,embedded:80,embedded_count:92,started:1}]
+  await open({accountWide:true})
+  expect(wrapper.find('.lss-index-progress').attributes('value')).toBe('25')
+  expect(wrapper.find('.lss-index-progress').attributes('aria-label')).toBe('会话时间段整理进度')
+  expect(wrapper.find('[data-metric=read] strong').text()).toBe('1,680')
+  expect(wrapper.find('[data-metric=saved] dd').text()).toBe('1,000条消息')
+  expect(wrapper.find('[data-metric=generated] dd').text()).toBe('92个片段')
+  expect(wrapper.find('[data-metric=indexed]').text()).toContain('等待索引统计')
+  expect(wrapper.find('.lss-status-details').attributes('open')).toBeUndefined()
+})
+it('未知任务范围不使用当前表单推算百分比，空范围不回退到聊天总数',async()=>{
+  ready();config.enabled=true
+  jobs=[{id:'run',status:'queued',stage:'queued',started:1,updated:1}]
+  await open()
+  expect(wrapper.find('.lss-index-progress').attributes('value')).toBeUndefined()
+  onEvent({kind:'local_search_index',account:'test-account',body:{...jobs[0],updated:2,segments:[],config:{usernames:['current']}}})
+  await flushPromises()
+  expect(wrapper.find('.lss-index-progress').attributes('value')).toBeUndefined()
+})
+it('首次零进度与完成进度明确区分',async()=>{
+  ready();config.enabled=true
+  jobs=[{id:'run',status:'running',stage:'reading',chat_index:0,segments:[{},{}],started:1,updated:1}]
+  await open()
+  expect(wrapper.find('.lss-index-progress').attributes('value')).toBe('0')
+  jobs=[{...jobs[0],status:'done',chat_index:2,updated:2,finished:2}]
+  onEvent({kind:'local_search_index',account:'test-account',body:jobs[0]})
+  await flushPromises()
+  expect(wrapper.find('.lss-index-progress').attributes('value')).toBe('100')
+  expect(button('暂停整理')).toBeUndefined()
+})
+it('失败保留真实进度并直接显示错误，不藏进详情',async()=>{
+  ready();config.enabled=true
+  jobs=[{id:'fail',status:'error',stage:'embedding',chat_index:1,segments:[{},{}],processed:100,embedded:8,error:'模型运行中断',started:1,finished:2}]
+  await open()
+  expect(wrapper.find('.lss-index-progress').attributes('value')).toBe('50')
+  expect(wrapper.find('.lss-status-title .fa-circle-exclamation').exists()).toBe(true)
+  expect(wrapper.find('.lss-status > [role=alert]').text()).toBe('模型运行中断')
+  expect(wrapper.find('[data-metric=saved] dd').text()).toBe('100条消息')
+})
 it('暂停后的片段数量以事务保存结果为准，手动暂停不是错误',async()=>{
   ready();config.enabled=true;config.agent_global=true
   jobs=[{id:'paused',status:'paused',stage:'embedding',processed:1617,read_count:2117,
     embedded:244,embedded_count:308,error:'处理已暂停',started:1,finished:37,config:{revision:1}}]
   indexStats={messages:1617,chunks:244}
   await open({accountWide:true})
-  expect(wrapper.find('.lss-live-count').text()).toContain('本次已保存 244 个片段')
-  expect(wrapper.find('.lss-live-count').text()).not.toContain('308')
+  expect(wrapper.find('[data-metric=generated]').text()).toBe('本次已保存片段244个片段')
+  expect(wrapper.find('[data-metric=generated]').text()).not.toContain('308')
   expect(wrapper.find('.lss-status .lss-error').exists()).toBe(false)
-  expect(wrapper.find('.lss-status').text()).toContain('已保存 1617 条消息的进度')
+  expect(wrapper.find('.lss-status').text()).toContain('已保存 1,617 条消息的进度')
   expect(primary().text()).toBe('继续整理')
 })
 it('大批量未保存时实时显示读取增长，旧事件不能倒退数量',async()=>{
@@ -181,8 +223,8 @@ it('大批量未保存时实时显示读取增长，旧事件不能倒退数量'
     onEvent({kind:'local_search_index',account:'test-account',body:{...jobs[0],updated,read_count}})
     await flushPromises()
   }
-  expect(wrapper.find('.lss-live-count').text()).toContain('已读取 1680 条消息')
-  expect(wrapper.find('.lss-status').text()).toContain('已保存 1000 条消息的进度')
+  expect(wrapper.find('[data-metric=read] strong').text()).toBe('1,680')
+  expect(wrapper.find('.lss-status').text()).toContain('已保存 1,000 条消息的进度')
   expect(request.mock.calls).toHaveLength(requests)
 })
 it('轮询旧响应不会覆盖读取中的实时数量',async()=>{
@@ -192,7 +234,7 @@ it('轮询旧响应不会覆盖读取中的实时数量',async()=>{
   await open()
   onEvent({kind:'local_search_index',account:'test-account',body:{...jobs[0],updated:3,read_count:700}})
   await vi.advanceTimersByTimeAsync(1500);await flushPromises()
-  expect(wrapper.find('.lss-live-count').text()).toContain('已读取 700 条消息')
+  expect(wrapper.find('[data-metric=read] strong').text()).toBe('700')
 })
 it('高级设置可选择更大批量并保存，不提交聊天草稿',async()=>{
   ready();config.usernames=[];await open();await selectScope()
@@ -427,3 +469,60 @@ it('macOS 展示 CPU 运行说明，不显示 NVIDIA 选项或组件下载',asyn
   expect(button('CPU').attributes('disabled')).toBeUndefined()
   expect(wrapper.find('.lss-advanced-copy').text()).not.toContain('GPU 加速')
 })
+
+
+it('消息分母固定，进度条按已保存消息占总量计算',async()=>{
+  ready();config.enabled=true
+  jobs=[{id:'run',status:'running',stage:'reading',read_count:26286,processed:25000,chat_index:1,segments:[{},{}],started:1}]
+  messageTotal={job_id:'run',status:'ready',value:58735,fixed:true}
+  await open()
+  expect(wrapper.find('[data-metric=read] strong').text()).toBe('26,286/ 58,735')
+  expect(wrapper.find('[data-metric=read] dt').text()).toContain('本轮总量')
+  expect(wrapper.find('.lss-index-progress').attributes('value')).toBe('42')
+})
+it.each([
+  [{job_id:'old',status:'ready',value:100},'总量统计中'],
+  [{job_id:'run',status:'counting'},'总量统计中'],
+  [{job_id:'run',status:'unavailable'},'总量统计未完成'],
+  [{job_id:'run',status:'ready',value:5,estimated:true},'总量统计中'],
+])('缺失或失效总量不伪造消息分母：%j',async(total,hint)=>{
+  ready();config.enabled=true
+  jobs=[{id:'run',status:'running',stage:'reading',processed:10,started:1}]
+  messageTotal=total
+  await open()
+  expect(wrapper.find('.lss-total-denominator').exists()).toBe(false)
+  expect(wrapper.find('[data-metric=read]').text()).toContain(hint)
+})
+it('历史完成任务缺少固定清单时兼容实际读取数，包括零消息',async()=>{
+  ready();config.enabled=true
+  jobs=[{id:'done',status:'done',stage:'done',processed:0,started:1,finished:2}]
+  messageTotal={job_id:'done',status:'ready',value:20,estimated:true}
+  await open()
+  expect(wrapper.find('[data-metric=read] strong').text()).toBe('0/ 0')
+  expect(wrapper.find('[data-metric=read] dt').text()).toContain('本轮总量')
+})
+
+
+it('统计阶段不展示临时总量与假百分比',async()=>{
+  ready();config.enabled=true
+  jobs=[{id:'count',status:'running',stage:'counting',processed:0,started:1,segments:[{},{}]}]
+  messageTotal={job_id:'count',status:'counting',value:10000}
+  await open()
+  expect(wrapper.find('.lss-status-title').text()).toBe('正在统计消息总量')
+  expect(wrapper.find('.lss-index-progress').attributes('value')).toBeUndefined()
+  expect(wrapper.find('.lss-total-denominator').exists()).toBe(false)
+  expect(wrapper.find('.lss-status-footer').text()).toContain('统计完成后开始整理')
+})
+it('固定分母在暂停和完成时保持一致，不按结果重写',async()=>{
+  ready();config.enabled=true
+  jobs=[{id:'run',status:'paused',stage:'embedding',processed:100,started:1,updated:1}]
+  messageTotal={job_id:'run',status:'ready',value:500,fixed:true}
+  await open()
+  expect(wrapper.find('.lss-total-denominator').text()).toBe('/ 500')
+  jobs=[{...jobs[0],status:'done',processed:499,updated:2,finished:2}]
+  onEvent({kind:'local_search_index',account:'test-account',body:jobs[0]})
+  await flushPromises()
+  // 即便旧接口给了不一致的完成数，界面也不偷偷降低分母或补成 100%。
+  expect(wrapper.find('.lss-total-denominator').text()).toBe('/ 500')
+  expect(wrapper.find('.lss-index-progress').attributes('value')).toBe('99')
+})
diff --git a/src/wechat_decrypt_tool/ai/deep_runtime.py b/src/wechat_decrypt_tool/ai/deep_runtime.py
index b81352fb..fef138d0 100644
--- a/src/wechat_decrypt_tool/ai/deep_runtime.py
+++ b/src/wechat_decrypt_tool/ai/deep_runtime.py
@@ -58,10 +58,11 @@
 只报告影响答案的资料缺口。正文保留业务结论、消息依据和必要的范围说明，不重复内部页数、范围句柄或 complete/warning 等字段；用户明确询问执行细节时再说明。不输出内部思考。内部文件仅用于笔记和资料回查，绝无终端或宿主文件权限。
 
 与用户保持沟通：
-阶段汇报是长任务的正常工作要求。涉及多轮读取、搜索或分析时，请主动汇报重要进展，不要全程静默调用工具、把所有正文留到最终答案。尚未取得资料时直接开始工作，无需开场预告。
-首次拿到有用资料后若仍需继续分析，请先用1—2句正常回复分享已有收获；完成一组操作、出现关键发现、判断发生变化或遇到影响结果的阻碍时，应再次简短汇报。每次说明已经完成的工作、具体发现及仍未确定的事项，随后继续执行，不等待用户确认。
-例如，资料确实支持时可以说“目前已找到两次安排变更，会议时间已调整，地点还没有确认。”不要照抄示例事实。只说“正在分析”“继续查询”不算有用汇报；不要逐次预告工具，不输出内部推理。
-阶段汇报写在面向用户的 assistant 正文中，并与继续执行所需的工具调用一起返回。调用工具不意味着正文必须为空；工具参数只填写业务数据。
+鼓励在长任务中主动分享简短的阶段性进展，让用户了解工作正在推进。预计需要多步处理时，适合先用一句话说明准备查看的范围或处理方向，随后开始工作；尚未读取的资料不能说成已有发现。
+取得初步收获、形成阶段结论、调整查询方向或遇到影响结果的阻碍时，主动用1—2句说明已核实的发现和接下来需要确认的事项。较长时间仍在处理中、暂时没有结论时，也可以简短交代实际完成了什么、还在核实什么，不必等到重大新发现才开口。汇报后继续执行，不等待用户确认。
+保持自然的沟通节奏，不要求每次读取、搜索或工具调用都回复，也不按页数或调用次数规定汇报频率。连续分页可合并成一段阶段反馈；是否开口取决于对用户是否有帮助，避免长任务从头到尾只显示工具记录。
+例如，资料确实支持时可以说“目前已找到两次安排变更，会议时间已调整，地点还没有确认。”不要照抄示例事实。避免“继续下读”“正在分析”等没有新信息的播报；不要逐次预告工具，不输出内部推理。
+阶段汇报写在面向用户的 assistant 正文中，并与继续执行所需的工具调用一起返回。调用工具与正常回复可以同时进行；工具参数只填写业务数据。
 简单任务或已经能给出最终结论时直接回答，无新进展时不重复播报。不要为了凑汇报而增加搜索、重复检查或延长任务。'''
 
 CHILD_SCOPE = ContextVar('deep_child_scope', default=None)
diff --git a/src/wechat_decrypt_tool/local_search/frozen.py b/src/wechat_decrypt_tool/local_search/frozen.py
new file mode 100644
index 00000000..55c3b376
--- /dev/null
+++ b/src/wechat_decrypt_tool/local_search/frozen.py
@@ -0,0 +1,109 @@
+"""本轮消息快照：分页落盘、精确计数，统计完成后不再访问变化中的消息源。"""
+from contextlib import contextmanager
+import json
+import sqlite3
+
+
+class FrozenMessages:
+    def __init__(self, path, job):
+        self.path = path
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with self.connection() as db:
+            db.executescript('''
+                CREATE TABLE IF NOT EXISTS meta(key TEXT PRIMARY KEY, body TEXT);
+                CREATE TABLE IF NOT EXISTS segments(position INTEGER PRIMARY KEY, body TEXT);
+                CREATE TABLE IF NOT EXISTS messages(segment INTEGER, ordinal INTEGER, source TEXT, body TEXT,
+                    PRIMARY KEY(segment,ordinal), UNIQUE(segment,source));
+            ''')
+            if not self._get(db, 'plan'):
+                self._put(db, 'plan', {'job_id': job['id'], 'base': job['processed'],
+                    'start_index': job['chat_index'], 'start_offset': job['offset'],
+                    'start_cursor': job.get('cursor'), 'ready': False})
+
+    @contextmanager
+    def connection(self):
+        db = sqlite3.connect(self.path, timeout=30)
+        try:
+            db.execute('PRAGMA cache_size=-1024')
+            with db:
+                yield db
+        finally:
+            db.close()
+
+    @staticmethod
+    def _get(db, key):
+        row = db.execute('SELECT body FROM meta WHERE key=?', (key,)).fetchone()
+        return json.loads(row[0]) if row else None
+
+    @staticmethod
+    def _put(db, key, value):
+        db.execute('INSERT OR REPLACE INTO meta VALUES(?,?)', (key, json.dumps(value, ensure_ascii=False)))
+
+    def metadata(self):
+        with self.connection() as db:
+            return self._get(db, 'plan')
+
+    def segment(self, position):
+        with self.connection() as db:
+            row = db.execute('SELECT body FROM segments WHERE position=?', (position,)).fetchone()
+            if row:
+                return json.loads(row[0])
+            plan = self._get(db, 'plan')
+            offset = plan['start_offset'] if position == plan['start_index'] else 0
+            return {'offset': offset, 'ordinal': offset, 'complete': False,
+                    'cursor': plan['start_cursor'] if position == plan['start_index'] else None}
+
+    def append(self, position, result, checkpoint):
+        state = self.segment(position)
+        with self.connection() as db:
+            if self._get(db, 'plan')['ready']:
+                raise ValueError('本轮消息范围已固定，不能追加消息')
+            for index, message in enumerate(result['messages']):
+                if index % 100 == 0:
+                    checkpoint()
+                inserted = db.execute('INSERT OR IGNORE INTO messages VALUES(?,?,?,?)',
+                    (position, state['ordinal'] + 1, message['source'], json.dumps(message, ensure_ascii=False)))
+                if inserted.rowcount:
+                    state['ordinal'] += 1
+            state.update(offset=state['offset'] + len(result['messages']), cursor=result.get('cursor'),
+                complete=not result.get('has_more', False), name=result.get('name', ''),
+                source=result.get('source', 'snapshot'), warning=result.get('warning', ''))
+            checkpoint()
+            db.execute('INSERT OR REPLACE INTO segments VALUES(?,?)',
+                       (position, json.dumps(state, ensure_ascii=False)))
+
+    def freeze(self, segment_count):
+        with self.connection() as db:
+            plan = self._get(db, 'plan')
+            if not plan['ready']:
+                states = [json.loads(row[0]) for row in db.execute('SELECT body FROM segments')]
+                if len(states) != segment_count - plan['start_index'] or not all(s['complete'] for s in states):
+                    raise ValueError('消息清单尚未统计完整')
+                plan.update(ready=True, total=plan['base'] + db.execute('SELECT COUNT(*) FROM messages').fetchone()[0])
+                self._put(db, 'plan', plan)
+            return plan
+
+    def page(self, position, offset, size, checkpoint):
+        checkpoint()
+        with self.connection() as db:
+            if not self._get(db, 'plan')['ready']:
+                raise ValueError('消息总量尚未统计完成')
+            rows = db.execute('SELECT body FROM messages WHERE segment=? AND ordinal>? ORDER BY ordinal LIMIT ?',
+                              (position, offset, size + 1))
+            messages, chars, more = [], 0, False
+            for row in rows:
+                checkpoint()
+                if len(messages) >= size or (messages and chars >= 128000):
+                    more = True
+                    break
+                message = json.loads(row[0])
+                messages.append(message)
+                chars += len(message.get('text', ''))
+            state = json.loads(db.execute('SELECT body FROM segments WHERE position=?', (position,)).fetchone()[0])
+        checkpoint()
+        return {'messages': messages, 'has_more': more,
+                'name': state['name'], 'source': state['source'], 'warning': state['warning']}
+
+    def discard(self):
+        # 只删除由任务 ID 推导的临时快照文件；索引与聊天数据库不受影响。
+        self.path.unlink(missing_ok=True)
diff --git a/src/wechat_decrypt_tool/local_search/progressive.py b/src/wechat_decrypt_tool/local_search/progressive.py
index 3e7ab809..2d0c10c3 100644
--- a/src/wechat_decrypt_tool/local_search/progressive.py
+++ b/src/wechat_decrypt_tool/local_search/progressive.py
@@ -69,8 +69,8 @@ async def ensure_global(self, account):
             return None
         jobs = self.store.list('index_job', account, limit=1)
         current_job = jobs[0] if jobs and jobs[0]['config'].get('revision') == cfg.get('revision') else None
-        # 保留当前全账号任务的暂停/错误状态；刷新会话目录不能偷偷恢复用户暂停。
-        if current_job and (current_job['status'] == 'paused' or (cfg.get('agent_global') and current_job['status'] == 'error')):
+        # 本轮聊天范围固定；新会话不能在后台刷新时改配置、打断任务或扩大总量。
+        if current_job and (current_job['status'] == 'paused' or (cfg.get('agent_global') and current_job['status'] in {'queued', 'running', 'error'})):
             return current_job
         from ..ai.agent_tools import ChatTools
         contacts = await ChatTools().conversations(account)
diff --git a/src/wechat_decrypt_tool/local_search/service.py b/src/wechat_decrypt_tool/local_search/service.py
index b084e12d..b4022acb 100644
--- a/src/wechat_decrypt_tool/local_search/service.py
+++ b/src/wechat_decrypt_tool/local_search/service.py
@@ -17,6 +17,7 @@
 from .index import SemanticIndex, make_chunks, fuse
 from .inference import LocalInference, InferenceFailure
 from .progressive import ProgressiveIndex, reading_segments, committed_coverage, coverage_complete
+from .totals import MessageTotals
 
 
 DEFAULTS = {'enabled': False, 'model': None, 'usernames': [], 'days': 90,
@@ -24,7 +25,7 @@
             'read_batch_size': 0, 'agent_global': False}
 
 
-class LocalSearch(ProgressiveIndex):
+class LocalSearch(ProgressiveIndex, MessageTotals):
     def __init__(self, root=None, model_root=None, reader=None, engine=None):
         self.root = Path(root or get_output_dir() / 'local_search')
         self.store = AIStore(self.root)
@@ -52,6 +53,7 @@ def status(self, account=None):
         cfg = self.config(account) if account else None
         jobs = self.store.list('index_job', account, limit=5) if account else []
         result = {'config': cfg, 'models': self.downloads.models(), 'device': self.engine.status, 'jobs': jobs, 'event_cursor': event_cursor,
+                  'message_total': self.store.get('index_message_total', jobs[0]['id']) if jobs else None,
                   'gpu': {**self.gpu.status(), 'failed': self.engine.gpu_failed}, 'audit': self.store.list('local_usage', account, limit=20) if account else []}
         if account:
             index = self.index(account)
@@ -80,6 +82,7 @@ async def _configure(self, account, values):
         self.store.put('config', cfg, id=account, account=account)
         # 范围或设备变更后，旧任务不得继续提交过期配置。
         await self.pause_account(account)
+        await asyncio.to_thread(self.clear_message_plans, account)
         if cfg.get('active'):
             start=cfg['start'] if cfg['start'] is not None else max(0,int(time.time())-cfg['days']*86400) if cfg['days'] else 0
             await asyncio.to_thread(self.index(account).prune,cfg['active']['generation'],cfg['usernames'],start,cfg['end'] or 2**53)
@@ -146,7 +149,7 @@ async def _build(self, account, rebuild=False, incremental=True):
         for id, task in self.jobs.items():
             job = self.store.get('index_job', id)
             if not task.done() and job and job['account'] == account: return job
-        end = cfg['end'] or int(time.time())
+        end = min(cfg['end'] or int(time.time()), int(time.time()))
         start = cfg['start'] if cfg['start'] is not None else max(0, end - cfg['days'] * 86400) if cfg['days'] else 0
         active = cfg.get('active') or {}
         new_generation = rebuild or active.get('model') != cfg['model'] or not active.get('generation')
@@ -204,7 +207,7 @@ async def pause_account(self, account):
                 await asyncio.gather(task, return_exceptions=True)
 
     @asynccontextmanager
-    async def open_pages(self, account, username, start, end, offset, checkpoint, page_size=0, on_progress=None, on_batch_size=None, cursor=None):
+    async def open_pages(self, account, username, start, end, offset, checkpoint, page_size=0, on_progress=None, on_batch_size=None, cursor=None, frozen=None):
         """在专用线程中顺序推进和关闭游标，避免线程池切换破坏 SQLite 连接。"""
         from ..ai.messages import iter_message_pages
         from .reading import choose_read_batch_size
@@ -222,7 +225,18 @@ def batch_size():
             return size
 
         def pages():
-            if self.reader:
+            if frozen:
+                plan, segment = frozen
+                position = offset
+                while True:
+                    result = plan.page(segment, position, batch_size(), check)
+                    position += len(result['messages'])
+                    if on_progress:
+                        loop.call_soon_threadsafe(on_progress, position)
+                    yield result
+                    if not result['has_more']:
+                        return
+            elif self.reader:
                 # 保留可注入的分页数据源，进度仍按事务提交的消息数量计算。
                 position = offset
                 while True:
@@ -254,6 +268,7 @@ def pages():
     @observed('search.run', id_field='task_id', execution=True)
     async def run(self, job):
         cfg, account = job['config'], job['account']
+        plan = None
         def cancelled(): return job['id'] in self.cancelled or account in self.revoked
         def check():
             if cancelled(): raise InferenceFailure('任务已暂停', 'cancelled')
@@ -266,6 +281,7 @@ def check():
                 tokenizer = Tokenizer.from_file(str(root / 'tokenizer.json'))
                 index = self.index(account)
                 self.update(job, status='running', read_count=job['processed'], embedded_count=job['embedded'])
+                plan = await self.count_message_total(job, check)
                 segments = job.get('segments')
                 for position in range(job['chat_index'], len(segments) if segments is not None else len(cfg['usernames'])):
                     segment = segments[position] if segments is not None else None
@@ -287,7 +303,8 @@ def batch_size_changed(size):
 
                     async with self.open_pages(account, username, read_start, read_end, offset, check,
                             page_size=cfg.get('read_batch_size', 0), on_progress=reading_progress,
-                            on_batch_size=batch_size_changed, cursor=job.get('cursor') if offset else None) as next_page:
+                            on_batch_size=batch_size_changed, cursor=job.get('cursor') if offset else None,
+                            frozen=(plan, position)) as next_page:
                         while True:
                             check()
                             await self.yield_to_queries(check)
@@ -353,6 +370,9 @@ def batch_size_changed(size):
                             if not more: break
                             offset += len(messages)
                 check()
+                frozen_total = (await asyncio.to_thread(plan.metadata))['total']
+                if job['processed'] != frozen_total:
+                    raise InferenceFailure('本轮消息清单与已保存数量不一致，已保留进度，请重试。', 'count_mismatch')
                 current = self.config(account)
                 if current.get('revision') != cfg.get('revision'): raise InferenceFailure('配置已更新', 'cancelled')
                 # 完成清理、范围约束和统计后才发布成功状态。
@@ -368,6 +388,10 @@ def batch_size_changed(size):
                 self.store.put('config', current, id=account, account=account)
                 await asyncio.to_thread(index.clear, job['generation'])
                 self.update(job, status='done', stage='done', index_stats=stats, finished=time.time())
+                try:
+                    await asyncio.to_thread(plan.discard)
+                except OSError as error:
+                    failures.report('search.plan.cleanup', error)
             except InferenceFailure as error:
                 diagnostic_event('index.execution.interrupted' if error.category=='cancelled' else 'index.execution.failed',
                                  level=logging.INFO if error.category=='cancelled' else logging.ERROR, error=error)
@@ -376,6 +400,8 @@ def batch_size_changed(size):
                 diagnostic_event('index.execution.failed', level=logging.ERROR, error=error)
                 self.update(job, status='error', error='索引处理失败，已保留进度，请检查数据源和模型后重试', error_type=type(error).__name__, finished=time.time())
             finally:
+                if account in self.revoked:
+                    await asyncio.to_thread(self.clear_message_plans, account)
                 self.store.put('local_usage', {'kind': 'index', 'account': account, 'model': cfg['model'], 'status':job['status'],
                     'messages': job['processed'], 'chunks': job['embedded'], 'seconds': time.time()-job['started'], **self.engine.status},id=job['id'],account=account)
 
@@ -464,15 +490,21 @@ async def clear(self, account):
         if not cfg['enabled']: cfg['model']=None
         self.store.put('config', cfg, id=account, account=account)
         await asyncio.to_thread(self.index(account).clear)
+        await asyncio.to_thread(self.clear_message_plans, account)
         self.queries.clear()
 
     @observed('search.purge', id_field='task_id')
     def purge(self, account):
         self.revoked.add(account)
-        for job in self.store.list('index_job',account): self.cancelled.add(job['id'])
+        active = False
+        for job in self.store.list('index_job',account):
+            self.cancelled.add(job['id'])
+            active |= job['id'] in self.jobs and not self.jobs[job['id']].done()
         self.store.purge_account(account)
         self.index(account).clear()
         self.queries.clear()
+        if not active:
+            self.clear_message_plans(account)
 
     @observed('search.start', id_field='task_id')
     async def start(self):
diff --git a/src/wechat_decrypt_tool/local_search/totals.py b/src/wechat_decrypt_tool/local_search/totals.py
new file mode 100644
index 00000000..a354f49a
--- /dev/null
+++ b/src/wechat_decrypt_tool/local_search/totals.py
@@ -0,0 +1,75 @@
+"""先准备完整消息快照，再发布固定总量；暂停继续不重新统计或更改分母。"""
+import asyncio
+import hashlib
+import time
+
+from .frozen import FrozenMessages
+from .inference import InferenceFailure
+
+
+class MessageTotals:
+    def save_message_total(self, job, **values):
+        total = {'job_id': job['id'], 'updated': time.time(), **values}
+        self.store.put('index_message_total', total, id=job['id'], account=job['account'])
+        self.store.event(job['account'], 'local_search_total', total)
+
+    def message_plan(self, job):
+        account_key = hashlib.sha256(job['account'].encode()).hexdigest()
+        job_key = hashlib.sha256(job['id'].encode()).hexdigest()
+        path = self.root / 'plans' / account_key / f'{job_key}.sqlite3'
+        previous = self.store.get('index_message_total', job['id']) or {}
+        if previous.get('fixed') and not path.exists():
+            raise InferenceFailure('本轮消息清单已丢失，请从头整理；原有索引仍保留。', 'plan_missing')
+        plan = FrozenMessages(path, job)
+        if previous.get('fixed') and not plan.metadata()['ready']:
+            raise InferenceFailure('本轮消息清单不完整，请从头整理；原有索引仍保留。', 'plan_missing')
+        return plan
+
+    async def count_message_total(self, job, check):
+        plan = await asyncio.to_thread(self.message_plan, job)
+        metadata = await asyncio.to_thread(plan.metadata)
+        if metadata['ready']:
+            self.save_message_total(job, status='ready', value=metadata['total'], fixed=True, estimated=False)
+            return plan
+        self.save_message_total(job, status='counting')
+        self.update(job, stage='counting')
+        targets = job.get('segments')
+        if targets is None:
+            targets = [{'username': username,
+                        'start': job.get('read_starts', {}).get(username, job.get('read_start', job['start'])),
+                        'end': job['end']} for username in job['config']['usernames']]
+        try:
+            for position in range(metadata['start_index'], len(targets)):
+                await self.yield_to_queries(check)
+                check()
+                state = await asyncio.to_thread(plan.segment, position)
+                if state['complete']:
+                    continue
+                target = targets[position]
+                async with self.open_pages(job['account'], target['username'], target['start'], target['end'],
+                        state['offset'], check, page_size=job['config'].get('read_batch_size', 0),
+                        cursor=state['cursor']) as next_page:
+                    while True:
+                        await self.yield_to_queries(check)
+                        check()
+                        result = await next_page()
+                        check()
+                        await asyncio.to_thread(plan.append, position, result, check)
+                        if not result.get('has_more', False):
+                            break
+            check()
+            metadata = await asyncio.to_thread(plan.freeze, len(targets))
+            self.save_message_total(job, status='ready', value=metadata['total'], fixed=True, estimated=False)
+            return plan
+        except InferenceFailure:
+            self.save_message_total(job, status='paused')
+            raise
+        except Exception as error:
+            self.save_message_total(job, status='unavailable')
+            raise InferenceFailure('消息总量统计未完成，已保留统计进度，请继续整理以重试。', 'count_failed') from error
+
+    def clear_message_plans(self, account):
+        account_key = hashlib.sha256(account.encode()).hexdigest()
+        directory = self.root / 'plans' / account_key
+        for path in directory.glob('*.sqlite3'):
+            path.unlink(missing_ok=True)
diff --git a/tests/test_ai_deepagents.py b/tests/test_ai_deepagents.py
index fcde4217..2df72f9b 100644
--- a/tests/test_ai_deepagents.py
+++ b/tests/test_ai_deepagents.py
@@ -164,9 +164,11 @@ async def check():
         assert service.run(run['id'])['subtask_plan_version'] == 2
         for request in client.requests:
             system = '\n'.join(str(message.content) for message in request if message.type == 'system')
-            assert '阶段汇报是长任务的正常工作要求' in system
-            assert '首次拿到有用资料后若仍需继续分析' in system
-            assert '阶段汇报写在面向用户的 assistant 正文中' in system
+            assert '鼓励在长任务中主动分享简短的阶段性进展' in system
+            assert '不要求每次读取、搜索或工具调用都回复' in system
+            assert '不必等到重大新发现才开口' in system
+            assert '避免长任务从头到尾只显示工具记录' in system
+            assert '写在面向用户的 assistant 正文中' in system
         for definition in client.definitions:
             params = definition['function']['parameters']
             assert 'progress_message' not in params.get('required', [])
diff --git a/tests/test_local_search.py b/tests/test_local_search.py
index dd13fbee..34cd1ca6 100644
--- a/tests/test_local_search.py
+++ b/tests/test_local_search.py
@@ -332,8 +332,10 @@ def reader(account,username,start,end,offset):
         monkeypatch.setattr(service,'enrichment_version',lambda _:[])
         await service.configure('a',{'enabled':True,'model':'bge-small-zh','days':0,'end':1000,'usernames':['allowed']})
         job=await service.build('a');await service.jobs[job['id']]
-        assert job['status']=='error' and job['processed']==2
-        assert service.index('a').progress(job['id'])['offset']==2
+        # 统计未完成不能提前建索引；统计本身的分页断点可继续。
+        assert job['status']=='error' and job['processed']==0
+        assert service.index('a').progress(job['id']) is None
+        assert service.message_plan(job).segment(0)['offset']==2
         resumed=await service.resume('a',job['id']);await service.jobs[job['id']]
         assert resumed['status']=='done' and resumed['processed']==6
         assert calls==[0,2,2,4]
@@ -407,7 +409,8 @@ def encode(root, spec, texts, *args):
         resumed = await service.resume('a', replacement['id'])
         await service.jobs[resumed['id']]
         assert resumed['status'] == 'done' and resumed['unchanged'] == 0
-        assert reads == [(0, 0)]
+        # 推理失败后直接使用原清单，不重读源消息或更改总量。
+        assert reads == []
         assert sum(count for _, count in encoded) == first['embedded'] == resumed['embedded']
         assert all(root == model_dir(service.downloads.root, target_model) for root, _ in encoded)
         assert service.config('a')['active']['generation'] == resumed['generation']
diff --git a/tests/test_local_search_totals.py b/tests/test_local_search_totals.py
new file mode 100644
index 00000000..00be0b85
--- /dev/null
+++ b/tests/test_local_search_totals.py
@@ -0,0 +1,203 @@
+"""固定本轮总量、源数据变化、暂停恢复与临时快照回收回归。"""
+import asyncio
+import copy
+from pathlib import Path
+
+import pytest
+from tokenizers import Tokenizer, models
+
+from test_local_search import FakeEngine, message
+from wechat_decrypt_tool.local_search.service import LocalSearch
+from wechat_decrypt_tool.local_search.frozen import FrozenMessages
+from wechat_decrypt_tool.local_search.index import SemanticIndex
+from wechat_decrypt_tool.local_search.inference import InferenceFailure
+from wechat_decrypt_tool.local_search.catalog import model_dir
+
+
+def snapshot(tmp_path, **values):
+    job = {'id': 'job', 'account': 'account', 'processed': 0, 'chat_index': 0, 'offset': 0, **values}
+    return FrozenMessages(tmp_path / 'plan.sqlite3', job)
+
+
+def test_snapshot_is_deduplicated_complete_and_immutable(tmp_path):
+    plan = snapshot(tmp_path)
+    plan.append(0, {'messages': [message('a'), message('a'), message('b')], 'has_more': True}, lambda: None)
+    with pytest.raises(ValueError):
+        plan.freeze(1)
+    plan.append(0, {'messages': [message('b'), message('c')], 'has_more': False}, lambda: None)
+    assert plan.freeze(1)['total'] == 3
+    reopened = snapshot(tmp_path, processed=2, offset=2)
+    assert reopened.metadata()['total'] == 3
+    assert [m['source'] for m in reopened.page(0, 1, 100, lambda: None)['messages']] == ['b', 'c']
+    with pytest.raises(ValueError, match='固定'):
+        reopened.append(0, {'messages': [message('new')]}, lambda: None)
+    assert reopened.freeze(1)['total'] == 3
+
+
+def test_snapshot_commit_cancel_rolls_back_count_and_cursor(tmp_path):
+    plan = snapshot(tmp_path)
+    checks = 0
+    def cancel():
+        nonlocal checks
+        checks += 1
+        if checks == 2:
+            raise InferenceFailure('暂停', 'cancelled')
+    with pytest.raises(InferenceFailure):
+        plan.append(0, {'messages': [message(str(i)) for i in range(200)], 'has_more': True}, cancel)
+    assert plan.segment(0)['offset'] == 0
+    plan.append(0, {'messages': [message('a')], 'has_more': False}, lambda: None)
+    assert plan.freeze(1)['total'] == 1
+
+
+def test_snapshot_pages_keep_character_budget_and_old_committed_base(tmp_path):
+    plan = snapshot(tmp_path, processed=500, offset=100, chat_index=1)
+    plan.append(1, {'messages': [message(str(i), '文' * 70000) for i in range(3)], 'has_more': False}, lambda: None)
+    assert plan.freeze(2)['total'] == 503
+    page = plan.page(1, 100, 1000, lambda: None)
+    assert len(page['messages']) == 2 and page['has_more']
+    assert len(plan.page(1, 102, 1000, lambda: None)['messages']) == 1
+
+
+async def service_for(tmp_path, monkeypatch, reader, engine=None):
+    service = LocalSearch(tmp_path / 'state', tmp_path / 'models', reader=reader, engine=engine or FakeEngine())
+    root = model_dir(service.downloads.root, 'bge-small-zh')
+    root.mkdir(parents=True)
+    Tokenizer(models.WordLevel({'[UNK]': 0}, unk_token='[UNK]')).save(str(root / 'tokenizer.json'))
+    monkeypatch.setattr(service.downloads, 'available', lambda _: True)
+    monkeypatch.setattr(service, 'enrichment_version', lambda _: [])
+    await service.configure('a', {'enabled': True, 'model': 'bge-small-zh', 'days': 0,
+                                'start': 0, 'end': 2000, 'usernames': ['allowed'], 'read_batch_size': 100})
+    return service
+
+
+def test_count_finishes_before_encoding_and_new_or_deleted_messages_do_not_change_total(tmp_path, monkeypatch):
+    async def run():
+        rows = [message('a'), message('a'), message('b')]
+        reads = []
+        def reader(account, username, start, end, offset):
+            reads.append(offset)
+            return {'messages': copy.deepcopy(rows[offset:offset + 2]), 'has_more': offset + 2 < len(rows)}
+        service = await service_for(tmp_path, monkeypatch, reader)
+        original = service.engine.encode
+        def encode(*args, **kwargs):
+            status = service.status('a')
+            assert status['message_total']['value'] == 2
+            assert status['message_total']['fixed'] is True
+            assert reads == [0, 2]
+            # 包括补入旧时间的消息、删除原记录，都不能改变已经固定的清单。
+            rows[:] = [message('new', timestamp=50)]
+            return original(*args, **kwargs)
+        monkeypatch.setattr(service.engine, 'encode', encode)
+        current = await service.build('a')
+        await service.jobs[current['id']]
+        assert current['status'] == 'done' and current['processed'] == 2
+        assert service.status('a')['message_total']['value'] == 2
+        assert not list((service.root / 'plans').rglob('*.sqlite3'))
+        monkeypatch.setattr(service.engine, 'encode', original)
+        next_round = await service.build('a', incremental=False)
+        await service.jobs[next_round['id']]
+        assert next_round['status'] == 'done' and next_round['processed'] == 1
+        assert service.status('a')['message_total']['value'] == 1
+        await service.stop()
+    asyncio.run(run())
+
+
+def test_pause_after_commit_resumes_same_plan_without_rereading_source(tmp_path, monkeypatch):
+    async def run():
+        rows = [message(str(i), timestamp=100 + i) for i in range(250)]
+        reads = []
+        def reader(account, username, start, end, offset):
+            reads.append(offset)
+            return {'messages': copy.deepcopy(rows[offset:offset + 100]), 'has_more': offset + 100 < len(rows)}
+        service = await service_for(tmp_path, monkeypatch, reader)
+        original_commit = SemanticIndex.commit
+        paused = False
+        def commit(index, generation, messages, chunks, vectors, current, checkpoint=None):
+            nonlocal paused
+            original_commit(index, generation, messages, chunks, vectors, current, checkpoint)
+            if not paused:
+                paused = True
+                service.cancelled.add(current['id'])
+        monkeypatch.setattr(SemanticIndex, 'commit', commit)
+        current = await service.build('a')
+        await service.jobs[current['id']]
+        assert current['status'] == 'paused' and current['processed'] == 100
+        assert service.status('a')['message_total']['value'] == 250
+        rows.clear()
+        reads_before = list(reads)
+        resumed = await service.resume('a', current['id'])
+        await service.jobs[resumed['id']]
+        assert resumed['status'] == 'done' and resumed['processed'] == 250
+        assert reads == reads_before
+        assert service.status('a')['message_total']['value'] == 250
+        assert service.index('a').stats(resumed['generation'])['messages'] == 250
+        await service.stop()
+    asyncio.run(run())
+
+
+def test_failed_preparation_never_starts_inference_and_can_resume_its_cursor(tmp_path, monkeypatch):
+    async def run():
+        reads, fail = [], True
+        def reader(account, username, start, end, offset):
+            nonlocal fail
+            reads.append(offset)
+            if offset == 1 and fail:
+                fail = False
+                raise OSError('源暂不可用')
+            return {'messages': [message(str(offset))], 'has_more': offset < 2}
+        service = await service_for(tmp_path, monkeypatch, reader)
+        current = await service.build('a')
+        await service.jobs[current['id']]
+        assert current['status'] == 'error' and current['processed'] == 0
+        assert service.engine.calls == 0
+        assert 'value' not in service.status('a')['message_total']
+        resumed = await service.resume('a', current['id'])
+        await service.jobs[resumed['id']]
+        assert resumed['status'] == 'done' and resumed['processed'] == 3
+        assert reads == [0, 1, 1, 2]
+        await service.stop()
+    asyncio.run(run())
+
+
+def test_missing_fixed_plan_fails_instead_of_recounting_a_different_total(tmp_path, monkeypatch):
+    async def run():
+        service = await service_for(tmp_path, monkeypatch, lambda *args: {'messages': []})
+        current = {'id': 'lost', 'account': 'a', 'processed': 0, 'chat_index': 0, 'offset': 0}
+        service.save_message_total(current, status='ready', value=10, fixed=True)
+        with pytest.raises(InferenceFailure, match='清单已丢失'):
+            await service.count_message_total(current, lambda: None)
+        assert service.store.get('index_message_total', 'lost')['value'] == 10
+        await service.stop()
+    asyncio.run(run())
+
+
+def test_zero_message_round_has_fixed_zero_total(tmp_path, monkeypatch):
+    async def run():
+        service = await service_for(tmp_path, monkeypatch, lambda *args: {'messages': [], 'has_more': False})
+        current = await service.build('a')
+        await service.jobs[current['id']]
+        assert current['status'] == 'done' and current['processed'] == 0
+        assert service.status('a')['message_total']['value'] == 0
+        assert service.status('a')['message_total']['fixed']
+        await service.stop()
+    asyncio.run(run())
+
+
+@pytest.mark.parametrize('status', ['queued', 'running', 'paused', 'error'])
+def test_global_refresh_does_not_expand_scope_while_round_is_unfinished(tmp_path, monkeypatch, status):
+    from unittest.mock import AsyncMock
+    from wechat_decrypt_tool.ai.agent_tools import ChatTools
+    async def run():
+        service = LocalSearch(tmp_path)
+        cfg = {'enabled': True, 'model': 'bge-small-zh', 'agent_global': True, 'usernames': ['old'], 'revision': 1}
+        current = {'id': 'run', 'account': 'a', 'status': status, 'config': cfg, 'end': 100}
+        service.store.put('config', cfg, id='a', account='a')
+        service.store.put('index_job', current, id='run', account='a')
+        monkeypatch.setattr(service.downloads, 'available', lambda _: True)
+        contacts = AsyncMock(return_value=[{'username': 'old'}, {'username': 'new'}])
+        monkeypatch.setattr(ChatTools, 'conversations', contacts)
+        assert (await service.ensure_global('a'))['id'] == 'run'
+        contacts.assert_not_called()
+        assert service.config('a')['revision'] == 1
+        assert service.config('a')['usernames'] == ['old']
+    asyncio.run(run())

From 1700040768aafab572a6930cb5128fa8ceac958f Mon Sep 17 00:00:00 2001
From: xiaosheng <73678111+xiaoshengbao@users.noreply.github.com>
Date: Tue, 15 Sep 2026 16:58:18 +0800
Subject: [PATCH 2/2] =?UTF-8?q?test(ai):=20=E4=BF=AE=E6=AD=A3=E5=BF=AB?=
 =?UTF-8?q?=E7=85=A7=E6=81=A2=E5=A4=8D=E6=96=AD=E8=A8=80=E5=B9=B6=E7=A8=B3?=
 =?UTF-8?q?=E5=AE=9A=E6=85=A2=E7=A3=81=E7=9B=98=E7=AD=89=E5=BE=85?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_ai_agent.py         |  3 ++-
 tests/test_ai_message_pages.py | 10 ++++++++--
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/tests/test_ai_agent.py b/tests/test_ai_agent.py
index 862d5881..98ba0486 100644
--- a/tests/test_ai_agent.py
+++ b/tests/test_ai_agent.py
@@ -266,7 +266,8 @@ async def run():
         service.model.waiting.set()
         # 首个旧动作会被丢弃，补充后需要重新执行读取。
         service.model.actions.insert(1, AgentAction(action='read_messages', username='friend'))
-        await asyncio.wait_for(replacement, 5)
+        # CI 的 SQLite 持久化可能超过 5 秒；超时应报告等待失败，不能取消任务后误判为业务中断。
+        await asyncio.wait_for(asyncio.shield(replacement), 60)
         saved = service.run(task['id'])
         assert saved['version'] == saved['applied_version'] == 2
         assert saved['status'] == 'completed', saved
diff --git a/tests/test_ai_message_pages.py b/tests/test_ai_message_pages.py
index e21db4d4..c91e62df 100644
--- a/tests/test_ai_message_pages.py
+++ b/tests/test_ai_message_pages.py
@@ -349,12 +349,18 @@ async def run():
         assert job['status'] == 'error' and job['processed'] == 500
         assert job['read_count'] == 1000
         assert service.index('a').progress(job['id'])['offset'] == 500
-        assert state['closed'] == 1
+        assert state['opens'] == state['closed'] == 1
+        assert service.status('a')['message_total']['value'] == 1250
+        scanned = state['scanned']
+        # 本轮清单已固定，恢复仅处理尚未提交的批次；源消息变化也不能触发重新扫描。
+        state['rows'].clear()
         resumed = await service.resume('a', job['id'])
         await service.jobs[job['id']]
         assert resumed['status'] == 'done'
         assert resumed['processed'] == resumed['read_count'] == 1250
-        assert state['opens'] == state['closed'] == 2
+        assert state['opens'] == state['closed'] == 1
+        assert state['scanned'] == scanned
+        assert service.status('a')['message_total']['value'] == 1250
         with service.index('a').connection() as db:
             assert db.execute('SELECT count(*) FROM messages').fetchone()[0] == 1250
         events = service.store.events()