cc 2 ngày trước cách đây
mục cha
commit
431fccb3ef
37 tập tin đã thay đổi với 2959 bổ sung và 188 xóa
  1. 213 0
      .zcode/plans/plan-sess_a053a248-f947-42a7-912d-859597e5cd25.md
  2. 1 1
      ai-electron/frontend/src/workbench/api/artifact.ts
  3. 13 0
      ai-electron/frontend/src/workbench/api/chat.ts
  4. 556 59
      ai-electron/frontend/src/workbench/views/chat/index.vue
  5. BIN
      ai-server/logs/sys-info.2026-11-18.log.gz
  6. 22 0
      ai-server/src/main/java/com/zsjz/ai/common/storage/StorageLayout.java
  7. 23 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/config/AiProperties.java
  8. 20 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/controller/AiChatController.java
  9. 2 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AgentAssembler.java
  10. 188 58
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiChatFacade.java
  11. 376 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiContextSyncService.java
  12. 27 2
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiExpertResumeDriver.java
  13. 8 25
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiIntegrationDriver.java
  14. 8 1
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiRouteOrchestrator.java
  15. 21 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiRunRegistry.java
  16. 19 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiSseSupport.java
  17. 5 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiStreamEventBridge.java
  18. 159 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiStreamProgressPersister.java
  19. 45 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiStreamState.java
  20. 145 15
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiTurnFinisher.java
  21. 55 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/WorkbenchArtifactPromptMiddleware.java
  22. 31 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/core/run/AiStaleRunReaper.java
  23. 5 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/domain/AiMessage.java
  24. 34 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/domain/vo/AiRunningTurnVo.java
  25. 7 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/domain/vo/AiSessionVo.java
  26. 8 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/service/IAiMessageStepService.java
  27. 90 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/service/IAiSessionService.java
  28. 37 18
      ai-server/src/main/java/com/zsjz/ai/module/ai/service/impl/AiArtifactServiceImpl.java
  29. 10 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/service/impl/AiMessageStepServiceImpl.java
  30. 195 0
      ai-server/src/main/java/com/zsjz/ai/module/ai/service/impl/AiSessionServiceImpl.java
  31. 40 9
      ai-server/src/main/java/com/zsjz/ai/module/plat/service/CaseInfoService.java
  32. 18 0
      ai-server/src/test/java/com/zsjz/ai/module/ai/core/agent/AgentAssemblerBuiltinToolsTest.java
  33. 117 0
      ai-server/src/test/java/com/zsjz/ai/module/ai/core/agent/AiContextSyncServiceTest.java
  34. 52 0
      ai-server/src/test/java/com/zsjz/ai/module/ai/core/agent/WorkbenchArtifactPromptMiddlewareTest.java
  35. 116 0
      ai-server/src/test/java/com/zsjz/ai/module/ai/service/impl/AiArtifactServiceImplTest.java
  36. 33 0
      ai-server/src/test/java/com/zsjz/ai/module/plat/service/CaseInfoServiceUsageTest.java
  37. 260 0
      test-reports-20261119-continue/test-report.md

+ 213 - 0
.zcode/plans/plan-sess_a053a248-f947-42a7-912d-859597e5cd25.md

@@ -0,0 +1,213 @@
+# 方案:AI 对话「后台继续」+ 中断后「继续」可续接上下文 + 多会话并行
+
+## 一、Context(为什么改)
+
+**问题 1:切页/切会话/刷新会把生成打断。**
+- 前端:聊天页 `onBeforeUnmount` / `onDeactivated` 直接 `abort` SSE(`ai-electron/frontend/src/workbench/views/chat/index.vue:1483-1514`),工作台 `<router-view>` 没有 KeepAlive,离开路由组件即销毁。
+- 后端:把 SSE 断连当取消——`AiChatFacade.java:451-465`、`streamResume` 的 `:764-778`、`AiIntegrationDriver.java:200-214` 在 `onCompletion/onTimeout/onError` 里调用 `runRegistry.cancel(sessionId)`。
+- 另外当前会话 id 只是组件内 `ref`(`index.vue:1100`),刷新/重新进入即丢失。
+
+**问题 2:中断后发「继续」,模型不知道上一轮在说什么。**
+- 模型上下文不在 `ai_message`,而在 AgentScope 按 `(userId, sessionId)` 存 Redis 的 `AgentState.context`;框架是「一次 call 正常结束才整体保存」。流被取消时正常保存路径可能被绕过,被中断那轮的「用户问题 + 半截回答」没有进入上下文。
+- 多条取消/错误路径还会丢半截正文:`AiTurnFinisher.finishCancelled` 在专家直答时取不到 `handoffAnswer`、HITL 恢复段传空串(`AiTurnFinisher.java:212-216`);`persistAssistantFailure` 只存错误不存已生成内容(`AiSessionServiceImpl.java:780-792`);专家续跑取消不更新消息(`AiExpertResumeDriver.java:251-267`)。
+- 若中断后刷新过页面,`currentSessionId` 丢失,再发「继续」甚至会在新会话里创建消息。
+
+**目标**:页面离开、切会话、切案件、刷新都不影响生成;回来能看到仍在生成的内容并最终看到完整回答;中断后「继续」能基于上一轮问题和已输出内容续写;**不同会话可后台并行,同一会话保持串行**,并在会话列表展示「生成中」。
+
+## 二、总体方案
+
+1. **后端运行与 SSE 解耦**:断连只停止推送,不取消执行;只有显式「停止生成」和「结束任务」才取消。
+2. **助手消息占位 + 增量落库**:一轮开始就插入 `role=assistant, streaming=1` 的占位行;生成期间每约 1.5s 把「用户可见正文」和执行步骤落库;正常/中止/失败/待确认收尾都更新同一条消息。
+3. **前端会话恢复 + 轮询续看**:持久化并自动恢复上次会话;回到会话若该轮仍在生成,每 2s 拉取运行状态刷新进度,完成后切换到最终结果;SSE 传输异常也降级为轮询恢复。
+4. **上下文校准**:每轮开始前用 `ai_message` 历史校准 `AgentState.context`,补齐被中断的一轮;对「继续/接着」类消息附加隐藏续写提示。
+5. **多会话并行 + 列表角标**:不同会话各自独立执行;会话列表返回 `running` 标志,后台有任务在跑时显示角标并每 5s 刷新列表。
+6. **修复所有取消/错误路径**,保证半截正文一定落库。
+7. **不改表结构**:复用 `ai_message.streaming / status / update_time`。
+
+不加 KeepAlive:它只防组件卸载,解决不了刷新、硬断网、多窗口以及后端「断连即取消」的问题。
+
+## 三、后端改动
+
+### 1. 断连不再取消(核心)
+- `AiChatFacade.streamChat`、`streamResume`:删除 `onCompletion/onTimeout/onError` 里的 `runRegistry.cancel(...)`。
+- `AiIntegrationDriver.driveIntegration`:删除三处 `run.cancel()` 回调。
+- `/stop` 保留显式取消;`AiChatController.closeSession` 先调 `aiChatFacade.stop(sessionId)` 再结束会话。
+- 由进度持久化器每 15s 下发一次 SSE 注释帧(`: ping`)做心跳,防止长工具调用被代理断开。
+
+### 2. 助手占位与增量持久化
+`IAiSessionService` / `AiSessionServiceImpl` 新增(`AiSessionServiceImpl.java:756-833` 附近):
+- `persistAssistantStreaming(sessionId)`:插入占位消息(`streaming=1, status=0, content=""`),`touchSession` 计数一次。
+- `updateAssistantStreaming(messageId, content)`:只更新正文与 `update_time`,不重复计数。
+- `updateAssistantTerminal(...)`:按正常/失败/中止/待确认更新同一行,`streaming=0`,写 replyId、工具明细、Token、耗时、来源、errorMsg;不再计数。
+- `queryStreamingAssistant(sessionId)`:查最新 `streaming=1` 的助手消息。
+- `abortStaleStreaming(messageId, reason)`:把超时占位行置中止。
+
+`AiChatFacade.streamChat`:
+- 配额/安全校验通过、`prepareRun` 之前创建占位行,写入 `state.assistantMessageId`;`start` 事件带上 `messageId`,前端可立即归位临时消息 id。
+- 启动 `AiStreamProgressPersister`(新组件,单线程调度):每 `streamProgressPersistIntervalMs=1500` 把 `state.visibleAnswer` 写入占位行、upsert 执行步骤、按需刷新会话活跃时间;每 `streamHeartbeatIntervalMs=15000` 发心跳;收尾回调里关闭任务。
+- `prepareRun`/订阅同步异常时,把占位行置失败,避免永久 `streaming=1`。
+
+`AiStreamState`(`AiStreamState.java:27-28`)新增:
+- `Long assistantMessageId`
+- `StringBuilder visibleAnswer`:真正下发给用户的正文(含专家直答/整合段)。
+- `String baseAnswerContent`:HITL 恢复段的已有正文前缀。
+- `resetAnswer()`:同时清空 `answer` 与 `visibleAnswer`。
+
+`AiStreamEventBridge` / `AiRouteOrchestrator` / `AiIntegrationDriver`:
+- 每个实际下发的 `text_delta` 同时 append 到 `visibleAnswer`;`flushSafety`、`blockAnswer` 同步维护。
+- 专家调用的独立 `AiStreamState` 共享入口 state 的 `visibleAnswer`。
+- `answer_reset`、`beginHandoff`、整合轮/指定专家兜底重置正文时,统一调 `resetAnswer()`。
+
+`AiTurnFinisher`(`AiTurnFinisher.java:186-336`):
+- `finish/finishPending/finishCancelled/错误路径` 优先用 `resumeMessageId`,其次 `state.assistantMessageId`,更新占位行;没有占位行时才走原来的 insert,保证兼容。
+- `finishCancelled` 正文取 `handoffAnswer → state.answer → visibleAnswer`;恢复段分支传入实际 `state.visibleAnswer`,不再传 `""`。
+- 错误路径改为「更新占位行:部分正文 + errorMsg,status=1」,不再只存错误。
+- `AiExpertResumeDriver.doOnCancel` 补 `finishCancelled`(或 `appendAssistantTurn`),把消息置中止,不能停在待确认。
+- `AiIntegrationDriver` 两处错误分支补写/更新助手消息,避免用户消息悬空。
+
+`AiStaleRunReaper`(`ai-server/.../core/run/AiStaleRunReaper.java:103-117`):
+- 新增 `reapStreamingMessages`:`streaming='1' and update_time < 阈值` → `streaming='0'`, `status='3'`, `error_msg='服务重启或长时间无进展,本轮回答已中断'`。只写 SET、不刷新 `update_time`,与现有回收口径一致。
+
+`AiProperties.Chat` 新增配置:
+- `streamProgressPersistIntervalMs=1500`
+- `streamHeartbeatIntervalMs=15000`
+- `streamingStaleSeconds=60`(运行状态接口判断失联用)
+
+### 3. 运行状态查询接口
+`AiChatController` 新增:
+- `GET /ai/chat/session/{sessionId}/running`,权限 `ai:chat:query`,返回 `AiRunningTurnVo { running, message, steps }`。
+- 逻辑:查最新 `streaming=1` 助手消息;若本机 `runRegistry` 无活跃执行且 `update_time` 超过 `streamingStaleSeconds`,就地标记中止并返回 `running=false`;否则返回消息与步骤。
+- `IAiMessageStepService` 增加 `listByMessage(messageId)`(现有只有 `listBySession`)。
+
+### 4. 多会话并行与会话列表角标
+- **执行层天然并行**:`AiRunRegistry` 按 `sessionId` 隔离(`Map<Long, Set<Cancelable>>`),不同会话的 entry/expert/integration 段互不影响;`/stop` 只取消指定会话。AgentScope 状态按 `(userId, sessionId)` 隔离,不同二元组并行。
+- **同一会话串行**:`streamChat` 开始时检查同会话是否已有活跃执行或新鲜的 `streaming=1` 消息,有则拒绝重复执行;同一会话的「检查 + 创建占位 + 登记运行」用会话级锁串行。
+- **列表角标**:
+  - `AiSessionVo` 增加 `@TableField(exist=false) private Boolean running;`
+  - `AiSessionServiceImpl.queryMySessions` 在 `fillDisplayNames` 后调用新增的 `fillRunningFlags(records)`:收集本页 sessionId,一次批量查询 `ai_message` 中 `role='assistant' and streaming='1'` 的 `session_id`(必要时加 `update_time` 新鲜度过滤),回填 `running`。
+  - 该查询跨节点有效(读 DB),不依赖 `runRegistry` 所在实例;后台某个会话完成或变为中止后,下次列表刷新角标自动消失。
+
+### 5. 中断后的上下文校准(问题 2 的核心)
+新增 `AiContextSyncService.syncBeforeTurn(agent, userId, sessionId, currentUserMessageId)`,在 `streamChat` 的 `prepareRun` 之前调用(`regenerate` 跳过,因为它已由 `AiRegenerateContextRestorer` 回退;HITL resume 不调用):
+
+1. 读取 `delegate.getAgentState(userId, sessionId).contextMutable()`。
+2. **context 为空**(Redis 状态被清理/重启/换节点)→ 复用 `AiRegenerateContextRestorer.loadHistoryMessages` 的逻辑,把当前消息之前的 DB 历史重建为纯文本上下文(跳过空正文与 system)。
+3. **context 非空** → 只比对尾部:
+   - 尾部最后一条助手正文已与 DB 中当前消息之前的最后一条助手消息一致 → 已同步,no-op。
+   - 尾部是同一用户问题、缺少助手回答 → 追加 DB 助手半截正文,并加标记 `(本条回答被用户中断)`。
+   - 尾部是更早的助手回答 → 追加缺失的「用户问题 + 助手半截正文」。
+   - DB 有中止/失败但没有正文 → 追加一条中断说明占位,让模型知道上一轮未完成。
+4. `delegate.saveAgentState(uid, sid)`。
+
+补充:
+- 内容可能因安全脱敏与 DB 原话不一致,比对采用「包含/前缀」容错;宁可补一次,不要漏掉。
+- 被中断的助手正文只写入模型上下文,不修改 DB 展示内容。
+- 当前消息是「继续/接着/继续生成/continue/go on」且上一条助手 `status` 为 `3`(中止)或 `1`(失败)且有正文时,给下发模型的 userContent 追加隐藏提示:`(用户要求从中断处继续上一条回答,请勿重复已输出内容。)`;DB 仍保存用户原话,安全审核仍按原话执行。
+- 这样即使取消时框架没保存状态、Redis 状态被回收、进程重启,只要 DB 有历史,「继续」都能接上。
+
+### 6. 并发与幂等
+- `POST /message` 可选增加「会话生成中」校验,防止绕过前端直接插入新提问。
+- 同一会话的占位创建与运行登记串行;不同会话不加锁,保持并行。
+- 暂不增加「每用户最大并行会话数」上限(按你的选择);后续若出现模型限流或资源打满,可再加配置与排队。
+
+## 四、前端改动
+
+### 1. 恢复上次会话
+- `localStorage` key:`ai-chat:last-session:{caseId}`;选择/创建会话时写入,结束任务/新建任务时清理。
+- `onMounted` 改为 `await getSessions()` 后自动选中上次会话(`index.vue:3585-3591`);案件切换后按该案件的 key 恢复。
+- 会话列表里找不到(已结束/删除)则清理 key,不报错。
+
+### 2. 回到会话后续看生成进度
+- `chat.ts` 新增 `getRunningTurn(sessionId)`。
+- `toLocalMessage`(`index.vue:2073-2108`)把 `item.streaming === '1'` 映射为 `streaming: true`。
+- `handleSelectSession`(`index.vue:2553-2636`)加载完成后:
+  - 若存在 streaming 助手消息:设置 `streaming=true`、`currentAssistantKey=该消息 id`,启动 2s 轮询。
+  - 轮询更新:按 id 找本地消息(找不到则把最后一个 streaming 的临时消息归位);更新 `content`(用一个文本 part 承载)、`status`、`steps`、`sources`;保留已有工具/路由/专家卡片,避免闪烁。
+  - 轮询返回 `running=false` 或 `status!='0'/streaming!='1'`:停止轮询,重新拉取该会话 messages/tools/routeRuns/steps 重建最终视图,刷新会话列表与重新生成预检。
+  - 轮询连续失败 3 次或超过 30 分钟:停止并提示,可手动刷新。
+- `onBeforeUnmount` / `onDeactivated` / 切换会话 / 新建 / 结束 / 切案件都 `stopPolling()`(不调用 `/stop`)。
+
+### 3. 多会话并行与列表角标
+- `ChatSessionVO` 增加 `running?: boolean`。
+- 左侧会话项(`index.vue:11-35`)在标题旁增加「生成中」小角标:`item.running` 时显示小转圈/脉冲点 + `title="生成中"`;不影响点击切换。
+- `getSessions()` 写入列表后调用 `scheduleSessionRefresh()`:
+  - 存在 `running` 会话时,每 5s 刷新一次列表(页面不可见时跳过 tick);
+  - 没有 `running` 会话时停止定时器;
+  - `onBeforeUnmount` 清理定时器。
+- 切换会话时只停止当前轮询,不停止后台会话;点进 `running` 会话后走上面的轮询续看。这样 A、B、C 可以在后端并行,左侧角标显示哪些还在跑。
+
+### 4. SSE 异常兜底
+- `openStream` 增加 `onDone`;收到 `done/aborted/error/tool_confirm` 时置终态标记(`index.vue:1515-1538`)。
+- `onError` 或流结束但无终态:不立即把消息标失败,先启动轮询恢复;轮询确认没有运行且没有最终消息后再显示失败。
+- `start` 事件现在带 `messageId`:`handleStreamEvent` 收到 `start` 时立即把临时消息 id 与 `currentAssistantKey` 归位,避免断流后临时 id 与数据库 id 不一致导致重复气泡。
+- 停止按钮:调用 `/stop` 后保持「正在停止…」状态,等 `aborted` 事件或轮询看到 `status='3'` 再解锁输入;超时兜底本地置中止。避免刚停就发「继续」被后端「生成中」拒绝。
+
+### 5. 相关竞态修复
+- `handleSelectSession` 的 `Promise.all` 返回后校验 `currentSessionId` 是否仍等于本次 `session.id`,防止快速切会话时旧响应覆盖新会话(报告已指出该风险)。
+
+## 五、状态流转(验收口径)
+
+| 场景 | 期望 |
+|---|---|
+| 发送后切到其他工作台页面 | SSE 断开,但后端继续生成;回来自动恢复会话,轮询显示进度,最终完整 |
+| 刷新页面 | 会话自动恢复;已生成的正文从 DB 显示,仍在生成则继续轮询 |
+| A 生成中切到 B 再发消息 | A、B 后端并行;左侧两个会话都显示「生成中」角标;切到任一可续看 |
+| 切到另一个会话再切回 | 原会话后台继续;切回后可续看/看到完整结果 |
+| 切换案件再切回 | 原案件会话后台继续;切回后按 case 维度恢复 |
+| 点「停止生成」 | `/stop` 取消该会话;已输出半截落库,状态「已中止」,不影响其他并行会话 |
+| 停止后发「继续」 | 上下文补齐后,模型基于上一轮问题+半截回答续写 |
+| HITL 待确认时离开 | 暂停态保留;回来能看到确认卡片并恢复 |
+| 后端重启/进程被杀 | 占位行被 `AiStaleRunReaper` 置中止;不会再永久「生成中」 |
+| 结束任务 | 显式取消该会话运行后再结束 |
+
+## 六、改动文件清单
+
+**后端**
+- `ai-server/.../module/ai/core/agent/AiChatFacade.java`
+- `.../core/agent/AiTurnFinisher.java`
+- `.../core/agent/AiStreamState.java`
+- `.../core/agent/AiStreamEventBridge.java`
+- `.../core/agent/AiRouteOrchestrator.java`
+- `.../core/agent/AiIntegrationDriver.java`
+- `.../core/agent/AiExpertResumeDriver.java`
+- `.../core/agent/AiContextSyncService.java`(新增)
+- `.../core/agent/AiStreamProgressPersister.java`(新增)
+- `.../core/run/AiStaleRunReaper.java`
+- `.../service/IAiSessionService.java` + `impl/AiSessionServiceImpl.java`(占位/终态更新、running 回填)
+- `.../service/IAiMessageStepService.java` + `impl/AiMessageStepServiceImpl.java`
+- `.../controller/AiChatController.java`
+- `.../domain/vo/AiSessionVo.java`(`running` 瞬态字段)
+- `.../domain/vo/AiRunningTurnVo.java`(新增)
+- `.../config/AiProperties.java`
+
+**前端**
+- `ai-electron/frontend/src/workbench/views/chat/index.vue`(会话恢复、轮询、角标、停止/异常兜底、竞态校验)
+- `ai-electron/frontend/src/workbench/api/chat.ts`(`ChatSessionVO.running`、`getRunningTurn`)
+- `ai-electron/frontend/src/workbench/api/chatSse.ts`(`onDone`/错误语义配合,改动很小)
+
+## 七、验证
+
+**构建**
+- 后端:`mvn -pl ai-server -am -DskipTests compile`;关键新增类补单测(上下文尾部匹配纯函数、占位消息状态流转)。
+- 前端:`cd ai-electron/frontend && pnpm type:check && pnpm lint:eslint && pnpm build`。
+
+**手工 E2E**
+1. 发一个长回答,切到「专家配置」页面,等待 30s 再回对话页:回答应已生成或仍在生成,进度可见。
+2. 生成中直接刷新页面:会话自动恢复,正文不丢,继续轮询到完成。
+3. 生成中点「停止生成」,再输入「继续」:模型应能接着半截回答写,且不重复已输出内容。
+4. 在专家直答阶段停止、在 HITL 恢复阶段停止:DB 中应有半截正文,状态为已中止,「继续」可用。
+5. 会话 A 生成中切到会话 B 发消息:两个会话同时后台生成,左侧都显示「生成中」;A 完成后角标消失;切回 A 能看到完整结果。
+6. 生成中重启 ai-server:稍后占位消息被回收为「已中止」,页面不再永久转圈。
+7. 结束任务:运行被取消,消息落为已中止。
+
+## 八、风险与边界
+
+- `AiRunRegistry` 是单实例内存态:多副本下跨节点 `/stop` 无法取消另一节点的运行;网关已按用户粘性路由,现有部署可接受。列表角标和轮询走数据库,跨节点不受影响。若后续要严格跨节点停止,再把取消信号改到 Redis。
+- 轮询是 2s 级刷新,不是逐字流式;如果要求回到会话后仍逐字输出,二期再做「运行与连接解耦 + 事件缓冲 + `/attach` SSE 重连回放」。
+- 多会话并行没有全局并发上限(按你的选择暂不加);多个会话同时跑会同时消耗模型配额、线程和 DB 写入。若出现模型供应商限流或资源打满,再加「每用户最大并行会话数」配置与排队。
+- 同一案件多个会话同时调用写类业务工具时,并发安全取决于工具/DuckDB 自身实现,会话调度层不做额外串行。
+- 增量落库会增加写库频率(每个活跃轮约 1.5s 一次),可通过 `streamProgressPersistIntervalMs` 调整;正文列已是 `text`,不需要改表。
+- 可选增强(二期):
+  1. 被打断回答下的「继续生成」按钮:新增 SSE 接口,基于半截回答追加更新同一条消息,不产生新用户消息。
+  2. 前端多路实时流(全局 chat store + 多 SSE)。
+  3. 取消轮次的 Token/配额统计补齐。

+ 1 - 1
ai-electron/frontend/src/workbench/api/artifact.ts

@@ -53,7 +53,7 @@ export interface ArtifactContentVO {
 
 const artifactBase = (sessionId: Id) => `/ai/chat/session/${encodeURIComponent(String(sessionId))}/artifacts`;
 
-/** 产物列表(直接扫描会话工作区磁盘) */
+/** 产物列表(直接扫描会话 outputs/ 与 plans/ 目录) */
 export function listArtifacts(sessionId: Id): Promise<ArtifactListVO> {
   return aiGet<ArtifactListVO>(artifactBase(sessionId));
 }

+ 13 - 0
ai-electron/frontend/src/workbench/api/chat.ts

@@ -28,6 +28,8 @@ export interface ChatSessionVO {
   planMode?: string;
   /** 权限模式(confirm 变更前确认 / full 完全访问;null 表示跟随全局配置) */
   permissionMode?: ChatPermissionMode | null;
+  /** 是否正在生成回答(后端按 ai_message.streaming 回填;多会话并行角标) */
+  running?: boolean;
   createTime?: string;
 }
 
@@ -263,6 +265,17 @@ export function listChatSteps(sessionId: Id): Promise<ChatMessageStepVO[]> {
   return aiGet<ChatMessageStepVO[]>(`/ai/chat/session/${sessionId}/steps`);
 }
 
+/** 会话当前运行中的一轮(切页 / 刷新后轮询续看) */
+export interface ChatRunningTurnVO {
+  running: boolean;
+  message?: ChatMessageVO | null;
+  steps?: ChatMessageStepVO[] | null;
+}
+
+export function getChatRunningTurn(sessionId: Id): Promise<ChatRunningTurnVO> {
+  return aiGet<ChatRunningTurnVO>(`/ai/chat/session/${sessionId}/running`);
+}
+
 export function sendChatMessage(
   sessionId: Id,
   data: { content?: string; attachmentIds?: Id[] },

+ 556 - 59
ai-electron/frontend/src/workbench/views/chat/index.vue

@@ -12,13 +12,16 @@
           v-for="item in sessions"
           :key="String(item.id)"
           class="session-item"
-          :class="{ 'is-active': item.id === currentSessionId }"
+          :class="{ 'is-active': String(item.id) === String(currentSessionId) }"
           @click="handleSelectSession(item)"
         >
           <div class="session-item__main">
             <div class="session-item__title">
               <Icon v-if="item.topFlag === '1'" class="session-item__pin" icon="i-mdi:pin" />
               <span class="session-item__text">{{ item.sessionTitle || '未命名任务' }}</span>
+              <span v-if="item.running" class="session-item__running" title="生成中">
+                <Icon icon="i-mdi:loading" />
+              </span>
             </div>
             <div class="session-item__time">{{ item.lastActiveTime || item.createTime }}</div>
           </div>
@@ -328,7 +331,7 @@
                   重新发送
                 </a-button>
               </div>
-              <div v-else-if="!msg.streaming && (msg.durationMs !== undefined || msg.status === '3')" class="msg-meta">
+              <div v-else-if="!msg.streaming && (hasDuration(msg) || msg.status === '3')" class="msg-meta">
                 <!-- 复制图标:始终显示(左对齐) -->
                 <Icon
                   class="msg-meta__icon"
@@ -356,14 +359,19 @@
                 <!-- 中止标记:本地停止或后端 aborted 时给出明确反馈 -->
                 <span v-if="msg.status === '3'" class="msg-meta__aborted">已中止</span>
                 <!-- 文字区域:悬停回复内容才显示;整体前带一个分隔竖线 -->
-                <span class="msg-meta__info">
-                  <span v-if="msg.durationMs !== undefined">耗时 {{ msg.durationMs }} ms</span>
+                <span v-if="hasDuration(msg) || msg.toolCallCount || msg.totalTokens" class="msg-meta__info">
+                  <span v-if="hasDuration(msg)">耗时 {{ msg.durationMs }} ms</span>
                   <span v-if="msg.toolCallCount">工具调用 {{ msg.toolCallCount }} 次</span>
                   <span v-if="msg.totalTokens">消耗 {{ msg.totalTokens }} tokens</span>
                 </span>
                 <!-- AI 生成声明:始终显示,右对齐 -->
                 <span class="msg-meta__ai">由 AI 生成</span>
               </div>
+              <!-- 中止原因:后端重启 / 长时间无进展等非用户主动停止的场景,DB 已写 errorMsg -->
+              <div v-if="msg.status === '3' && msg.errorMsg" class="msg-error msg-error--aborted" :title="msg.errorMsg">
+                <Icon icon="i-mdi:information-outline" />
+                <span>{{ msg.errorMsg }}</span>
+              </div>
             </div>
           </div>
 
@@ -576,9 +584,21 @@
                 </button>
               </a-tooltip>
               <span class="composer-tip">Enter 发送,Shift + Enter 换行</span>
-              <a-tooltip v-if="streaming" title="停止生成" placement="top" overlay-class-name="composer-tooltip">
-                <a-button v-auth="'ai:chat:execute'" danger class="composer-send-btn" aria-label="停止生成" @click="handleStop">
-                  <Icon icon="i-mdi:stop" />
+              <a-tooltip
+                v-if="streaming"
+                :title="stopping ? '正在停止…' : '停止生成'"
+                placement="top"
+                overlay-class-name="composer-tooltip"
+              >
+                <a-button
+                  v-auth="'ai:chat:execute'"
+                  danger
+                  class="composer-send-btn"
+                  :loading="stopping"
+                  aria-label="停止生成"
+                  @click="handleStop"
+                >
+                  <Icon v-if="!stopping" icon="i-mdi:stop" />
                 </a-button>
               </a-tooltip>
               <a-tooltip v-else title="发送" placement="top" overlay-class-name="composer-tooltip">
@@ -599,7 +619,7 @@
       </div>
     </section>
 
-    <!-- 右侧产物面板:直接扫描本会话工作区磁盘,按会话隔离 -->
+    <!-- 右侧产物面板:直接扫描本会话 outputs/ 与 plans/ 目录,按会话隔离 -->
     <aside v-if="currentSessionId && artifactSupported && artifactPanelOpen" class="chat-artifact-panel">
       <div class="chat-artifact-panel__header">
         <div class="chat-artifact-panel__heading">
@@ -864,6 +884,7 @@
     createChatSession,
     deleteChatAttachment,
     deleteChatMessage,
+    getChatRunningTurn,
     registerChatAttachment,
     listChatMessage,
     listChatPending,
@@ -887,6 +908,7 @@
     ChatAttachmentVO,
     ChatMessageStepVO,
     ChatMessageVO,
+    ChatRunningTurnVO,
     ChatPendingToolCall,
     ChatPermissionMode,
     ChatRegenerateCheckVO,
@@ -1102,6 +1124,30 @@
   const inputText = ref('');
   const streaming = ref(false);
   const sending = ref(false);
+  /** 已发出停止请求,等待后端 aborted / 轮询看到终态 */
+  const stopping = ref(false);
+  /** SSE 是否已收到本轮终态事件(done / aborted / error / tool_confirm) */
+  let streamTerminal = false;
+  /** 流式段序号:每次 openStream 递增,用于识别「停止兜底」是否已跨到新一轮 */
+  let streamRound = 0;
+  /** 运行中轮询续看(切页 / 刷新 / SSE 异常恢复) */
+  let runningPollTimer: number | undefined;
+  let runningPollStartedAt = 0;
+  let runningPollMisses = 0;
+  let runningPollFailures = 0;
+  /** 当前轮询任务与会话:网络恢复 / 页面可见 / 窗口聚焦时立即唤醒重试 */
+  let runningPollTick: (() => void) | undefined;
+  let runningPollSession: string | number | undefined;
+  /** 正在执行的轮询代次(0 表示空闲),避免唤醒与在途请求叠加 */
+  let runningPollInFlight = 0;
+  /** 轮询代次:停止 / 重启后旧请求的结果直接丢弃 */
+  let runningPollGeneration = 0;
+  /** 「连接中断」提示只弹一次 */
+  let runningPollWarningShown = false;
+  /** 会话列表刷新定时器:存在后台生成中的会话时每 5s 刷新一次角标 */
+  let sessionListTimer: number | undefined;
+  /** 上次打开的会话(localStorage,按案件隔离;刷新后自动恢复) */
+  const LAST_SESSION_KEY_PREFIX = 'ai-chat:last-session:';
   /** 案件上下文:会话 / 资源 / 附件均按当前案件隔离 */
   const userStore = useUserStore();
   const { hasPermission } = usePermission();
@@ -1192,7 +1238,7 @@
   /** 产物面板只支持智能工作台会话(source=workbench,按会话隔离工作区) */
   const artifactSupported = computed(() => currentSession.value?.source === 'workbench');
 
-  // ==================== 产物面板(直接扫描会话工作区磁盘) ====================
+  // ==================== 产物面板(直接扫描会话 outputs/ 与 plans/ 目录) ====================
 
   /** 面板开关(持久化;默认收起) */
   const artifactPanelOpen = ref(localStorage.getItem('chat.artifactPanelOpen') === '1');
@@ -1478,18 +1524,26 @@
 
   onActivated(() => {
     syncWorkbenchHeight();
+    // keep-alive 场景:回到页面时若仍有生成中的消息,恢复轮询续看
+    const running = messages.value.find((item) => item.role === 'assistant' && item.streaming);
+    if (!streaming.value && running && currentSessionId.value) {
+      streaming.value = true;
+      currentAssistantKey.value = running.id;
+      startRunningPoll(currentSessionId.value);
+    }
   });
 
-  /** 离开聊天页(keep-alive 失活):关闭 SSE,让后端按「运行中→中止 / 已暂停→保留待确认」收尾,
-   *  避免残留运行与回来后的确认/恢复冲突(连接中断)。 */
+  /**
+   * 离开聊天页:只断开前端连接,**不取消**后端执行。
+   * 用户回来时按会话恢复 + 轮询续看;只有显式「停止生成」/「结束任务」才取消。
+   */
   onDeactivated(() => {
-    closeStream();
-    streaming.value = false;
+    finishStream();
   });
 
   onBeforeUnmount(() => {
-    closeStream();
-    streaming.value = false;
+    finishStream();
+    stopSessionListRefresh();
     workbenchTimers.forEach((timer) => window.clearTimeout(timer));
     workbenchTimers = [];
     if (artifactRefreshTimer) {
@@ -1517,28 +1571,37 @@
       return;
     }
     closeStream();
-    streamHandle = openChatStream(streamUrl.value, {
-      onEvent: (event) => handleStreamEvent(event as ChatStreamEvent),
-      onError: () => {
-        if (!streaming.value) {
+    const url = streamUrl.value;
+    streamRound += 1;
+    streamTerminal = false;
+    streamHandle = openChatStream(url, {
+      onEvent: (event) => {
+        // 旧流的迟到事件不能落到新会话 / 新一轮上
+        if (streamUrl.value !== url) {
           return;
         }
-        const msg = currentAssistant();
-        if (msg) {
-          msg.streaming = false;
-          clearPhase(msg);
-          msg.status = '1';
-          msg.errorMsg = '连接中断,请重试';
+        handleStreamEvent(event as ChatStreamEvent);
+      },
+      onDone: () => {
+        if (streamUrl.value !== url || !streaming.value || streamTerminal) {
+          return;
         }
-        antMessage.error('连接中断,请重试');
-        finishStream();
-        regenerateBackup = null;
+        // 流结束但没有 done/aborted/error/tool_confirm:可能是超时、代理断开或服务端直接收尾。
+        // 后端已与连接解耦,此时不判失败,转轮询确认运行状态。
+        recoverByPolling('连接中断,正在恢复…');
+      },
+      onError: () => {
+        if (streamUrl.value !== url || !streaming.value) {
+          return;
+        }
+        // 同理:传输错误不立即判失败,交给轮询确认后端是否仍在生成
+        recoverByPolling('连接中断,正在恢复…');
       },
     });
   };
 
-  /** 当前正在流式输出的助手消息 */
-  const currentAssistant = () => messages.value.find((item) => item.id === currentAssistantKey.value);
+  /** 当前正在流式输出的助手消息(雪花 ID 可能以字符串 / 数字混合到达,统一按字符串比较) */
+  const currentAssistant = () => messages.value.find((item) => String(item.id) === String(currentAssistantKey.value));
 
   /** 工具入参片段 */
   const findToolPart = (msg: LocalMessage, toolCallId?: string) =>
@@ -1982,11 +2045,16 @@
     }
   };
 
-  /** 关闭当前流并复位流式状态 */
+  /** 关闭当前流 / 轮询并复位流式状态 */
   const finishStream = () => {
     streaming.value = false;
+    stopping.value = false;
     currentAssistantKey.value = undefined;
     closeStream();
+    stopRunningPoll();
+    streamTerminal = false;
+    // 清掉本轮流地址:迟到的 onDone / onError 据此识别「旧流」而不再干扰新会话
+    streamUrl.value = undefined;
   };
 
   /** 清掉某条消息的进度状态(收尾 / 失败 / 中止 / 待确认时调用) */
@@ -2095,7 +2163,8 @@
       role: item.role,
       content: item.content ?? '',
       parts,
-      streaming: false,
+      // streaming='1':后端仍在生成(切页 / 刷新后据此启动轮询续看)
+      streaming: item.streaming === '1',
       status: item.status ?? '0',
       createTime: item.createTime,
       errorMsg: item.errorMsg,
@@ -2446,15 +2515,18 @@
   const loadSessionResourceSet = async (session: ChatSessionVO) => {
     // 载入已有会话即以其服务端真值为准,本地兜底的未落库选择作废
     clearPendingExpertCache();
-    pinnedExpert.value = session.pinnedExpertId
-      ? { id: session.pinnedExpertId, name: session.pinnedExpertName || String(session.pinnedExpertId) }
-      : undefined;
     try {
       const res = await listChatResources(session.id);
+      // 竞态保护:快速切会话时,旧请求不能覆盖新会话的资源集
+      if (String(currentSessionId.value) !== String(session.id)) return;
       sessionResources.value = res ?? [];
     } catch {
+      if (String(currentSessionId.value) !== String(session.id)) return;
       sessionResources.value = [];
     }
+    pinnedExpert.value = session.pinnedExpertId
+      ? { id: session.pinnedExpertId, name: session.pinnedExpertName || String(session.pinnedExpertId) }
+      : undefined;
   };
 
   /** 加载我的会话列表(仅进行中的会话;后端同时按当前案件强制过滤) */
@@ -2475,6 +2547,323 @@
       caseId: currentCaseId.value,
     });
     sessions.value = res?.rows ?? [];
+    // 多会话并行:存在后台生成中的任务时,定时刷新列表角标
+    scheduleSessionListRefresh();
+  };
+
+  /** 上次打开的会话 key(按当前案件隔离) */
+  const lastSessionKey = () => (currentCaseId.value ? `${LAST_SESSION_KEY_PREFIX}${currentCaseId.value}` : '');
+
+  /** 记住 / 清除上次打开的会话 */
+  const rememberLastSession = (sessionId?: string | number) => {
+    const key = lastSessionKey();
+    if (!key) {
+      return;
+    }
+    try {
+      if (sessionId === undefined || sessionId === null || sessionId === '') {
+        localStorage.removeItem(key);
+      } else {
+        localStorage.setItem(key, String(sessionId));
+      }
+    } catch {
+      // 本地存储不可用不影响聊天
+    }
+  };
+
+  /** 刷新 / 重进页面后恢复上次打开的会话(找不到则清理 key) */
+  const restoreLastSession = async () => {
+    const key = lastSessionKey();
+    if (!key) {
+      return;
+    }
+    let stored: string | null = null;
+    try {
+      stored = localStorage.getItem(key);
+    } catch {
+      return;
+    }
+    if (!stored) {
+      return;
+    }
+    const session = sessions.value.find((item) => String(item.id) === stored);
+    if (!session) {
+      try {
+        localStorage.removeItem(key);
+      } catch {
+        // ignore
+      }
+      return;
+    }
+    await handleSelectSession(session);
+  };
+
+  /** 停止会话列表后台刷新 */
+  const stopSessionListRefresh = () => {
+    if (sessionListTimer !== undefined) {
+      window.clearInterval(sessionListTimer);
+      sessionListTimer = undefined;
+    }
+  };
+
+  /** 存在后台生成中的会话时,每 5s 刷新列表角标 */
+  const scheduleSessionListRefresh = () => {
+    const hasRunning = sessions.value.some((item) => item.running);
+    if (!hasRunning) {
+      stopSessionListRefresh();
+      return;
+    }
+    if (sessionListTimer !== undefined) {
+      return;
+    }
+    sessionListTimer = window.setInterval(() => {
+      if (document.visibilityState !== 'visible') {
+        return;
+      }
+      void getSessions().catch(() => undefined);
+    }, 5000);
+  };
+
+  /** 停止运行中轮询 */
+  const stopRunningPoll = () => {
+    // 递增代次:在途请求返回后直接丢弃,不会再把旧会话的进度写回页面
+    runningPollGeneration += 1;
+    if (runningPollTimer !== undefined) {
+      window.clearTimeout(runningPollTimer);
+      runningPollTimer = undefined;
+    }
+    runningPollTick = undefined;
+    runningPollSession = undefined;
+    runningPollInFlight = 0;
+    runningPollMisses = 0;
+    runningPollFailures = 0;
+    runningPollWarningShown = false;
+  };
+
+  /**
+   * 立即唤醒一次运行中轮询(网络恢复 / 页面重新可见 / 窗口聚焦时调用)。
+   *
+   * <p>不依赖固定退避等待:后端恢复后可以马上重试 `/running`,避免页面长期停在旧生成态。</p>
+   */
+  const wakeRunningPoll = () => {
+    if (!runningPollTick || runningPollInFlight !== 0 || runningPollSession === undefined) {
+      return;
+    }
+    if (String(currentSessionId.value) !== String(runningPollSession)) {
+      return;
+    }
+    if (runningPollTimer !== undefined) {
+      window.clearTimeout(runningPollTimer);
+      runningPollTimer = undefined;
+    }
+    runningPollTick();
+  };
+
+  /** 用运行状态快照更新本地消息(保留已有工具 / 路由 / 专家卡片) */
+  const applyRunningSnapshot = (snapshot: ChatRunningTurnVO) => {
+    const incoming = snapshot.message;
+    if (!incoming) {
+      return;
+    }
+    let target = messages.value.find((item) => String(item.id) === String(incoming.id));
+    if (!target) {
+      // 临时消息归位:SSE 中断时本地气泡还挂着 pending-xxx
+      const temp = messages.value.find(
+        (item) => item.role === 'assistant' && item.streaming && String(item.id).startsWith('pending-'),
+      );
+      if (temp) {
+        target = temp;
+        target.id = incoming.id;
+      }
+    }
+    if (!target) {
+      target = toLocalMessage(incoming, []);
+      messages.value.push(target);
+    }
+    target.role = incoming.role;
+    target.content = incoming.content ?? '';
+    target.status = incoming.status ?? target.status;
+    target.errorMsg = incoming.errorMsg;
+    target.durationMs = incoming.durationMs;
+    target.toolCallCount = incoming.toolCallCount;
+    target.totalTokens = incoming.totalTokens;
+    const sources = parseSources(incoming.sources);
+    if (sources) {
+      target.sources = sources;
+    }
+    target.streaming = incoming.streaming === '1' && (incoming.status ?? '0') === '0';
+    if (!stopping.value) {
+      // 轮询快照不携带 phase 文案:清掉 SSE 中断前的旧进度,避免显示过期状态
+      target.phaseText = undefined;
+    }
+    // 轮询期间正文整体刷新:去掉旧文本片段后按最新内容重建
+    // (运行结束后会重新拉取 REST 权威数据,工具 / 路由 / 专家卡片顺序会恢复精确)
+    target.parts = target.parts.filter((part) => part.kind !== 'text');
+    if (target.content) {
+      target.parts.push({ kind: 'text', text: target.content });
+    }
+    if (snapshot.steps?.length) {
+      target.steps = buildStepsFromVo(snapshot.steps);
+      target.processOverflow = false;
+      autoExpandProcess(target);
+    }
+    currentAssistantKey.value = target.id;
+    streaming.value = true;
+    scrollToBottomSoon();
+  };
+
+  /**
+   * 启动运行中轮询:每 2s 拉一次进度,结束后重新加载会话。
+   *
+   * <p>后端不可用时不再 3 次失败即永久停止,而是进入退避重试;
+   * 网络恢复 / 页面重新可见 / 窗口聚焦会立即唤醒一次,后端恢复后页面可自动回连。</p>
+   */
+  const startRunningPoll = (sessionId: string | number) => {
+    stopRunningPoll();
+    const generation = ++runningPollGeneration;
+    runningPollStartedAt = Date.now();
+    runningPollSession = sessionId;
+    const tick = async () => {
+      if (generation !== runningPollGeneration) {
+        return;
+      }
+      if (String(currentSessionId.value) !== String(sessionId)) {
+        stopRunningPoll();
+        return;
+      }
+      if (Date.now() - runningPollStartedAt > 30 * 60 * 1000) {
+        stopRunningPoll();
+        antMessage.warning('生成时间较长,请稍后刷新查看结果');
+        return;
+      }
+      runningPollInFlight = generation;
+      try {
+        const snapshot = await getChatRunningTurn(sessionId);
+        if (generation !== runningPollGeneration) {
+          return;
+        }
+        runningPollFailures = 0;
+        runningPollWarningShown = false;
+        if (String(currentSessionId.value) !== String(sessionId)) {
+          stopRunningPoll();
+          return;
+        }
+        const active =
+          Boolean(snapshot?.running) &&
+          snapshot?.message?.streaming === '1' &&
+          (snapshot.message.status ?? '0') === '0';
+        if (active) {
+          runningPollMisses = 0;
+          applyRunningSnapshot(snapshot);
+          if (generation !== runningPollGeneration) {
+            return;
+          }
+          runningPollTimer = window.setTimeout(tick, 2000);
+          return;
+        }
+        // 极小概率的启动窗口:已登记运行但占位行还没落库
+        if (snapshot?.running && !snapshot.message && runningPollMisses < 3) {
+          runningPollMisses += 1;
+          runningPollTimer = window.setTimeout(tick, 1200);
+          return;
+        }
+        // 运行结束 / 已暂停:按权威数据重建当前会话(完成时也会显示确认卡片)
+        stopRunningPoll();
+        let session = sessions.value.find((item) => String(item.id) === String(sessionId));
+        if (!session) {
+          // 断网期间列表可能未刷新成功:先补一次列表再定位,避免把仍在的会话误判为已结束
+          await getSessions().catch(() => undefined);
+          session = sessions.value.find((item) => String(item.id) === String(sessionId));
+        }
+        if (session) {
+          await handleSelectSession(session, true);
+        } else {
+          // 会话已不在进行中列表(被结束 / 删除):本地收尾,避免气泡停在「生成中」
+          const stale =
+            currentAssistant() ?? messages.value.find((item) => item.role === 'assistant' && item.streaming);
+          if (stale) {
+            stale.streaming = false;
+            stale.status = '3';
+            stale.errorMsg = stale.errorMsg || '本轮回答已结束,请刷新查看最终结果';
+            clearPhase(stale);
+            autoCollapseProcess(stale);
+          }
+          finishStream();
+        }
+      } catch {
+        if (generation !== runningPollGeneration) {
+          return;
+        }
+        runningPollFailures += 1;
+        if (!runningPollWarningShown && runningPollFailures >= 3) {
+          runningPollWarningShown = true;
+          antMessage.warning('连接中断,正在等待服务恢复…');
+        }
+        // 保持可见的「重试中」状态,避免页面看起来仍正常生成
+        const pending =
+          currentAssistant() ?? messages.value.find((item) => item.role === 'assistant' && item.streaming);
+        if (pending && !stopping.value && runningPollFailures >= 2) {
+          pending.phaseText = '连接中断,正在重试…';
+        }
+        // 3s → 6s → 9s … 最长 15s;网络恢复 / 可见性变化会立即唤醒
+        const delay = runningPollFailures <= 3 ? 3000 : Math.min(15000, 3000 * (runningPollFailures - 2));
+        if (generation !== runningPollGeneration) {
+          return;
+        }
+        runningPollTimer = window.setTimeout(tick, delay);
+      } finally {
+        // 只清理本次代次,避免旧请求把新轮询的 in-flight 标记清掉
+        if (runningPollInFlight === generation) {
+          runningPollInFlight = 0;
+        }
+      }
+    };
+    runningPollTick = () => {
+      void tick();
+    };
+    runningPollTick();
+  };
+
+  /** 网络恢复 / 页面重新可见 / 窗口聚焦:立即唤醒轮询,后端恢复后可自动回连 */
+  const handlePollWake = () => wakeRunningPoll();
+  const handlePollVisibility = () => {
+    if (document.visibilityState === 'visible') {
+      wakeRunningPoll();
+    }
+  };
+  onMounted(() => {
+    window.addEventListener('online', handlePollWake);
+    window.addEventListener('focus', handlePollWake);
+    document.addEventListener('visibilitychange', handlePollVisibility);
+  });
+  onBeforeUnmount(() => {
+    window.removeEventListener('online', handlePollWake);
+    window.removeEventListener('focus', handlePollWake);
+    document.removeEventListener('visibilitychange', handlePollVisibility);
+  });
+
+  /** SSE 异常 / 无终态结束:转为轮询恢复,不立即判失败 */
+  const recoverByPolling = (tip?: string) => {
+    const sessionId = currentSessionId.value;
+    if (!sessionId) {
+      finishStream();
+      return;
+    }
+    if (tip) {
+      antMessage.warning(tip);
+    }
+    const msg = currentAssistant() ?? messages.value.find((item) => item.role === 'assistant' && item.streaming);
+    if (msg) {
+      msg.streaming = true;
+      clearPhase(msg);
+    }
+    // 权威数据由轮询后的会话重载接管,旧回答回滚快照不再使用
+    regenerateBackup = null;
+    streaming.value = true;
+    // 关闭旧连接并清掉流地址:避免迟到的 onDone / onError 再次触发恢复
+    closeStream();
+    streamUrl.value = undefined;
+    startRunningPoll(sessionId);
   };
 
   /** 新建会话(清空当前会话上下文与资源选择,发送时再真正落库) */
@@ -2485,6 +2874,8 @@
     }
     finishStream();
     currentSessionId.value = undefined;
+    // 新建任务是显式离开当前会话:不再自动恢复旧会话
+    rememberLastSession(undefined);
     messages.value = [];
     expandedToolKeys.value = [];
     artifacts.value = [];
@@ -2550,13 +2941,20 @@
     }
   };
 
-  /** 切换会话 */
-  const handleSelectSession = async (session: ChatSessionVO) => {
-    if (session.id === currentSessionId.value) {
+  /**
+   * 切换 / 重新加载会话。
+   *
+   * @param session 目标会话
+   * @param force   为 true 时即使已是当前会话也重新拉取(轮询结束后刷新权威数据)
+   */
+  const handleSelectSession = async (session: ChatSessionVO, force = false) => {
+    if (!force && String(session.id) === String(currentSessionId.value)) {
       return;
     }
     finishStream();
     currentSessionId.value = session.id;
+    // 刷新 / 重进页面后自动恢复该会话
+    rememberLastSession(session.id);
     planModeEnabled.value = session.planMode === '1';
     permissionMode.value = session.permissionMode === 'full' ? 'full' : 'confirm';
     // 已有会话以服务端值为准;未显式落库(null)时展示「变更前确认」,实际跟随全局配置
@@ -2571,6 +2969,9 @@
     expandedProcessKeys.value = [];
     // 资源选择(REQ-AI-32):切会话时载入该会话的服务端资源集与指定专家
     await loadSessionResourceSet(session);
+    if (String(currentSessionId.value) !== String(session.id)) {
+      return;
+    }
     const [messageRes, toolRes, routeRes, stepRes] = await Promise.all([
       listChatMessage(session.id),
       listChatToolCall(session.id),
@@ -2578,6 +2979,10 @@
       // 执行步骤(精确回放):失败降级为空数组,旧消息走 legacy 卡片渲染
       listChatSteps(session.id).catch(() => [] as ChatMessageStepVO[]),
     ]);
+    // 竞态保护:快速连续切换会话时,旧请求的响应不能覆盖新会话
+    if (String(currentSessionId.value) !== String(session.id)) {
+      return;
+    }
     const toolsByMessage = new Map<string, ToolCallLogVO[]>();
     (toolRes ?? []).forEach((tool) => {
       const key = String(tool.messageId);
@@ -2610,6 +3015,9 @@
     });
     // 恢复未决的工具确认卡片(Redis 暂存失效时标记为已过期)
     const pendingRes = await listChatPending(session.id);
+    if (String(currentSessionId.value) !== String(session.id)) {
+      return;
+    }
     (pendingRes ?? []).forEach((pending) => {
       const target = messages.value.find((item) => String(item.id) === String(pending.messageId));
       if (!target) {
@@ -2622,6 +3030,13 @@
         confirmState: pending.expired ? 'expired' : 'pending',
       });
     });
+    // 后台仍在生成的会话:进入后按 2s 轮询续看进度,完成后重新加载
+    const runningMessage = messages.value.find((item) => item.role === 'assistant' && item.streaming);
+    if (runningMessage) {
+      streaming.value = true;
+      currentAssistantKey.value = runningMessage.id;
+      startRunningPoll(session.id);
+    }
     // 最后一轮的重新生成可用性由后端预检决定(写操作轮次置灰)
     void refreshRegenerateCheck();
     scrollToBottomSoon(true);
@@ -2633,6 +3048,8 @@
     if (artifactPanelOpen.value && artifactSupported.value) {
       void loadArtifacts();
     }
+    // 刷新列表:保证切走后其他会话的「生成中」角标及时出现
+    void getSessions().catch(() => undefined);
   };
 
   /** 会话「更多操作」:置顶 / 重命名 / 结束任务 */
@@ -2694,9 +3111,10 @@
     }
     await closeChatSession(session.id);
     antMessage.success('任务已结束,记录保留在任务管理中');
-    if (session.id === currentSessionId.value) {
+    if (String(session.id) === String(currentSessionId.value)) {
       finishStream();
       currentSessionId.value = undefined;
+      rememberLastSession(undefined);
       messages.value = [];
       // 权限档位不跨会话继承:结束当前任务后回到最安全的「变更前确认」,
       // 否则输入框仍显示「完全访问」而新会话实际按确认模式执行(实测缺陷 BUG-05)
@@ -2707,6 +3125,10 @@
   };
 
   /** 消息时间显示:今天只显示时分,其余日期补上「月-日」 */
+  /** 是否有可展示的耗时(后端 Long 可能以字符串到达;null / 空串都不展示) */
+  const hasDuration = (msg: LocalMessage) =>
+    msg.durationMs !== undefined && msg.durationMs !== null && String(msg.durationMs).trim() !== '';
+
   const formatMessageTime = (createTime?: string) => {
     if (!createTime) {
       return '';
@@ -2860,6 +3282,7 @@
       streaming.value = true;
       streamUrl.value = buildChatRegenerateUrl(sessionId, userMessage.id);
       openStream();
+      void getSessions().catch(() => undefined);
     } catch (error) {
       antMessage.error((error as Error)?.message || '重新生成失败');
     }
@@ -2899,27 +3322,47 @@
   /** 停止生成:通知后端取消本轮执行(避免后端继续跑并落库),随后关闭前端流 */
   const handleStop = () => {
     const sessionId = currentSessionId.value;
-    if (sessionId) {
-      // 通知后端取消;失败不阻塞前端收尾(如后端本轮已结束)
-      stopChat(sessionId).catch(() => undefined);
+    if (!sessionId) {
+      finishStream();
+      return;
     }
-    const msg = currentAssistant();
+    if (stopping.value) {
+      return;
+    }
+    stopping.value = true;
+    // 通知后端取消;保持「正在停止」直到收到 aborted 事件或轮询看到终态,
+    // 避免刚点停止就发「继续」被后端「生成中」拒绝。
+    stopChat(sessionId).catch(() => undefined);
+    const msg = currentAssistant() ?? messages.value.find((item) => item.role === 'assistant' && item.streaming);
+    // 记录本次停止所属的流式段:5s 兜底只作用于它,避免误伤随后新开的一轮
+    const stopRound = streamRound;
     if (msg) {
-      msg.streaming = false;
       clearPhase(msg);
-      // 前端随即关闭 SSE,很可能收不到后端随后的 aborted 事件,故本地即时标记「已中止」
-      msg.status = '3';
-      // 过程面板:running 步本地标为已中止(与消息状态同口径),并自动折叠
-      msg.steps?.forEach((step) => {
-        if (step.status === 'running') {
-          step.status = 'aborted';
-        }
-      });
-      autoCollapseProcess(msg);
+      msg.phaseText = '正在停止…';
     }
-    finishStream();
-    // 中止时已落盘的部分产物也要展示
-    scheduleArtifactRefresh();
+    // 兜底:后端迟迟没有收尾时本地解锁(此时后端可能仍在取消中,再发消息会被提示生成中)
+    window.setTimeout(() => {
+      if (String(currentSessionId.value) !== String(sessionId) || !streaming.value) {
+        return;
+      }
+      if (streamRound !== stopRound) {
+        return;
+      }
+      const target = currentAssistant() ?? messages.value.find((item) => item.role === 'assistant' && item.streaming);
+      if (target) {
+        target.streaming = false;
+        clearPhase(target);
+        target.status = '3';
+        target.steps?.forEach((step) => {
+          if (step.status === 'running') {
+            step.status = 'aborted';
+          }
+        });
+        autoCollapseProcess(target);
+      }
+      finishStream();
+      scheduleArtifactRefresh();
+    }, 5000);
   };
 
   /** 处置待确认的工具调用:写入结果后建立恢复流继续生成 */
@@ -2977,6 +3420,7 @@
     streaming.value = true;
     streamUrl.value = buildChatResumeUrl(sessionId, messageId);
     openStream();
+    void getSessions().catch(() => undefined);
   };
 
   /** 拒绝待确认的工具调用:可填写拒绝原因(可选),交后端回传模型并留痕 */
@@ -3013,6 +3457,13 @@
 
     switch (event.type) {
       case 'start':
+        // 后端已落库本轮助手占位消息:立即把临时气泡归位,
+        // 断流后轮询按 messageId 精确匹配,不会多出一个重复气泡
+        if (event.messageId !== undefined && event.messageId !== null) {
+          rekeyProcess(msg, event.messageId);
+          msg.id = event.messageId;
+          currentAssistantKey.value = event.messageId;
+        }
         break;
       case 'phase': {
         // 对话期实时进度:长等待时播报后端在干什么(文案由后端拼好,前端只渲染)
@@ -3088,6 +3539,7 @@
       }
       case 'tool_confirm': {
         // 工具被配置为「需人工确认」:本轮暂停,等待用户处置后再恢复
+        streamTerminal = true;
         rekeyProcess(msg, event.messageId);
         msg.id = event.messageId ?? msg.id;
         msg.streaming = false;
@@ -3173,6 +3625,7 @@
         break;
       }
       case 'done': {
+        streamTerminal = true;
         rekeyProcess(msg, event.messageId);
         msg.id = event.messageId ?? msg.id;
         msg.streaming = false;
@@ -3201,6 +3654,7 @@
       }
       case 'aborted': {
         // 中止也按收尾处理:给用户明确的「已中止」反馈(兜底服务端主动中止等场景)
+        streamTerminal = true;
         rekeyProcess(msg, event.messageId);
         msg.id = event.messageId ?? msg.id;
         msg.streaming = false;
@@ -3225,6 +3679,7 @@
         break;
       }
       case 'error': {
+        streamTerminal = true;
         if (event.reasonCode && regenerateBackup) {
           // 预检 / 上下文回退被拒:本轮尚未产生新回答,恢复旧回答展示
           restoreRegenerateBackup();
@@ -3282,6 +3737,8 @@
       return undefined;
     }
     currentSessionId.value = session.id;
+    // 首次发送建会话后同样记住:刷新可回到这次对话
+    rememberLastSession(session.id);
     // 指定专家已随 pinnedExpertId 落库,本地兜底记录可清除
     clearPendingExpertCache();
     // 首次建会话时把本地暂存的资源选择一并提交(REQ-AI-32)
@@ -3515,6 +3972,8 @@
       streaming.value = true;
       streamUrl.value = buildChatStreamUrl(sessionId, userMessageId);
       openStream();
+      // 刷新左侧列表角标:本会话开始生成,切走后也能看到「生成中」
+      void getSessions().catch(() => undefined);
       return true;
     } finally {
       sending.value = false;
@@ -3576,18 +4035,31 @@
     pendingAttachments.value = [];
     clearPendingExpertCache();
     if (newCaseId) {
-      await getSessions();
+      try {
+        await getSessions();
+        // 切回某案件时,恢复该案件上次打开的会话(按 caseId 隔离的 key)
+        await restoreLastSession();
+      } catch {
+        // 列表加载失败不影响案件切换本身
+      }
     } else {
       sessions.value = [];
+      stopSessionListRefresh();
     }
   });
 
-  onMounted(() => {
+  onMounted(async () => {
     // 刷新后恢复「尚未落库的指定专家」(仅当前无会话时生效),兜住选择随刷新丢失的窗口
     restorePendingExpertCache();
     loadAgents();
     loadResourceOptions();
-    getSessions();
+    try {
+      await getSessions();
+      // 刷新 / 重进页面后自动恢复上次打开的会话,并对其中的生成中回答启动轮询
+      await restoreLastSession();
+    } catch {
+      // 列表加载失败时保留 last-session key,下次进入再恢复
+    }
   });
 </script>
 
@@ -3681,6 +4153,26 @@
     text-overflow: ellipsis;
   }
 
+  /* 多会话并行:后台仍在生成的会话角标 */
+  .session-item__running {
+    display: inline-flex;
+    flex: 0 0 auto;
+    align-items: center;
+    color: var(--app-accent-strong, #2a50ec);
+    font-size: 13px;
+    animation: session-running-spin 1s linear infinite;
+  }
+
+  @keyframes session-running-spin {
+    from {
+      transform: rotate(0deg);
+    }
+
+    to {
+      transform: rotate(360deg);
+    }
+  }
+
   .session-item__time {
     margin-top: 4px;
     color: var(--app-text-muted);
@@ -4217,6 +4709,11 @@
     font-size: 12px;
   }
 
+  /* 中止原因:非用户主动停止(后端重启 / 失联回收),用提示色区别于真实失败 */
+  .msg-error--aborted {
+    color: var(--el-color-warning, #e6a23c);
+  }
+
   /* 工具调用卡片 */
   .tool-card {
     margin: 10px 0;

BIN
ai-server/logs/sys-info.2026-11-18.log.gz


+ 22 - 0
ai-server/src/main/java/com/zsjz/ai/common/storage/StorageLayout.java

@@ -62,6 +62,10 @@ public class StorageLayout {
     public static final String CASE_AI_WORKBENCH_DIR = "workbench";
     /** 智能工作台共享副本目录:{@code cases/{caseId}/ai/workbench/shared}。 */
     public static final String WORKBENCH_SHARED_DIR = "shared";
+    /** 智能工作台会话交付物目录:{@code cases/{caseId}/ai/workbench/{sessionId}/outputs}。 */
+    public static final String WORKBENCH_OUTPUTS_DIR = "outputs";
+    /** 智能工作台会话计划文档目录:{@code cases/{caseId}/ai/workbench/{sessionId}/plans}。 */
+    public static final String WORKBENCH_PLANS_DIR = "plans";
     public static final String CASE_TMP_DIR = "tmp";
     /** 桌面端工作区根:{@code cases/{caseId}/desktop}(只放派生副本,删案时随案件目录清理)。 */
     public static final String CASE_DESKTOP_DIR = "desktop";
@@ -330,6 +334,24 @@ public class StorageLayout {
         return caseWorkbenchDir(caseId).resolve(Long.toString(sessionId));
     }
 
+    /**
+     * 智能工作台会话交付物目录:{@code cases/{caseId}/ai/workbench/{sessionId}/outputs}。
+     *
+     * <p>产物面板只扫描这个目录;会话根下的脚本、中间文件不进入产物列表。</p>
+     */
+    public Path caseWorkbenchSessionOutputsDir(long caseId, long sessionId) {
+        return caseWorkbenchSessionDir(caseId, sessionId).resolve(WORKBENCH_OUTPUTS_DIR);
+    }
+
+    /**
+     * 智能工作台会话计划文档目录:{@code cases/{caseId}/ai/workbench/{sessionId}/plans}。
+     *
+     * <p>计划模式产出的 {@code plans/PLAN.md} 等计划文档同样作为会话产物展示。</p>
+     */
+    public Path caseWorkbenchSessionPlansDir(long caseId, long sessionId) {
+        return caseWorkbenchSessionDir(caseId, sessionId).resolve(WORKBENCH_PLANS_DIR);
+    }
+
     /**
      * 删除智能工作台会话工作区(含会话产物)。
      *

+ 23 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/config/AiProperties.java

@@ -280,6 +280,29 @@ public class AiProperties {
          */
         private long streamTimeoutMs = 0L;
 
+        /**
+         * 生成期间「用户可见正文 + 执行步骤」的周期落库间隔(毫秒)。
+         *
+         * <p>用于切断 SSE 后仍能在会话里看到已生成内容;同时刷新 {@code ai_message.update_time},
+         * 作为「仍在运行」的存活信号。设为 0 时关闭周期落库(退回只在收尾落库)。</p>
+         */
+        private long streamProgressPersistIntervalMs = 1500L;
+
+        /**
+         * SSE 心跳间隔(毫秒),0 表示关闭。
+         *
+         * <p>长工具调用期间没有正文事件,靠注释帧保活,避免网关 / 代理按空闲超时断开。</p>
+         */
+        private long streamHeartbeatIntervalMs = 15000L;
+
+        /**
+         * 判定流式消息「失联」的秒数。
+         *
+         * <p>运行状态接口与列表角标据此区分「别的副本正在跑」与「进程已死但占位行还在」:
+         * 超过该时间没有进度更新,才就地置为已中止。</p>
+         */
+        private int streamingStaleSeconds = 60;
+
         /**
          * 「执行过程」时间线总开关(思考过程 + 分步结论)。
          *

+ 20 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/controller/AiChatController.java

@@ -19,6 +19,7 @@ import com.zsjz.ai.module.ai.domain.vo.AiChatPendingVo;
 import com.zsjz.ai.module.ai.domain.vo.AiMessageVo;
 import com.zsjz.ai.module.ai.domain.vo.AiRegenerateCheckVo;
 import com.zsjz.ai.module.ai.domain.vo.AiRouteRunDetailVo;
+import com.zsjz.ai.module.ai.domain.vo.AiRunningTurnVo;
 import com.zsjz.ai.module.ai.domain.vo.AiSessionResourceVo;
 import com.zsjz.ai.module.ai.domain.vo.AiSessionVo;
 import com.zsjz.ai.module.ai.domain.vo.AiToolCallLogVo;
@@ -289,6 +290,10 @@ public class AiChatController extends BaseController {
                                       @Validated @RequestBody AiChatSendBo bo) {
         // 案件级隔离:跨案件 sessionId 一律拒绝
         aiSessionService.assertSessionInCurrentCase(sessionId);
+        // 同一会话仍在生成时拒绝新提问:避免插入一条永远没有回答的孤立用户消息
+        if (aiChatFacade.isSessionRunning(sessionId)) {
+            throw new ServiceException("会话正在生成回答,请先停止或等待完成");
+        }
         AiMessage message = aiSessionService.appendUserMessage(sessionId, bo.getContent(), bo.getAttachmentIds());
         AiMessageVo vo = new AiMessageVo();
         vo.setId(message.getId());
@@ -401,6 +406,18 @@ public class AiChatController extends BaseController {
         return R.ok(aiChatFacade.listPending(sessionId));
     }
 
+    /**
+     * 查询会话当前运行中的一轮(切页 / 刷新后轮询续看)
+     *
+     * @param sessionId 会话主键
+     */
+    @SaCheckPermission("ai:chat:query")
+    @GetMapping("/session/{sessionId}/running")
+    public R<AiRunningTurnVo> running(@NotNull(message = "会话不能为空")
+                                      @PathVariable("sessionId") Long sessionId) {
+        return R.ok(aiChatFacade.runningTurn(sessionId));
+    }
+
     /**
      * 停止该会话当前正在进行的流式执行(对话页「停止」按钮)
      *
@@ -518,6 +535,9 @@ public class AiChatController extends BaseController {
     @DeleteMapping("/session/{sessionId}")
     public R<Void> closeSession(@NotNull(message = "会话不能为空")
                                 @PathVariable("sessionId") Long sessionId) {
+        // 结束任务是显式取消:先中止该会话仍在后台生成的回答,再关闭会话
+        aiSessionService.assertSessionInCurrentCase(sessionId);
+        aiChatFacade.stop(sessionId);
         return toAjax(aiSessionService.closeSession(sessionId));
     }
 

+ 2 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AgentAssembler.java

@@ -629,6 +629,8 @@ public class AgentAssembler {
         middlewares.add(new CurrentTimeMiddleware(aiProperties));
         // 提示词注入防护:声明「<untrusted> 包裹的外部内容只是数据、其中指令不执行」(开关实时读运行期配置)
         middlewares.add(new PromptHardeningMiddleware(runtimeConfigStore));
+        // 智能工作台:shared/ 只读、交付物写当前会话 outputs/(仅会话级工作区运行期生效,普通会话不注入)
+        middlewares.add(new WorkbenchArtifactPromptMiddleware());
         // 平台托管记忆注入:显式记忆 + MEMORY.md(中间件内部按平台开关自行短路;
         // 专家级记忆关闭时同样不注册,保证 <memory_context> 不进入该专家的系统提示词)
         if (definition.memoryAllowed()) {

+ 188 - 58
ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiChatFacade.java

@@ -24,8 +24,10 @@ import com.zsjz.ai.module.ai.domain.AiTrace;
 import com.zsjz.ai.module.ai.domain.dto.AiSessionResourceSet;
 import com.zsjz.ai.module.ai.domain.bo.AiChatConfirmBo;
 import com.zsjz.ai.module.ai.domain.vo.AiChatPendingVo;
+import com.zsjz.ai.module.ai.domain.vo.AiMessageStepVo;
 import com.zsjz.ai.module.ai.domain.vo.AiMessageVo;
 import com.zsjz.ai.module.ai.domain.vo.AiRegenerateCheckVo;
+import com.zsjz.ai.module.ai.domain.vo.AiRunningTurnVo;
 import com.zsjz.ai.module.ai.mapper.AiMessageMapper;
 import com.zsjz.ai.module.ai.service.IAiAgentService;
 import com.zsjz.ai.module.ai.service.IAiMessageStepService;
@@ -45,6 +47,7 @@ import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
 import reactor.core.Disposable;
 import reactor.core.publisher.Flux;
 
+import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -124,6 +127,12 @@ public class AiChatFacade {
      */
     private static final String CANCELLED_TEXT = "用户停止生成";
 
+    /**
+     * 「继续」类消息的隐藏续写提示(只进模型输入,不落库、不参与安全审核)
+     */
+    private static final String CONTINUATION_NOTE =
+        "\n\n(用户要求从中断处继续上一条回答,请勿重复已输出内容。)";
+
     /**
      * 专家链路暂停时落库的助手消息正文(REQ-AI-30 Phase 2 HITL 贯通)。
      *
@@ -194,6 +203,16 @@ public class AiChatFacade {
      */
     private final AiRegenerateContextRestorer contextRestorer;
 
+    /**
+     * 新一轮开始前的上下文尾部校准(补上被中断那轮的 user + 半截 assistant)
+     */
+    private final AiContextSyncService contextSync;
+
+    /**
+     * 生成期间的正文 / 步骤周期落库与 SSE 心跳
+     */
+    private final AiStreamProgressPersister progressPersister;
+
     /**
      * 领域专家名录(REQ-AI-30):入口智能体每轮现算候选专家清单
      */
@@ -284,6 +303,20 @@ public class AiChatFacade {
         }
     }
 
+    /**
+     * 会话当前是否仍在生成回答(供发送消息前拦截,避免插入无回答的孤立提问)。
+     *
+     * @param sessionId 会话主键
+     * @return 是否运行中
+     */
+    public boolean isSessionRunning(Long sessionId) {
+        if (runRegistry.isActive(sessionId)) {
+            return true;
+        }
+        AiMessage streaming = sessionService.queryStreamingAssistant(sessionId);
+        return streaming != null && isFreshStreaming(streaming);
+    }
+
     /**
      * 发起一轮流式对话。
      *
@@ -321,6 +354,20 @@ public class AiChatFacade {
         // 对入口智能体(自答 / 整合轮)与被执行专家同时可见;改选择后下一轮即按新集合装配生效
         AiSessionResourceSet resources = sessionResourceService.resolveForSession(session);
         Long userId = LoginHelper.getUserId();
+        // 同一会话互斥:同一会话不能并行跑两轮(不同会话仍可并行)。
+        // 跨副本时 runRegistry 只能看到本实例,故同时检查 DB 里新鲜的 streaming=1 占位行。
+        if (runRegistry.isActive(sessionId)) {
+            throw new ServiceException("会话正在生成回答,请先停止或等待完成");
+        }
+        AiMessage streamingMessage = sessionService.queryStreamingAssistant(sessionId);
+        if (streamingMessage != null) {
+            if (isFreshStreaming(streamingMessage)) {
+                throw new ServiceException("会话正在生成回答,请先停止或等待完成");
+            }
+            // 陈旧占位行(进程重启 / 长时间无进展):就地收尾,允许本轮继续
+            sessionService.abortStaleStreaming(streamingMessage.getId(),
+                "服务重启或长时间无进展,本轮回答已中断");
+        }
         // 配额闸门:超限直接拒绝,避免产生「有提问无回答」的消耗
         quotaService.check(userId, definition);
         // 安全合规(输入):命中即留痕;BLOCK 直接回拒答、不调模型(避免「有提问无回答」的被动消耗)
@@ -442,33 +489,43 @@ public class AiChatFacade {
         }
         AtomicBoolean finished = new AtomicBoolean(false);
         try {
-            AiSseSupport.send(emitter, AiSseSupport.envelope(EVENT_START));
-            // SSE 断连 / 超时:取消该会话**当前全部**后端执行(与对话页「停止」同一路径)。
-            // 统一在此登记一次——SseEmitter 的回调是单槽覆盖,分支内再注册会顶掉这里;
-            // 故入口轮、短路轮、指定专家兜底、整合轮与恢复段共用这一套(原先只有入口轮分支注册过)。
-            // 例外:本轮已暂停等待人工确认(pendingConfirm)时**不取消**——切页/断连不应摧毁
-            // 框架的 ASKING 暂停态与 Redis 待确认暂存,否则用户回来点确认会因会话状态被取消而恢复失败。
-            emitter.onCompletion(() -> {
-                if (!state.pendingConfirm) {
-                    runRegistry.cancel(sessionId);
-                }
-            });
-            emitter.onTimeout(() -> {
-                if (!state.pendingConfirm) {
-                    runRegistry.cancel(sessionId);
-                }
-            });
-            emitter.onError(ignored -> {
-                if (!state.pendingConfirm) {
-                    runRegistry.cancel(sessionId);
-                }
-            });
-            // 单次执行句柄(AgentScope 2.0.4):登记后可由「停止」/ SSE 断连取消本段后端执行
+            // 本轮助手占位行:生成期间周期落库;创建失败则退回收尾一次性落库
+            try {
+                AiMessage placeholder = sessionService.persistAssistantStreaming(sessionId);
+                state.assistantMessageId = placeholder.getId();
+            } catch (Exception e) {
+                log.warn("创建流式助手占位消息失败,退回收尾一次性落库:sessionId={}, {}",
+                    sessionId, e.getMessage());
+            }
+            Map<String, Object> startPayload = AiSseSupport.envelope(EVENT_START);
+            if (state.assistantMessageId != null) {
+                startPayload.put("messageId", state.assistantMessageId);
+            }
+            AiSseSupport.send(emitter, startPayload);
+            // 说明:SSE 断连 / 超时只停止推送,**不取消**后端执行;
+            // 取消只由显式「停止生成」(/stop) 触发,保证切页 / 刷新后回答继续生成。
+            // 新一轮下发前校准模型上下文:补齐被中断那一轮的 user + 半截 assistant
+            if (replaceAnswerIds == null || replaceAnswerIds.isEmpty()) {
+                contextSync.syncBeforeTurn(agent, userId, sessionId, userMessageId);
+            }
+            // 「继续」类消息:上下文已补齐后,再给模型一条隐藏续写提示(不落库、不参与安全审核)
+            String modelContent = userContent;
+            if ((replaceAnswerIds == null || replaceAnswerIds.isEmpty())
+                && contextSync.isContinuation(userContent)
+                && contextSync.previousTurnInterrupted(sessionId, userMessageId)) {
+                modelContent = userContent + CONTINUATION_NOTE;
+            }
+            // 单次执行句柄:登记后可由「停止」取消本段后端执行;tryRegister 保证同一会话只有一轮
             AgentRun<AgentEvent> run = agent.prepareRun(
-                List.of(attachmentAssembler.buildUserMsg(userContent, attachmentBlocks)), ctx);
+                List.of(attachmentAssembler.buildUserMsg(modelContent, attachmentBlocks)), ctx);
             AiRunRegistry.Cancelable cancelable = run::cancel;
-            runRegistry.register(sessionId, cancelable);
-            Disposable disposable = run.stream()
+            if (!runRegistry.tryRegister(sessionId, cancelable)) {
+                throw new ServiceException("会话正在生成回答,请先停止或等待完成");
+            }
+            // 生成期间周期落库 + SSE 心跳
+            state.progress = progressPersister.start(emitter, sessionId, state.assistantMessageId, state);
+            try {
+                Disposable disposable = run.stream()
                 .doFinally(signal -> runRegistry.unregister(sessionId, cancelable))
                 .subscribe(
                 event -> dispatchEntryEvent(emitter, state, route, event),
@@ -494,22 +551,11 @@ public class AiChatFacade {
                     }
                     log.error("对话流式执行失败,sessionId={}", sessionId, error);
                     String message = AiSseSupport.rootCauseMessage(error);
-                    // 执行过程:running 步标为已中止(保留已走步骤供排障)
-                    if (state.process != null) {
-                        state.process.abortRunning(message);
-                    }
                     traceService.appendTransition(state.traceId, "error", message);
                     traceService.accumulate(state.traceId, AiTrace.STATUS_FAILED, durationMs, null,
                         null, null, null, message);
-                    try {
-                        AiMessage failed = sessionService.persistAssistantFailure(sessionId, message, durationMs);
-                        // 执行过程:失败消息也落步骤(保留已走步骤供排障与回放)
-                        if (failed != null) {
-                            turnFinisher.persistProcessSteps(state, sessionId, failed.getId());
-                        }
-                    } catch (Exception e) {
-                        log.error("落库失败消息异常,sessionId={}", sessionId, e);
-                    }
+                    // 失败收尾:保留已生成的半截正文 + 错误原因(更新同一条占位消息)
+                    turnFinisher.failTurn(sessionId, state, durationMs, message, route);
                     turnFinisher.failStream(emitter, message, error);
                     // 编排运行收尾:异常也算终态,便于事后从 ai_route_run 定位本次编排
                     turnFinisher.finishRoute(route, null, AiRouteRun.STATUS_ABORTED, message, durationMs);
@@ -540,12 +586,37 @@ public class AiChatFacade {
                         null, durationMs);
                 }
             );
+            } catch (Exception e) {
+                // 订阅同步异常:先释放运行句柄,避免会话被永久判定为「生成中」
+                runRegistry.unregister(sessionId, cancelable);
+                throw e;
+            }
         } catch (Exception e) {
+            // 启动阶段异常(含同会话互斥、prepareRun 失败):把占位行收尾为失败,避免永久 streaming
+            turnFinisher.failTurn(sessionId, state, (System.nanoTime() - startNanos) / 1_000_000,
+                AiSseSupport.rootCauseMessage(e), route);
             throw e instanceof ServiceException serviceException
                 ? serviceException : new ServiceException("对话启动失败:" + e.getMessage());
         }
     }
 
+    /**
+     * 判断流式占位消息是否仍在存活窗口内。
+     *
+     * <p>周期落库会持续刷新 {@code update_time};超过窗口仍未刷新,说明执行所在进程已死
+     * (或另一副本的任务长时间无进展),可以安全地就地收尾。</p>
+     *
+     * @param message 流式助手消息
+     * @return 是否新鲜
+     */
+    private boolean isFreshStreaming(AiMessage message) {
+        if (message == null || message.getUpdateTime() == null) {
+            return true;
+        }
+        int staleSeconds = Math.max(1, aiProperties.getChat().getStreamingStaleSeconds());
+        return message.getUpdateTime().isAfter(LocalDateTime.now().minusSeconds(staleSeconds));
+    }
+
     /**
      * 重新生成预检(含同实例执行互斥)。
      *
@@ -565,6 +636,63 @@ public class AiChatFacade {
         return check;
     }
 
+    /**
+     * 查询会话当前运行中的一轮(供前端切页 / 刷新后轮询续看)。
+     *
+     * <p>返回流式助手消息与已落库的执行步骤;若占位行长时间没有进度刷新且本机也没有
+     * 活跃执行,说明执行所在进程已死(或换了副本),就地置为已中止,避免前端永久转圈。</p>
+     *
+     * @param sessionId 会话主键
+     * @return 运行状态、流式消息与步骤
+     */
+    public AiRunningTurnVo runningTurn(Long sessionId) {
+        sessionService.assertSessionInCurrentCase(sessionId);
+        AiRunningTurnVo vo = new AiRunningTurnVo();
+        AiMessage streaming = sessionService.queryStreamingAssistant(sessionId);
+        if (streaming != null && !runRegistry.isActive(sessionId) && !isFreshStreaming(streaming)) {
+            sessionService.abortStaleStreaming(streaming.getId(),
+                "服务重启或长时间无进展,本轮回答已中断");
+            streaming = null;
+        }
+        if (streaming == null) {
+            // 极短窗口:已登记运行但占位行尚未落库;前端下一次轮询即可拿到消息
+            vo.setRunning(runRegistry.isActive(sessionId));
+            vo.setSteps(List.of());
+            return vo;
+        }
+        vo.setRunning(true);
+        vo.setMessage(toMessageVo(streaming));
+        List<AiMessageStepVo> steps = stepService.listByMessage(streaming.getId());
+        vo.setSteps(steps == null ? List.of() : steps);
+        return vo;
+    }
+
+    /**
+     * 实体转消息视图(运行状态接口只返回当前这一条,无需回填附件)。
+     *
+     * @param message 消息实体
+     * @return 消息视图
+     */
+    private AiMessageVo toMessageVo(AiMessage message) {
+        AiMessageVo vo = new AiMessageVo();
+        vo.setId(message.getId());
+        vo.setSessionId(message.getSessionId());
+        vo.setRole(message.getRole());
+        vo.setContent(message.getContent());
+        vo.setReplyId(message.getReplyId());
+        vo.setStreaming(message.getStreaming());
+        vo.setStatus(message.getStatus());
+        vo.setErrorMsg(message.getErrorMsg());
+        vo.setToolCallCount(message.getToolCallCount());
+        vo.setPromptTokens(message.getPromptTokens());
+        vo.setCompletionTokens(message.getCompletionTokens());
+        vo.setTotalTokens(message.getTotalTokens());
+        vo.setDurationMs(message.getDurationMs());
+        vo.setSources(message.getSources());
+        vo.setCreateTime(message.getCreateTime());
+        return vo;
+    }
+
     /**
      * 重新生成最后一轮回答。
      *
@@ -734,6 +862,9 @@ public class AiChatFacade {
         state.userId = pending.userId();
         state.agentId = pending.agentId();
         state.modelId = definition.getModelId();
+        // 恢复段复用暂停时落库的同一条助手消息:周期落库以已有正文为前缀,收尾追加到同一行
+        state.assistantMessageId = messageId;
+        state.baseAnswerContent = existMessage.getContent() == null ? "" : existMessage.getContent();
         // 恢复段不会重新收到 ToolCallDeltaEvent:先回填暂停时暂存的原始入参,
         // 保证确认/拒绝/计划批准的工具明细落库时 toolInput 不为空
         state.seedPendingToolCalls(pending.toolCalls());
@@ -754,31 +885,20 @@ public class AiChatFacade {
         }
         AtomicBoolean finished = new AtomicBoolean(false);
         try {
-            AiSseSupport.send(emitter, AiSseSupport.envelope(EVENT_START));
+            // 恢复段复用同一条消息:先标回 streaming=1,周期落库 / 轮询续看才能生效
+            sessionService.markAssistantStreaming(messageId);
+            Map<String, Object> startPayload = AiSseSupport.envelope(EVENT_START);
+            startPayload.put("messageId", messageId);
+            AiSseSupport.send(emitter, startPayload);
             // 对话期进度:恢复请求到首个事件之间有一整段空窗(装配 + 专家续跑),先播报「在继续执行」
             AiPhaseSupport.emit(emitter, state, AiPhaseSupport.PHASE_RESUMING,
                 "数剑正在继续执行你已确认的操作…", null);
-            // SSE 断连 / 超时:取消该会话**当前全部**后端执行(与对话页「停止」同一路径)。
-            // 恢复段是**另一条 SSE 请求**,故此处同样要登记(与 streamChat 同款;SseEmitter 回调单槽覆盖)。
-            // 已暂停等待确认(pendingConfirm)时不取消,保留暂停态供用户回来继续确认。
-            emitter.onCompletion(() -> {
-                if (!state.pendingConfirm) {
-                    runRegistry.cancel(sessionId);
-                }
-            });
-            emitter.onTimeout(() -> {
-                if (!state.pendingConfirm) {
-                    runRegistry.cancel(sessionId);
-                }
-            });
-            emitter.onError(ignored -> {
-                if (!state.pendingConfirm) {
-                    runRegistry.cancel(sessionId);
-                }
-            });
+            // 说明:SSE 断连只停止推送,**不取消**后端执行;取消只由显式「停止生成」(/stop) 触发。
             AgentRun<AgentEvent> run = agent.prepareRun(AiResumeMessageFactory.build(pending), ctx);
             AiRunRegistry.Cancelable cancelable = run::cancel;
             runRegistry.register(sessionId, cancelable);
+            // 恢复段的进度持久化:已有正文作为前缀,刷新后能看到本段新生成的内容
+            state.progress = progressPersister.start(emitter, sessionId, messageId, state);
             Disposable disposable = run.stream()
                 .doFinally(signal -> runRegistry.unregister(sessionId, cancelable))
                 .subscribe(
@@ -808,6 +928,7 @@ public class AiChatFacade {
                     }
                     log.error("HITL 恢复执行失败,sessionId={}, messageId={}", sessionId, messageId, error);
                     String message = AiSseSupport.rootCauseMessage(error);
+                    turnFinisher.closeProgress(state);
                     if (state.process != null) {
                         state.process.abortRunning(message);
                     }
@@ -815,7 +936,12 @@ public class AiChatFacade {
                     traceService.accumulate(state.traceId, AiTrace.STATUS_ABORTED, durationMs, null,
                         null, null, null, message);
                     try {
-                        sessionService.appendAssistantTurn(messageId, "\n\n" + message,
+                        // 恢复段已流出的部分正文同样保留;周期落库已写入「前缀 + 本段正文」,
+                        // 这里按「已有前缀 + 本段正文 + 错误说明」整体覆盖,避免重复
+                        String partial = state.visibleAnswer.toString();
+                        String fullContent = (state.baseAnswerContent == null ? "" : state.baseAnswerContent)
+                            + (StringUtils.isBlank(partial) ? "" : "\n\n" + partial) + "\n\n" + message;
+                        sessionService.replaceAssistantTurn(messageId, fullContent,
                             AiMessage.STATUS_ABORTED, durationMs, null, state.toTokenUsage(), state.sources);
                         usageStatService.accumulate(state.userId, state.agentId, state.modelId,
                             state.toTokenUsage(), 0, 0);
@@ -853,6 +979,10 @@ public class AiChatFacade {
                 }
             );
         } catch (Exception e) {
+            turnFinisher.closeProgress(state);
+            // 恢复段启动失败:把同一条消息收尾为失败,避免永久停留在 streaming=1
+            turnFinisher.failTurn(sessionId, state, (System.nanoTime() - startNanos) / 1_000_000,
+                AiSseSupport.rootCauseMessage(e), null);
             throw e instanceof ServiceException serviceException
                 ? serviceException : new ServiceException("恢复执行失败:" + e.getMessage());
         }

+ 376 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiContextSyncService.java

@@ -0,0 +1,376 @@
+package com.zsjz.ai.module.ai.core.agent;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import io.agentscope.core.ReActAgent;
+import io.agentscope.core.message.Msg;
+import io.agentscope.core.message.MsgRole;
+import io.agentscope.core.state.AgentState;
+import io.agentscope.harness.agent.HarnessAgent;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import com.zsjz.ai.module.ai.domain.AiMessage;
+import com.zsjz.ai.module.ai.mapper.AiMessageMapper;
+import com.zsjz.ai.common.compat.StringUtils;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+
+/**
+ * 新一轮开始前的模型上下文校准。
+ *
+ * <p><b>要解决什么问题</b>:模型上下文不在 {@code ai_message},而在 AgentScope 按
+ * {@code (userId, sessionId)} 存放的 {@link AgentState#contextMutable()};框架通常在
+ * 一次 call 正常结束时才整体保存。用户打断流后,被中断那轮的「用户问题 + 已输出正文」
+ * 可能没有进入上下文,用户再发「继续」时模型就不知道上一轮在说什么。</p>
+ *
+ * <p><b>做法</b>:以数据库历史为兜底真值,在新一轮下发前只校准上下文尾部:</p>
+ * <ol>
+ *   <li>上下文为空(Redis 状态被回收 / 重启 / 换节点)→ 按 DB 历史全量重放;</li>
+ *   <li>上下文非空 → 比对最后一条 user/assistant,补齐缺失的一轮;</li>
+ *   <li>被中止 / 失败的助手正文追加中断标记,让模型明确「上一轮没写完」。</li>
+ * </ol>
+ *
+ * <p>只写 AgentScope 状态,不改 {@code ai_message};上下文校准失败只告警,绝不影响本轮生成。</p>
+ *
+ * @author BizBuddy
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class AiContextSyncService {
+
+    /**
+     * 尾部比对窗口:只取最近若干条 DB 消息,避免每轮全量查询
+     */
+    private static final int TAIL_LIMIT = 6;
+
+    private static final String ROLE_USER = "user";
+
+    private static final String ROLE_ASSISTANT = "assistant";
+
+    /**
+     * 中断 / 失败标记(只进模型上下文,不写 DB)
+     */
+    private static final String ABORTED_MARKER = "\n\n(本条回答被用户中断,未完整输出)";
+
+    private static final String FAILED_MARKER = "\n\n(本条回答生成失败,未完整输出)";
+
+    /**
+     * 「继续」类消息:仅对短消息做包含匹配,避免把正常提问误判为续写
+     */
+    private static final Set<String> CONTINUATIONS = Set.of(
+        "继续", "接着", "继续生成", "继续写", "接着写", "请继续", "继续吧", "接着吧",
+        "continue", "goon", "keepgoing", "pleasecontinue");
+
+    private static final int CONTINUATION_MAX_LENGTH = 20;
+
+    private final AiMessageMapper messageMapper;
+
+    /**
+     * 新一轮下发前校准上下文尾部。
+     *
+     * @param agent              会话对应的智能体实例
+     * @param userId             会话归属用户
+     * @param sessionId          会话主键
+     * @param currentUserMessageId 本轮用户消息主键(校准范围严格在其之前)
+     */
+    public void syncBeforeTurn(HarnessAgent agent, Long userId, Long sessionId, Long currentUserMessageId) {
+        if (agent == null || userId == null || sessionId == null || currentUserMessageId == null) {
+            return;
+        }
+        ReActAgent delegate = agent.getDelegate();
+        String uid = String.valueOf(userId);
+        String sid = String.valueOf(sessionId);
+        try {
+            AgentState state = delegate.getAgentState(uid, sid);
+            if (state == null) {
+                return;
+            }
+            List<Msg> context = state.contextMutable();
+            List<AiMessage> dbTail = loadTail(sessionId, currentUserMessageId);
+            if (dbTail.isEmpty()) {
+                return;
+            }
+            Msg ctxLast = lastDialogMessage(context);
+            if (ctxLast == null) {
+                // 上下文为空(或只剩 system / 摘要):按 DB 历史全量重建
+                List<Msg> replay = loadHistory(sessionId, currentUserMessageId);
+                if (!replay.isEmpty()) {
+                    context.addAll(replay);
+                    delegate.saveAgentState(uid, sid);
+                    log.info("会话上下文为空,已按历史重建:sessionId={}, messages={}", sessionId, replay.size());
+                }
+                return;
+            }
+            List<Msg> append = missingTail(ctxLast, dbTail);
+            if (!append.isEmpty()) {
+                context.addAll(append);
+                delegate.saveAgentState(uid, sid);
+                log.info("会话上下文尾部已校准:sessionId={}, appended={}", sessionId, append.size());
+            }
+        } catch (Exception e) {
+            log.warn("会话上下文校准失败(不影响本轮生成):sessionId={}, {}", sessionId, e.getMessage());
+        }
+    }
+
+    /**
+     * 判断用户输入是否属于「继续上一轮」的短指令。
+     *
+     * @param content 用户输入
+     * @return 是否续写指令
+     */
+    public boolean isContinuation(String content) {
+        String text = StringUtils.trim(content);
+        if (StringUtils.isBlank(text)) {
+            return false;
+        }
+        String normalized = text.toLowerCase(Locale.ROOT).replaceAll("[\\s。..!!??,,、;;::]+", "");
+        if (CONTINUATIONS.contains(normalized)) {
+            return true;
+        }
+        return normalized.length() <= CONTINUATION_MAX_LENGTH
+            && (normalized.contains("继续") || normalized.contains("接着")
+            || normalized.contains("continue") || normalized.contains("goon"));
+    }
+
+    /**
+     * 判断当前消息之前的最后一轮是否被中断 / 失败。
+     *
+     * <p>最后一条消息是用户消息(说明上一轮没有助手行)也视为未完成。</p>
+     *
+     * @param sessionId            会话主键
+     * @param currentUserMessageId 当前用户消息主键
+     * @return 上一轮是否未正常完成
+     */
+    public boolean previousTurnInterrupted(Long sessionId, Long currentUserMessageId) {
+        if (sessionId == null || currentUserMessageId == null) {
+            return false;
+        }
+        LambdaQueryWrapper<AiMessage> lqw = Wrappers.lambdaQuery();
+        lqw.eq(AiMessage::getSessionId, sessionId)
+            .lt(AiMessage::getId, currentUserMessageId)
+            .in(AiMessage::getRole, ROLE_USER, ROLE_ASSISTANT)
+            .orderByDesc(AiMessage::getId)
+            .last("limit 1");
+        return isInterrupted(messageMapper.selectOne(lqw));
+    }
+
+    /**
+     * 判断一条尾消息是否表示上一轮未正常完成(纯函数,便于单测)。
+     *
+     * @param last 当前消息之前的最后一条 user / assistant 消息
+     * @return 是否未正常完成
+     */
+    boolean isInterrupted(AiMessage last) {
+        if (last == null) {
+            return false;
+        }
+        if (ROLE_USER.equals(last.getRole())) {
+            // 上一轮用户消息之后没有助手行:上一轮没有正常完成
+            return true;
+        }
+        return AiMessage.STATUS_ABORTED.equals(last.getStatus())
+            || AiMessage.STATUS_FAILED.equals(last.getStatus());
+    }
+
+    /**
+     * 计算需要补进上下文的尾部消息。
+     *
+     * @param ctxLast 上下文最后一条 user / assistant
+     * @param dbTail  DB 中当前消息之前的尾部消息(升序,已过滤空正文)
+     * @return 需要追加的消息;为空表示已同步
+     */
+    List<Msg> missingTail(Msg ctxLast, List<AiMessage> dbTail) {
+        AiMessage dbLast = dbTail.get(dbTail.size() - 1);
+        if (ROLE_ASSISTANT.equals(dbLast.getRole())) {
+            AiMessage prevUser = previousUser(dbTail);
+            if (ctxLast.getRole() == MsgRole.ASSISTANT) {
+                String ctxText = StringUtils.trim(ctxLast.getTextContent());
+                String dbText = StringUtils.trim(dbLast.getContent());
+                if (StringUtils.isNotBlank(ctxText) && StringUtils.isNotBlank(dbText)) {
+                    // 上下文已有完整回答(或比 DB 更完整)
+                    if (ctxText.equals(dbText) || ctxText.startsWith(dbText)) {
+                        return List.of();
+                    }
+                    // 上下文只有前缀(例如恢复段只保存了部分正文):只补缺失的后缀,避免整段重复
+                    if (dbText.startsWith(ctxText) && ctxText.length() >= 2) {
+                        return List.of(assistantMsg(dbText.substring(ctxText.length()), dbLast.getStatus()));
+                    }
+                }
+            }
+            List<Msg> append = new ArrayList<>();
+            boolean userAlready = ctxLast.getRole() == MsgRole.USER
+                && prevUser != null && sameText(ctxLast.getTextContent(), prevUser.getContent());
+            if (!userAlready && prevUser != null) {
+                append.add(toMsg(prevUser));
+            }
+            append.add(toMsg(dbLast));
+            return append;
+        }
+        // 最后一条是用户消息:上下文已有同一问题则无需补
+        if (ctxLast.getRole() == MsgRole.USER && sameText(ctxLast.getTextContent(), dbLast.getContent())) {
+            return List.of();
+        }
+        return List.of(toMsg(dbLast));
+    }
+
+    /**
+     * 取尾部消息中最后一条用户消息。
+     *
+     * @param dbTail DB 尾部消息
+     * @return 用户消息;没有则返回 null
+     */
+    private AiMessage previousUser(List<AiMessage> dbTail) {
+        for (int index = dbTail.size() - 1; index >= 0; index--) {
+            if (ROLE_USER.equals(dbTail.get(index).getRole())) {
+                return dbTail.get(index);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 读取当前消息之前的尾部消息(只取最近 {@link #TAIL_LIMIT} 条,升序)。
+     *
+     * @param sessionId            会话主键
+     * @param currentUserMessageId 当前用户消息主键
+     * @return 非空正文的 user / assistant 消息
+     */
+    private List<AiMessage> loadTail(Long sessionId, Long currentUserMessageId) {
+        LambdaQueryWrapper<AiMessage> lqw = Wrappers.lambdaQuery();
+        lqw.eq(AiMessage::getSessionId, sessionId)
+            .lt(AiMessage::getId, currentUserMessageId)
+            .in(AiMessage::getRole, ROLE_USER, ROLE_ASSISTANT)
+            .orderByDesc(AiMessage::getId)
+            .last("limit " + TAIL_LIMIT);
+        List<AiMessage> rows = messageMapper.selectList(lqw);
+        Collections.reverse(rows);
+        List<AiMessage> result = new ArrayList<>();
+        for (AiMessage row : rows) {
+            if (StringUtils.isNotBlank(row.getContent())) {
+                result.add(row);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 读取当前消息之前的全部历史并转换为框架消息(上下文为空时使用)。
+     *
+     * @param sessionId            会话主键
+     * @param currentUserMessageId 当前用户消息主键
+     * @return 框架消息列表
+     */
+    private List<Msg> loadHistory(Long sessionId, Long currentUserMessageId) {
+        LambdaQueryWrapper<AiMessage> lqw = Wrappers.lambdaQuery();
+        lqw.eq(AiMessage::getSessionId, sessionId)
+            .lt(AiMessage::getId, currentUserMessageId)
+            .orderByAsc(AiMessage::getId);
+        List<AiMessage> history = messageMapper.selectList(lqw);
+        List<Msg> messages = new ArrayList<>();
+        for (AiMessage item : history) {
+            if (StringUtils.isBlank(item.getContent())) {
+                continue;
+            }
+            if (!ROLE_USER.equals(item.getRole()) && !ROLE_ASSISTANT.equals(item.getRole())) {
+                continue;
+            }
+            messages.add(toMsg(item));
+        }
+        return messages;
+    }
+
+    /**
+     * 上下文最后一条有正文的 user / assistant 消息。
+     *
+     * @param context 上下文
+     * @return 最后一条对话消息;没有则返回 null
+     */
+    private Msg lastDialogMessage(List<Msg> context) {
+        for (int index = context.size() - 1; index >= 0; index--) {
+            Msg message = context.get(index);
+            if ((message.getRole() == MsgRole.USER || message.getRole() == MsgRole.ASSISTANT)
+                && StringUtils.isNotBlank(message.getTextContent())) {
+                return message;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * DB 消息转框架消息;被中止 / 失败的助手正文追加标记。
+     *
+     * @param item DB 消息
+     * @return 框架消息
+     */
+    private Msg toMsg(AiMessage item) {
+        boolean assistant = ROLE_ASSISTANT.equals(item.getRole());
+        String text = item.getContent();
+        if (assistant) {
+            return assistantMsg(text, item.getStatus());
+        }
+        return Msg.builder()
+            .role(MsgRole.USER)
+            .textContent(text)
+            .build();
+    }
+
+    /**
+     * 构造助手消息(附加中断 / 失败标记)。
+     *
+     * @param text   正文(可空)
+     * @param status 消息状态
+     * @return 框架助手消息
+     */
+    private Msg assistantMsg(String text, String status) {
+        return Msg.builder()
+            .role(MsgRole.ASSISTANT)
+            .textContent((text == null ? "" : text) + marker(status))
+            .build();
+    }
+
+    /**
+     * 中断标记。
+     *
+     * @param status 消息状态
+     * @return 标记文本;正常状态为空串
+     */
+    private String marker(String status) {
+        if (AiMessage.STATUS_ABORTED.equals(status)) {
+            return ABORTED_MARKER;
+        }
+        if (AiMessage.STATUS_FAILED.equals(status)) {
+            return FAILED_MARKER;
+        }
+        return "";
+    }
+
+    /**
+     * 文本是否视为同一轮内容。
+     *
+     * <p>安全脱敏可能让上下文与 DB 原话存在差异,故在精确相等之外允许「包含」;
+     * 只对较长的文本做包含匹配,避免短文本误判。</p>
+     *
+     * @param left  上下文文本
+     * @param right DB 文本
+     * @return 是否视为同一内容
+     */
+    private boolean sameText(String left, String right) {
+        String a = StringUtils.trim(left);
+        String b = StringUtils.trim(right);
+        if (StringUtils.isBlank(a) || StringUtils.isBlank(b)) {
+            return false;
+        }
+        if (a.equals(b)) {
+            return true;
+        }
+        String shorter = a.length() <= b.length() ? a : b;
+        String longer = a.length() <= b.length() ? b : a;
+        return shorter.length() >= 4 && longer.contains(shorter);
+    }
+}

+ 27 - 2
ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiExpertResumeDriver.java

@@ -11,6 +11,7 @@ import com.zsjz.ai.module.ai.domain.AiRouteRun;
 import com.zsjz.ai.module.ai.domain.AiSession;
 import com.zsjz.ai.module.ai.domain.AiTrace;
 import com.zsjz.ai.module.ai.domain.dto.AiSessionResourceSet;
+import com.zsjz.ai.module.ai.mapper.AiMessageMapper;
 import com.zsjz.ai.module.ai.config.AiProperties;
 import com.zsjz.ai.module.ai.service.IAiAgentService;
 import com.zsjz.ai.module.ai.service.IAiMessageStepService;
@@ -24,6 +25,7 @@ import reactor.core.Disposable;
 import reactor.core.publisher.Mono;
 import reactor.core.scheduler.Schedulers;
 
+import java.util.Map;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -64,6 +66,11 @@ public class AiExpertResumeDriver {
 
     private final IAiSessionService sessionService;
 
+    /**
+     * 读取暂停时已落库的助手消息正文(恢复段可见正文的前缀)
+     */
+    private final AiMessageMapper messageMapper;
+
     private final IAiAgentService agentService;
 
     private final AgentRegistry agentRegistry;
@@ -110,6 +117,11 @@ public class AiExpertResumeDriver {
      */
     private final AiTurnFinisher turnFinisher;
 
+    /**
+     * 恢复段生成期间的正文 / 步骤周期落库与心跳
+     */
+    private final AiStreamProgressPersister progressPersister;
+
     /**
      * 整合轮驱动(R4 拆出):降级时由入口智能体兜底整合
      */
@@ -191,6 +203,11 @@ public class AiExpertResumeDriver {
         state.agentId = definition.getId();
         state.modelId = definition.getModelId();
         state.traceId = traceId;
+        // 恢复段复用暂停时落库的同一条助手消息:取消 / 正常收尾都追加到这条消息
+        state.assistantMessageId = messageId;
+        AiMessage pausedMessage = messageMapper.selectById(messageId);
+        state.baseAnswerContent = pausedMessage == null || pausedMessage.getContent() == null
+            ? "" : pausedMessage.getContent();
         route.entryState = state;
         // 执行过程:恢复段新建时间线续接(专家步同键 upsert);先回填确认步终态
         if (aiProperties.getChat().isProcessStepsEnabled()) {
@@ -222,7 +239,11 @@ public class AiExpertResumeDriver {
         traceService.appendTransition(traceId, "resume", "人工确认后恢复专家执行");
 
         long startNanos = System.nanoTime();
-        AiSseSupport.send(emitter, AiSseSupport.envelope(EVENT_START));
+        // 恢复段复用同一条消息:标回 streaming=1,周期落库与轮询续看才能生效
+        sessionService.markAssistantStreaming(messageId);
+        Map<String, Object> startPayload = AiSseSupport.envelope(EVENT_START);
+        startPayload.put("messageId", messageId);
+        AiSseSupport.send(emitter, startPayload);
         // 对话期进度:续跑请求到首个事件之间有一整段空窗(装配 + 专家续跑),先播报「在继续执行」
         AiPhaseSupport.emit(emitter, state, AiPhaseSupport.PHASE_RESUMING,
             "数剑正在继续执行你已确认的操作…", null);
@@ -241,6 +262,8 @@ public class AiExpertResumeDriver {
             return true;
         };
         runRegistry.register(sessionId, cancelable);
+        // 恢复段同样周期落库:已有正文作为前缀,刷新 / 切页后能看到本段新生成的内容
+        state.progress = progressPersister.start(emitter, sessionId, messageId, state);
         // 收尾幂等:外层 dispose(doOnCancel)、内层专家被中断(route.cancelled)、异常三者只会生效一个,
         // 避免「内层取消」与「外层 dispose」同时触发导致重复落库 / 重复 aborted
         AtomicBoolean settled = new AtomicBoolean(false);
@@ -262,7 +285,9 @@ public class AiExpertResumeDriver {
                         turnFinisher.finishPendingResume(emitter, sessionId, state, durationMs, messageId, route);
                         turnFinisher.finishRoute(route, messageId, AiRouteRun.STATUS_PENDING, "等待人工确认", durationMs);
                     } else {
-                        turnFinisher.finishRoute(route, null, AiRouteRun.STATUS_ABORTED, CANCELLED_TEXT, durationMs);
+                        // 与其它取消路径同口径:把本段已流出的正文追加到同一条助手消息并置「已中止」,
+                        // 否则消息会一直停在「待确认」,用户发「继续」也看不到上一轮的半截回答
+                        turnFinisher.finishCancelled(emitter, sessionId, state, durationMs, messageId, route);
                         pendingStore.release(sessionId, messageId);
                     }
                 })

+ 8 - 25
ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiIntegrationDriver.java

@@ -114,7 +114,7 @@ public class AiIntegrationDriver {
         route.routeDone = true;
         // 兜底轮(专家失败/超时):专家可能已流出部分正文,先清掉再让数剑自答,避免两者拼接
         AiSseSupport.send(emitter, AiSseSupport.envelope(EVENT_ANSWER_RESET));
-        state.answer.setLength(0);
+        state.resetAnswer();
         // 对话期进度:整合轮是一次完整的模型调用(可能数秒),播报「在汇总」避免正文重开前的静默
         AiPhaseSupport.emit(emitter, state, AiPhaseSupport.PHASE_INTEGRATING, "数剑正在汇总专家结论…", null);
         // 执行过程:整合步(收尾时终态;失败/中止由 abortRunning 统一处置)
@@ -158,13 +158,9 @@ public class AiIntegrationDriver {
                 }
                 String message = AiSseSupport.rootCauseMessage(error);
                 log.error("编排整合轮失败,sessionId={}, messageId={}", sessionId, messageId, error);
-                if (state.process != null) {
-                    state.process.abortRunning(message);
-                }
-                if (messageId != null) {
-                    turnFinisher.persistProcessSteps(state, sessionId, messageId);
-                }
                 traceService.appendTransition(state.traceId, "error", "整合失败:" + message);
+                // 失败收尾:保留已生成的半截正文 + 错误原因(更新同一条占位 / 恢复消息)
+                turnFinisher.failTurn(sessionId, state, durationMs, message, route);
                 if (messageId != null) {
                     pendingStore.release(sessionId, messageId);
                 }
@@ -195,23 +191,8 @@ public class AiIntegrationDriver {
                     pendingStore.release(sessionId, messageId);
                 }
             });
-        // SSE 断连 / 超时:取消后端执行(与对话页「停止」同一路径)
-        // SSE 断连 / 超时:取消后端执行;已暂停等待确认时不取消,保留暂停态
-        emitter.onCompletion(() -> {
-            if (!state.pendingConfirm) {
-                run.cancel();
-            }
-        });
-        emitter.onTimeout(() -> {
-            if (!state.pendingConfirm) {
-                run.cancel();
-            }
-        });
-        emitter.onError(ignored -> {
-            if (!state.pendingConfirm) {
-                run.cancel();
-            }
-        });
+        // 说明:SSE 断连只停止推送,**不取消**后端执行(用户切页 / 刷新后回答仍需继续生成)。
+        // 取消只由显式「停止生成」(/stop) 或结束任务触发,经 AiRunRegistry 落到 run.cancel()。
     }
 
     /**
@@ -242,7 +223,7 @@ public class AiIntegrationDriver {
         route.action = AiRouteRun.ACTION_PINNED;
         route.decisionJson = pinnedFallbackDecision(route);
         AiSseSupport.send(emitter, AiSseSupport.envelope(EVENT_ANSWER_RESET));
-        state.answer.setLength(0);
+        state.resetAnswer();
         // 兜底编排同为阻塞式调用:登记「dispose 该 Mono」为取消句柄
         AtomicReference<Disposable> holder = new AtomicReference<>();
         AiRunRegistry.Cancelable cancelable = () -> {
@@ -318,6 +299,8 @@ public class AiIntegrationDriver {
                 String message = AiSseSupport.rootCauseMessage(error);
                 log.error("指定专家兜底编排失败,sessionId={}", sessionId, error);
                 traceService.appendTransition(route.traceId, "error", "指定专家兜底失败:" + message);
+                // 失败收尾:保留已生成的半截正文 + 错误原因,避免用户消息悬空
+                turnFinisher.failTurn(sessionId, state, durationMs, message, route);
                 turnFinisher.failStream(emitter, message, error);
                 turnFinisher.finishRoute(route, null, AiRouteRun.STATUS_ABORTED, message, durationMs);
             });

+ 8 - 1
ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiRouteOrchestrator.java

@@ -652,6 +652,12 @@ public class AiRouteOrchestrator {
         state.agentId = candidate.agentId();
         state.modelId = definition.getModelId();
         state.traceId = childTraceId;
+        // 专家正文直传用户:与入口轮共享同一个「用户可见正文」缓冲,
+        // 生成期间周期落库与取消收尾才能拿到专家已流出的半截正文
+        if (route.entryState != null) {
+            state.visibleAnswer = route.entryState.visibleAnswer;
+            state.assistantMessageId = route.entryState.assistantMessageId;
+        }
         // 对话期进度:专家的思考 / 工具动作按专家身份播报(「专家「X」正在调用…」)
         state.speakerExpertName = candidate.agentName();
         // 执行过程:专家轮共享入口轮装配的时间线;正文增量附带专家步键供前端镜像专家输出
@@ -867,7 +873,8 @@ public class AiRouteOrchestrator {
     private void beginHandoff(AiRouteContext route) {
         route.handoff = true;
         if (route.entryState != null) {
-            route.entryState.answer.setLength(0);
+            // 同时清空入口累积正文与用户可见正文:专家接管后不能把数剑的过渡语拼进最终回答
+            route.entryState.resetAnswer();
         }
         emit(route, EVENT_ANSWER_RESET, Map.of());
     }

+ 21 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiRunRegistry.java

@@ -38,6 +38,27 @@ public class AiRunRegistry {
         active.computeIfAbsent(sessionId, key -> ConcurrentHashMap.newKeySet()).add(cancelable);
     }
 
+    /**
+     * 仅当该会话没有活跃执行时登记(入口轮互斥:同一会话不并行跑两轮)。
+     *
+     * @param sessionId  会话主键
+     * @param cancelable 取消句柄
+     * @return 是否登记成功;false 表示该会话已有活跃执行
+     */
+    boolean tryRegister(Long sessionId, Cancelable cancelable) {
+        boolean[] registered = {false};
+        active.compute(sessionId, (key, handles) -> {
+            Set<Cancelable> set = handles == null ? ConcurrentHashMap.newKeySet() : handles;
+            if (!set.isEmpty()) {
+                return set;
+            }
+            set.add(cancelable);
+            registered[0] = true;
+            return set;
+        });
+        return registered[0];
+    }
+
     /**
      * 注销取消句柄(按**身份**移除,避免误删仍在跑的另一段执行)。
      *

+ 19 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiSseSupport.java

@@ -51,6 +51,25 @@ final class AiSseSupport {
         }
     }
 
+    /**
+     * 下发一条 SSE 注释帧(心跳)。
+     *
+     * <p>长工具调用期间没有正文事件,靠注释帧保活,避免网关 / 代理按空闲超时断开;
+     * 前端 SSE 解析器会忽略以 {@code :} 开头的行。</p>
+     *
+     * @param emitter SSE 发射器;为 null 时不做处理
+     */
+    static void comment(SseEmitter emitter) {
+        if (emitter == null) {
+            return;
+        }
+        try {
+            emitter.send(SseEmitter.event().comment("ping"));
+        } catch (Exception e) {
+            log.debug("SSE 心跳下发失败(客户端可能已断开):{}", e.getMessage());
+        }
+    }
+
     /**
      * 关闭 SSE 流。
      *

+ 5 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiStreamEventBridge.java

@@ -357,6 +357,7 @@ public class AiStreamEventBridge {
         if (!safetyGuard.anyActive()) {
             // 快速路径:无安全能力时保持原行为(零额外开销)
             state.answer.append(delta);
+            state.visibleAnswer.append(delta);
             emitTextDelta(emitter, state, textDelta, delta);
             return;
         }
@@ -382,6 +383,7 @@ public class AiStreamEventBridge {
             return;
         }
         state.answer.append(decision.text());
+        state.visibleAnswer.append(decision.text());
         emitTextDelta(emitter, state, textDelta, decision.text());
     }
 
@@ -504,6 +506,8 @@ public class AiStreamEventBridge {
         state.safetyPending.setLength(0);
         state.answer.setLength(0);
         state.answer.append(AiSafetyGuard.REFUSAL_TEXT);
+        state.visibleAnswer.setLength(0);
+        state.visibleAnswer.append(AiSafetyGuard.REFUSAL_TEXT);
         AiSseSupport.send(emitter, AiSseSupport.envelope(EVENT_ANSWER_RESET));
         Map<String, Object> payload = AiSseSupport.envelope(EVENT_TEXT_DELTA);
         payload.put("delta", AiSafetyGuard.REFUSAL_TEXT);
@@ -533,6 +537,7 @@ public class AiStreamEventBridge {
             return;
         }
         state.answer.append(decision.text());
+        state.visibleAnswer.append(decision.text());
         // 补发未下发的尾部,保证「前端所见 == 落库内容」
         if (StringUtils.isNotBlank(decision.text())) {
             Map<String, Object> payload = AiSseSupport.envelope(EVENT_TEXT_DELTA);

+ 159 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiStreamProgressPersister.java

@@ -0,0 +1,159 @@
+package com.zsjz.ai.module.ai.core.agent;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import com.zsjz.ai.module.ai.config.AiProperties;
+import com.zsjz.ai.module.ai.service.IAiSessionService;
+import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * 生成期间的进度持久化器(正文 + 执行步骤 + SSE 心跳)。
+ *
+ * <p><b>要解决什么问题</b>:助手消息原本只在流结束时落库,用户切页 / 刷新 / 断网后
+ * 既看不到已生成内容,进程崩溃还会整段丢失。本组件在运行期间按固定间隔把
+ * {@link AiStreamState#visibleText()} 写入助手占位行,并把执行步骤 upsert 到
+ * {@code ai_message_step};同时刷新 {@code update_time},作为「仍在运行」的存活信号。</p>
+ *
+ * <p><b>与收尾的关系</b>:收尾前调用 {@link Handle#close()} 停止周期任务;即使有迟到的
+ * 一次写入,{@code updateAssistantStreaming} 也带 {@code streaming=1} 条件,不会覆盖
+ * 收尾事件写入的最终正文与状态。</p>
+ *
+ * @author BizBuddy
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+class AiStreamProgressPersister {
+
+    /**
+     * 步骤落库的最小间隔(毫秒):正文按配置间隔刷新,步骤写库更重,按 3 倍间隔节流
+     */
+    private static final long MIN_STEP_PERSIST_INTERVAL_MS = 3000L;
+
+    /**
+     * 会话活跃时间刷新间隔(毫秒):无需每次正文刷新都写 ai_session
+     */
+    private static final long SESSION_ACTIVE_TOUCH_INTERVAL_MS = 15000L;
+
+    private final IAiSessionService sessionService;
+
+    private final AiTurnFinisher turnFinisher;
+
+    private final AiProperties aiProperties;
+
+    /**
+     * 单线程守护调度器:任务只做轻量的 DB 更新,不占用业务线程
+     */
+    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(runnable -> {
+        Thread thread = new Thread(runnable, "ai-stream-progress");
+        thread.setDaemon(true);
+        return thread;
+    });
+
+    /**
+     * 启动一轮的周期持久化。
+     *
+     * @param emitter   SSE 发射器(可空:无人值守链路只落库,不发心跳)
+     * @param sessionId 会话主键
+     * @param messageId 助手占位消息主键(可空:为空时不落库)
+     * @param state     本轮流式状态
+     * @return 停止句柄;收尾时必须 close
+     */
+    Handle start(SseEmitter emitter, Long sessionId, Long messageId, AiStreamState state) {
+        AiProperties.Chat chat = aiProperties.getChat();
+        long interval = chat.getStreamProgressPersistIntervalMs();
+        if (messageId == null || interval <= 0 || state == null) {
+            return Handle.noop();
+        }
+        long heartbeatMs = Math.max(0L, chat.getStreamHeartbeatIntervalMs());
+        long stepInterval = Math.max(MIN_STEP_PERSIST_INTERVAL_MS, interval * 3);
+        Handle handle = new Handle();
+        long[] lastStepAt = {0L};
+        long[] lastActiveAt = {0L};
+        long[] lastHeartbeatAt = {0L};
+        ScheduledFuture<?> future = scheduler.scheduleWithFixedDelay(
+            () -> handle.runGuarded(() -> {
+                try {
+                    sessionService.updateAssistantStreaming(messageId, state.visibleText());
+                    long now = System.currentTimeMillis();
+                    if (now - lastStepAt[0] >= stepInterval) {
+                        lastStepAt[0] = now;
+                        turnFinisher.persistProcessSteps(state, sessionId, messageId);
+                    }
+                    if (now - lastActiveAt[0] >= SESSION_ACTIVE_TOUCH_INTERVAL_MS) {
+                        lastActiveAt[0] = now;
+                        sessionService.touchSessionActive(sessionId);
+                    }
+                    if (heartbeatMs > 0 && emitter != null && now - lastHeartbeatAt[0] >= heartbeatMs) {
+                        lastHeartbeatAt[0] = now;
+                        AiSseSupport.comment(emitter);
+                    }
+                } catch (Exception e) {
+                    // 周期落库失败不影响生成:正文仍会在收尾时整体落库
+                    log.debug("生成进度周期落库失败:sessionId={}, messageId={}, {}",
+                        sessionId, messageId, e.getMessage());
+                }
+            }), interval, interval, TimeUnit.MILLISECONDS);
+        handle.setFuture(future);
+        return handle;
+    }
+
+    /**
+     * 停止句柄。
+     */
+    static final class Handle {
+
+        private final AtomicBoolean closed = new AtomicBoolean(false);
+
+        private ScheduledFuture<?> future;
+
+        static Handle noop() {
+            Handle handle = new Handle();
+            handle.closed.set(true);
+            return handle;
+        }
+
+        /**
+         * 绑定调度任务;若句柄已关闭则立即取消(覆盖「任务已提交、句柄还没来得及绑定」的窗口)。
+         *
+         * @param future 调度句柄
+         */
+        synchronized void setFuture(ScheduledFuture<?> future) {
+            this.future = future;
+            if (closed.get()) {
+                future.cancel(false);
+            }
+        }
+
+        /**
+         * 在关闭保护下执行一次周期任务。
+         *
+         * <p>与 {@link #close()} 共用同一把锁:收尾调用 close 时会等待正在执行的 DB 写入结束,
+         * 保证「close 返回后不会再有迟到的进度写入覆盖最终正文」。</p>
+         *
+         * @param task 周期任务
+         */
+        synchronized void runGuarded(Runnable task) {
+            if (closed.get()) {
+                return;
+            }
+            task.run();
+        }
+
+        /**
+         * 停止周期任务;幂等。
+         */
+        synchronized void close() {
+            if (closed.compareAndSet(false, true) && future != null) {
+                future.cancel(false);
+            }
+        }
+    }
+}

+ 45 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiStreamState.java

@@ -27,6 +27,30 @@ final class AiStreamState {
     /** 回答正文 */
     final StringBuilder answer = new StringBuilder();
 
+    /**
+     * 用户可见正文(真正下发给前端的正文增量,含专家直答 / 整合段)。
+     *
+     * <p>与 {@link #answer} 的区别:专家直答时入口轮的 {@code answer} 会被清空,
+     * 专家正文只存在于专家自己的状态里;这里由事件桥在**实际下发**时统一累积,
+     * 供生成期间周期落库使用。专家状态共享入口状态的同一个缓冲区。</p>
+     */
+    volatile StringBuilder visibleAnswer = new StringBuilder();
+
+    /**
+     * 恢复段已有正文前缀(HITL 恢复时拼在 {@link #visibleAnswer} 前;新轮为空串)。
+     */
+    volatile String baseAnswerContent = "";
+
+    /**
+     * 本轮助手消息主键(流式占位行;HITL 恢复段复用暂停时落库的同一条)。
+     */
+    volatile Long assistantMessageId;
+
+    /**
+     * 生成期间进度持久化句柄(收尾时由 {@link AiTurnFinisher} 关闭;可空)。
+     */
+    volatile AiStreamProgressPersister.Handle progress;
+
     /**
      * 安全守卫的未下发尾部缓冲(跨片命中防切断):内容安全开启时,正文先入此缓冲,
      * 仅下发「安全的头部」,尾部保留待下一次拼接后再扫描;收尾由 {@code AiTurnFinisher} 冲刷。
@@ -135,6 +159,27 @@ final class AiStreamState {
     /** 待确认的工具调用 */
     List<AiConfirmPendingStore.PendingToolCall> pendingToolCalls = List.of();
 
+    /**
+     * 清空本轮正文(回答重置 / 专家直答接管 / 整合轮重新作答)。
+     *
+     * <p>必须同时清空 {@link #answer} 与 {@link #visibleAnswer}:
+     * 前者用于最终收尾口径,后者用于生成期间的周期落库,否则刷新后仍会看到已丢弃的旧正文。</p>
+     */
+    void resetAnswer() {
+        answer.setLength(0);
+        visibleAnswer.setLength(0);
+    }
+
+    /**
+     * 取本轮用户可见正文(含恢复段前缀)。
+     *
+     * @return 可见正文;无内容时为空串
+     */
+    String visibleText() {
+        String base = baseAnswerContent == null ? "" : baseAnswerContent;
+        return base + visibleAnswer;
+    }
+
     /**
      * 汇总本轮 Token 用量。
      *

+ 145 - 15
ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/AiTurnFinisher.java

@@ -185,6 +185,8 @@ public class AiTurnFinisher {
      */
     void finishCancelled(SseEmitter emitter, Long sessionId, AiStreamState state, long durationMs,
                          Long resumeMessageId, AiRouteContext route) {
+        // 先停止周期落库,避免迟到的进度写入覆盖本次中止收尾
+        closeProgress(state);
         // 执行过程:running 步统一标为已中止(waiting 步不动;用户主动停止不是失败)
         if (state.process != null) {
             state.process.abortRunning(CANCELLED_TEXT);
@@ -196,10 +198,22 @@ public class AiTurnFinisher {
         // 与 done 同口径的助手消息主键:首段中止取本次落库的消息,恢复段为同一 messageId
         Long messageId = resumeMessageId;
         Long totalDuration = durationMs;
+        // 取消正文必须取「实际已下发的正文」:专家直答时入口 state.answer 已被清空,
+        // 专家半截正文在 handoffAnswer / visibleAnswer 里;恢复段则只追加本段新增正文。
+        String content = answerContent(state, route);
         try {
             if (resumeMessageId == null) {
-                AiMessage assistant = sessionService.persistAssistantAborted(sessionId, state.answer.toString(),
-                    durationMs, buildDoneToolLogs(state, route), state.userId, state.sources);
+                AiMessage assistant = null;
+                if (state.assistantMessageId != null) {
+                    assistant = sessionService.updateAssistantTerminal(state.assistantMessageId, content,
+                        state.replyId, AiMessage.STATUS_ABORTED, durationMs, buildDoneToolLogs(state, route),
+                        state.toTokenUsage(), state.userId, state.sources, null);
+                }
+                if (assistant == null) {
+                    // 占位行不存在(兼容旧链路 / 行被删):回退为新建中止消息,保证半截正文不丢
+                    assistant = sessionService.persistAssistantAborted(sessionId, content,
+                        durationMs, buildDoneToolLogs(state, route), state.userId, state.sources);
+                }
                 messageId = assistant == null ? null : assistant.getId();
                 if (assistant != null && assistant.getDurationMs() != null) {
                     totalDuration = assistant.getDurationMs();
@@ -210,7 +224,9 @@ public class AiTurnFinisher {
                     deleteReplacedAnswers(sessionId, state);
                 }
             } else {
-                AiMessage assistant = sessionService.appendAssistantTurn(resumeMessageId, "",
+                // 恢复段:进度持久化已把「已有前缀 + 本段正文」写回同一条消息,收尾整体覆盖而不是追加
+                String fullContent = (state.baseAnswerContent == null ? "" : state.baseAnswerContent) + content;
+                AiMessage assistant = sessionService.replaceAssistantTurn(resumeMessageId, fullContent,
                     AiMessage.STATUS_ABORTED, durationMs, buildDoneToolLogs(state, route), state.toTokenUsage(),
                     state.sources);
                 messageId = assistant.getId();
@@ -247,6 +263,8 @@ public class AiTurnFinisher {
      */
     AiMessage finish(SseEmitter emitter, Long sessionId, AiStreamState state, long durationMs,
                      Long resumeMessageId, AiRouteContext route) {
+        // 先停止周期落库,避免迟到的进度写入覆盖本次最终正文
+        closeProgress(state);
         // 对话期进度:收尾要做安全复检与落库,先播报「在整理」;正文尾部冲刷会随后清掉该状态行
         AiPhaseSupport.emit(emitter, state, AiPhaseSupport.PHASE_FINALIZING, "数剑正在整理回答…", null);
         // 安全合规:先冲刷尾部缓冲(与 SSE 同源),再对最终正文做一次完整守卫(含专家直答正文)
@@ -254,9 +272,9 @@ public class AiTurnFinisher {
         List<AiToolCallLog> logs = buildToolLogs(state, route);
         String replyId = state.replyId;
         ChatTokenUsage tokens = state.toTokenUsage();
-        // 专家直答接管态(REQ-AI-30 直答修订):回答正文取专家完整正文,而非入口轮(已被丢弃的)正文
-        String content = route != null && route.handoff && route.handoffAnswer.length() > 0
-            ? route.handoffAnswer.toString() : state.answer.toString();
+        // 专家直答接管态(REQ-AI-30 直答修订):回答正文取专家完整正文,而非入口轮(已被丢弃的)正文;
+        // 两者都为空时回退到「实际下发正文」,避免专家直答/整合段异常时落库空回答。
+        String content = answerContent(state, route);
         SafetyDecision outputGuard = safetyGuard.guard(content, SafetyScene.OUTPUT);
         if (outputGuard.hit()) {
             safetyEventService.record(SafetyScene.OUTPUT, outputGuard, safetyGuard.engineName(),
@@ -270,10 +288,19 @@ public class AiTurnFinisher {
         AiMessage assistant;
         try {
             if (resumeMessageId == null) {
-                assistant = sessionService.persistAssistantTurn(sessionId, content,
-                    replyId, durationMs, logs, tokens, state.userId, state.sources);
+                // 新轮:优先更新本轮开始时插入的流式占位行(保留同一条消息,刷新后不会多出一条)
+                assistant = state.assistantMessageId == null
+                    ? null
+                    : sessionService.updateAssistantTerminal(state.assistantMessageId, content, replyId,
+                        AiMessage.STATUS_NORMAL, durationMs, logs, tokens, state.userId, state.sources, null);
+                if (assistant == null) {
+                    assistant = sessionService.persistAssistantTurn(sessionId, content,
+                        replyId, durationMs, logs, tokens, state.userId, state.sources);
+                }
             } else {
-                assistant = sessionService.appendAssistantTurn(resumeMessageId, content,
+                // 恢复段:周期落库写的是「已有前缀 + 本段正文」,收尾整体覆盖,避免追加成两份
+                String fullContent = (state.baseAnswerContent == null ? "" : state.baseAnswerContent) + content;
+                assistant = sessionService.replaceAssistantTurn(resumeMessageId, fullContent,
                     AiMessage.STATUS_NORMAL, durationMs, logs, tokens, state.sources);
             }
         } catch (Exception e) {
@@ -335,6 +362,37 @@ public class AiTurnFinisher {
         return assistant;
     }
 
+    /**
+     * 取本轮回答正文(优先专家直答接管正文,其次入口累积正文,最后实际下发正文)。
+     *
+     * <p>取消 / 暂停可能发生在专家直答中途:此时入口轮 {@code answer} 已被清空,
+     * 专家已流出的正文在 {@code visibleAnswer} 里。不取它会导致「已中止但正文为空」。</p>
+     *
+     * @param state 流式累积状态
+     * @param route 编排上下文(可为 null)
+     * @return 本轮正文
+     */
+    private String answerContent(AiStreamState state, AiRouteContext route) {
+        // 仅「专家直答接管态」才取 handoffAnswer;降级 / 整合轮即使残留专家正文也不能采用
+        if (route != null && route.handoff && route.handoffAnswer.length() > 0) {
+            return route.handoffAnswer.toString();
+        }
+        if (state.answer.length() > 0) {
+            return state.answer.toString();
+        }
+        return state.visibleAnswer.toString();
+    }
+
+    /**
+     * 取本段新增正文(不含恢复段的已有前缀),用于追加更新同一条助手消息。
+     *
+     * @param state 流式累积状态
+     * @return 本段正文
+     */
+    private String segmentContent(AiStreamState state) {
+        return state.answer.length() > 0 ? state.answer.toString() : state.visibleAnswer.toString();
+    }
+
     /**
      * 删除重新生成时要替换掉的旧回答。
      *
@@ -367,18 +425,26 @@ public class AiTurnFinisher {
      */
     Long finishPending(SseEmitter emitter, Long sessionId, AiStreamState state, long durationMs,
                        AiRouteContext route) {
+        // 暂停也是本段终态:停止周期落库,恢复段会重新启动
+        closeProgress(state);
         streamBridge.flushSafety(emitter, state);
         AiConfirmPendingStore.ExpertResume expertResume = route == null ? null : route.pendingResume;
         // 专家链路的暂停:正文用**平台文案**,不落入口智能体在暂停后可能续写的残句
-        String content = expertResume == null ? state.answer.toString() : PENDING_EXPERT_TEXT;
+        String content = expertResume == null ? answerContent(state, route) : PENDING_EXPERT_TEXT;
         // 暂停前已完成的工具调用(如被拒前的只读探测)同样计次:链路追踪按本段实际落库数累加
         List<AiToolCallLog> logs = buildDoneToolLogs(state, route);
         AiMessage assistant;
         try {
             // 本段已完成(含被拒)的工具调用照常落明细:暂停发生在工具首次请求之后,
             // 之前已执行的读/内置工具不应因为「本轮暂停」而从审计里消失
-            assistant = sessionService.persistPendingTurn(sessionId, content, state.pendingReplyId, durationMs,
-                logs, state.toTokenUsage(), state.userId, state.sources);
+            assistant = state.assistantMessageId == null ? null
+                : sessionService.updateAssistantTerminal(state.assistantMessageId, content, state.pendingReplyId,
+                    AiMessage.STATUS_PENDING_CONFIRM, durationMs, logs, state.toTokenUsage(), state.userId,
+                    state.sources, null);
+            if (assistant == null) {
+                assistant = sessionService.persistPendingTurn(sessionId, content, state.pendingReplyId, durationMs,
+                    logs, state.toTokenUsage(), state.userId, state.sources);
+            }
         } catch (Exception e) {
             log.error("落库待确认消息异常,sessionId={}", sessionId, e);
             sendPendingSaveError(emitter, e);
@@ -406,17 +472,20 @@ public class AiTurnFinisher {
      */
     void finishPendingResume(SseEmitter emitter, Long sessionId, AiStreamState state, long durationMs,
                              Long messageId, AiRouteContext route) {
+        // 暂停也是本段终态:停止周期落库,恢复段会重新启动
+        closeProgress(state);
         streamBridge.flushSafety(emitter, state);
         AiConfirmPendingStore.ExpertResume expertResume = route == null ? null : route.pendingResume;
         // 专家链路的暂停文案在首次暂停时已写入同一条消息,再次暂停不再重复追加(空串=只回写状态)
-        String content = expertResume == null ? state.answer.toString() : "";
+        String content = expertResume == null ? segmentContent(state) : "";
         List<AiToolCallLog> logs = buildDoneToolLogs(state, route);
         AiMessage assistant;
         try {
             // 同上:暂停前已完成的工具调用(如用户刚确认并已执行的写操作)必须落行,
             // 否则恢复段换了新的编排上下文,这些明细就丢了
-            assistant = sessionService.appendAssistantTurn(messageId, content, AiMessage.STATUS_PENDING_CONFIRM,
-                durationMs, logs, state.toTokenUsage(), state.sources);
+            String fullContent = (state.baseAnswerContent == null ? "" : state.baseAnswerContent) + content;
+            assistant = sessionService.replaceAssistantTurn(messageId, fullContent,
+                AiMessage.STATUS_PENDING_CONFIRM, durationMs, logs, state.toTokenUsage(), state.sources);
         } catch (Exception e) {
             log.error("落库待确认消息异常(恢复段),sessionId={}, messageId={}", sessionId, messageId, e);
             sendPendingSaveError(emitter, e);
@@ -425,6 +494,67 @@ public class AiTurnFinisher {
         afterPendingPersisted(emitter, state, durationMs, assistant, 0, expertResume, logs.size());
     }
 
+    /**
+     * 失败收尾:把已生成的可见正文与错误原因落库到同一条助手消息。
+     *
+     * <p>原实现只落错误文案、丢弃半截回答,用户刷新后实时看到的正文会消失。这里优先更新
+     * 本轮占位行(正文 + errorMsg,status=1);没有占位行时才回退为新建失败消息。</p>
+     *
+     * @param sessionId  会话主键
+     * @param state      流式累积状态
+     * @param durationMs 本轮耗时(毫秒)
+     * @param errorMsg   面向用户的失败原因
+     * @param route      编排上下文(可为 null)
+     * @return 落库的失败消息;落库失败时返回 null
+     */
+    AiMessage failTurn(Long sessionId, AiStreamState state, long durationMs, String errorMsg,
+                       AiRouteContext route) {
+        closeProgress(state);
+        // 把安全尾部缓冲并入正文(无人值守:emitter 传 null,只累积不下发)
+        try {
+            streamBridge.flushSafety(null, state);
+        } catch (Exception e) {
+            log.warn("失败收尾冲刷正文尾部异常,sessionId={}:{}", sessionId, e.getMessage());
+        }
+        if (state.process != null) {
+            state.process.abortRunning(errorMsg);
+        }
+        List<AiToolCallLog> logs = buildDoneToolLogs(state, route);
+        AiMessage failed = null;
+        try {
+            if (state.assistantMessageId != null) {
+                failed = sessionService.updateAssistantTerminal(state.assistantMessageId, state.visibleText(),
+                    state.replyId, AiMessage.STATUS_FAILED, durationMs, logs, state.toTokenUsage(),
+                    state.userId, state.sources, errorMsg);
+            }
+            if (failed == null) {
+                failed = sessionService.persistAssistantFailure(sessionId, errorMsg, durationMs);
+            }
+            if (failed != null) {
+                persistProcessSteps(state, sessionId, failed.getId());
+            }
+        } catch (Exception e) {
+            log.error("落库失败消息异常,sessionId={}", sessionId, e);
+        }
+        return failed;
+    }
+
+    /**
+     * 关闭本轮生成期间的进度持久化(幂等;收尾 / 失败 / 暂停前调用)。
+     *
+     * @param state 流式累积状态
+     */
+    void closeProgress(AiStreamState state) {
+        if (state == null) {
+            return;
+        }
+        AiStreamProgressPersister.Handle handle = state.progress;
+        state.progress = null;
+        if (handle != null) {
+            handle.close();
+        }
+    }
+
     /**
      * 待确认落库后的公共收尾:用量、链路、决策留痕、暂存与确认卡片下发。
      *

+ 55 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/core/agent/WorkbenchArtifactPromptMiddleware.java

@@ -0,0 +1,55 @@
+package com.zsjz.ai.module.ai.core.agent;
+
+import io.agentscope.core.agent.Agent;
+import io.agentscope.core.agent.RuntimeContext;
+import io.agentscope.core.middleware.MiddlewareBase;
+import reactor.core.publisher.Mono;
+
+/**
+ * 智能工作台「工作区与产物落盘」约束注入中间件。
+ *
+ * <p>背景:智能工作台的文件工具限定在会话命名空间 {@code workbench/{sessionId}},
+ * 而 {@code workbench/shared/} 是案件的只读数据副本({@code import/} 原件与
+ * {@code db/case.duckdb})。模型通过 {@code execute} 直接在宿主机执行命令时可以绕过文件工具
+ * 命名空间,把交付物写进 {@code shared/};产物面板只扫描会话目录且将 {@code shared}
+ * 列为保留目录,导致这些文件在产物列表中不可见。</p>
+ *
+ * <p>本中间件只在运行期上下文标记为「会话级工作台工作区」
+ * ({@link AiRuntimeKeys#SESSION_SCOPED_WORKSPACE})时,向系统提示词追加一段明确约束:
+ * 交付物统一写当前会话目录的 {@code ./outputs/},{@code shared/} 只读。普通会话不受影响,
+ * 也不会改变装配缓存指纹(约束按轮次注入,不参与智能体装配)。</p>
+ *
+ * @author cc
+ */
+public class WorkbenchArtifactPromptMiddleware implements MiddlewareBase {
+
+    /**
+     * 段落标题:同时用于幂等判断,避免中间件被重复调用时重复追加
+     */
+    static final String SECTION_TITLE = "## 工作区与产物落盘约束(智能工作台)";
+
+    /**
+     * 注入正文
+     */
+    static final String DISCIPLINE = """
+
+        ## 工作区与产物落盘约束(智能工作台)
+
+        - 当前工作目录是本次会话的独立工作区,文件工具的“相对路径”都以它为根。
+        - `shared/` 是案件的**只读数据副本**(`import/` 原件、`db/case.duckdb`),禁止写入、修改、删除;`shared/case.json` 只描述数据源,不是输出目录。
+        - 所有交付物必须写到当前会话工作区的 `./outputs/` 下(例如 `./outputs/研判报告.html`);产物面板扫描 `outputs/` 与 `plans/`,写到会话根目录、`shared/` 或其他位置都不会出现在产物列表中。
+        - `plans/` 仅用于计划模式的计划文档(如 `plans/PLAN.md`),不要放普通交付物。
+        - 中间脚本、日志等临时文件可以留在当前目录;用 `execute` 运行脚本时,脚本内部写文件也必须指向 `./outputs/`,不要 `cd` 到 `shared/` 或把结果写进 `shared/`。
+        - 读取案件数据时使用相对路径 `import/...`、`db/case.duckdb`;文件工具默认就能看到 `shared/` 的只读副本。
+        """;
+
+    @Override
+    public Mono<String> onSystemPrompt(Agent agent, RuntimeContext ctx, String currentPrompt) {
+        String base = currentPrompt == null ? "" : currentPrompt;
+        Object scoped = ctx == null ? null : ctx.get(AiRuntimeKeys.SESSION_SCOPED_WORKSPACE);
+        if (!"1".equals(String.valueOf(scoped)) || base.contains(SECTION_TITLE)) {
+            return Mono.just(base);
+        }
+        return Mono.just(base + DISCIPLINE);
+    }
+}

+ 31 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/core/run/AiStaleRunReaper.java

@@ -7,8 +7,10 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import com.zsjz.ai.module.ai.config.AiProperties;
 import com.zsjz.ai.module.ai.domain.AiDocument;
+import com.zsjz.ai.module.ai.domain.AiMessage;
 import com.zsjz.ai.module.ai.domain.AiRouteRun;
 import com.zsjz.ai.module.ai.mapper.AiDocumentMapper;
+import com.zsjz.ai.module.ai.mapper.AiMessageMapper;
 import com.zsjz.ai.module.ai.mapper.AiRouteRunMapper;
 import org.springframework.boot.context.event.ApplicationReadyEvent;
 import org.springframework.context.event.EventListener;
@@ -59,6 +61,7 @@ public class AiStaleRunReaper {
     static final String DOC_PARSE_MESSAGE = "任务因服务重启或长时间无进展被中断,请重新执行解析";
     static final String DOC_VECTOR_MESSAGE = "任务因服务重启或长时间无进展被中断,请重新执行向量化";
     static final String ROUTE_MESSAGE = "服务重启或长时间无进展,本次编排已中断";
+    static final String STREAM_MESSAGE = "服务重启或长时间无进展,本轮回答已中断";
 
     /**
      * 最小扫描间隔(秒):防止把配置误填成 0 导致空转
@@ -69,6 +72,8 @@ public class AiStaleRunReaper {
 
     private final AiRouteRunMapper routeRunMapper;
 
+    private final AiMessageMapper messageMapper;
+
     private final AiProperties aiProperties;
 
     /**
@@ -110,6 +115,7 @@ public class AiStaleRunReaper {
         total += safely("文档解析", () -> reapParsingDocuments(deadline));
         total += safely("文档向量化", () -> reapVectorizingDocuments(deadline));
         total += safely("编排运行", () -> reapRouteRuns(deadline));
+        total += safely("流式回答", () -> reapStreamingMessages(deadline));
         if (total > 0) {
             log.warn("已回收 {} 条中断的在跑记录(阈值 {} 分钟)", total, config.getStaleMinutes());
         }
@@ -158,6 +164,31 @@ public class AiStaleRunReaper {
         return count;
     }
 
+    /**
+     * 流式助手消息:streaming=1 → streaming=0 + 已中止。
+     *
+     * <p>进程重启 / 容器被 kill 后,占位行不会自动收尾,页面会永远显示「生成中」。
+     * 生成期间进度持久化会持续刷新 {@code update_time},因此「超过阈值未刷新」才是可靠的死亡判据;
+     * 只写 SET、不刷新时间,保证同一轮扫描不会被自己的更新挡住。</p>
+     *
+     * @param deadline 逾期阈值
+     * @return 回收条数
+     */
+    private int reapStreamingMessages(LocalDateTime deadline) {
+        LambdaUpdateWrapper<AiMessage> wrapper = Wrappers.lambdaUpdate();
+        wrapper.set(AiMessage::getStreaming, "0")
+            .set(AiMessage::getStatus, AiMessage.STATUS_ABORTED)
+            .set(AiMessage::getErrorMsg, STREAM_MESSAGE)
+            .eq(AiMessage::getRole, AiMessage.ROLE_ASSISTANT)
+            .eq(AiMessage::getStreaming, "1")
+            .lt(AiMessage::getUpdateTime, deadline);
+        int count = messageMapper.update(null, wrapper);
+        if (count > 0) {
+            log.warn("回收中断的流式回答:{} 条", count);
+        }
+        return count;
+    }
+
     /**
      * 编排运行:running → aborted。
      *

+ 5 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/domain/AiMessage.java

@@ -37,6 +37,11 @@ public class AiMessage extends BaseEntity {
      */
     public static final String STATUS_NORMAL = "0";
 
+    /**
+     * 消息状态:失败
+     */
+    public static final String STATUS_FAILED = "1";
+
     /**
      * 消息状态:等待人工确认工具调用(HITL 暂停)
      */

+ 34 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/domain/vo/AiRunningTurnVo.java

@@ -0,0 +1,34 @@
+package com.zsjz.ai.module.ai.domain.vo;
+
+import lombok.Data;
+
+import java.io.Serial;
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * 会话当前运行中的一轮(供前端切页 / 刷新后轮询续看)。
+ *
+ * @author BizBuddy
+ */
+@Data
+public class AiRunningTurnVo implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 是否仍在生成(含「已登记运行但占位行尚未落库」的极短窗口)
+     */
+    private boolean running;
+
+    /**
+     * 当前流式助手消息({@code streaming=1});不存在时为空
+     */
+    private AiMessageVo message;
+
+    /**
+     * 当前这一轮已落库的执行步骤(可为空)
+     */
+    private List<AiMessageStepVo> steps;
+}

+ 7 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/domain/vo/AiSessionVo.java

@@ -125,6 +125,13 @@ public class AiSessionVo implements Serializable {
     @TableField(exist = false)
     private String pinnedExpertName;
 
+    /**
+     * 是否正在生成回答(附加字段,由 Service 按 ai_message.streaming 回填;
+     * 供多会话并行时左侧任务列表展示「生成中」角标)
+     */
+    @TableField(exist = false)
+    private Boolean running;
+
     /**
      * 备注
      */

+ 8 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/service/IAiMessageStepService.java

@@ -32,6 +32,14 @@ public interface IAiMessageStepService {
      */
     List<AiMessageStepVo> listBySession(Long sessionId);
 
+    /**
+     * 按助手消息主键查询步骤(运行状态轮询时只取当前这一轮的步骤)。
+     *
+     * @param messageId 助手消息主键
+     * @return 步骤视图列表(按 seq 升序)
+     */
+    List<AiMessageStepVo> listByMessage(Long messageId);
+
     /**
      * 按助手消息主键批量物理删除(重新生成 / 删除轮次级联)。
      *

+ 90 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/service/IAiSessionService.java

@@ -213,6 +213,77 @@ public interface IAiSessionService {
                                    List<AiToolCallLog> toolLogs, ChatTokenUsage tokens, Long userId,
                                    List<AiSourceVo> sources);
 
+    /**
+     * 本轮开始时插入助手占位消息({@code streaming=1}),供生成期间增量落库与断线后回看。
+     *
+     * <p>占位行会先计入会话消息数一次;后续收尾只更新同一行,不再重复计数。</p>
+     *
+     * @param sessionId 会话主键
+     * @return 占位消息实体
+     */
+    AiMessage persistAssistantStreaming(Long sessionId);
+
+    /**
+     * 生成期间增量更新助手占位消息的正文(只刷新正文与更新时间,不改状态、不重复计数)。
+     *
+     * @param messageId 助手消息主键
+     * @param content   当前已生成的用户可见正文
+     */
+    void updateAssistantStreaming(Long messageId, String content);
+
+    /**
+     * 收尾更新助手占位消息(正常 / 失败 / 已中止 / 待确认),并落工具明细、Token、耗时与来源。
+     *
+     * @param messageId  助手消息主键
+     * @param content    最终正文
+     * @param replyId    AgentScope replyId(可空)
+     * @param status     消息状态(0 正常 / 1 失败 / 2 待确认 / 3 已中止)
+     * @param durationMs 本轮耗时(毫秒)
+     * @param toolLogs   工具调用明细(可空)
+     * @param tokens     Token 用量(可空)
+     * @param userId     触发用户(工具明细归属用户)
+     * @param sources    回答参考来源(可空)
+     * @param errorMsg   失败原因(可空)
+     * @return 更新后的助手消息;行不存在时返回 null
+     */
+    AiMessage updateAssistantTerminal(Long messageId, String content, String replyId, String status,
+                                      Long durationMs, List<AiToolCallLog> toolLogs, ChatTokenUsage tokens,
+                                      Long userId, List<AiSourceVo> sources, String errorMsg);
+
+    /**
+     * 查询会话内最新的流式助手消息({@code streaming=1})。
+     *
+     * @param sessionId 会话主键
+     * @return 流式助手消息;没有则返回 null
+     */
+    AiMessage queryStreamingAssistant(Long sessionId);
+
+    /**
+     * 把失联的流式助手消息置为已中止(服务重启 / 长时间无进展)。
+     *
+     * @param messageId 助手消息主键
+     * @param reason    中止原因
+     */
+    void abortStaleStreaming(Long messageId, String reason);
+
+    /**
+     * 把暂停等待确认的助手消息重新标记为「生成中」(HITL 恢复段开始时调用)。
+     *
+     * <p>恢复段会复用暂停时落库的同一条消息;标记 streaming=1 后,周期落库与
+     * 运行状态轮询才能像首段一样工作(切页 / 刷新后可继续续看)。再次暂停或收尾时
+     * 会按终端状态写回 streaming=0。</p>
+     *
+     * @param messageId 助手消息主键
+     */
+    void markAssistantStreaming(Long messageId);
+
+    /**
+     * 只刷新会话最后活跃时间,不累加消息条数(生成期间周期调用)。
+     *
+     * @param sessionId 会话主键
+     */
+    void touchSessionActive(Long sessionId);
+
     /**
      * 落库助手失败消息。
      *
@@ -274,6 +345,25 @@ public interface IAiSessionService {
     AiMessage appendAssistantTurn(Long messageId, String appendContent, String status, Long additionalDurationMs,
                                   List<AiToolCallLog> toolLogs, ChatTokenUsage tokens, List<AiSourceVo> sources);
 
+    /**
+     * 覆盖更新同一条助手消息的正文(HITL 恢复段使用)。
+     *
+     * <p>恢复段期间进度持久化会把「已有正文 + 本段新增」整体写回同一条消息;
+     * 收尾若再追加一次就会重复,故收尾按「已有前缀 + 本段最终正文」整体覆盖。
+     * 耗时 / Token / 工具次数仍按段累加。</p>
+     *
+     * @param messageId          助手消息主键
+     * @param fullContent        本轮完整正文(已有前缀 + 本段正文)
+     * @param status             覆盖后的消息状态
+     * @param additionalDurationMs 本段耗时(毫秒)
+     * @param toolLogs           本段工具调用明细(可为空)
+     * @param tokens             本段 Token 用量(可为空)
+     * @param sources            回答参考来源(可空:为空时保留原值)
+     * @return 更新后的助手消息实体
+     */
+    AiMessage replaceAssistantTurn(Long messageId, String fullContent, String status, Long additionalDurationMs,
+                                   List<AiToolCallLog> toolLogs, ChatTokenUsage tokens, List<AiSourceVo> sources);
+
     /**
      * 查询会话内仍处于「等待确认」状态的助手消息(供刷新页面后恢复确认卡片)。
      *

+ 37 - 18
ai-server/src/main/java/com/zsjz/ai/module/ai/service/impl/AiArtifactServiceImpl.java

@@ -34,10 +34,12 @@ import java.util.Map;
 import java.util.Set;
 
 /**
- * AI 会话产物服务实现:直接扫描智能工作台会话工作区。
+ * AI 会话产物服务实现:扫描智能工作台会话的 {@code outputs/} 与 {@code plans/} 目录。
  *
- * <p>不落库、不复制副本:文件是唯一事实来源。扫描时排除框架运行目录与共享输入副本,
- * 只返回会话根下的普通文件(含 {@code outputs/} 等业务目录)。</p>
+ * <p>不落库、不复制副本:文件是唯一事实来源。扫描范围固定为
+ * {@code cases/{caseId}/ai/workbench/{sessionId}/{outputs|plans}},会话根下的脚本、日志、
+ * 框架运行目录与共享输入副本都不进入产物列表;产物路径以会话工作区为根,
+ * 形如 {@code outputs/报告.html}、{@code plans/PLAN.md}。</p>
  *
  * @author cc
  */
@@ -47,7 +49,7 @@ import java.util.Set;
 public class AiArtifactServiceImpl implements IAiArtifactService {
 
     /**
-     * 扫描最大深度(相对会话根)
+     * 扫描最大深度(相对产物根 {@code outputs/})
      */
     private static final int MAX_DEPTH = 8;
 
@@ -56,6 +58,12 @@ public class AiArtifactServiceImpl implements IAiArtifactService {
      */
     private static final int MAX_FILES = 500;
 
+    /**
+     * 允许作为会话产物的顶级目录(相对会话工作区根)
+     */
+    private static final List<String> ARTIFACT_DIRS = List.of(
+            StorageLayout.WORKBENCH_OUTPUTS_DIR, StorageLayout.WORKBENCH_PLANS_DIR);
+
     /**
      * 文本预览最多读取的字节数
      */
@@ -148,15 +156,19 @@ public class AiArtifactServiceImpl implements IAiArtifactService {
     @Override
     public AiArtifactListVo list(Long sessionId) {
         AiSession session = requireWorkbenchSession(sessionId);
-        Path root = workspaceRoot(session);
+        Path root = sessionRoot(session);
         List<AiArtifactVo> items = new ArrayList<>();
         boolean[] truncated = {false};
-        if (Files.isDirectory(root)) {
+        for (String dirName : ARTIFACT_DIRS) {
+            Path dir = root.resolve(dirName);
+            if (!Files.isDirectory(dir)) {
+                continue;
+            }
             ArtifactCollector collector = new ArtifactCollector(root, items, truncated);
             try {
-                Files.walkFileTree(root, EnumSet.noneOf(FileVisitOption.class), MAX_DEPTH, collector);
+                Files.walkFileTree(dir, EnumSet.noneOf(FileVisitOption.class), MAX_DEPTH, collector);
             } catch (IOException e) {
-                log.warn("扫描会话产物失败:sessionId={}, root={}, err={}", sessionId, root, e.getMessage());
+                log.warn("扫描会话产物失败:sessionId={}, dir={}, err={}", sessionId, dir, e.getMessage());
             }
         }
         items.sort(Comparator.comparing(AiArtifactVo::getLastModified,
@@ -203,7 +215,7 @@ public class AiArtifactServiceImpl implements IAiArtifactService {
             truncated = true;
         }
         AiArtifactContentVo vo = new AiArtifactContentVo();
-        vo.setPath(relativePath(workspaceRoot(session), file));
+        vo.setPath(relativePath(sessionRoot(session), file));
         vo.setName(name);
         vo.setKind(kind);
         vo.setMime(mimeOf(file, name));
@@ -240,21 +252,23 @@ public class AiArtifactServiceImpl implements IAiArtifactService {
     }
 
     /**
-     * 会话工作区根目录(绝对化 + 规范化)。
+     * 会话工作区根目录(绝对化 + 规范化)。产物路径以它为根,带 {@code outputs/} 或
+     * {@code plans/} 前缀。
      */
-    private Path workspaceRoot(AiSession session) {
+    private Path sessionRoot(AiSession session) {
         return storageLayout.caseWorkbenchSessionDir(session.getCaseId(), session.getId())
                 .toAbsolutePath().normalize();
     }
 
     /**
-     * 解析并校验产物文件:只允许会话根下的普通文件,拒绝绝对路径、穿越、保留目录与符号链接。
+     * 解析并校验产物文件:只允许会话工作区 {@code outputs/} 或 {@code plans/} 下的普通文件,
+     * 拒绝绝对路径、穿越、保留目录与符号链接。
      */
     private Path resolveArtifact(AiSession session, String rawPath) {
         if (StringUtils.isBlank(rawPath)) {
             throw new ServiceException("产物路径不能为空");
         }
-        Path root = workspaceRoot(session);
+        Path root = sessionRoot(session);
         if (!Files.isDirectory(root)) {
             throw new ServiceException("会话工作区不存在");
         }
@@ -267,25 +281,30 @@ public class AiArtifactServiceImpl implements IAiArtifactService {
         if (relative.isAbsolute() || relative.getNameCount() == 0) {
             throw new ServiceException("产物路径不合法");
         }
+        String top = relative.getName(0).toString();
+        if (!ARTIFACT_DIRS.contains(top)) {
+            throw new ServiceException("产物路径不合法");
+        }
         for (Path segment : relative) {
             String name = segment.toString();
             if (name.isBlank() || "..".equals(name) || ".".equals(name) || isReservedName(name)) {
                 throw new ServiceException("产物路径不合法");
             }
         }
+        Path allowedDir = root.resolve(top).normalize();
         Path target = root.resolve(relative).normalize();
-        if (!target.startsWith(root) || Files.isSymbolicLink(target)) {
+        if (!target.startsWith(root) || Files.isSymbolicLink(target) || Files.isSymbolicLink(allowedDir)) {
             throw new ServiceException("产物路径不合法");
         }
-        Path realRoot;
+        Path realAllowedDir;
         Path realTarget;
         try {
-            realRoot = root.toRealPath();
+            realAllowedDir = allowedDir.toRealPath();
             realTarget = target.toRealPath();
         } catch (IOException e) {
             throw new ServiceException("产物文件不存在");
         }
-        if (!realTarget.startsWith(realRoot)) {
+        if (!realTarget.startsWith(realAllowedDir)) {
             throw new ServiceException("产物路径不合法");
         }
         if (!Files.isRegularFile(realTarget)) {
@@ -368,7 +387,7 @@ public class AiArtifactServiceImpl implements IAiArtifactService {
     }
 
     /**
-     * 相对会话根目录的 POSIX 路径。
+     * 相对会话工作区根目录的 POSIX 路径(带 {@code outputs/} 或 {@code plans/} 前缀)。
      */
     private static String relativePath(Path root, Path file) {
         return root.relativize(file).toString().replace('\\', '/');

+ 10 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/service/impl/AiMessageStepServiceImpl.java

@@ -78,6 +78,16 @@ public class AiMessageStepServiceImpl implements IAiMessageStepService {
             .orderByAsc(AiMessageStep::getSeq));
     }
 
+    @Override
+    public List<AiMessageStepVo> listByMessage(Long messageId) {
+        if (messageId == null) {
+            return List.of();
+        }
+        return baseMapper.selectVoList(Wrappers.<AiMessageStep>lambdaQuery()
+            .eq(AiMessageStep::getMessageId, messageId)
+            .orderByAsc(AiMessageStep::getSeq));
+    }
+
     @Override
     public void deleteByMessageIds(Collection<Long> messageIds) {
         if (messageIds == null || messageIds.isEmpty()) {

+ 195 - 0
ai-server/src/main/java/com/zsjz/ai/module/ai/service/impl/AiSessionServiceImpl.java

@@ -8,6 +8,7 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import io.agentscope.core.state.AgentStateStore;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import com.zsjz.ai.module.ai.config.AiProperties;
 import com.zsjz.ai.module.ai.core.agent.AiExpertDirectory;
 import com.zsjz.ai.module.ai.core.chat.AiAttachmentReclaimer;
 import com.zsjz.ai.module.ai.domain.AiAgent;
@@ -131,6 +132,11 @@ public class AiSessionServiceImpl implements IAiSessionService {
      */
     private static final String STREAMING_DONE = "0";
 
+    /**
+     * 流式状态:生成中
+     */
+    private static final String STREAMING_RUNNING = "1";
+
     /**
      * 会话状态:进行中
      */
@@ -198,6 +204,11 @@ public class AiSessionServiceImpl implements IAiSessionService {
      */
     private final StorageLayout storageLayout;
 
+    /**
+     * 对话配置:列表「生成中」角标按 streaming 新鲜度过滤,避免展示崩溃残留
+     */
+    private final AiProperties aiProperties;
+
     @Override
     @Transactional(rollbackFor = Exception.class)
     public AiSessionVo createSession(Long agentId, Long scenarioPackId, String title, Long pinnedExpertId,
@@ -359,6 +370,8 @@ public class AiSessionServiceImpl implements IAiSessionService {
         Page<AiSessionVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
         // 会话列表需回显所选场景包名称(对话页底栏把「已固化的场景包」以只读标签展示)
         fillDisplayNames(result.getRecords());
+        // 多会话并行:回填「生成中」标志,供左侧任务列表展示角标
+        fillRunningFlags(result.getRecords());
         return PageResult.build(result.getRecords(), result.getTotal());
     }
 
@@ -791,6 +804,154 @@ public class AiSessionServiceImpl implements IAiSessionService {
         return message;
     }
 
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AiMessage persistAssistantStreaming(Long sessionId) {
+        AiMessage message = new AiMessage();
+        message.setSessionId(sessionId);
+        message.setRole(AiMessage.ROLE_ASSISTANT);
+        message.setContent("");
+        message.setStreaming(STREAMING_RUNNING);
+        message.setStatus(MESSAGE_NORMAL);
+        message.setToolCallCount(0);
+        messageMapper.insert(message);
+        // 占位行先计一次消息数;收尾只更新同一行,不再重复计数
+        touchSession(sessionId);
+        return message;
+    }
+
+    @Override
+    public void updateAssistantStreaming(Long messageId, String content) {
+        if (messageId == null) {
+            return;
+        }
+        // 只更新仍在生成中的行:收尾 / 中止后即使有迟到的周期任务,也不会覆盖最终正文。
+        // 用 wrapper 显式写 update_time(无实体自动填充),同时作为「仍在跑」的存活信号。
+        LambdaUpdateWrapper<AiMessage> wrapper = Wrappers.lambdaUpdate();
+        wrapper.set(AiMessage::getContent, content == null ? "" : content)
+            .set(AiMessage::getUpdateTime, LocalDateTime.now())
+            .eq(AiMessage::getId, messageId)
+            .eq(AiMessage::getStreaming, STREAMING_RUNNING);
+        messageMapper.update(null, wrapper);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AiMessage updateAssistantTerminal(Long messageId, String content, String replyId, String status,
+                                             Long durationMs, List<AiToolCallLog> toolLogs, ChatTokenUsage tokens,
+                                             Long userId, List<AiSourceVo> sources, String errorMsg) {
+        if (messageId == null) {
+            return null;
+        }
+        AiMessage exists = messageMapper.selectById(messageId);
+        if (exists == null) {
+            return null;
+        }
+        AiMessage update = new AiMessage();
+        update.setId(messageId);
+        update.setContent(content == null ? "" : content);
+        update.setReplyId(replyId);
+        update.setStreaming(STREAMING_DONE);
+        update.setStatus(status == null ? MESSAGE_NORMAL : status);
+        update.setDurationMs(durationMs);
+        update.setToolCallCount(toolLogs == null ? 0 : toolLogs.size());
+        applyTokens(update, tokens);
+        applySources(update, sources);
+        update.setErrorMsg(errorMsg);
+        messageMapper.updateById(update);
+        insertToolLogs(exists.getSessionId(), messageId, toolLogs, userId);
+        touchSessionActive(exists.getSessionId());
+        return messageMapper.selectById(messageId);
+    }
+
+    @Override
+    public AiMessage queryStreamingAssistant(Long sessionId) {
+        if (sessionId == null) {
+            return null;
+        }
+        LambdaQueryWrapper<AiMessage> lqw = Wrappers.lambdaQuery();
+        lqw.eq(AiMessage::getSessionId, sessionId)
+            .eq(AiMessage::getRole, AiMessage.ROLE_ASSISTANT)
+            .eq(AiMessage::getStreaming, STREAMING_RUNNING)
+            .orderByDesc(AiMessage::getId)
+            .last("limit 1");
+        return messageMapper.selectOne(lqw);
+    }
+
+    @Override
+    public void abortStaleStreaming(Long messageId, String reason) {
+        if (messageId == null) {
+            return;
+        }
+        LambdaUpdateWrapper<AiMessage> wrapper = Wrappers.lambdaUpdate();
+        wrapper.set(AiMessage::getStreaming, STREAMING_DONE)
+            .set(AiMessage::getStatus, AiMessage.STATUS_ABORTED)
+            .set(AiMessage::getErrorMsg, StringUtils.substring(reason, 0, ERROR_MSG_MAX_LENGTH))
+            .set(AiMessage::getUpdateTime, LocalDateTime.now())
+            .eq(AiMessage::getId, messageId)
+            .eq(AiMessage::getStreaming, STREAMING_RUNNING);
+        messageMapper.update(null, wrapper);
+    }
+
+    @Override
+    public void markAssistantStreaming(Long messageId) {
+        if (messageId == null) {
+            return;
+        }
+        LambdaUpdateWrapper<AiMessage> wrapper = Wrappers.lambdaUpdate();
+        wrapper.set(AiMessage::getStreaming, STREAMING_RUNNING)
+            .set(AiMessage::getStatus, MESSAGE_NORMAL)
+            .set(AiMessage::getUpdateTime, LocalDateTime.now())
+            .eq(AiMessage::getId, messageId);
+        messageMapper.update(null, wrapper);
+    }
+
+    @Override
+    public void touchSessionActive(Long sessionId) {
+        if (sessionId == null) {
+            return;
+        }
+        AiSession update = new AiSession();
+        update.setId(sessionId);
+        update.setLastActiveTime(LocalDateTime.now());
+        baseMapper.updateById(update);
+    }
+
+    /**
+     * 批量回填会话「生成中」标志(多会话并行的列表角标)。
+     *
+     * <p>只查本页会话,避免 N+1;读 DB 的 {@code ai_message.streaming},
+     * 跨副本部署时也能反映后台真实运行状态。</p>
+     *
+     * @param records 会话列表
+     */
+    private void fillRunningFlags(List<AiSessionVo> records) {
+        if (records == null || records.isEmpty()) {
+            return;
+        }
+        List<Long> sessionIds = records.stream()
+            .map(AiSessionVo::getId)
+            .filter(Objects::nonNull)
+            .toList();
+        if (sessionIds.isEmpty()) {
+            return;
+        }
+        // 只统计「最近仍有进度刷新」的流式行:进程崩溃后的陈旧占位行不再显示角标
+        // (打开会话时 /running 会把它就地收尾,reaper 也会兜底)
+        int staleSeconds = Math.max(1, aiProperties.getChat().getStreamingStaleSeconds());
+        LambdaQueryWrapper<AiMessage> lqw = Wrappers.lambdaQuery();
+        lqw.select(AiMessage::getSessionId)
+            .in(AiMessage::getSessionId, sessionIds)
+            .eq(AiMessage::getRole, AiMessage.ROLE_ASSISTANT)
+            .eq(AiMessage::getStreaming, STREAMING_RUNNING)
+            .gt(AiMessage::getUpdateTime, LocalDateTime.now().minusSeconds(staleSeconds));
+        Set<Long> runningIds = messageMapper.selectList(lqw).stream()
+            .map(AiMessage::getSessionId)
+            .filter(Objects::nonNull)
+            .collect(Collectors.toSet());
+        records.forEach(item -> item.setRunning(runningIds.contains(item.getId())));
+    }
+
     @Override
     @Transactional(rollbackFor = Exception.class)
     public AiMessage persistAssistantAborted(Long sessionId, String content, Long durationMs,
@@ -846,6 +1007,8 @@ public class AiSessionServiceImpl implements IAiSessionService {
         update.setContent(StringUtils.isEmpty(appendContent)
             ? exists.getContent() : (exists.getContent() == null ? "" : exists.getContent()) + appendContent);
         update.setStatus(status);
+        // 恢复段开始时会把消息标回 streaming=1;本段结束(正常 / 中止 / 再次暂停)必须回到已完成
+        update.setStreaming(STREAMING_DONE);
         update.setDurationMs((exists.getDurationMs() == null ? 0L : exists.getDurationMs())
             + (additionalDurationMs == null ? 0L : additionalDurationMs));
         update.setToolCallCount((exists.getToolCallCount() == null ? 0 : exists.getToolCallCount())
@@ -863,6 +1026,38 @@ public class AiSessionServiceImpl implements IAiSessionService {
         return messageMapper.selectById(messageId);
     }
 
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AiMessage replaceAssistantTurn(Long messageId, String fullContent, String status, Long additionalDurationMs,
+                                          List<AiToolCallLog> toolLogs, ChatTokenUsage tokens,
+                                          List<AiSourceVo> sources) {
+        AiMessage exists = messageMapper.selectById(messageId);
+        if (exists == null) {
+            throw new ServiceException("助手消息不存在或已被删除");
+        }
+        AiMessage update = new AiMessage();
+        update.setId(messageId);
+        update.setContent(fullContent == null ? "" : fullContent);
+        update.setStatus(status);
+        update.setStreaming(STREAMING_DONE);
+        update.setDurationMs((exists.getDurationMs() == null ? 0L : exists.getDurationMs())
+            + (additionalDurationMs == null ? 0L : additionalDurationMs));
+        update.setToolCallCount((exists.getToolCallCount() == null ? 0 : exists.getToolCallCount())
+            + (toolLogs == null ? 0 : toolLogs.size()));
+        update.setPromptTokens(sumNullable(exists.getPromptTokens(), tokens == null ? null : tokens.promptTokens()));
+        update.setCompletionTokens(sumNullable(exists.getCompletionTokens(),
+            tokens == null ? null : tokens.completionTokens()));
+        update.setTotalTokens(sumNullable(exists.getTotalTokens(), tokens == null ? null : tokens.totalTokens()));
+        if (sources != null && !sources.isEmpty()) {
+            update.setSources(JsonUtils.toJsonString(sources));
+        }
+        messageMapper.updateById(update);
+        AiSession session = baseMapper.selectById(exists.getSessionId());
+        insertToolLogs(exists.getSessionId(), messageId, toolLogs, session == null ? null : session.getUserId());
+        touchSessionActive(exists.getSessionId());
+        return messageMapper.selectById(messageId);
+    }
+
     @Override
     public List<AiMessageVo> queryPendingMessages(Long sessionId) {
         assertSessionInCurrentCase(sessionId);

+ 40 - 9
ai-server/src/main/java/com/zsjz/ai/module/plat/service/CaseInfoService.java

@@ -213,7 +213,7 @@ public class CaseInfoService extends ServiceImpl<CaseInfoMapper, CaseInfo> {
                 storageLayout.aideskDbDir(caseId),
                 storageLayout.aideskDb(caseId),
                 storageLayout.aideskCaseJson(caseId),
-                "AI 客户端");
+                "AI 客户端", false);
         return PublicAideskVO.of(caseInfo, aideskDir);
     }
 
@@ -241,7 +241,7 @@ public class CaseInfoService extends ServiceImpl<CaseInfoMapper, CaseInfo> {
                 storageLayout.workbenchDbDir(caseId),
                 storageLayout.workbenchDb(caseId),
                 storageLayout.workbenchCaseJson(caseId),
-                "智能工作台");
+                "智能工作台", true);
         return WorkbenchWorkspaceVO.of(caseInfo, workbenchDir, sharedDir);
     }
 
@@ -267,7 +267,7 @@ public class CaseInfoService extends ServiceImpl<CaseInfoMapper, CaseInfo> {
      */
     private void refreshCaseCopyWorkspace(CaseInfo caseInfo, Long batchId,
                                           Path importDir, Path dbDir, Path targetDb,
-                                          Path caseJsonPath, String label) {
+                                          Path caseJsonPath, String label, boolean workbenchCopy) {
         Long caseId = caseInfo.getId();
         Path sourceDb = validateCaseDbPath(caseInfo);
         Object lock = workspaceCreationLocks.computeIfAbsent(caseId, key -> new Object());
@@ -296,7 +296,7 @@ public class CaseInfoService extends ServiceImpl<CaseInfoMapper, CaseInfo> {
                             label + "数据库副本不可用:请关闭占用 " + targetDb + " 的进程后重试");
                 }
                 try {
-                    writeCaseJson(caseJsonPath, caseInfo, stats.copied(), label);
+                    writeCaseJson(caseJsonPath, caseInfo, stats.copied(), label, workbenchCopy);
                 } catch (IOException e) {
                     // case.json 被占用时不影响副本本身,跳过本次说明文件刷新
                     log.info("{} case.json 写入失败(可能被占用),跳过: {}", label, e.getMessage());
@@ -318,7 +318,7 @@ public class CaseInfoService extends ServiceImpl<CaseInfoMapper, CaseInfo> {
      * 同时带案件 ID/名称、生成时间与导入文件数,便于 AI 判断副本是否最新。
      */
     private void writeCaseJson(Path caseJsonPath, CaseInfo caseInfo, int importFileCount,
-                               String label) throws IOException {
+                               String label, boolean workbenchCopy) throws IOException {
         // 工作区根目录(case.json 所在目录):workbench 为 shared/、aidesk 为 aidesk/。
         // 相对路径以它为基准;同时给出绝对路径,供 cwd 不在本目录的 shell/python 直接使用。
         Path root = caseJsonPath.toAbsolutePath().normalize().getParent();
@@ -328,7 +328,9 @@ public class CaseInfoService extends ServiceImpl<CaseInfoMapper, CaseInfo> {
         meta.put("caseName", caseInfo.getName());
         meta.put("createdAt", LocalDateTime.now().toString());
         meta.put("workspacePath", root.toString());
-        meta.put("description", label + "案件副本工作区:import/ 是上传原件副本,db/ 是 DuckDB 案件库副本。");
+        meta.put("description", workbenchCopy
+                ? label + "案件只读数据副本:import/ 是上传原件副本,db/ 是 DuckDB 案件库副本。"
+                : label + "案件副本工作区:import/ 是上传原件副本,db/ 是 DuckDB 案件库副本。");
         Map<String, Object> importMeta = new LinkedHashMap<>();
         importMeta.put("path", "import");
         importMeta.put("absolutePath", root.resolve("import").toString());
@@ -344,12 +346,41 @@ public class CaseInfoService extends ServiceImpl<CaseInfoMapper, CaseInfo> {
         dirs.put("import", importMeta);
         dirs.put("db", dbMeta);
         meta.put("directories", dirs);
-        meta.put("usage", "读取原始文件用 import/,DuckDB 查询用 db/case.duckdb(相对本工作区根目录)。"
-                + "若命令行/Python 的当前目录不在本工作区根目录(如智能工作台会话目录),相对路径会打不开,"
-                + "请改用绝对路径:import 目录见 directories.import.absolutePath,DuckDB 库见 directories.db.dbFileAbsolute。");
+        if (workbenchCopy) {
+            // 智能工作台:shared/ 是只读数据源,不是交付物目录;产物面板只扫描会话目录
+            meta.put("readOnly", true);
+            meta.put("artifactOutput", "outputs/");
+            meta.put("artifactDirs", List.of("outputs/", "plans/"));
+            meta.put("artifactOutputHint",
+                    "交付物写到当前会话工作目录的 outputs/ 子目录;产物面板扫描 outputs/ 与 plans/,"
+                            + "shared/ 只读且写入的文件不会出现在产物列表。");
+        }
+        meta.put("usage", buildCaseJsonUsage(workbenchCopy));
         Files.writeString(caseJsonPath, Json.toStr(meta), StandardCharsets.UTF_8);
     }
 
+    /**
+     * 组装 case.json 的 {@code usage} 文案。
+     *
+     * <p>智能工作台的 {@code shared/} 是只读案件副本,必须在文案里明确“数据源而非输出目录”;
+     * 否则模型容易用绝对路径把交付物写进 {@code shared/},而产物面板扫描不到。
+     * 抽成包内可见纯函数,便于单测锁定文案语义。</p>
+     *
+     * @param workbenchCopy 是否为智能工作台 shared/ 副本
+     * @return usage 文案
+     */
+    static String buildCaseJsonUsage(boolean workbenchCopy) {
+        String usage = "读取原始文件用 import/,DuckDB 查询用 db/case.duckdb(相对本工作区根目录)。"
+                + "若命令行/Python 的当前目录不在本工作区根目录(如智能工作台会话目录),相对路径会打不开,"
+                + "请改用绝对路径:import 目录见 directories.import.absolutePath,DuckDB 库见 directories.db.dbFileAbsolute。";
+        if (workbenchCopy) {
+            usage += "【重要】本目录(shared/)是案件的只读数据副本,不是交付物目录:"
+                    + "不要在其中写入、修改或删除文件;所有交付物请写到当前会话工作目录的 ./outputs/ 下"
+                    + "(产物面板扫描 outputs/ 与 plans/),否则产物面板不会展示。";
+        }
+        return usage;
+    }
+
     /**
      * 复制上传原件到 {@code aidesk/import}。
      *

+ 18 - 0
ai-server/src/test/java/com/zsjz/ai/module/ai/core/agent/AgentAssemblerBuiltinToolsTest.java

@@ -113,6 +113,24 @@ class AgentAssemblerBuiltinToolsTest {
         assertTrue(Files.exists(aiRoot.resolve("workbench").resolve("s1").resolve("expert.txt")));
     }
 
+    @Test
+    void workbenchWriteCreatesOutputsParentDirectory() throws Exception {
+        Path aiRoot = tempDir.resolve("ai-outputs");
+        Files.createDirectories(aiRoot);
+        AbstractFilesystem filesystem = AgentAssembler.buildLocalWorkspaceFilesystem(aiRoot, 7L);
+        RuntimeContext workbench = RuntimeContext.builder()
+            .userId("42")
+            .sessionId("s1")
+            .put(AiRuntimeKeys.SESSION_SCOPED_WORKSPACE, "1")
+            .build();
+
+        WriteResult write = filesystem.write(workbench, "outputs/report.html", "<html>ok</html>");
+        assertTrue(write.isSuccess(), write.error());
+        assertTrue(Files.exists(aiRoot.resolve("workbench").resolve("s1")
+            .resolve("outputs").resolve("report.html")),
+            "写入 outputs/ 时应自动创建父目录");
+    }
+
     @Test
     void localFilesystemScopesFileToolsToUserNamespace() throws Exception {
         Path workspace = tempDir.resolve("agent-workspace");

+ 117 - 0
ai-server/src/test/java/com/zsjz/ai/module/ai/core/agent/AiContextSyncServiceTest.java

@@ -0,0 +1,117 @@
+package com.zsjz.ai.module.ai.core.agent;
+
+import io.agentscope.core.message.Msg;
+import io.agentscope.core.message.MsgRole;
+import com.zsjz.ai.module.ai.domain.AiMessage;
+import com.zsjz.ai.module.ai.mapper.AiMessageMapper;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+
+/**
+ * 上下文尾部校准测试:中断后「继续」能否看到上一轮的问题与半截回答。
+ *
+ * @author BizBuddy
+ */
+class AiContextSyncServiceTest {
+
+    private final AiMessageMapper messageMapper = mock(AiMessageMapper.class);
+
+    private final AiContextSyncService service = new AiContextSyncService(messageMapper);
+
+    @Test
+    void recognizesContinuationCommands() {
+        assertTrue(service.isContinuation("继续"));
+        assertTrue(service.isContinuation("请继续!"));
+        assertTrue(service.isContinuation("接着写"));
+        assertTrue(service.isContinuation("continue"));
+        assertTrue(service.isContinuation("继续之前的分析"));
+        assertFalse(service.isContinuation("帮我分析一下这个表格"));
+        assertFalse(service.isContinuation(""));
+    }
+
+    @Test
+    void noAppendWhenContextAlreadyHasSameAnswer() {
+        Msg context = assistantMsg("完整回答");
+        AiMessage dbAnswer = assistant("完整回答", AiMessage.STATUS_NORMAL);
+
+        assertTrue(service.missingTail(context, List.of(dbAnswer)).isEmpty());
+    }
+
+    @Test
+    void appendsAssistantWhenUserQuestionAlreadyInContext() {
+        Msg context = userMsg("问题");
+        AiMessage dbUser = user("问题");
+        AiMessage dbAnswer = assistant("半截回答", AiMessage.STATUS_ABORTED);
+
+        List<Msg> append = service.missingTail(context, List.of(dbUser, dbAnswer));
+
+        assertEquals(1, append.size());
+        assertEquals(MsgRole.ASSISTANT, append.get(0).getRole());
+        assertTrue(append.get(0).getTextContent().contains("半截回答"));
+        assertTrue(append.get(0).getTextContent().contains("中断"));
+    }
+
+    @Test
+    void appendsOnlyMissingSuffixWhenContextHasPrefix() {
+        Msg context = assistantMsg("前半段");
+        AiMessage dbAnswer = assistant("前半段后半段", AiMessage.STATUS_ABORTED);
+
+        List<Msg> append = service.missingTail(context, List.of(dbAnswer));
+
+        assertEquals(1, append.size());
+        assertTrue(append.get(0).getTextContent().startsWith("后半段"));
+    }
+
+    @Test
+    void appendsUserAndAssistantWhenContextIsOlderTurn() {
+        Msg context = assistantMsg("更早的回答");
+        AiMessage dbUser = user("新问题");
+        AiMessage dbAnswer = assistant("被中断的回答", AiMessage.STATUS_ABORTED);
+
+        List<Msg> append = service.missingTail(context, List.of(dbUser, dbAnswer));
+
+        assertEquals(2, append.size());
+        assertEquals(MsgRole.USER, append.get(0).getRole());
+        assertEquals("新问题", append.get(0).getTextContent());
+        assertEquals(MsgRole.ASSISTANT, append.get(1).getRole());
+    }
+
+    @Test
+    void interruptedChecksLastMessageStatus() {
+        assertTrue(service.isInterrupted(user("问题")));
+        assertFalse(service.isInterrupted(assistant("回答", AiMessage.STATUS_NORMAL)));
+        assertTrue(service.isInterrupted(assistant("半截", AiMessage.STATUS_ABORTED)));
+        assertTrue(service.isInterrupted(assistant("失败", AiMessage.STATUS_FAILED)));
+        assertFalse(service.isInterrupted(null));
+    }
+
+    private static Msg userMsg(String content) {
+        return Msg.builder().role(MsgRole.USER).textContent(content).build();
+    }
+
+    private static Msg assistantMsg(String content) {
+        return Msg.builder().role(MsgRole.ASSISTANT).textContent(content).build();
+    }
+
+    private static AiMessage user(String content) {
+        AiMessage message = new AiMessage();
+        message.setRole(AiMessage.ROLE_USER);
+        message.setContent(content);
+        message.setStatus(AiMessage.STATUS_NORMAL);
+        return message;
+    }
+
+    private static AiMessage assistant(String content, String status) {
+        AiMessage message = new AiMessage();
+        message.setRole(AiMessage.ROLE_ASSISTANT);
+        message.setContent(content);
+        message.setStatus(status);
+        return message;
+    }
+}

+ 52 - 0
ai-server/src/test/java/com/zsjz/ai/module/ai/core/agent/WorkbenchArtifactPromptMiddlewareTest.java

@@ -0,0 +1,52 @@
+package com.zsjz.ai.module.ai.core.agent;
+
+import io.agentscope.core.agent.RuntimeContext;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * {@link WorkbenchArtifactPromptMiddleware} 单元测试。
+ *
+ * @author cc
+ */
+class WorkbenchArtifactPromptMiddlewareTest {
+
+    private final WorkbenchArtifactPromptMiddleware middleware = new WorkbenchArtifactPromptMiddleware();
+
+    @Test
+    void doesNotAppendForNormalSession() {
+        RuntimeContext ctx = RuntimeContext.builder().userId("1").sessionId("s1").build();
+        String prompt = middleware.onSystemPrompt(null, ctx, "base-prompt").block();
+        assertEquals("base-prompt", prompt);
+    }
+
+    @Test
+    void appendsWorkspaceDisciplineForWorkbenchSession() {
+        RuntimeContext ctx = RuntimeContext.builder()
+            .userId("1")
+            .sessionId("s1")
+            .put(AiRuntimeKeys.SESSION_SCOPED_WORKSPACE, "1")
+            .build();
+        String prompt = middleware.onSystemPrompt(null, ctx, "base-prompt").block();
+        assertTrue(prompt.startsWith("base-prompt"));
+        assertTrue(prompt.contains(WorkbenchArtifactPromptMiddleware.SECTION_TITLE));
+        assertTrue(prompt.contains("./outputs/"), "交付物必须指向会话目录的 outputs/");
+        assertTrue(prompt.contains("plans/"), "产物扫描必须包含 plans/");
+        assertTrue(prompt.contains("shared/"), "必须明确 shared/ 只读");
+        assertTrue(prompt.contains("禁止写入"), "必须明确禁止写入 shared/");
+    }
+
+    @Test
+    void doesNotDuplicateSectionWhenPromptAlreadyContainsIt() {
+        RuntimeContext ctx = RuntimeContext.builder()
+            .userId("1")
+            .sessionId("s1")
+            .put(AiRuntimeKeys.SESSION_SCOPED_WORKSPACE, "1")
+            .build();
+        String once = middleware.onSystemPrompt(null, ctx, "base-prompt").block();
+        String twice = middleware.onSystemPrompt(null, ctx, once).block();
+        assertEquals(once, twice);
+    }
+}

+ 116 - 0
ai-server/src/test/java/com/zsjz/ai/module/ai/service/impl/AiArtifactServiceImplTest.java

@@ -0,0 +1,116 @@
+package com.zsjz.ai.module.ai.service.impl;
+
+import com.zsjz.ai.common.compat.ServiceException;
+import com.zsjz.ai.common.storage.StorageLayout;
+import com.zsjz.ai.module.ai.domain.AiSession;
+import com.zsjz.ai.module.ai.domain.vo.AiArtifactContentVo;
+import com.zsjz.ai.module.ai.domain.vo.AiArtifactListVo;
+import com.zsjz.ai.module.ai.service.IAiSessionService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * {@link AiArtifactServiceImpl} 扫描范围测试。
+ *
+ * <p>产物列表只扫描会话工作区的 {@code outputs/} 与 {@code plans/},会话根下的脚本、
+ * memory 等目录不进入列表;返回路径带顶级目录前缀。</p>
+ *
+ * @author cc
+ */
+class AiArtifactServiceImplTest {
+
+    private static final long CASE_ID = 100L;
+
+    private static final long SESSION_ID = 200L;
+
+    @TempDir
+    Path tempDir;
+
+    private AiArtifactServiceImpl service;
+
+    private Path sessionRoot;
+
+    @BeforeEach
+    void setUp() {
+        IAiSessionService sessionService = mock(IAiSessionService.class);
+        StorageLayout storageLayout = mock(StorageLayout.class);
+        sessionRoot = tempDir.resolve("session");
+
+        AiSession session = new AiSession();
+        session.setId(SESSION_ID);
+        session.setCaseId(CASE_ID);
+        session.setSource(AiSession.SOURCE_WORKBENCH);
+        when(sessionService.assertSessionInCurrentCase(SESSION_ID)).thenReturn(session);
+        when(storageLayout.caseWorkbenchSessionDir(CASE_ID, SESSION_ID)).thenReturn(sessionRoot);
+
+        service = new AiArtifactServiceImpl(sessionService, storageLayout);
+    }
+
+    @Test
+    void listScansOnlyOutputsAndPlans() throws Exception {
+        Files.createDirectories(sessionRoot.resolve("outputs").resolve("sub"));
+        Files.createDirectories(sessionRoot.resolve("plans"));
+        Files.createDirectories(sessionRoot.resolve("memory"));
+        Files.writeString(sessionRoot.resolve("outputs").resolve("report.html"), "<html>ok</html>");
+        Files.writeString(sessionRoot.resolve("outputs").resolve("sub").resolve("data.csv"), "a,b\n1,2\n");
+        Files.writeString(sessionRoot.resolve("plans").resolve("PLAN.md"), "# plan");
+        // 会话根下的脚本/中间文件/记忆目录不应进入产物列表
+        Files.writeString(sessionRoot.resolve("dump.py"), "print('x')");
+        Files.writeString(sessionRoot.resolve("memory").resolve("2026-11-19.md"), "memory");
+
+        AiArtifactListVo vo = service.list(SESSION_ID);
+
+        assertEquals(3, vo.getTotal());
+        assertTrue(vo.getItems().stream().anyMatch(item -> "outputs/report.html".equals(item.getPath())));
+        assertTrue(vo.getItems().stream().anyMatch(item -> "outputs/sub/data.csv".equals(item.getPath())));
+        assertTrue(vo.getItems().stream().anyMatch(item -> "plans/PLAN.md".equals(item.getPath())));
+        assertTrue(vo.getItems().stream().noneMatch(item -> "dump.py".equals(item.getPath())));
+        assertTrue(vo.getItems().stream().noneMatch(item -> item.getPath().startsWith("memory/")));
+    }
+
+    @Test
+    void listReturnsEmptyWhenOutputsAndPlansMissing() {
+        AiArtifactListVo vo = service.list(SESSION_ID);
+
+        assertEquals(0, vo.getTotal());
+        assertTrue(vo.getItems().isEmpty());
+    }
+
+    @Test
+    void contentResolvesRelativeToSessionRootWithPrefix() throws Exception {
+        Files.createDirectories(sessionRoot.resolve("outputs"));
+        Files.createDirectories(sessionRoot.resolve("plans"));
+        Files.writeString(sessionRoot.resolve("outputs").resolve("report.md"), "# report");
+        Files.writeString(sessionRoot.resolve("plans").resolve("PLAN.md"), "# plan");
+
+        AiArtifactContentVo output = service.content(SESSION_ID, "outputs/report.md");
+        assertEquals("outputs/report.md", output.getPath());
+        assertEquals("# report", output.getText());
+
+        AiArtifactContentVo plan = service.content(SESSION_ID, "plans/PLAN.md");
+        assertEquals("plans/PLAN.md", plan.getPath());
+        assertEquals("# plan", plan.getText());
+    }
+
+    @Test
+    void contentRejectsTraversalAndUnscannedDirectories() throws Exception {
+        Files.createDirectories(sessionRoot.resolve("outputs"));
+        Files.createDirectories(sessionRoot.resolve("memory"));
+        Files.writeString(tempDir.resolve("secret.txt"), "secret");
+        Files.writeString(sessionRoot.resolve("memory").resolve("2026-11-19.md"), "memory");
+
+        assertThrows(ServiceException.class, () -> service.content(SESSION_ID, "../secret.txt"));
+        assertThrows(ServiceException.class, () -> service.content(SESSION_ID, "memory/2026-11-19.md"));
+        assertThrows(ServiceException.class, () -> service.content(SESSION_ID, "outputs/missing.txt"));
+    }
+}

+ 33 - 0
ai-server/src/test/java/com/zsjz/ai/module/plat/service/CaseInfoServiceUsageTest.java

@@ -0,0 +1,33 @@
+package com.zsjz.ai.module.plat.service;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * {@code case.json} usage 文案单元测试。
+ *
+ * @author cc
+ */
+class CaseInfoServiceUsageTest {
+
+    @Test
+    void workbenchUsageMarksSharedAsReadOnlyAndOutputsAsArtifactDir() {
+        String usage = CaseInfoService.buildCaseJsonUsage(true);
+        assertTrue(usage.contains("只读数据副本"), "必须声明 shared/ 是只读数据副本");
+        assertTrue(usage.contains("./outputs/"), "必须给出交付物目录");
+        assertTrue(usage.contains("plans/"), "必须说明产物面板也扫描 plans/");
+        assertTrue(usage.contains("产物面板"), "必须说明产物面板的可见性");
+        assertTrue(usage.contains("不要在其中写入"), "必须禁止写入 shared/");
+    }
+
+    @Test
+    void aideskUsageKeepsLegacyWording() {
+        String usage = CaseInfoService.buildCaseJsonUsage(false);
+        assertFalse(usage.contains("只读数据副本"));
+        assertFalse(usage.contains("./outputs/"));
+        assertTrue(usage.contains("import/"));
+        assertTrue(usage.contains("db/case.duckdb"));
+    }
+}

+ 260 - 0
test-reports-20261119-continue/test-report.md

@@ -0,0 +1,260 @@
+# 「后台继续 + 中断续接 + 多会话并行」E2E 测试报告
+
+- 测试日期:2026-11-19
+- 测试方式:内置浏览器(ZCode In-app Browser)模拟真实用户操作,辅以接口/DB 快照/后端日志交叉验证;**未修改任何代码**
+- 被测计划:`.zcode/plans/plan-sess_a053a248-f947-42a7-912d-859597e5cd25.md`
+- 环境:前端 `http://localhost:3100`(Vite dev)、后端 `http://127.0.0.1:8980/js/a`、案件 `Ces`、账号 `系统管理员`、模型 `deepseek-v4.1-flash:1017`
+- 证据目录:`test-reports-20261119-continue/evidence/`
+
+> 说明:本次内置浏览器截图接口持续返回 `browser screenshot surface preparation timed out after 3000ms`,因此未取得有效页面截图;结论均基于 DOM 快照、页面可见文本、接口返回与后端日志,证据可复核。
+
+---
+
+## 一、结论摘要
+
+| 维度 | 结论 |
+|---|---|
+| 核心目标 1:离开页面/刷新不影响生成 | **通过**。切页 30 秒期间后端继续生成并完成(111 → 8944 字);刷新后自动恢复会话并轮询续看(838 → 7083 字) |
+| 核心目标 2:中断后「继续」可续接 | **通过**。停止后半截正文落库(status=3,2635 字);「继续」后模型从「第三章后半」接着写,未重复开头;日志确认上下文尾部校准 `appended=1` |
+| 核心目标 3:多会话并行 + 角标 | **通过**。A/B 同时 running=true,列表 2 个「生成中」角标;A 完成后角标消失;切回 A 可见完整结果 |
+| 显式停止 / 结束任务 | **通过**。停止后 status=3、输入解锁;结束任务后会话 status=1、消息 status=3、列表角标消失 |
+| 后端重启占位回收 | **通过(走 running 接口的失联收尾路径)**。约 60s 新鲜度阈值后占位行置 status=3,errorMsg=“服务重启或长时间无进展,本轮回答已中断”;刷新后页面显示「已中止」 |
+| HITL 待确认离开 / HITL 恢复阶段停止 | **未覆盖**。当前环境写文件/execute 工具在「变更前确认」下仍直接执行,未出现确认卡片 |
+| 切换案件再切回 | **未覆盖**。当前工作台顶栏案件区为静态展示,无切案入口 |
+
+**总体判定:计划的核心可验收目标全部通过;未发现 P1 级阻塞缺陷。存在 1 个 P2 级体验边界、3 个 P3 级观察项,以及 3 个环境限制导致的未覆盖场景。**
+
+---
+
+## 二、用例结果总览
+
+| 编号 | 用例(对应计划章节) | 结果 | 关键证据 |
+|---|---|---|---|
+| E2E-1 | 发送长回答后切到「专家配置」30s 再回(§七.1) | **PASS** | 切走时 streaming=1/111 字;30s 后 streaming=0/8944 字;返回自动恢复会话,完整展示,耗时 40330ms/14410 tokens |
+| E2E-2 | 生成中刷新页面(§七.2) | **PASS** | 刷新后自动选中会话、输入禁用、停止按钮在;轮询使正文 838→5924→7083 字;最终 status=0/17082 字 |
+| E2E-3 | 生成中点「停止生成」(§七.3/4) | **PASS** | 停止后 1s 内解锁;status=3、streaming=0、半截正文 2635 字、耗时 21754ms;UI 显示「已中止」 |
+| E2E-3b | 停止后发「继续」(§七.3) | **PASS** | 模型思考明确“上一轮在第三章中断,从第三章后半继续”;答复开头“(接上条,第三章后半)……”,未重复第一章;日志 `appended=1` |
+| E2E-4 | 专家直答阶段停止 + 继续(§七.4) | **部分 PASS** | 指定专家路由 `action=pinned`,专家调用取消落库(status=3/126 字,expertCalls=1);「继续」被受理且上下文校准 `appended=1`;续跑轮在完成前被手动停止,未验证完整结果 |
+| E2E-5 | A 生成中切 B 再发消息,多会话并行(§七.5) | **PASS** | 列表 2 个 running 会话/2 个角标;切 A 后续看正文 3382→4582 字;A 完成 running=false 且角标剩 1(B);A 全文「全文完」 |
+| E2E-6 | 生成中重启 ai-server(§七.6) | **PASS(有边界)** | 重启后 `/running` 在阈值后返回 false,消息 status=3、errorMsg 正确;刷新后页面「已中止」、无角标;前端轮询在连续失败 3 次后停止、无自动回连,需手动刷新(见问题 P2-1) |
+| E2E-7 | 结束任务(§七.7) | **PASS** | 结束后会话 status=1、消息 status=3、运行 running=false、列表角标 0、从进行中列表移除 |
+| UX-1 | 上次会话恢复(§四.1) | **PASS** | localStorage key `ai-chat:last-session:{caseId}` 选中即写入、新建任务即清除、刷新自动恢复 |
+| UX-2 | 新建任务后刷新不恢复旧会话 | **PASS** | 新建任务后 key=null,刷新为欢迎页,无会话上下文条 |
+| UX-3 | 会话列表 5s 角标刷新(§四.3) | **PASS** | 发送 B 后约 5-6s 列表由 1 个角标变为 2 个;A 完成/结束 B 后角标递减至 0 |
+| UX-4 | SSE 异常兜底(§四.4) | **部分覆盖** | 杀后端后页面未立即判失败,保持生成态;轮询失败提示因 ant-message 自动消失未捕获;后端恢复后刷新可恢复 |
+| UX-5 | 停止按钮中间态「正在停止…」 | **未捕获** | 中止在 1s 内完成,未观测到中间 loading;停止后立即解锁 |
+| UX-6 | 快速切会话竞态保护(§四.5) | **代码级确认** | `handleSelectSession` 两处 `currentSessionId` 校验存在(index.vue:2864/2875),未做高并发压测 |
+| HITL-1 | HITL 待确认时离开再回来 | **未覆盖** | 变更前确认模式下 write_file/execute 均直接执行,无确认卡片可测 |
+| CASE-1 | 切换案件再切回 | **未覆盖** | 工作台顶栏案件区为静态 `<span>`,无切换入口 |
+
+---
+
+## 三、详细用例记录
+
+### E2E-1 切页 30 秒后后台继续生成
+
+- 会话:`2123353086229032961`(《雾港疑云》20000 字)
+- 操作:
+  1. 新建任务,发送长文生成提示。
+  2. 正文出现 111 字时点击左侧「专家配置」,停留 30 秒。
+  3. 返回「任务工作台」。
+- 观测:
+  - 切走前:`streaming=1, status=0, contentLen=111`。
+  - 专家配置页停留 30s 后:`streaming=0, status=0, contentLen=8944`,说明 SSE 已随组件卸载断开而后端仍继续生成并完成。
+  - 返回后:`chat-context-bar` 标题自动恢复为原会话;仅 1 个助手气泡;正文完整;页脚显示「耗时 40330 ms / 消耗 14410 tokens」;无停止按钮。
+- 判定:**PASS**(计划 §七.1、验收表第 1 行)。
+
+### E2E-2 生成中刷新页面
+
+- 会话:`2123353347290902530`(《暗潮》20000 字);助手消息 `2123353351887859713`。
+- 操作:
+  1. 发送长文提示,正文出现后(DB 124 字)执行浏览器刷新。
+  2. 刷新后不做任何点击,观察自动恢复与轮询。
+- 观测:
+  - 刷新后 URL 仍为 `/workbench/chat`,会话标题自动恢复;`输入框 disabled`、`停止生成`按钮存在。
+  - 页面正文从 838 字开始持续增长:5s 内 5924 → 7083 字。
+  - `/running` 两次采样(间隔 5s):`running=true, streaming=1, len=1834 → 3475, steps=1`。
+  - 最终:`streaming=0, status=0, len=17082, durationMs=71083, totalTokens=17701`;停止按钮消失,出现「重新生成」。
+- 判定:**PASS**(计划 §七.2、验收表第 2 行)。
+
+### E2E-3 停止生成 + 半截正文落库
+
+- 会话:`2123353701546012674`(《沉船名单》12000 字);助手消息 `2123353703626387457`。
+- 操作:生成到正文 1486 字时点击「停止生成」。
+- 观测:
+  - 1s 内 `停止生成` 消失、`发送` 恢复、输入框 enabled;气泡页脚显示「已中止 / 耗时 21754 ms」。
+  - DB:`streaming=0, status=3, contentLen=2635, durationMs=21754`;正文末尾停在「沈砚把卷宗翻到最后」。
+  - `/running` 返回 `running=false`;会话列表 `running=false`。
+- 判定:**PASS**(计划 §七.3/4、验收表第 6 行)。
+
+### E2E-3b 停止后「继续」续接上下文
+
+- 紧接 E2E-3,发送「继续」(DB 用户原话长度 2,未改写)。
+- 观测:
+  - 模型思考内容:“上一轮回答在第三章中途被截断,应从第三章后半继续写第 3—12 章”,证明模型知道中断位置。
+  - 新答复正文开头:`(接上条,第三章后半)……卷宗翻到最后,夹着一张保险理赔单。`,**未重复第一章**。
+  - 新答复最终 `status=0, len=10028`;旧答复保持 `status=3` 不被覆盖。
+  - 后端日志:`AiContextSyncService - 会话上下文尾部已校准:sessionId=2123353701546012674, appended=1`。
+- 判定:**PASS**(计划 §七.3、验收表第 7 行)。
+
+### E2E-4 专家直答阶段停止(含「继续」受理)
+
+- 会话:`2123355739415724033`;通过资源选择器指定「涉毒案件分析研判专家」。
+- 操作:发送「全面涉毒数据分析研判,输出不少于 5000 字报告」,在专家已调用 17 个步骤、正文 126 字时停止;随后发送「继续」。
+- 观测:
+  - 路由:`/routeRuns` 首轮 `action=pinned, status=aborted, expertCalls=1`;日志 `专家调用被用户停止:expert=asdf, attempt=1`。
+  - 消息:`streaming=0, status=3, len=126, durationMs=90805`,半截正文保留。
+  - 「继续」:新用户消息「继续」被受理,进入新一轮生成;日志 `会话上下文尾部已校准 ... appended=1`(18:02:10)。
+  - 续跑轮在完成前被手动停止:`status=3, len=0, durationMs=18712`,未出现「永久待确认/生成中」。
+  - 观察:取消时该轮 `/routeRuns` 记录为 `action=self, expertCalls=0`(模型在取消前走了自答路径);服务端的「指定专家兜底」只在流正常结束且未调用路由工具时触发,因此**取消场景下「继续」是否必然由指定专家作答未得到证明**,见观察项 O-2。
+- 判定:**部分 PASS**(专家直答停止通过;HITL 恢复阶段停止未覆盖)。
+
+### E2E-5 双会话并行 + 列表角标
+
+- 会话 A:`2123354104459243522`(《双城谜案》);会话 B:`2123354126529671169`(《无声证词》)。
+- 操作:
+  1. A 生成中点击「新建任务」并发送 B。
+  2. 观察列表角标;切回 A 续看;等待 A 完成;对 B 执行「结束任务」。
+- 观测:
+  - 发送 B 后立即 1 个角标(B 的占位行尚在创建,A 已 running),约 5-6s 后变为 **2 个角标**;接口两行均 `running=true`。
+  - 切回 A:A 的正文 5s 内 3382 → 4582 字(轮询续看);角标仍为 2;A 显示「停止生成」。
+  - A 完成:`running=false`、正文含「全文完」、耗时 86634ms/23918 tokens;接口仍显示 B `running=true`,角标剩 1 个 → **A 角标按时消失**。
+  - B「结束任务」:确认弹窗后列表移除 B,角标 0;接口 `session.status=1`,B 消息 `status=3, streaming=0, len=28941, durationMs=187157`。
+- 判定:**PASS**(计划 §七.5、验收表第 3/4 行)。
+
+### E2E-7 结束任务取消运行
+
+- 会话 B(同上,运行中)通过会话项「更多 → 结束任务 → 确定」。
+- 观测:
+  - 会话从 `status=0` 列表消失;`GET /session/{id}` 返回 `status=1`。
+  - 助手消息 `streaming=0, status=3`,半截(实际已接近全文)正文 28941 字落库;`/running` 返回 `running=false`。
+  - 列表无残留「生成中」角标。
+- 判定:**PASS**(计划 §七.7、验收表第 10 行)。
+- 观察:B 的正文已写到「全文完」,但仍被结束任务的显式取消标记为 `已中止`(见观察项 O-3)。
+
+### E2E-6 生成中重启后端
+
+- 会话:`2123354968091602945`(《长夜灯塔》15000 字);占位消息 `2123354970251669505`。
+- 操作:
+  1. 生成进入占位阶段(`streaming=1, len=0`)时强杀后端进程(PID 28304,17:57:51)。
+  2. 于 17:58:38 重启完成(`Started App in 6.466 seconds`)。
+  3. 调用 `/running` 探测;随后刷新页面。
+- 观测:
+  - 17:58:41:`running=true`(占位行仍在 60s 新鲜度窗口内)。
+  - 17:58:53:`running=false`;消息变为 `streaming=0, status=3, len=0, errorMsg=服务重启或长时间无进展,本轮回答已中断`。
+  - 刷新后:会话自动恢复;无停止按钮;输入框 enabled;列表角标 0;气泡显示「已中止 · 完成 1 个步骤」。
+  - 随后在该会话发送「继续」:日志 `会话上下文为空,已按历史重建:sessionId=..., messages=1`,模型基于 DB 历史继续(覆盖“Redis 状态被清理/重启/换节点”分支)。
+- 判定:**PASS(有边界)**(计划 §七.6、验收表第 9 行)。
+- 注意:本次由 `/running` 接口的失联收尾路径完成,不等同于 `AiStaleRunReaper` 的定时 60min 回收;定时回收未实测。
+
+### UX-1/UX-2 上次会话恢复与新建任务清理
+
+- 选中会话后:`localStorage["ai-chat:last-session:2121846987260764162"] = 2123354968091602945`。
+- 点击「新建任务」后:该 key 被删除(`{}`)。
+- 选中另一会话后:key 重新写入。
+- 新建任务后刷新:欢迎页,`chat-context-bar` 数量 0,key 为 null,不恢复旧会话。
+- 判定:**PASS**(计划 §四.1)。
+
+### 增量落库(占位行 + 周期更新)
+
+- 会话 `2123352911376887810`,生成期间每 3s 采样:
+  - `assistant id=2123352915327922178, streaming=1, len=3943 → 5134 → 5479`,随后 `streaming=0, status=0`。
+- 会话 `2123353347290902530` 采样:`len=1834 → 3475`(间隔 5s)。
+- 说明:生成期间同一条助手占位消息持续增长,未出现多行/重复消息;与计划「每 1.5s 增量落库」方向一致(未精确测量 1.5s 间隔)。
+- 判定:**PASS**(计划 §三.2)。
+
+---
+
+## 四、计划验收口径逐项对照(§五)
+
+| 验收场景 | 结果 | 说明 |
+|---|---|---|
+| 发送后切到其他工作台页面 | **PASS** | 30s 后内容 111→8944,返回可见完整回答 |
+| 刷新页面 | **PASS** | 自动恢复会话,轮询续看至完成 |
+| A 生成中切到 B 再发消息 | **PASS** | A/B 并行,两个角标,接口双 running |
+| 切到另一个会话再切回 | **PASS** | 切回 A 续看,A 完成后角标消失 |
+| 切换案件再切回 | **未覆盖** | 当前工作台无切案入口(静态案件标签) |
+| 点「停止生成」 | **PASS** | 半截正文落库,status=3,不影响其他并行会话(A 不受 B 结束影响) |
+| 停止后发「继续」 | **PASS** | 上下文补齐(日志 appended=1),模型接续未重复 |
+| HITL 待确认时离开 | **未覆盖** | 本次环境未触发确认卡片 |
+| 后端重启/进程被杀 | **PASS(边界)** | `/running` 失联收尾 status=3;需刷新页面恢复 UI |
+| 结束任务 | **PASS** | 显式取消后会话 status=1、消息 status=3 |
+
+---
+
+## 五、问题与观察项
+
+### P2-1 后端恢复后页面无自动回连,需要手动刷新
+- 现象:生成中强杀后端后,SSE 断开→前端降级轮询;后端下线 12s 时页面仍保持「生成中/停止生成」状态(实测)。代码路径显示 `startRunningPoll` 连续失败 3 次即 `stopRunningPoll()` 并提示,之后没有网络恢复/可见性变化触发的自动回连;本次在后端恢复后通过刷新页面才恢复为「已中止」。
+- 影响:符合计划「轮询连续失败 3 次…可手动刷新」的设计,但与验收表「不会再永久生成中」存在体验差距:若不刷新,页面可能长期保持旧生成态。
+- 建议:后端恢复后(如下一次可见性变化/网络恢复)自动重试一次 `/running`,或在 3 次失败提示中提供「立即刷新」按钮。
+- 证据:E2E-6 操作记录(断连期间 UI 实测 + 刷新后恢复);轮询停止逻辑见 `index.vue` 的 `startRunningPoll` 失败分支。说明:未在“后端已恢复但尚未刷新”的窗口逐秒观察页面状态,该结论结合了代码路径。
+
+### P3-1 中止消息显示「耗时 ms」且不展示中止原因
+- 现象:E2E-6 会话 `2123354968091602945` 的助手气泡文案为「已中止 · 完成 1 个步骤 … 已中止 耗时 ms 由 AI 生成」;`durationMs` 为 null 时直接渲染了单位。
+- 影响:仅展示瑕疵;DB 中 `errorMsg` 已正确写入「服务重启或长时间无进展,本轮回答已中断」,但页面未展示。
+- 建议:durationMs 为空时隐藏耗时;对 status=3 且 errorMsg 非空的消息展示中止原因。
+
+### P3-2 结束任务与自然完成存在竞态
+- 现象:会话 B 在点击「结束任务」前正文已增长到 28906 字,确认后最终 contentLen=28941 且末尾为「全文完」,但状态被置为 `status=3(已中止)`。
+- 影响:用户看到「已中止」但正文其实完整,语义上略矛盾;数据未丢失。
+- 建议:若取消时该轮已完成终态写入,则保留原 status;或明确「结束任务」始终以中止收尾的产品语义。
+
+### P3-3 长上下文压缩出现一次摘要被拒
+- 现象:专家会话(约 6.6 万 tokens)触发 `Compaction triggered` 两次,其中一次 `Rejected summary: model returned non-text content or tool calls`;后续继续执行未中断。
+- 影响:本次未造成功能失败,但超长专家会话下压缩稳定性需关注。
+- 证据:`evidence/backend-log-excerpt.txt`。
+
+### O-1 指定专家会话取消后「继续」的路由边界(需产品确认)
+- 现象:专家首轮 `action=pinned, expertCalls=1`;「继续」轮在取消时 `/routeRuns` 为 `action=self, expertCalls=0`。
+- 分析:服务端「指定专家兜底」只在流正常结束且未调用路由工具时补强制编排;本轮在兜底前被手动停止,因此不能证明「继续」轮一定由指定专家作答,也不能据此判定缺陷。
+- 建议:若产品要求「指定专家会话在取消后继续仍必须由指定专家作答」,建议补充取消场景的单测/E2E。
+
+### 环境限制(未覆盖项)
+1. **HITL 确认卡片**:在「变更前确认」模式下,`write_file` 与 `execute` 均直接执行成功,未出现确认卡片,导致「HITL 待确认时离开」「HITL 恢复阶段停止」无法验证。属于当前工具授权绑定/配置行为,不是本次计划改动的直接回归。
+2. **切换案件**:工作台顶栏「案件:Ces」为静态展示(`span.app-topbar__case`),本壳层无切案入口,无法模拟。
+3. **定时回收器**:`AiStaleRunReaper` 配置为 `staleMinutes=60, scanIntervalSeconds=300`,未等待 60 分钟验证;改为验证 `/running` 的 60s 失联收尾路径。
+4. **截图**:内置浏览器截图接口连续超时,未取得页面截图。
+
+---
+
+## 六、正向结论(本次已验证的机制)
+
+1. **运行与 SSE 解耦成立**:切页/刷新/新建任务会触发前端 `abort`,但后端继续生成并最终落库(E2E-1/E2E-2/E2E-5)。
+2. **占位行 + 增量落库成立**:生成期间始终只有一条助手消息,内容持续增长;完成/中止后同一行收尾(E2E-3/E2E-5)。
+3. **上下文校准成立**:两条“停止后继续”路径均记录 `appended=1`;重启后 Redis 上下文为空时按 DB 历史重建(`messages=1`)。
+4. **多会话并行与串行边界成立**:不同会话可同时 `running=true`;同会话停止/结束互不影响其他会话。
+5. **列表角标成立**:`AiSessionVo.running` 由 DB `streaming` 回填,页面 5s 轮询刷新;完成后角标自动消失。
+6. **结束任务先取消再关闭**:会话 status=1、消息 status=3、运行句柄释放,无幽灵「生成中」。
+
+---
+
+## 七、测试数据与附录
+
+### 测试会话
+| 用途 | 会话 ID | 最终状态 |
+|---|---|---|
+| E2E-1 切页后台继续 | 2123353086229032961 | 完成,8944 字 |
+| E2E-2 刷新恢复 | 2123353347290902530 | 完成,17082 字 |
+| E2E-3 停止 + 继续 | 2123353701546012674 | 中止 2635 字 + 续写 10028 字 |
+| E2E-4 专家停止 | 2123355739415724033 | 中止 126 字 + 续跑中止 |
+| E2E-5 A 并行 | 2123354104459243522 | 完成,23067 字 |
+| E2E-5 B / E2E-7 结束任务 | 2123354126529671169 | 会话已结束 status=1,消息 status=3 |
+| E2E-6 重启回收 | 2123354968091602945 | 中止(重启),errorMsg 已写入 |
+| 增量落库样例 | 2123352911376887810 | 完成,5479 字 |
+
+> 说明:以上为本次测试新建的会话,未删除;如需清理可在「任务管理」中处理。
+
+### 证据文件
+- `evidence/api-session-snapshot.json`:各测试会话与消息的最终接口快照(streaming/status/长度/耗时/errorMsg)
+- `evidence/backend-log-excerpt.txt`:上下文校准、专家取消、压缩告警、重启启动日志摘录
+
+### 关键接口
+- `GET /js/a/ai/chat/session/{id}/running` → `{running, message, steps}`
+- `GET /js/a/ai/chat/session/{id}/messages` → `streaming/status/durationMs/totalTokens/errorMsg/content`
+- `GET /js/a/ai/chat/session/list?status=0&caseId=...` → 每行 `running`
+- `POST /js/a/ai/chat/session/{id}/stop`、`DELETE /js/a/ai/chat/session/{id}`
+
+---
+
+**报告结论:本次计划的核心链路(后台继续、刷新恢复、中断续写、多会话并行、停止/结束、重启回收)已通过真实用户路径验证;建议优先处理 P2-1(恢复后自动回连)与 P3-1(中止文案),并补充 HITL 与切案场景的测试环境。**