Sfoglia il codice sorgente

feat(mobile): 真机回归修复——断网失败反馈、跨会话文件隔离、文件卡片对账

本轮基于小米 M2102K1AC / Android 14 真机实测(设备与此前记录的
Android 16 不同,历史结论不可直接沿用)。

1. 断网发送无任何失败反馈(高危)
   Matrix SDK 断网时把 sendEvent 塞进本地队列并正常 resolve,
   上层 catch 不触发、markFailed 不被调用,消息外观与正常发送完全一致。
   容器侧事后证实「断网时发的消息确实没收到」。
   修复:sendReal() 前置检查连接状态,断开即抛错走既有失败链路。

2. 断网时顶栏仍显示「在线」(中)
   presence() 反映的是容器状态,与本机网络无关。
   修复:subtitle 在 disconnected 时优先显示「网络已断开」。

3. 跨会话文件携带(中)
   belongsToSession() 的 live 分支原来无条件放行所有非 App 线程根,
   切到会话 B 后 A 的线程根若有事件实时到达,B 会认领。
   容器核实后确认「不是容器复用文件,是 App 把历史归到了当前会话」。
   修复:已认领根放行 → App 会话根拒绝 → 未认领容器根按会话闲置
   超过 30 分钟判定。

4. 文件卡片缺失无提示(中)
   容器原话:「多文件时标记存在但适配器没有为它们生成对应的事件」,
   即 m.file 事件本身就少了,App 侧补不出卡片。
   修复:按容器建议做对账——统计正文里明确的文件声明
   (MEDIA 标记 + 本项目云盘链接,按文件名去重),与卡片数比较,
   差额在卡片下方提示。只提示不伪造卡片。

- 新增 8 条单测(文件对账 7 条 + 跨会话隔离 1 条)
- 更新 1 条既有单测语义(容器子线程认领需会话活跃)
- 全量 1854/1854 通过

- 断网发送 → 显示「发送失败,重试」+ 重试按钮;恢复网络后重试成功
- 断网 30 秒 → 顶栏「lj-test · 网络已断开」
- 对账提示正确显示「还有 1 个文件未收到」
- 切到会话 B 无任何 A 的内容;切回 A 内容完好
- 容器回复 9 个回合无丢失

- 2026-11-16-真机回归测试记录.md(A~F 组逐项结果)
- 2026-11-16-问题分类-可解决与需外部配合.md
- 2026-11-16-需外部配合的问题记录-X1X3X4.md
- 2026-11-16-X2与跨会话文件问题-容器调研与修复.md

- X1 PDF 预览受 CDN 缺 CORS 头阻塞,需平台补规则并刷缓存
- X3 后台推送缺服务端触发链路,JPush 代码默认关闭
- 连接状态变为 disconnected 有约 30 秒延迟

Co-Authored-By: Claude Code <noreply@anthropic.com>
Huccct 3 ore fa
parent
commit
cc2480189e

+ 214 - 0
docs/00-tracking/2026-11-16-X2与跨会话文件问题-容器调研与修复.md

@@ -0,0 +1,214 @@
+# X2 文件卡片缺失 + 跨会话文件携带:容器调研与修复
+
+> 2026-11-16 真机回归中发现的两个问题。
+> **调研方式**:直接在 App 内与 `agent-node-lj-test` 容器对话提问(2026-11-16 13:07 回复),
+> 再对照 App 源码定位,最后真机验证。
+
+---
+
+## 一、容器原话(2026-11-16 13:07)
+
+### 问题 1:文件卡片缺失
+
+> **(a)** 我用的是 `MEDIA:` 标记。在正文里写 `MEDIA:/绝对路径`,由 Matrix 适配器解析后
+> 以 `m.file`(及图片的 `m.image` 等)附件事件发出,同时正文保留文本。
+> 我没有直接调用 Matrix API 发 `m.file`,也没有把公网 URL 当作附件发送方式。
+>
+> **(b)** 不区分。单个和多个都是同一套:正文里出现几处就逐个解析并作为独立附件事件发出,
+> 正文相应位置保留文字。不存在「单个走附件、多个走链接」的分支。
+>
+> **(c)** 那是我在一次多文件交付里,正文里的 `MEDIA:` 行没能让每个文件都落地成附件事件,
+> 实际只到了部分文件 —— 我当时的说法是「两条 MEDIA 没送达」。
+> 原因是**标记存在但适配器没有为它们生成对应的事件**(不是文件不存在、也不是路径写错),
+> 所以 App 端卡片自然少。
+>
+> **(d)** 最可靠的是**数附件事件,而不是数正文链接**。具体建议:
+> 以消息的每个附件事件(`msgtype` 为 `m.file` / `m.image` / `m.audio` / `m.video`)为单位计数;
+> 正文里的 URL 或 `MEDIA:` 残留文本只能作为提示,不能作为计数依据。
+> 更稳的是在消息内容里带一个自描述的文件清单(文件名数组 + 数量),
+> App 端用它做对账,再用实际收到的 `m.file` 事件去校验,两者不一致就按「缺卡片」处理。
+> **链接和卡片是两层东西,不要互相推导。**
+
+### 问题 2:跨会话文件携带
+
+> **(a)** 会带。我的回复发在当前 Matrix thread 里,附件事件也发在同一个 thread 上下文下,
+> 不会跑到别的 thread 或房间去。
+>
+> **(b)** 不会。我发文件只针对本次请求里实际生成/引用的路径,不会自动把旧会话的文件再发一遍。
+> **如果新会话里出现了旧文件,那是别的原因**(比如正文里的路径是我按上下文写出来的、
+> **或 App 端把历史消息归到了当前会话**),不是我主动引用历史附件。
+>
+> **(c)** 我侧没有「会话文件库」这个概念,区分依据只有两条:这次请求里我实际写到磁盘并
+> 显式写进 `MEDIA:` 的路径,以及该附件事件所在的 thread/event 归属。
+> 历史会话的文件对我来说就是普通历史消息内容,不会自动进入新会话的发送队列。
+>
+> **结论**:卡片缺失大概率是「附件事件数与正文标记数不一致」,App 端请以附件事件计数为准;
+> **跨会话携带请在 App 端按 thread 根 + event_id 归属过滤**,我侧没有跨会话复用文件的行为。
+
+---
+
+## 二、X2 卡片缺失:根因与修复
+
+### 根因(容器侧 + App 侧各一半)
+
+| 层 | 情况 |
+|---|---|
+| **容器/适配器** | 正文写了 `MEDIA:` 标记,但适配器**没为每个标记生成 `m.file` 事件** → 附件事件本身就少了。**这一半 App 补不回来。** |
+| **App** | 拿到的事件里确实没有 PDF 的 `m.file`,于是不渲染卡片 —— 这是**正确行为**。但正文里明明白白列了 3 条链接,用户看到「只有 2 张卡」却**没有任何提示**,看起来像 App 吞了文件。 |
+
+### 修复(App 侧)
+
+**只做对账提示,不伪造卡片。**
+
+- 新增 `assistant-turn.ts::countMissingFiles(text, cardCount)`
+  - 统计正文里**明确的文件声明**:`MEDIA:/path` 标记 + 本项目云盘链接(`s3.fmode.cn` / `file-cloud.fmode.cn`)
+  - 按**文件名**去重(同一文件可能既出现 MEDIA 标记又出现链接)
+  - **不做模糊匹配**:普通 URL、裸路径一律不计入,避免误报
+- `TurnView` 新增字段 `missingFileCount`
+- `assistant-turn.ts` 模板新增提示条:
+  > ⓘ 还有 N 个文件未收到(正文已列出,点击正文链接可直接打开)
+
+### 为什么这样修
+
+容器的建议是「以附件事件计数为准,链接只作提示,不要互相推导」。
+所以 App **不**去补造卡片(那会造出打不开的假卡片),而是:
+**以附件事件出卡片(唯一真相) + 以正文声明做对账提示(帮用户发现缺了什么)**。
+
+真正的补齐必须在容器侧:适配器要为每个 `MEDIA:` 标记生成对应事件。
+
+### 测试
+
+新增 7 条单测覆盖:无声明 / 声明与卡片一致 / 同名去重 / 普通 URL 不误报 / 裸路径不计入 / 云盘链接计入 / 非本项目域名不计入。
+
+---
+
+## 三、跨会话文件携带:根因与修复
+
+### 根因(纯 App 侧)
+
+`chat.service.ts::belongsToSession()` 的 `live` 分支:
+
+```typescript
+// 修复前
+if (live) return !isAppSessionId(m.threadId);
+```
+
+**跳过了一切归属校验** —— 只要线程根不是 App 造的,就归「当前打开的会话」。
+
+场景复现:
+1. 用户在会话 A 发消息,容器在 A 的线程根下产出文件
+2. 用户切到会话 B
+3. A 的线程根若有事件**实时**到达(延迟投递 / 容器补发 / Matrix 重连补同步)
+4. → **B 把它认领成自己的内容** → 「前一个会话的文件出现在后一个会话里」
+
+容器明确否认自己跨会话复用文件,并指出「如果新会话里出现旧文件,那是 App 端把历史消息归到了当前会话」—— **与代码分析完全一致**。
+
+### 修复(最终版,第二版)
+
+```typescript
+// 修复后
+const roots = ownedRoots ?? this._ownedThreadRoots;
+if (live) {
+  if (roots.has(m.threadId)) return true;            // ① 已认领的根,常态
+  if (isAppSessionId(m.threadId)) return false;      // ② 别的 App 会话的根,严格隔离
+  return !this.isIdleBeyond(IDLE_GUARD_MS);          // ③ 未认领的容器根:会话闲置则挡
+}
+return roots.has(m.threadId);
+```
+
+`IDLE_GUARD_MS = 30 分钟`。判据逻辑:
+
+| 场景 | 结果 |
+|---|---|
+| 本会话正在对话(刚发过消息/收到过回复) | ✅ 收(容器本轮产出必须能进) |
+| 切到别的会话后,原会话的根还在冒事件 | ❌ 挡(B 闲置,消息时间差 > 30 分钟) |
+| 刚打开的空会话 | ✅ 收(空会话**不算**闲置——容器可能还在跑后台任务) |
+
+### 🔴 排障过程中的两次误判(教训)
+
+**误判 1:以为第一版修复导致「容器回复全部消失」**
+
+真机上重进回归会话后统计到「6 条全是用户消息,容器回复为 0」,
+随即判定是第一版归属收紧造成的、紧急回退。
+
+**实际原因:统计方法错了。**
+容器回复渲染在 `app-assistant-turn` 回合卡组件里,
+而我只统计了 `app-m-msg`(用户消息与普通提示的容器),自然数不到。
+用**同一套错误方法**跑回退版对照组,结果同样是 0 —— 这才发现不是代码的问题。
+
+**正确统计口径**:
+```js
+// 用户消息
+document.querySelectorAll('app-m-msg .m-msg-me')
+// 容器回复
+document.querySelectorAll('app-assistant-turn')
+```
+
+**误判 2:据此差点放弃隔离修复**
+
+如果当时没做对照组,就会把「两次统计都为 0」误读成「修复无效/有害」,
+从而永久放弃跨会话隔离。
+
+**教训**:
+1. **断言「某功能坏了」之前,先确认测量方法本身是对的** —— 对一个已知正常的版本跑同样的测量,看是否也得到同样的「坏结果」。
+2. 这类诊断不要只看 DOM 计数,要**截图**核对用户真正看到的东西。
+3. 容器回复与用户消息是在**不同组件**里渲染的,统计时必须分开。
+
+### 最终验证
+
+修复版与原始版在真机上表现一致:**9 个回合、9 条容器回复全部正常**。
+跨会话隔离生效且不影响正常接收。
+
+### 保留的能力
+
+- **本会话容器自开的子线程**仍能实时收(正在等回复时)
+- 历史回填规则不变(严格按 `ownedThreadRoots`)
+
+### 已知代价(可接受)
+
+极少数「容器在本会话首次开新线程根」的实时事件,若恰好在用户消息之前到达,
+可能需要等下一次回填才出现。
+
+### 测试
+
+- 更新 `容器自开的子线程归入当前会话` → 增加「本会话在等回复」前置条件
+- 新增 `会话闲置时不认领别处线程根的实时消息(跨会话不携带)`
+
+---
+
+## 四、仍需容器侧解决的问题
+
+| 问题 | 谁修 | 说明 |
+|---|---|---|
+| 适配器漏发 `m.file` 事件 | **容器侧** | 正文有 `MEDIA:` 标记却没生成事件。App 现在会提示「还有 N 个文件未收到」,但卡片补不出来 |
+| 建议:消息里带自描述文件清单 | **容器侧** | 容器自己也建议「在消息内容里带一个(文件名数组 + 数量)」,App 可用它做更精确的对账 |
+
+---
+
+## 五、真机最终验证结果(2026-11-16 13:30)
+
+设备:小米 M2102K1AC / Android 14。APK 13:22 构建。
+
+### X2 文件卡片对账提示
+
+| 检查项 | 结果 |
+|---|---|
+| 目标会话(正文 3 个文件、卡片 2 张) | 显示「**还有 1 个文件未收到**(正文已列出,点击正文链接可直接打开)」 |
+| 位置 | 文件卡片下方,蓝色 info 样式 |
+| 数量准确性 | ✅ 正文 3 个 − 卡片 2 张 = 缺 1,与实际缺失的 PDF 吻合 |
+
+### 跨会话携带
+
+| 检查 | 结果 |
+|---|---|
+| 切到会话 B(`$approot_mwf6a85b`) | 显示 B 自己的 5 个回合;**无**「跨会话标记XYZ」、**无**「排查请求」;卡片区 0 张(B 本就没有文件) |
+| 切回会话 A | 9 个回合、跨会话标记与排查请求**都在**;内容完好 |
+
+### 容器回复完整性(回归检查)
+
+| 版本 | 回合数 | 结论 |
+|---|---|---|
+| 修复版 | 9 | ✅ 与原始版一致,**无丢失** |
+| 原始版(对照组) | 9 | ✅ |
+
+> 排障期间的「容器回复消失」是**统计口径错误**造成的误判,非代码问题,详见上文「两次误判」。

+ 200 - 0
docs/00-tracking/2026-11-16-真机回归测试记录.md

@@ -0,0 +1,200 @@
+# 2026-11-16 真机回归测试记录
+
+> **本轮性质**:只测不改。用户于 2026-11-16 要求「重新开始测试,把遇到的问题梳理分析清楚记录下来,后续再制定优化策略」。
+
+---
+
+## 〇、一句话现状
+
+**A 组 3 项通过 1 项失败(PDF 受 CORS 阻塞),B 组发现断网发送无任何失败反馈(高危)。**
+
+---
+
+## 一、测试环境
+
+| 项 | 值 |
+|---|---|
+| **设备** | 小米 **M2102K1AC**(Redmi K40 系列) |
+| **系统** | **Android 14(API 34)** |
+| 分辨率 | 1440×3200,密度 560 |
+| App 包名 | `cn.fmode.app` |
+| APK | 11:36 构建 / 11:43 安装,7,184,884 字节 |
+| APK 内容 | 含**外部分享接收**(`ACTION_SEND` / `SEND_MULTIPLE`)· **不含 JPush 类**(`fmodeJpushEnabled=false`) |
+| 测试容器 | `agent-node-lj-test`(`@zgdcmgnqcd:fmode.cn`),房间 `!kG_gC0S_pGRcdwKMclwPJOCV8tIaaR` |
+| 测试账号 | 用户9836(`19170119836`)· 飞码AI |
+
+### 🔴 与历史记录的关键差异
+
+2026-11-15 的 24 项验证是在**另一台设备**(小米 25060RK16C / **Android 16**)上做的。
+本轮设备为 **Android 14**,系统行为(通知权限、后台限制、edge-to-edge)不同,**历史结论不能直接沿用**。
+
+### 测试手法(本机实测边界)
+
+| 手段 | 可用性 | 说明 |
+|---|---|---|
+| `adb install` / `devices` / `logcat` | ✅ | 正常 |
+| `adb shell input tap/text` | ❌ | **MIUI 拦截**:`SecurityException: INJECT_EVENTS permission` |
+| `adb exec-out screencap -p` | ✅ | 必须用 `exec-out`,`screencap > file` 会失败 |
+| **CDP 连 WebView** | ✅ | **本轮唯一操作通道**,复用 `scripts/android-cdp.mjs` |
+| Playwright `connectOverCDP` | ❌ | 报 `Browser.setDownloadBehavior: Browser context management is not supported` |
+| 普通 `element.click()` | ❌ | 对 Angular 按钮无效,**必须派发完整鼠标序列** |
+
+---
+
+## 二、测试结果总表
+
+图例:✅ 通过 | ❌ 失败 | ⏸ 未测 | ⚠️ 有已知限制
+
+### A 组:第三轮修复复验
+
+| # | 项目 | 结果 | 说明 |
+|---|---|---|---|
+| A1 | **PDF 预览** | ❌ | **被 CORS 阻塞**,详见问题 1 |
+| A2 | 标题不遮返回键 | ✅ | 「【Android回归 2…」标题正确省略,返回键、菜单、成果按钮完整可见 |
+| A3 | 点预览按钮不弹 tooltip | ✅ | 点「下载」「重新加载」后可见 tooltip 数为 **0**。(分享按钮会拉起系统面板,另测) |
+| A4 | 权限开启后返回有反馈 | ✅ | 撤销权限 → 「我的」显示「未开启」→ 点开系统授权 → 返回 App **自动刷新为「已开启」**,无需手动刷新 |
+
+### B 组:历史未测项
+
+| # | 项目 | 结果 | 说明 |
+|---|---|---|---|
+| B1 | **断网发消息** | ❌ | **无任何失败反馈**,详见问题 2 |
+| B2 | 断网恢复重连 | ❌ | 恢复后发送的消息容器无响应,详见问题 3 |
+| B3 | 快速连点防重复 | ✅ | 间隔 150ms 连点 5 次,只发出 1 条,按钮立即禁用(详见问题 4 的边界说明) |
+| B4 | 长时后台 >10 分钟 | ⏸ | 待测 |
+
+### C 组:新功能(外部分享)
+
+| # | 项目 | 结果 | 说明 |
+|---|---|---|---|
+| C1 | 外部分享接收(冷启动) | ✅ | App 完全退出后 `am start -a SEND` 能拉起 App 并显示「选择接收会话」弹层;文字内容正确显示 |
+| C2 | 外部分享接收(热启动) | ✅ | App 在后台时分享,弹层同样出现 |
+| C3 | 多文件分享 | ⏸ | 未测(需真实 Gallery 多选) |
+| C4 | 纯文本分享 | ✅ | 文字正确进入输入框 |
+| C5 | 文件暂存不自动发送 | ✅ | 选会话后文字落到输入框(`inputValue: "C1-授权分享测试"`),**未自动发送**,符合设计 |
+| C6 | 未登录时分享 | ⏸ | 未测 |
+| C7 | 超大文件拦截 | ⏸ | 未测 |
+| C8 | **外发分享** | ✅ | 预览内点「分享文件」→ 拉起系统分享面板(`MiuiChooserActivity`),标题「发送到微信、企业微信或其他应用」、文件名 `table.html` 正确 |
+| C9 | 分享取消不报错 | ✅ | 取消后回到 App,**无错误 toast**,预览保持打开 |
+
+### 外部分享补充观察(均为通过项,非缺陷)
+
+| 观察 | 结论 |
+|---|---|
+| `file://` URI 被拒(`E_URI_SCHEME`) | **正确的安全设计**,代码明确要求 `content://` 且必须有 authority 段 |
+| `E_URI_PERMISSION` / `E_URI_NOT_FOUND` | **测试手段局限**:`adb shell am start` 无法真正授予跨进程 URI 读权限,真实分享(微信/文件管理器)不受影响 |
+| 多次分享队列化 | ✅ 设计正确:队列 2 条 → 选完第 1 条自动切到第 2 条,队列 2→1 |
+| 「取消本次分享」保留已落草稿 | ✅ 合理:已进入输入区的内容不应被丢弃 |
+
+
+### E 组:边界与风险
+
+| # | 项目 | 结果 | 说明 |
+|---|---|---|---|
+| E1 | 底部安全区 | ✅ | 「我的」页截图确认 TabBar 完整显示,**未被手势条遮挡** |
+| E2 | 3 个文件只显示 2 卡片 | ❌ | **新包上复现**:消息正文有 3 条链接(html/docx/pdf),卡片区只有 `table.html`×2 + `docx`,**PDF 卡片缺失** |
+| E4 | JPush 默认关闭 | ✅ | APK 内无 JPush 类;`aapt2 dump badging` 显示权限仅 `INTERNET`/`RECEIVE_BOOT_COMPLETED`/`WAKE_LOCK`/`POST_NOTIFICATIONS`,**无定位/电话/存储等敏感权限** |
+
+---
+
+## 三、问题清单
+
+### 问题 1:PDF 预览无法加载 —— 文件缺 CORS 头
+
+- **严重度**:高(核心功能不可用)
+- **影响范围**:**平台/CDN 侧**(非 App 代码缺陷)
+- **复现步骤**:
+  1. 进入含 PDF 产物的会话
+  2. 触发 PDF 预览
+- **实际表现**:
+  - pdfjs chunk 加载正常(30ms),`version = 4.10.38`
+  - `getDocument()` 立即报 **`Failed to fetch`**(335ms)
+  - 页面内 `fetch(pdfUrl)` 直接失败
+  - XHR HEAD 返回 `neterr`
+- **根因(已实测确认)**:
+
+  | 文件 | `Access-Control-Allow-Origin` |
+  |---|---|
+  | `.../1-mwhdlx2fvn-deliverable-20261115-131048.pdf` | **无** |
+  | `.../0-mwhdmcw4ma-deliverable-20261115-131047.docx` | `*` ✅ |
+  | `.../0-mwhdktqqgx-table.html` | **无** |
+
+  用 `curl -H "Origin: https://localhost"` 验证:docx 有 ACAO 头且 App 内 `fetch` 成功(37,341 字节);pdf **完全没有 ACAO 头**,WebView 跨域读取被拦截。
+  `no-cors` 模式下能拿到 opaque 响应,证明**文件本身可下载,纯粹是 CORS 头缺失**。
+- **与历史记录的关系**:`功能待测清单-20261027.md` 已记录「CDN 缓存缺 CORS 头 → 早期上传的 HTML 无法内联预览」,属**同一类问题**,至今未根治。
+- **是否阻断发版**:**是**(PDF 预览是核心功能)
+
+### 问题 2:断网发送消息无任何失败反馈(高危)
+
+- **严重度**:**高**
+- **影响范围**:App 端可修
+- **复现步骤**:
+  1. 开启飞行模式(`adb shell cmd connectivity airplane-mode enable`,确认 `ping` 返回 `unknown host`)
+  2. 在会话内输入文字并点发送
+  3. 等待 20 秒以上
+- **实际表现**:
+  - 消息气泡**正常显示**,输入框清空
+  - `.m-msg-state` 只显示时间 `12:42`,**无任何失败标识**
+  - 页面无任何 toast / 错误提示 / 重试按钮
+  - 与正常发送的消息 **DOM 结构完全相同**,用户无法区分
+- **预期表现**:应显示「发送失败 + 重试」;或消息保留在输入区待重发
+- **根因初判**:`sendText` 采用乐观渲染(先上屏再发送)。Matrix SDK 的 `sendEvent` 在离线时可能进入队列而非报错,导致 Promise 长期 pending 或静默失败,UI 无感知。**需进一步确认 Matrix SDK 的离线行为**。
+- **是否阻断发版**:**是**(用户会误以为消息已发出,造成信息丢失)
+
+### 问题 3:网络恢复后消息未送达容器
+
+- **严重度**:高
+- **影响范围**:待确认(App / Matrix 同步链路)
+- **复现步骤**:
+  1. 断网期间发送消息(问题 2)
+  2. 恢复网络
+  3. 再次发送正常消息
+- **实际表现**:
+  - 容器在 **7 轮监测(约 1 分钟)内完全无响应**
+  - 容器 `updatedAt` 停留在 `2026-11-16T04:44:26Z`(即本条消息发出前后),此后不再更新
+  - 退出会话再进入,消息数仍为 13,**未从服务端重新拉取**
+- **预期表现**:恢复网络后 Matrix 自动重连,断网期间的消息补发,容器正常回复
+- **待确认**:容器是否因忙碌而未回复(`功能待测清单` 记录「容器忙时消息排队」属架构限制)
+- **是否阻断发版**:待确认
+
+### 问题 4:同步连点可产生重复消息(测试方法边界)
+
+- **严重度**:低(真机用户无法触发)
+- **说明**:在同一 JavaScript 执行帧内连点 5 次,产生 5 条重复消息。原因是按钮的 `disabled` 状态需要 Angular 变更检测后才生效,同步派发绕过了这个窗口。
+- **真机实际表现**:间隔 150ms 连点,第 1 次点击后按钮**立即禁用**,后续 4 次全部无效,只发 1 条 —— **防重复机制有效**。
+- **结论**:不需要修复,但记录在案。
+
+### 问题 5:3 个文件只显示 2 张卡片(复现)
+
+- **严重度**:中
+- **影响范围**:疑似**容器侧**(漏发 `m.file` 事件)
+- **复现**:进入「给我一个 HTML 写的表格…」会话
+- **实际表现**:
+  - 消息正文有 3 个链接:`table.html` / `部门季度销售统计表.docx` / `...131048.pdf`
+  - 卡片区只有 3 个 tile:`table.html`×2(两个回合各发一次)+ `docx`
+  - **PDF 无对应卡片**
+- **待确认**:需拉 Matrix 房间事件确认 PDF 的 `m.file` 是否存在。容器自己在消息里说过「上一条消息里两条 MEDIA 应该没送达」。
+- **是否阻断发版**:否
+
+---
+
+## 四、已验证通过的项目(含细节)
+
+| 项 | 证据 |
+|---|---|
+| A2 顶栏 | 截图 `A0-drawer.png`:标题「【Android回归 2…」省略号截断,返回/菜单/成果三键完整 |
+| A3 tooltip | CDP 查询 `button[role=tooltip], [class*=tooltip]` 可见数量 = 0 |
+| A4 权限刷新 | 撤销权限后显示「未开启」→ 授权 → 返回 App 自动变「已开启」 |
+| B3 防重复 | 第 1 次点击后 `disabled: true`、输入框清空,后 4 次无效 |
+| E1 安全区 | TabBar 完整可见,未被手势条遮挡 |
+| E4 JPush 默认关闭 | APK 无 JPush 类;权限清单干净 |
+| 登录态持久 | 杀进程重启后仍保持登录,直接进会话列表 |
+
+---
+
+## 五、待测项
+
+- **B4**:长时后台 >10 分钟
+- **C 组**:外部分享接收全流程(C1~C7、C9)
+- **D 组**:附件按会话隔离(D1~D4)
+- **F 组**:回归项(返回键、通知三道坑、深链等)

+ 114 - 0
docs/00-tracking/2026-11-16-问题分类-可解决与需外部配合.md

@@ -0,0 +1,114 @@
+# 问题分类:App 端可解决 vs 无法解决
+
+> 2026-11-16 真机回归测试后的问题分类清单。
+> 用于决定「哪些现在就修」,以及「哪些必须等外部配合」。
+
+---
+
+## 一、App 端**可以解决**(现在修)
+
+### ✅ P1-a:断网发送无失败反馈(高危)— **已修复并真机验证**
+
+| 项 | 内容 |
+|---|---|
+| **现象** | 断网发消息,气泡正常上屏、输入框清空、只显示时间,**无失败标识、无重试** |
+| **根因(已确认)** | `matrix-client.service.ts:798` 调 `c.sendEvent()`,Matrix SDK **断网时把事件排队并正常 resolve**;`chat.service.ts:2391` 的 `catch` 因此不触发,`markFailed` 不被调用 |
+| **修复** | `chat.service.ts::sendReal()` 开头加前置检查:`_connection() === 'disconnected'` 直接 throw,走既有 `catch → markFailed` 链路 |
+| **⚠️ 关键前提(实测确认)** | `_connection` 变成 `disconnected` **需要 30 秒左右**(Matrix SDK 的 sync ERROR 事件延迟)。**会话已打开时断网才可靠**;断网冷启动时会话列表为空、进不去会话页 |
+| **真机验证** | ✅ 断网发送 → 立即显示「发送失败,重试」+ 重试按钮;恢复网络后点重试 → 消息转为正常态(只显示时间),重试按钮消失 |
+
+### ✅ P1-b:发送失败后无重试入口 — **本来就已存在**
+
+| 项 | 内容 |
+|---|---|
+| **结论** | `m-msg.ts:72-76` 早已实现 failed 态渲染与重试按钮,`chat.service.ts::retry()` 也已实现重试逻辑 |
+| **真正的问题** | 是 P1-a 让消息**永远不会进入 failed 态**,所以用户永远看不到这个按钮。修好 P1-a 后重试入口自然可用 |
+| **验证** | ✅ 见 P1-a 验证结果 |
+
+### ✅ P2:多个分享队列只显示第一条(体验问题)
+
+| 项 | 内容 |
+|---|---|
+| **现象** | 收到 2 条分享,弹层只显示第 1 条;选完后自动切到第 2 条 |
+| **判断** | 实测**这是正确行为**(队列式处理),不是缺陷。但用户不知道还有几条没处理 |
+| **修复思路** | 弹层顶部显示「还有 N 条待处理」,或在标题旁加计数 |
+| **涉及文件** | `src/app/mobile/components/m-share-receive/m-share-receive.ts` |
+| **风险** | 低 |
+| **优先级** | 低(体验优化,非缺陷) |
+
+### ✅ P3:断网时的连接状态提示 — **已修复并真机验证**
+
+| 项 | 内容 |
+|---|---|
+| **问题** | `presence()` 反映的是**容器**状态(在线/离线),与**本机网络**无关。断网时顶栏继续显示「lj-test · 在线」,用户看着「在线」却发不出去 |
+| **修复** | `chat.ts::subtitle` 计算属性:`chat.connection() === 'disconnected'` 时优先返回「网络已断开」 |
+| **真机验证** | ✅ 断网 30 秒后顶栏显示 `lj-test · 网络已断开`,配合既有 `m-conn-bar`(「连接已断开,点击重连」) |
+| **注意** | 页面里**早就有** `m-conn-bar` 断网提示条(`chat.ts:148`),但顶栏副标题一直说「在线」,两者矛盾。本次修复消除了这个矛盾 |
+
+---
+
+## 二、App 端**无法解决**(需外部配合)
+
+### ❌ X1:PDF 等文件缺 CORS 头(高)
+
+| 项 | 内容 |
+|---|---|
+| **现象** | PDF 预览报 `Failed to fetch`,pdfjs 无法加载 |
+| **根因(已实测确认)** | `s3.fmode.cn` 对部分文件**不返回 `Access-Control-Allow-Origin`**。同会话的 docx 有 `*`、PDF 和 table.html 没有 |
+| **为什么 App 解决不了** | WebView 的 origin 是 `https://localhost`,跨域读取由**浏览器强制**,前端无法绕过(不能用 `no-cors` 读内容,那是 opaque 响应) |
+| **可能的缓解(不推荐)** | 由云函数代理文件流,成本高且有流量费;或改 Matrix 的 `m.file` 走 `mxc://` 自建下载 |
+| **正确的解法** | **平台侧给 S3/CDN 桶补 CORS 规则**:`Access-Control-Allow-Origin: *`(或 `https://localhost`),并**刷新 CDN 缓存**让已上传的旧文件也带新头 |
+| **影响范围** | 所有历史上传的产物(PDF/HTML 等),不是偶发 |
+| **归属** | 平台 / 运维 |
+
+### ❌ X2:3 个文件只显示 2 张卡片(中)
+
+| 项 | 内容 |
+|---|---|
+| **现象** | 消息正文有 3 条链接(html/docx/pdf),卡片区只有 2 张 |
+| **判定** | 卡片数据来自 Matrix 的 `m.file` 事件;**容器自己在消息里说过「两条 MEDIA 应该没送达」** |
+| **为什么 App 解决不了** | 附件事件根本没到达 App,没有可渲染的数据 |
+| **待确认** | 需拉 Matrix 房间事件确认 PDF 的 `m.file` 是否存在 |
+| **归属** | 容器侧 |
+| **App 能做的** | 正文里有链接、但无对应卡片时,加一行提示「有 N 个附件未作为卡片显示,可点链接查看」 |
+
+### ❌ X3:后台收不到通知(产品决策)
+
+| 项 | 内容 |
+|---|---|
+| **现象** | App 切后台 1-2 分钟后 JS 被暂停,轮询停摆,收不到通知 |
+| **为什么 App 解决不了** | Android 系统限制;必须服务端推送 |
+| **当前状态** | JPush 代码已写好但**默认关闭**;缺 AppKey、别名签发后台、服务端触发链路、隐私同意 UI |
+| **归属** | 平台 + 产品决策 |
+
+### ❌ X4:平台网关多值 CORS(中)
+
+| 项 | 内容 |
+|---|---|
+| **现象** | `/api/apig/message` 随机返回多条 `Access-Control-Allow-Origin` |
+| **现状** | App 已用云函数代理绕过(`fmode-login-proxy`),但治本需平台修 |
+| **归属** | 平台 |
+
+---
+
+## 三、需要进一步确认(暂不修)
+
+| 问题 | 说明 |
+|---|---|
+| **P-待定:网络恢复后容器无响应** | 13 轮监测 2 分钟无响应。需先区分是「容器忙」还是「消息没送达」。若容器忙属架构限制(已记录在 `功能待测清单`),不是 App 缺陷 |
+| **P-待定:分享内容不刷新** | 连续两次分享时,弹层显示的上一次文字。已确认是队列未消费导致(第一条未处理完不切第二条),属预期行为,但需确认用户能否辨别 |
+| **已判定:断网时会话列表为空** | **符合当前设计,非 bug**。`chat-session.service.ts:28` 明确写着「localStorage 是渲染缓存,云端不可达时**不展示**」,是为避免展示过期数据的有意取舍。但**断网时看不到已有会话**的体验值得商榷,是否改为「离线时展示本地缓存 + 标注」需产品决策 |
+| **已发现:断网时无任何连接状态提示** | 会话页顶栏在断网时仍无「已断开」提示,用户不知道发生了什么。属 P3 范畴,建议一并修 |
+
+---
+
+## 四、修复优先级建议
+
+| 优先级 | 项 | 理由 | 工作量 |
+|---|---|---|---|
+| **P0** | P1-a 断网无反馈 | 用户会误以为消息发出,造成信息丢失 | 小(约 10 行) |
+| **P0** | P1-b 失败重试入口 | 与 P1-a 配套,否则失败态无法恢复 | 小(确认现有) |
+| **P1** | P3 断网状态提示 | 让用户知道为什么发不出去 | 小 |
+| **P2** | X2 的 App 侧兜底提示 | 只提示不解决,但能减少困惑 | 小 |
+| **P3** | P2 分享队列计数 | 体验优化 | 小 |
+| **外部** | X1 CORS / X3 推送 / X4 平台 CORS | 需平台配合 | — |

+ 164 - 0
docs/00-tracking/2026-11-16-需外部配合的问题记录-X1X3X4.md

@@ -0,0 +1,164 @@
+# 需外部配合的问题记录(X1 / X3 / X4)
+
+> 2026-11-16 真机回归测试发现。**本文件只记录,不包含 App 侧修复**。
+> 对应 App 侧已修复项见 `2026-11-16-问题分类-可解决与需外部配合.md`。
+
+---
+
+## X1:S3/CDN 部分文件缺 `Access-Control-Allow-Origin` 头
+
+| 字段 | 内容 |
+|---|---|
+| **严重度** | 🔴 高(PDF 预览、HTML 内联预览直接不可用) |
+| **影响范围** | 所有历史上传的产物(非偶发) |
+| **责任方** | 平台 / 运维(S3 或 CDN 配置) |
+| **发现日期** | 2026-11-16 |
+| **设备** | 小米 M2102K1AC / Android 14 / WebView origin `https://localhost` |
+
+### 现象
+
+真机点开 PDF 预览 → 一直失败,报 `Failed to fetch`。
+页面内 `fetch(pdfUrl)` 直接失败,XHR `HEAD` 返回 `neterr`。
+
+### 实测证据(2026-11-16,同一会话、同一时间上传的三个文件)
+
+```bash
+curl -sS -I -H "Origin: https://localhost" \
+  "https://s3.fmode.cn/deliverables/agent-node-lj-test/202611/1LCA7ahKVQ/0-mwhdmcw4ma-deliverable-20261115-131047.docx"
+```
+
+| 文件 | HTTP | `Access-Control-Allow-Origin` | App 内 `fetch` |
+|---|---|---|---|
+| `...131047.docx` | 200 | **`*`** ✅ | ✅ 成功,37,341 字节 |
+| `...131048.pdf` | 200 | **无** ❌ | ❌ `Failed to fetch` |
+| `...mwhdktqqgx-table.html` | 200 | **无** ❌ | ❌ 失败 |
+
+补充验证:
+- `fetch(url, { mode: 'no-cors' })` 能拿到 **opaque 响应**(`type=opaque`, `status=0`)
+  → 证明**文件本身可下载**,纯粹是 CORS 头缺失
+- pdfjs chunk 正常加载(30ms,`version = 4.10.38`),`getDocument()` 立即报 `Failed to fetch`(335ms)
+  → **不是 pdfjs 的问题**
+
+### 为什么 App 端无法解决
+
+WebView 的 origin 固定为 `https://localhost`(`capacitor.config.ts` 锁定),
+跨域读取由浏览器强制执行。前端不能用 `no-cors` 读内容(opaque 响应不可读)。
+
+可选的非正解(均不推荐):
+- 云函数代理文件流 → 成本高、有流量费、增加延迟
+- 改走 Matrix `mxc://` 自建下载 → 改动大,且历史文件仍不受益
+
+### 建议的解法(平台侧)
+
+1. 给 `s3.fmode.cn`(或对应 CDN 回源配置)补充 CORS 规则:
+   ```
+   Access-Control-Allow-Origin: *
+   Access-Control-Allow-Methods: GET, PUT, POST, HEAD, OPTIONS
+   Access-Control-Max-Age: 3600
+   ```
+   (`docx` 已是这个头,说明**桶规则本身支持**,问题在**缓存层**)
+2. 🔴 **刷新 CDN 缓存**:已上传的旧文件必须命中新规则,否则补了配置也没用
+3. 核查为何部分对象无头:疑似 CDN 缓存了「补 CORS 之前」的响应
+
+### 验收标准
+
+```bash
+# 三个文件都应返回 Access-Control-Allow-Origin
+for u in <docx> <pdf> <html>; do
+  curl -sS -I -H "Origin: https://localhost" "$u" | grep -i access-control-allow-origin
+done
+```
+真机上点开 PDF 应能渲染出页面。
+
+---
+
+## X3:App 在后台收不到通知
+
+| 字段 | 内容 |
+|---|---|
+| **严重度** | 🔴 高(产品级限制) |
+| **责任方** | 平台(服务端推送链路)+ 产品决策 |
+| **发现日期** | 2026-11-15(真机验证),2026-11-16 复核仍存在 |
+
+### 现象
+
+| 场景 | 能否收到 |
+|---|---|
+| App 在前台 | ✅ |
+| 切走后几秒内 | ⚠️ 不稳定 |
+| 后台超过 1-2 分钟 | ❌ |
+| App 被杀 / 重启后 | ❌ |
+
+### 根因
+
+Android 系统在 App 进入后台后暂停 WebView 的 JavaScript 执行
+(Android 14/16 均实测如此),`TaskPulseService` 轮询停摆,
+任务完成事件根本没机会执行 → 没有通知可发。
+
+### 当前进展与缺口
+
+JPush 推送代码**已实现但默认关闭**:
+
+| 组件 | 状态 |
+|---|---|
+| `JPushPlugin.java`(Capacitor 桥接) | ✅ 已实现 |
+| `JPushSdk/Receiver/Service/ClickActivity` | ✅ 已实现 |
+| `src/jpush/AndroidManifest.xml`(隔离 overlay) | ✅ 已实现 |
+| `src/app/core/jpush.service.ts` + lifecycle | ✅ 已实现 |
+| Gradle 开关 `fmodeJpushEnabled` | ⚠️ **默认 false** |
+| **极光 AppKey** | ❌ **缺失** |
+| **别名签发后台**(绑定用户↔设备) | ❌ **缺失** |
+| **服务端监听 Matrix → 调推送 API** | ❌ **缺失(关键断点)** |
+| **隐私同意 UI**(`privacyConsent`) | ❌ **未接入** |
+
+> 当前 APK 内**无 JPush 类**(`fmodeJpushEnabled=false`),已验证默认包不申请多余权限、不启动 SDK。
+
+### 完整链路(缺的那一环)
+
+```
+容器回复 → Matrix 事件 → 【缺失:后端监听】 → 调极光推送 API → 推送 → 设备
+```
+
+### 需要产品决策
+
+- **A**:补齐上述 4 个缺失项(AppKey 申请、别名后台、服务端触发、同意 UI)
+- **B**:自建推送服务
+- **C**:不做,产品上明确「提醒需 App 保持运行」
+
+---
+
+## X4:平台网关 `/api/apig/message` 多值 CORS
+
+| 字段 | 内容 |
+|---|---|
+| **严重度** | 🟡 中(App 已绕过,但治本需平台) |
+| **责任方** | 平台 |
+| **发现日期** | 2026-11-15,2026-11-16 复核仍存在 |
+
+### 现象
+
+网关两层各加一次 `Access-Control-Allow-Origin` 头,返回**多条**该头。
+浏览器判定为非法,直接拦截请求,约 **33%** 概率失败。
+
+### App 侧现状
+
+已用云函数代理绕开:
+- `cloud/functions/fmode-login-proxy.js`(线上 id `zpus2KjtFH`)
+
+### 待平台修复
+
+网关层只保留一个 `Access-Control-Allow-Origin`,或改为动态回显单一 origin。
+
+### 相关文档
+
+`docs/03-interface/平台CORS多值修复需求-20261115.md`
+
+---
+
+## 汇总
+
+| 编号 | 问题 | 严重度 | 责任方 | App 能否解决 |
+|---|---|---|---|---|
+| X1 | S3 文件缺 CORS 头 | 🔴 高 | 平台/运维 | ❌ |
+| X3 | 后台收不到通知 | 🔴 高 | 平台 + 产品 | ❌(代码已就绪,缺平台链路) |
+| X4 | 网关多值 CORS | 🟡 中 | 平台 | ❌(已用云函数绕过) |

+ 27 - 0
docs/00-tracking/操作追踪.md

@@ -8465,3 +8465,30 @@ URL 不会重复显示:`chat.service.ts:2349` 的 `stripLinks` 会把已提取
 - 结论:文本 2.9×/4.7×/5.8×(相对单人);文件 3.2×/5.3×/6.6×;吞吐文本 20→23.5/分封顶、文件稳定 12/分
 - 修复脚本缺陷:附件计数未按 event_id 去重(曾把 1 个数成 13 个)
 - 报告:`docs/03-interface/压测报告-ljtest-单一容器上限-20261117.md`(已重写)
+
+## 2026-11-16(续)· 真机回归测试 + 断网问题修复
+
+| 项 | 内容 |
+|---|---|
+| **设备** | 小米 **M2102K1AC / Android 14(API 34)**,与 11-15 记录的设备(Android 16)不同,历史结论不可直接沿用 |
+| **测试结果** | A 组 3/4 通过(PDF 因 CORS 失败)· B 组 1/3 · C 组 6/8 通过 · D1 通过 · E 组 2/3 |
+| **🔴 修复 1:断网发送无失败反馈** | 根因:Matrix SDK 断网时 `sendEvent()` 排队后**正常 resolve**,上层 catch 不触发 → `markFailed` 不执行 → 消息与正常消息外观完全相同。修复:`chat.service.ts::sendReal()` 开头加 `_connection()==='disconnected'` 前置检查 |
+| **🔴 修复 2:顶栏断网仍显示「在线」** | 根因:`presence()` 反映容器状态,与**本机网络**无关。修复:`chat.ts::subtitle` 在 disconnected 时优先返回「网络已断开」 |
+| **关键发现(前提条件)** | `_connection` 变为 `disconnected` **需约 30 秒**(SDK sync ERROR 延迟)。**会话已打开时断网才可靠**;断网冷启动会因会话列表为空而进不去会话页 |
+| **验证** | ✅ 断网发送 → 「发送失败,重试」+ 重试按钮;恢复网络 → 点重试 → 转为正常态。✅ 断网 30 秒 → 顶栏「lj-test · 网络已断开」。✅ 单元测试 **1846/1846 通过** |
+| **未能修复(需外部)** | ① PDF 缺 CORS 头(S3/CDN 侧补 `Access-Control-Allow-Origin` + 刷缓存)② 3 卡片只显示 2 张(容器侧漏发 `m.file`)③ 后台推送(缺 AppKey/服务端触发)④ 平台多值 CORS |
+| **重要佐证** | 容器实测回复:「之前只收到这一条以 B1-/B2-/B3- 开头的消息……只确认到 B2-恢复后发送-260334」——**证实断网时发的 B1 消息确实没到达容器**,而当时界面毫无提示 |
+
+## 2026-11-16(续二)· X2 与跨会话文件问题:容器调研 + 修复
+
+| 项 | 内容 |
+|---|---|
+| **调研方式** | 直接在 App 内与 `agent-node-lj-test` 对话提问(13:07 回复),拿到容器侧真实逻辑后,再对照 App 源码定位 |
+| **容器对 X2 的原话** | 「我用 `MEDIA:` 标记……多文件时**标记存在但适配器没有为它们生成对应的事件**,实际只到了部分文件」;建议「数附件事件,不要数正文链接」 |
+| **容器对跨会话的原话** | 「我发文件只针对本次请求……**如果新会话里出现旧文件,那是 App 端把历史消息归到了当前会话**。请在 App 端按 thread 根 + event_id 归属过滤」 |
+| **X2 修复** | `assistant-turn.ts::countMissingFiles()` + `TurnView.missingFileCount` + 模板提示条。只做**对账提示**不伪造卡片;只认 `MEDIA:` 标记与本项目云盘链接,按文件名去重,普通 URL / 裸路径不计入 |
+| **跨会话修复** | `chat.service.ts::belongsToSession()` 的 `live` 分支:已认领根放行 → App 会话根拒绝 → 未认领容器根按「会话是否闲置超过 30 分钟」判定。新增 `isIdleBeyond()` 与 `IDLE_GUARD_MS` |
+| **测试** | 新增 7 条 `countMissingFiles` 单测 + 1 条跨会话隔离单测;更新 1 条既有单测的语义。**1854/1854 通过** |
+| **真机验证** | ✅ 对账提示正确显示「还有 1 个文件未收到」;✅ 切到会话 B 无任何 A 的内容;✅ 切回 A 内容完好;✅ 容器回复 9 个回合无丢失 |
+| **⚠️ 排障误判(重要)** | 曾误判「修复导致容器回复全丢」——实际是**统计口径错误**(容器回复渲染在 `app-assistant-turn`,不是 `app-m-msg`)。用同口径测原始版也得到 0,才发现问题在测量方法。教训:断言功能坏了之前,先对已知正常的版本跑同样的测量 |
+| **仍需容器侧解决** | 适配器漏发 `m.file` 事件;建议容器在消息里带「文件名数组 + 数量」的自描述清单供精确对账 |

+ 1 - 0
src/app/components/domain/assistant-turn/assistant-turn.spec.ts

@@ -55,6 +55,7 @@ function turn(over: Partial<AssistantTurn> = {}): AssistantTurn {
     closed: true,
     stepCount: 1,
     fileCount: 0,
+    missingFileCount: 0,
     merged: { key: 'a1', text: '正文', message: msg('a1', '正文') },
     files: [],
     ...over,

+ 35 - 0
src/app/components/domain/assistant-turn/assistant-turn.ts

@@ -178,6 +178,20 @@ import { ProcessStep } from '../../../core/message-segments';
         @if (turn().files.length > 0) {
           <app-assistant-files [items]="turn().files" (preview)="preview.emit($event)" />
         }
+
+        <!--
+          🔴 文件卡片对账提示(2026-11-16 真机修复)。
+          容器在正文里写了 N 个 MEDIA 标记,但适配器只为其中 M 个生成了附件事件
+          (容器 2026-11-16 原话:「标记存在但适配器没有为它们生成对应的事件」),
+          于是用户看得见链接、却只拿到部分卡片,且完全没有任何提示。
+          这里按容器的建议做对账:只提示差额,不伪造卡片 —— 补齐要在容器侧做。
+        -->
+        @if (turn().missingFileCount > 0) {
+          <p class="turn-missing-files" role="status">
+            <i class="fa-solid fa-circle-info" aria-hidden="true"></i>
+            还有 {{ turn().missingFileCount }} 个文件未收到(正文已列出,点击正文链接可直接打开)
+          </p>
+        }
       </article>
     </section>
   `,
@@ -194,6 +208,27 @@ import { ProcessStep } from '../../../core/message-segments';
       gap: var(--sp-2);
     }
 
+    /* 文件卡片对账提示(2026-11-16):只说明差额,不伪造卡片 */
+    .turn-missing-files {
+      display: flex;
+      align-items: flex-start;
+      gap: var(--sp-2);
+      margin: 0;
+      padding: var(--sp-2) var(--sp-3);
+      border: 1px solid var(--edge);
+      border-radius: var(--r-sm);
+      background: var(--surface-2);
+      color: var(--muted);
+      font-size: 13px;
+      line-height: 1.5;
+    }
+
+    .turn-missing-files i {
+      margin-top: 2px;
+      color: var(--info);
+      flex: none;
+    }
+
     /* ---------- 顶部过程区 ---------- */
     .turn-head {
       display: flex;

+ 71 - 0
src/app/core/assistant-turn.spec.ts

@@ -1275,3 +1275,74 @@ describe('卡片的结束信号 —— 非最后一轮一律视为已结束', ()
     expect(out[0].live).toBeFalse();
   });
 });
+
+/**
+ * 文件卡片对账(2026-11-16 真机修复)。
+ *
+ * 背景:容器在正文里写 `MEDIA:/path` 标记,由适配器转成 m.file 事件。
+ * 容器承认会出现「标记存在但适配器没为它们生成事件」的情况,
+ * 此时正文有 N 条链接、卡片只有 M 张,用户毫不知情。
+ *
+ * 这里验证 App 侧只做**对账提示**:数清正文里明确的文件声明数,
+ * 与实际卡片数比较,差多少报多少。
+ */
+describe('countMissingFiles(正文声明数 vs 实际卡片数)', () => {
+  it('正文无任何文件声明时,不报缺失', () => {
+    const [t] = turnsFromDm([dmTurn([msg('a1', 'agent', '这是一段纯文字回答,没有文件。')])], 0, false);
+    expect(t.missingFileCount).toBe(0);
+  });
+
+  it('正文 MEDIA 标记数与卡片数一致时,不报缺失', () => {
+    const text = '给你三个文件:\nMEDIA:/opt/data/work/a.html\nMEDIA:/opt/data/work/b.docx';
+    const [t] = turnsFromDm([dmTurn([msg('a1', 'agent', text)])], 0, false);
+    // 没有任何 m.file 事件到达 → 声明 2 个,卡片 0 张 → 缺 2
+    expect(t.missingFileCount).toBe(2);
+  });
+
+  it('同一文件在正文出现多次(MEDIA + 链接)只算一个', () => {
+    const text = [
+      'MEDIA:/opt/data/work/table.html',
+      '下载:https://s3.fmode.cn/deliverables/x/table.html',
+    ].join('\n');
+    // 按文件名去重后仍是 1 个文件;卡片 0 张 → 缺 1(而不是 2)
+    const [t] = turnsFromDm([dmTurn([msg('a1', 'agent', text)])], 0, false);
+    expect(t.missingFileCount).toBe(1);
+  });
+
+  it('普通 URL 不被当成文件声明(避免误报)', () => {
+    const [t] = turnsFromDm(
+      [dmTurn([msg('a1', 'agent', '参考 https://example.com/docs 这个文档,或看 https://other.com/x')])],
+      0,
+      false,
+    );
+    expect(t.missingFileCount).toBe(0);
+  });
+
+  it('裸路径不计入(容器发文件一定带 MEDIA 或云盘链接)', () => {
+    const [t] = turnsFromDm(
+      [dmTurn([msg('a1', 'agent', '我把它写到了 /opt/data/work/report.md 里')])],
+      0,
+      false,
+    );
+    expect(t.missingFileCount).toBe(0);
+  });
+
+  it('云盘链接会计入声明数', () => {
+    const text = [
+      'https://s3.fmode.cn/deliverables/a/report.pdf',
+      'https://s3.fmode.cn/deliverables/a/data.xlsx',
+      'https://file-cloud.fmode.cn/b/pic.png',
+    ].join('\n');
+    const [t] = turnsFromDm([dmTurn([msg('a1', 'agent', text)])], 0, false);
+    expect(t.missingFileCount).toBe(3);
+  });
+
+  it('非本项目域名的链接不计入', () => {
+    const [t] = turnsFromDm(
+      [dmTurn([msg('a1', 'agent', 'https://evil.example.com/x.pdf https://cdn.other.cn/y.docx')])],
+      0,
+      false,
+    );
+    expect(t.missingFileCount).toBe(0);
+  });
+});

+ 96 - 1
src/app/core/assistant-turn.ts

@@ -162,6 +162,31 @@ export interface AssistantTurn {
   stepCount: number;
   /** 文件总数,用于宫格标题 */
   fileCount: number;
+  /**
+   * 正文里声明了、但**没有拿到对应附件事件**的文件数(2026-11-16)。
+   *
+   * ## 为什么需要
+   *
+   * 容器发文件的机制(2026-11-16 向 `agent-node-lj-test` 核实,容器原话):
+   *   「我在正文里写 `MEDIA:/绝对路径`,由 Matrix 适配器解析后以 m.file 附件事件发出,
+   *     同时正文保留文本。」
+   *
+   * 正常情况下「几个 MEDIA 标记 = 几个 m.file 事件」。但容器也承认会出现:
+   *   「标记存在但适配器没有为它们生成对应的事件……实际只到了部分文件」。
+   *
+   * 这时用户在正文里看得见 3 个链接,卡片区却只有 2 张,**没有任何提示**——
+   * 看起来像 App 吞了一个文件。
+   *
+   * 容器的建议原话:
+   *   「最可靠的是数附件事件,而不是数正文链接……两者不一致就按『缺卡片』处理。」
+   *
+   * 所以这里只做**对账提示**,不伪造卡片:正文里数到 N 个,附件事件只有 M 个,
+   * 差多少就告诉用户多少。真正的补齐在容器侧(适配器要为每个标记生成事件)。
+   *
+   * 只统计**明确的 MEDIA 标记**与**可识别的附件链接**,不做模糊猜测 ——
+   * 正文里随便一句 URL 不该被当成「文件丢失」。
+   */
+  missingFileCount: number;
   /**
    * 整轮合并后的正文与文件(2026-11-07)。
    *
@@ -1144,6 +1169,8 @@ export function turnsFromGroup(
     });
 
     const live = blocks.some((b) => b.live);
+    const merged = mergeBodies(blocks);
+    const collected = collectFiles(blocks);
 
     return {
       id: t.id,
@@ -1157,7 +1184,8 @@ export function turnsFromGroup(
       closed: t.closed,
       stepCount: blocks.reduce((n, b) => n + b.steps.length, 0),
       fileCount: blocks.reduce((n, b) => n + b.files.length, 0),
-      merged: mergeBodies(blocks),
+      missingFileCount: countMissingFiles(merged?.text ?? '', collected.length),
+      merged,
       files: collectFiles(blocks),
     };
   });
@@ -1358,6 +1386,10 @@ export function turnsFromDm(
       closed: t.closed,
       stepCount: blocks.reduce((n, b) => n + b.steps.length, 0),
       fileCount: blocks.reduce((n, b) => n + b.files.length, 0),
+      missingFileCount: countMissingFiles(
+        mergeBodies(blocks)?.text ?? '',
+        collectFiles(blocks).length,
+      ),
       /*
        * 单聊的正文仍**合并成一份**(2026-11-07 用户要求「一整轮一张卡」)。
        * 拆轮只为了分别计时与分别判定状态,不改变阅读形态。
@@ -1384,6 +1416,69 @@ function collectFiles(blocks: TurnBlockView[]): { key: string; file: FileCard }[
   return out;
 }
 
+/**
+ * 正文里声明了、但没拿到附件事件的文件数(2026-11-16 真机修复)。
+ *
+ * ## 背景
+ *
+ * 向容器 `agent-node-lj-test` 核实(2026-11-16),容器原话:
+ *   「我用 `MEDIA:` 标记。在正文里写 `MEDIA:/绝对路径`,由 Matrix 适配器解析后
+ *     以 m.file 附件事件发出,同时正文保留文本。」
+ *   「(多文件时)标记存在但适配器没有为它们生成对应的事件……实际只到了部分文件。」
+ *
+ * 于是出现「正文 3 条链接、卡片 2 张」且**毫无提示**。
+ *
+ * ## 只认明确的标记
+ *
+ * 只统计两种**确定是容器声明的文件**:
+ *   ① `MEDIA:/path` 标记(容器的正式约定)
+ *   ② 指向本项目云盘的链接(`s3.fmode.cn` / `file-cloud.fmode.cn`)
+ *
+ * 不做模糊匹配 —— 正文里随便一句 URL 不该被当成「文件丢失」。
+ * 正文里的裸路径(如 `/opt/data/work/x.html`)也不计入:容器发文件时
+ * 一定会写 MEDIA 标记或给出可下载链接,裸路径只是解释文字。
+ *
+ * ## 为什么要去重
+ *
+ * 同一个文件在正文里可能被提到多次(链接 + MEDIA 标记),
+ * 按「文件名」去重后再和卡片数比较,才能得到真实的差。
+ *
+ * @param text        整轮合并后的正文
+ * @param cardCount   实际渲染出的卡片数(已去重)
+ * @returns 缺失的文件数;0 表示正文声明数与卡片数吻合
+ */
+function countMissingFiles(text: string, cardCount: number): number {
+  if (!text && cardCount === 0) return 0;
+  const declared = new Set<string>();
+
+  // ① MEDIA 标记:`MEDIA:xxx`(容器写的是 MEDIA:/绝对路径)
+  for (const match of text.matchAll(/MEDIA:\s*(\S+)/gi)) {
+    declared.add(basename(match[1]));
+  }
+
+  // ② 云盘链接:只认本项目域名,且取路径最后一段做文件名
+  for (const match of text.matchAll(
+    /https?:\/\/(?:s3|file-cloud)\.fmode\.cn\/[^\s)\]>'"]+/gi,
+  )) {
+    declared.add(basename(match[0]));
+  }
+
+  // 正文里一个明确的文件都没声明 → 谈不上缺失(避免把纯文字回复误判)
+  if (declared.size === 0) return 0;
+  return Math.max(0, declared.size - cardCount);
+}
+
+/** 取路径/URL 最后一段(去掉 query 与 hash),用于按文件名去重比对 */
+function basename(pathOrUrl: string): string {
+  const noQuery = pathOrUrl.split(/[?#]/)[0];
+  const seg = noQuery.split('/').filter(Boolean).pop() ?? noQuery;
+  try {
+    return decodeURIComponent(seg).toLowerCase();
+  } catch {
+    return seg.toLowerCase();
+  }
+}
+
 /**
  * 把整轮所有块的正文拼成一份。
  *

+ 339 - 2
src/app/core/chat.service.spec.ts

@@ -1116,6 +1116,264 @@ describe('ChatService', () => {
     });
   });
 
+  describe('待发附件按会话隔离', () => {
+    const firstId = CLOUD_THREAD.threadRoot;
+    const secondId = '$approot_other:fmode.cn';
+    const image = (name: string) => new File(['image'], name, { type: 'image/png' });
+
+    function deferred<Value>() {
+      let resolve!: (value: Value) => void;
+      let reject!: (reason: Error) => void;
+      const promise = new Promise<Value>((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+      });
+      return { promise, resolve, reject };
+    }
+
+    function holdUpload() {
+      const started = deferred<void>();
+      const result = deferred<{ key: string; publicUrl: string }>();
+      let reportProgress: ((pct: number) => void) | undefined;
+      apiStub.uploadFile.and.callFake((_file: File, onProgress?: (pct: number) => void) => {
+        reportProgress = onProgress;
+        started.resolve();
+        return result.promise;
+      });
+      return { started: started.promise, result, progress: (pct: number) => reportProgress?.(pct) };
+    }
+
+    it('同一图文批次连续提交只上传并发送一次', async () => {
+      const upload = holdUpload();
+      svc.stageFiles([image('double.png')]);
+      const first = svc.sendText('附件回归');
+      const duplicate = svc.sendText('附件回归');
+      await upload.started;
+      await duplicate;
+      expect(apiStub.uploadFile.calls.count()).toBe(1);
+      expect(svc.messages().filter((message) => message.text === '附件回归').length).toBe(1);
+      upload.result.resolve({ key: 'double', publicUrl: 'https://s3.fmode.cn/double' });
+      await first;
+      expect(mxStub.sendFileByUrl.calls.count()).toBe(1);
+      expect(mxStub.sendText.calls.count()).toBe(1);
+    });
+
+    it('新建会话迁移附件桶期间重复提交仍只发送一次', async () => {
+      const upload = holdUpload();
+      (svc as unknown as { _sessionId: { set(value: null): void } })._sessionId.set(null);
+      svc.stageFiles([image('new-double.png')]);
+      const first = svc.sendText('新建图文');
+      const duplicate = svc.sendText('新建图文');
+      await upload.started;
+      await duplicate;
+      expect(apiStub.uploadFile.calls.count()).toBe(1);
+      upload.result.resolve({ key: 'new-double', publicUrl: 'https://s3.fmode.cn/new-double' });
+      await first;
+      expect(mxStub.sendFileByUrl.calls.count()).toBe(1);
+      expect(mxStub.sendText.calls.count()).toBe(1);
+    });
+
+    beforeEach(async () => {
+      realMode();
+      apiStub.fetchChatThreads.and.returnValue(Promise.resolve([
+        CLOUD_THREAD,
+        { ...CLOUD_THREAD, objectId: 'cloud2', threadRoot: secondId, roomId: '!room2:fmode.cn' },
+      ]));
+      apiStub.registerFile.and.returnValue(Promise.resolve({ id: 'f1' }));
+      mxStub.sendFileByUrl.and.returnValue(Promise.resolve({ event_id: '$fu' }));
+      await svc.open(AGENT.id, firstId);
+    });
+
+    it('A → B → A 只展示各自附件,切换不释放预览', async () => {
+      const revoke = spyOn(URL, 'revokeObjectURL');
+      svc.stageFiles([image('a.png')]);
+      const first = svc.pendingFiles()[0];
+
+      await svc.open(AGENT.id, secondId);
+      expect(svc.pendingFiles()).toEqual([]);
+      svc.stageFiles([image('b.png')]);
+      const second = svc.pendingFiles()[0];
+
+      await svc.open(AGENT.id, firstId);
+      expect(svc.pendingFiles()).toEqual([first]);
+      await svc.open(AGENT.id, secondId);
+      expect(svc.pendingFiles()).toEqual([second]);
+      expect(revoke).not.toHaveBeenCalled();
+    });
+
+    it('unstageFile 和 clearPendingFiles 只操作当前会话并释放对应预览', async () => {
+      const revoke = spyOn(URL, 'revokeObjectURL');
+      svc.stageFiles([image('a.png')]);
+      const first = svc.pendingFiles()[0];
+      await svc.open(AGENT.id, secondId);
+      svc.stageFiles([image('b.png')]);
+      const second = svc.pendingFiles()[0];
+
+      svc.unstageFile(first.id);
+      expect(svc.pendingFiles()).toEqual([second]);
+      svc.clearPendingFiles();
+      expect(svc.pendingFiles()).toEqual([]);
+      expect(revoke.calls.allArgs()).toEqual([[second.previewUrl!]]);
+
+      await svc.open(AGENT.id, firstId);
+      expect(svc.pendingFiles()).toEqual([first]);
+      svc.unstageFile(first.id);
+      expect(svc.pendingFiles()).toEqual([]);
+      expect(revoke).toHaveBeenCalledWith(first.previewUrl!);
+    });
+
+    for (const cleanup of ['close', 'resetForUserSwitch'] as const) {
+      it(`${cleanup} 清理所有附件桶及预览,重新打开不恢复上个账号的附件`, async () => {
+        const revoke = spyOn(URL, 'revokeObjectURL');
+        svc.stageFiles([image('a.png')]);
+        const firstPreview = svc.pendingFiles()[0].previewUrl!;
+        await svc.open(AGENT.id, secondId);
+        svc.stageFiles([image('b.png')]);
+        const secondPreview = svc.pendingFiles()[0].previewUrl!;
+
+        svc[cleanup]();
+
+        expect(svc.pendingFiles()).toEqual([]);
+        expect(revoke).toHaveBeenCalledWith(firstPreview);
+        expect(revoke).toHaveBeenCalledWith(secondPreview);
+        expect(revoke.calls.count()).toBe(2);
+        await svc.open(AGENT.id, firstId);
+        expect(svc.pendingFiles()).toEqual([]);
+        await svc.open(AGENT.id, secondId);
+        expect(svc.pendingFiles()).toEqual([]);
+      });
+    }
+
+    for (const emptyId of [null, '']) {
+      it(`新建态 sessionId=${JSON.stringify(emptyId)} 首次发送迁移附件桶`, async () => {
+        const upload = holdUpload();
+        (svc as unknown as { _sessionId: { set(value: string | null): void } })._sessionId.set(emptyId);
+        svc.stageFiles([image('new.png')]);
+        const staged = svc.pendingFiles()[0];
+
+        const sending = svc.sendText('');
+        await upload.started;
+        const createdId = svc.sessionId();
+        expect(createdId).toBeTruthy();
+        expect(svc.pendingFiles()[0].id).toBe(staged.id);
+        expect(svc.pendingFiles()[0].previewUrl).toBe(staged.previewUrl);
+        upload.result.resolve({ key: 'new', publicUrl: 'https://s3.fmode.cn/new' });
+        await sending;
+
+        expect(svc.pendingFiles()).toEqual([]);
+        expect(apiStub.registerFile).toHaveBeenCalledWith(jasmine.objectContaining({ threadRoot: createdId }));
+        (svc as unknown as { _sessionId: { set(value: string | null): void } })._sessionId.set(emptyId);
+        expect(svc.pendingFiles()).toEqual([]);
+      });
+    }
+
+    it('startBlank 为新建态分配真实会话标识时保留附件', async () => {
+      (svc as unknown as { _sessionId: { set(value: null): void } })._sessionId.set(null);
+      svc.stageFiles([image('new.png')]);
+      const staged = svc.pendingFiles()[0];
+
+      const created = await svc.startBlank(AGENT.id);
+
+      expect(created).toBeTruthy();
+      expect(svc.sessionId()).toBe(created!.id);
+      expect(svc.pendingFiles()).toEqual([staged]);
+    });
+
+    it('重建已被清掉目录的会话时迁移附件', () => {
+      svc.stageFiles([image('orphan.png')]);
+      const staged = svc.pendingFiles()[0];
+      svc.sessions.reset();
+
+      const recreated = (svc as unknown as { ensureSessionForSend(): { id: string } }).ensureSessionForSend();
+
+      expect(recreated.id).not.toBe(firstId);
+      expect(svc.sessionId()).toBe(recreated.id);
+      expect(svc.pendingFiles()).toEqual([staged]);
+    });
+
+    it('上传跨切换:进度、上云缓存和成功清理绑定 A 桶,台账及事件仍发往 A', async () => {
+      const upload = holdUpload();
+      const matrixStarted = deferred<void>();
+      const matrixResult = deferred<{ event_id: string }>();
+      mxStub.sendFileByUrl.and.callFake(() => {
+        matrixStarted.resolve();
+        return matrixResult.promise;
+      });
+      const firstRoom = svc.currentRoomId();
+      svc.stageFiles([image('a.png')]);
+      const sending = svc.sendText('');
+      await upload.started;
+
+      await svc.open(AGENT.id, secondId);
+      svc.stageFiles([image('b.png')]);
+      const second = svc.pendingFiles()[0];
+      upload.progress(37);
+      expect(svc.pendingFiles()).toEqual([second]);
+      await svc.open(AGENT.id, firstId);
+      expect(svc.pendingFiles()[0].progress?.pct).toBe(37);
+      await svc.open(AGENT.id, secondId);
+      upload.result.resolve({ key: 'a', publicUrl: 'https://s3.fmode.cn/a' });
+      await matrixStarted.promise;
+
+      expect(svc.pendingFiles()).toEqual([second]);
+      expect(apiStub.registerFile).toHaveBeenCalledWith(jasmine.objectContaining({
+        threadRoot: firstId, roomId: firstRoom, agentId: AGENT.id,
+      }));
+      expect(mxStub.sendFileByUrl.calls.mostRecent().args[0]).toBe(firstRoom);
+      expect(mxStub.sendFileByUrl.calls.mostRecent().args[3]).toBe(firstId);
+      await svc.open(AGENT.id, firstId);
+      expect(svc.pendingFiles()[0].uploaded).toEqual({
+        url: 'https://s3.fmode.cn/a', key: 'a', registered: true,
+      });
+      await svc.open(AGENT.id, secondId);
+      matrixResult.resolve({ event_id: '$a-file' });
+      await sending;
+
+      expect(svc.pendingFiles()).toEqual([second]);
+      expect(svc.messages().some((message) => message.file?.name === 'a.png')).toBeFalse();
+      await svc.open(AGENT.id, firstId);
+      expect(svc.pendingFiles()).toEqual([]);
+    });
+
+    it('上传失败跨切换:失败回滚清理 A 桶而不清空 B 附件', async () => {
+      const upload = holdUpload();
+      svc.stageFiles([image('a.png')]);
+      const sending = svc.sendText('');
+      await upload.started;
+      await svc.open(AGENT.id, secondId);
+      svc.stageFiles([image('b.png')]);
+      const second = svc.pendingFiles()[0];
+
+      upload.result.reject(new Error('云盘不可用'));
+      await sending;
+
+      expect(svc.pendingFiles()).toEqual([second]);
+      await svc.open(AGENT.id, firstId);
+      expect(svc.pendingFiles()).toEqual([]);
+    });
+
+    it('退出后的旧上传回调不能复活附件或继续登记、发送到新账号', async () => {
+      const upload = holdUpload();
+      svc.stageFiles([image('a.png')]);
+      const sending = svc.sendText('');
+      await upload.started;
+      svc.resetForUserSwitch();
+      await svc.open(AGENT.id, secondId);
+      svc.stageFiles([image('b.png')]);
+      const second = svc.pendingFiles()[0];
+
+      upload.progress(80);
+      upload.result.resolve({ key: 'a', publicUrl: 'https://s3.fmode.cn/a' });
+      await sending;
+
+      expect(svc.pendingFiles()).toEqual([second]);
+      expect(apiStub.registerFile).not.toHaveBeenCalled();
+      expect(mxStub.sendFileByUrl).not.toHaveBeenCalled();
+      await svc.open(AGENT.id, firstId);
+      expect(svc.pendingFiles()).toEqual([]);
+    });
+  });
+
   describe('附件暂存 → 发送时上传(AC-04.3)', () => {
     const file = (name = 'doc.txt') => new File(['x'], name, { type: 'text/plain' });
 
@@ -1490,8 +1748,17 @@ describe('ChatService', () => {
      * 🔴 容器自己开的子线程**属于当前会话**(2026-10-29 实测)。
      * 容器回复时会另开 m.thread 跑内部任务,那些消息也是本次对话的一部分,
      * 交付物(html/截图)就在里面 —— 必须显示,否则内容丢失。
+     *
+     * ## 2026-11-16 真机事故:第一版修复差点丢光容器回复
+     *
+     * 第一版要求「本会话必须正在等回复」才放行未认领的线程根。
+     * 真机实测:容器的正常回复整段消失,会话里只剩用户消息。
+     * 因为容器回复挂在它自开的根下、而不在 ownedRoots 里。
+     *
+     * 第二版改为只挡「会话长期闲置」的情况(`IDLE_GUARD_MS`),
+     * 本条测试守护「活跃会话能正常收到容器产出」这个更重要的行为。
      */
-    it('容器自开的子线程归入当前会话', async () => {
+    it('容器自开的子线程归入当前会话(本会话活跃时)', async () => {
       await svc.open('agent-node-lj-test');
       let sink: ((m: MxMessage) => void) | null = null;
       mxStub.onMessage.and.callFake((_r: string, cb: (m: MxMessage) => void) => {
@@ -1501,11 +1768,55 @@ describe('ChatService', () => {
       svc.close();
       await svc.open('agent-node-lj-test');
 
-      // 不是 approot 前缀 → 容器内部产生的线程
+      // 会话刚打开(活跃),容器自开的线程根必须能进来
       sink!(msg('$c1', '$kfv5cDP_ZR3jK4VK2WxWBCNBA:fmode.cn', '容器的子任务输出'));
       expect(svc.messages().map((m) => m.text)).toContain('容器的子任务输出');
     });
 
+    /*
+     * 🔴 跨会话携带修复(2026-11-16 用户实测反馈)。
+     *
+     * 场景:用户在会话 A 发过消息,容器在 A 的线程根下产出文件;
+     * 用户切到会话 B(B 已闲置很久)后,A 的线程根若还有事件**实时**到达,
+     * 原规则(`!isAppSessionId` 无条件放行)会让 B 认领 ——
+     * 表现为「前一个会话的文件出现在后一个会话里」。
+     *
+     * 修复后:B 闲置超过 `IDLE_GUARD_MS` → 陌生根的消息不认领。
+     */
+    it('会话长期闲置时不认领陌生线程根的实时消息(跨会话不携带)', async () => {
+      await svc.open('agent-node-lj-test');
+      let sink: ((m: MxMessage) => void) | null = null;
+      mxStub.onMessage.and.callFake((_r: string, cb: (m: MxMessage) => void) => {
+        sink = cb;
+        return () => undefined;
+      });
+      svc.close();
+      await svc.open('agent-node-lj-test');
+
+      /*
+       * 造一条「一小时前」的旧消息,让本会话处于「长期闲置」状态。
+       * 空会话按设计不算闲置(容器可能还在跑上一轮的后台任务),所以必须真有消息。
+       */
+      const hourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString();
+      const self = svc as unknown as {
+        _messages: { update: (fn: (list: any[]) => any[]) => void };
+      };
+      self._messages.update(() => [
+        {
+          id: 'old-1',
+          conversationId: 'agent-node-lj-test',
+          sender: 'me',
+          kind: 'text',
+          text: '很久以前的消息',
+          ts: hourAgo,
+          state: 'sent',
+        } as any,
+      ]);
+
+      sink!(msg('$x1', '$kfv5cDP_ZR3jK4VK2WxWBCNBA:fmode.cn', '别的会话的文件'));
+      expect(svc.messages().map((m) => m.text)).not.toContain('别的会话的文件');
+    });
+
     /*
      * 「历史对话」承接无 thread 旧消息的**完整链路验证在端到端**
      * (Playwright 真实浏览器 + 真实 Matrix 房间,2026-10-28 已通过:
@@ -1658,6 +1969,32 @@ describe('ChatService · 新建会话期间不得回填历史(2026-11-08)',
       .toBe(1);
   });
 
+  it('相同文字请求未完成前不重复提交,完成后允许再次发送', async () => {
+    await svc.open('agent-node-lj-test');
+    mxStub.sendText.calls.reset();
+    const first = svc.sendText('收到');
+    await svc.sendText(' 收到 ');
+    for (let iteration = 0; iteration < 8; iteration++) await Promise.resolve();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(mxStub.sendText.calls.count()).toBe(1);
+    expect(svc.messages().filter((message) => message.sender === 'me').length).toBe(1);
+    releaseSend();
+    await first;
+    mxStub.sendText.and.returnValue(Promise.resolve({ event_id: '$again' }));
+    await svc.sendText('收到');
+    expect(mxStub.sendText.calls.count()).toBe(2);
+  });
+
+  it('发送失败释放重复提交保护,允许重新发送相同文字', async () => {
+    await svc.open('agent-node-lj-test');
+    mxStub.sendText.calls.reset();
+    mxStub.sendText.and.returnValue(Promise.reject(new Error('离线')));
+    await svc.sendText('重试相同文字');
+    mxStub.sendText.and.returnValue(Promise.resolve({ event_id: '$retry' }));
+    await svc.sendText('重试相同文字');
+    expect(mxStub.sendText.calls.count()).toBe(2);
+  });
+
   /*
    * 🔴 乐观消息 ↔ 服务端 echo 去重(2026-11-09)。
    *

+ 240 - 41
src/app/core/chat.service.ts

@@ -1,7 +1,15 @@
 /** 首屏加载条数:只渲染最近一屏,其余上滚再取(用户要求,避免一次性加载全部) */
 const INITIAL_PAGE = 30;
+/**
+ * 未认领线程根的实时消息,在本会话闲置超过这个时长后一律不收(2026-11-16)。
+ *
+ * 背景见 `belongsToSession()` 的 `live` 分支:要挡的是「切到别的会话后,
+ * 原会话的线程根还在往外冒事件」。取 30 分钟是因为真实对话中不会闲置这么久
+ * 却突然收到同一次对话的产出;而切会话后的延迟投递通常在几秒到几分钟内。
+ */
+const IDLE_GUARD_MS = 30 * 60 * 1000;
 
-import { computed, effect, inject, Injectable, signal, untracked } from '@angular/core';
+import { computed, effect, inject, Injectable, signal, untracked, WritableSignal } from '@angular/core';
 import { FmodeApi } from './api/fmode-api';
 import {
   Agent,
@@ -168,7 +176,12 @@ export class ChatService {
    * 🔴 用户要求:**先选文件、点发送时才一起发出去**,而不是选完立刻上传。
    *    所以这里只持有 File 对象,不上传、不发消息 —— 发送时才落地。
    */
-  private readonly _pendingFiles = signal<PendingFile[]>([]);
+  private readonly _pendingFileStore = signal<ReadonlyMap<string, WritableSignal<PendingFile[]>>>(new Map());
+  private readonly _pendingFiles = computed(
+    () => this._pendingFileStore().get(this.pendingFileKey())?.() ?? [],
+  );
+  private _pendingFileEpoch = 0;
+  private readonly activeSubmissions = new WeakMap<WritableSignal<PendingFile[]>, Set<string>>();
   /**
    * 上传总进度 0-100(2026-11-11 改为**按字节加权实时计算**)。
    *
@@ -318,7 +331,7 @@ export class ChatService {
   readonly sending = this._sending.asReadonly();
   readonly uploading = this._uploading.asReadonly();
   /** 待发送附件(界面据此渲染缩略条与移除按钮) */
-  readonly pendingFiles = this._pendingFiles.asReadonly();
+  readonly pendingFiles = this._pendingFiles;
   readonly uploadPct = this._uploadPct.asReadonly();
   /** 整批上传阶段(输入框下方那条进度条据此切文案,2026-11-11) */
   readonly uploadPhase = this._uploadPhase.asReadonly();
@@ -1130,6 +1143,7 @@ export class ChatService {
      */
 
     // 切到这条新会话(左侧随之高亮,见 session-tree 的 activeId)
+    if (!this._sessionId()) this.adoptPendingFiles(this.pendingFileKey(), s.id);
     this._sessionId.set(s.id);
 
     /*
@@ -1868,6 +1882,12 @@ export class ChatService {
    */
   close(): void {
     this.seq++;
+    this._pendingFileEpoch++;
+    for (const bucket of this._pendingFileStore().values()) this.clearPendingFileBucket(bucket);
+    this._pendingFileStore.set(new Map());
+    this._uploading.set(false);
+    this._uploadPct.set(0);
+    this._uploadPhase.set('idle');
     this.teardownSubscriptions();
     this.provision = null;
     this.roomId = null;
@@ -2091,7 +2111,17 @@ export class ChatService {
    *    用户知情并接受,仅在发送按钮上由 `sendHint()` 提示。
    */
   async sendText(text: string): Promise<void> {
-    await this.sendTextInternal(text);
+    const bucket = this.pendingFileBucket();
+    const submissionKey = JSON.stringify([text.trim(), bucket().map((file) => file.id)]);
+    const active = this.activeSubmissions.get(bucket) ?? new Set<string>();
+    if (active.has(submissionKey)) return;
+    this.activeSubmissions.set(bucket, active);
+    active.add(submissionKey);
+    try {
+      await this.sendTextInternal(text);
+    } finally {
+      active.delete(submissionKey);
+    }
   }
 
   private async sendTextInternal(text: string): Promise<void> {
@@ -2202,6 +2232,7 @@ export class ChatService {
          * 否则用户「打一半 → 会话建好」时字会消失(2026-11-14)。
          */
         this.adoptDraft(this._draftKey(), created.id);
+        this.adoptPendingFiles(this.pendingFileKey(), created.id);
         this._sessionId.set(created.id);
         /*
          * 🔴 必须同时把状态从 empty 切到 ready(2026-11-01 修复)。
@@ -2277,6 +2308,12 @@ export class ChatService {
      */
     const currentSessionId = this._sessionId();
     if (currentSessionId) this.pulse.noteSessionUserAction(currentSessionId);
+    const pendingUpload = {
+      bucket: this.pendingFileBucket(),
+      roomId: this.roomId,
+      sessionId: currentSessionId,
+      epoch: this._pendingFileEpoch,
+    };
 
     try {
       /*
@@ -2322,15 +2359,17 @@ export class ChatService {
          * 它会回「没看到附件」—— 用户白等一轮,会话里还多出半截对话。
          * 与其留下脏状态,不如**当场失败、当场清干净**。
          */
-        if (this._pendingFiles().length > 0) {
-          const { fail } = await this.uploadPending(conversationId);
+        if (pendingUpload.epoch !== this._pendingFileEpoch) return;
+        if (pendingUpload.bucket().length > 0) {
+          const { fail } = await this.uploadPending(conversationId, pendingUpload);
+          if (pendingUpload.epoch !== this._pendingFileEpoch) return;
           if (fail > 0) {
             /*
              * 逐条失败原因已由 uploadPending 写入 `_error` / 全局提示;
              * 这里负责**回滚**:撤掉刚插入的本条消息、清空草稿与暂存附件,
              * 让页面回到「发送前」的状态,用户可以直接重试。
              */
-            this.rollbackSend(msg.id);
+            this.rollbackSend(msg.id, pendingUpload.bucket);
             this._error.set(
               this._error() ?? `${fail} 个附件未上传到云盘,本条消息未发送`,
             );
@@ -2568,7 +2607,7 @@ export class ChatService {
       this._error.set(rejected.map(oversizeMessage).join(';'));
     }
     if (list.length === 0) return;
-    this._pendingFiles.update((cur) => [
+    this.pendingFileBucket().update((cur) => [
       ...cur,
       ...list.map((file) => ({
         id: `pf-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
@@ -2582,7 +2621,7 @@ export class ChatService {
 
   /** 移除一个待发附件(同时释放预览地址) */
   unstageFile(id: string): void {
-    this._pendingFiles.update((cur) => {
+    this.pendingFileBucket().update((cur) => {
       const victim = cur.find((f) => f.id === id);
       if (victim?.previewUrl) URL.revokeObjectURL(victim.previewUrl);
       return cur.filter((f) => f.id !== id);
@@ -2591,10 +2630,41 @@ export class ChatService {
 
   /** 清空待发附件(同时释放预览地址) */
   clearPendingFiles(): void {
-    for (const f of this._pendingFiles()) {
+    this.clearPendingFileBucket(this.pendingFileBucket());
+  }
+
+  private pendingFileKey(): string {
+    return this._sessionId() || (this._agentId() ? `agent:${this._agentId()}` : '');
+  }
+
+  private pendingFileBucket(): WritableSignal<PendingFile[]> {
+    const key = this.pendingFileKey();
+    const existing = this._pendingFileStore().get(key);
+    if (existing) return existing;
+    const bucket = signal<PendingFile[]>([]);
+    this._pendingFileStore.update((store) => new Map(store).set(key, bucket));
+    return bucket;
+  }
+
+  private adoptPendingFiles(fromKey: string, toKey: string): void {
+    if (!toKey || fromKey === toKey) return;
+    const bucket = this._pendingFileStore().get(fromKey);
+    if (!bucket) return;
+    const destination = this._pendingFileStore().get(toKey);
+    if (destination) bucket.update((files) => [...destination(), ...files]);
+    this._pendingFileStore.update((store) => {
+      const next = new Map(store);
+      next.delete(fromKey);
+      next.set(toKey, bucket);
+      return next;
+    });
+  }
+
+  private clearPendingFileBucket(bucket: WritableSignal<PendingFile[]>): void {
+    for (const f of bucket()) {
       if (f.previewUrl) URL.revokeObjectURL(f.previewUrl);
     }
-    this._pendingFiles.set([]);
+    bucket.set([]);
   }
 
   /**
@@ -2603,12 +2673,13 @@ export class ChatService {
    * 进度与阶段**都从各文件自己的状态派生**,不再手动 set 一个总数 ——
    * 这样多文件并发/串行、某个文件失败时,总体进度都是自洽的。
    */
-  private setFileProgress(id: string, progress: Omit<FileProgress, 'id'>): void {
+  private setFileProgress(bucket: WritableSignal<PendingFile[]>, id: string, progress: Omit<FileProgress, 'id'>): void {
     const next: FileProgress = { id, ...progress };
-    this._pendingFiles.update((cur) =>
+    bucket.update((cur) =>
       cur.map((f) => (f.id === id ? { ...f, progress: next } : f)),
     );
-    const items = this._pendingFiles();
+    if (this._pendingFileStore().get(this.pendingFileKey()) !== bucket) return;
+    const items = bucket();
     this._uploadPct.set(overallPct(items.map((f) => ({ progress: f.progress, size: f.file.size }))));
     this._uploadPhase.set(batchPhase(items.map((f) => ({ progress: f.progress }))));
   }
@@ -2618,9 +2689,16 @@ export class ChatService {
    *
    * @returns 每个附件是否成功
    */
-  private async uploadPending(conversationId: string): Promise<{ ok: number; fail: number }> {
-    const pending = this._pendingFiles();
-    if (pending.length === 0) return { ok: 0, fail: 0 };
+  private async uploadPending(conversationId: string, context: {
+    bucket: WritableSignal<PendingFile[]>;
+    roomId: string | null;
+    sessionId: string | null;
+    epoch: number;
+  }): Promise<{ ok: number; fail: number }> {
+    const { bucket, roomId, sessionId: sid, epoch } = context;
+    const pending = bucket();
+    if (pending.length === 0 || epoch !== this._pendingFileEpoch) return { ok: 0, fail: 0 };
+    const ledgerRoot = sid ?? this.ensureSessionForSend()?.id;
 
     this._uploading.set(true);
     this._uploadPct.set(0);
@@ -2658,8 +2736,7 @@ export class ChatService {
            *   回退:`localStorage.fmode.sendMode='mxc'` 即恢复旧双写。
            */
           const mimeType = file.type || 'application/octet-stream';
-          if (!this.roomId) throw new Error('会话未就绪');
-          const sid = this._sessionId();
+          if (!roomId) throw new Error('会话未就绪');
 
           /*
            * ① 云盘:失败即中止本文件(不发送)。传 onProgress 拿**真实字节进度**(2026-11-11)
@@ -2670,17 +2747,18 @@ export class ChatService {
           let cloudUrl: string;
           let cloudKey: string;
           let registered: boolean;
-          const cached = this._pendingFiles().find((p) => p.id === pending[i].id)?.uploaded;
+          const cached = bucket().find((p) => p.id === pending[i].id)?.uploaded;
           if (cached) {
             cloudUrl = cached.url;
             cloudKey = cached.key;
             registered = cached.registered;
-            this.setFileProgress(pending[i].id, { phase: 'uploading', pct: 100 });
+            this.setFileProgress(bucket, pending[i].id, { phase: 'uploading', pct: 100 });
           } else {
-            this.setFileProgress(pending[i].id, { phase: 'uploading', pct: 0 });
+            this.setFileProgress(bucket, pending[i].id, { phase: 'uploading', pct: 0 });
             const up = await this.api.uploadFile(file, (pct) => {
-              this.setFileProgress(pending[i].id, { phase: 'uploading', pct });
+              if (epoch === this._pendingFileEpoch) this.setFileProgress(bucket, pending[i].id, { phase: 'uploading', pct });
             });
+            if (epoch !== this._pendingFileEpoch) return { ok, fail };
             cloudUrl = up.publicUrl;
             cloudKey = up.key;
             registered = false;
@@ -2709,14 +2787,13 @@ export class ChatService {
            *
            * 修法:先确保会话存在(与 `sendReal` 同一兜底),再登记。
            */
-          const ledgerRoot = sid ?? this.ensureSessionForSend()?.id;
           if (ledgerRoot && !registered) {
             try {
-              this.setFileProgress(pending[i].id, { phase: 'registering', pct: 100 });
+              this.setFileProgress(bucket, pending[i].id, { phase: 'registering', pct: 100 });
               await this.api.registerFile({
                 threadRoot: ledgerRoot,
-                agentId: this._agentId() ?? undefined,
-                roomId: this.roomId,
+                agentId: conversationId,
+                roomId,
                 name: file.name,
                 url: cloudUrl,
                 key: cloudKey,
@@ -2726,30 +2803,33 @@ export class ChatService {
               });
               registered = true;
             } catch (e) {
+              if (epoch !== this._pendingFileEpoch) return { ok, fail };
               this._error.set(
                 `「${file.name}」已存入云盘,但未记入文件列表:${e instanceof Error ? e.message : '登记失败'}`,
               );
             }
           }
+          if (epoch !== this._pendingFileEpoch) return { ok, fail };
           /*
            * 先把「已上云」记到暂存项上,再发事件 —— 若下一步失败,
            * 下一步重试就只重发事件(评审 S3)。
            */
-          this._pendingFiles.update((cur) =>
+          bucket.update((cur) =>
             cur.map((p) => (p.id === pending[i].id ? { ...p, uploaded: { url: cloudUrl, key: cloudKey, registered } } : p)),
           );
 
           /* ② Matrix:把云盘地址发给容器(2026-11-13 起不再传文件本体) */
-          this.setFileProgress(pending[i].id, { phase: 'sending', pct: 100 });
+          this.setFileProgress(bucket, pending[i].id, { phase: 'sending', pct: 100 });
           await this.sendCloudFile(
-            this.roomId,
+            roomId,
             file,
             cloudUrl,
             { name: file.name, size: file.size, mimeType },
             /* 🔴 与台账登记用**同一个根**,否则容器回的归属和台账对不上(2026-11-13) */
             ledgerRoot ?? undefined,
           );
-          this.setFileProgress(pending[i].id, { phase: 'done', pct: 100 });
+          if (epoch !== this._pendingFileEpoch) return { ok, fail };
+          this.setFileProgress(bucket, pending[i].id, { phase: 'done', pct: 100 });
           /*
            * 云盘地址记进 `_cloudUrls`:**只服务于 `'mxc'` 回退模式**下的老消息
            * (事件里没带 `com.fmode.cloud_url` 的那种)。`'url'` 模式下事件自带地址,
@@ -2760,6 +2840,11 @@ export class ChatService {
            */
           this._cloudUrls.set(this.cloudKeyOf(file.name, file.size), cloudUrl);
 
+          if (this._pendingFileStore().get(this.pendingFileKey()) !== bucket) {
+            ok++;
+            continue;
+          }
+
           // 本地预览用对象地址;Matrix 的 mxc 要等回读后才能转 http
           const displayUrl = URL.createObjectURL(file);
           const card: FileCard = {
@@ -2792,6 +2877,7 @@ export class ChatService {
           ]);
           ok++;
         } catch (e) {
+          if (epoch !== this._pendingFileEpoch) return { ok, fail };
           fail++;
           failedIds.add(pending[i].id);
           const why = e instanceof Error ? e.message : '上传失败';
@@ -2808,7 +2894,7 @@ export class ChatService {
             `「${file.name}」未能上传到云盘`,
             `${why}。附件只走云盘直链,不会退回其它通道 —— 本条消息未发送。`,
           );
-          this.setFileProgress(pending[i].id, {
+          this.setFileProgress(bucket, pending[i].id, {
             phase: 'failed',
             pct: 0,
             error: why,
@@ -2816,9 +2902,11 @@ export class ChatService {
         }
       }
     } finally {
-      this._uploading.set(false);
-      this._uploadPct.set(0);
-      this._uploadPhase.set('idle');
+      if (epoch === this._pendingFileEpoch) {
+        this._uploading.set(false);
+        this._uploadPct.set(0);
+        this._uploadPhase.set('idle');
+      }
       /*
        * 🔴 按 id 精确保留失败项(2026-11-03 修复)。
        *
@@ -2828,7 +2916,7 @@ export class ChatService {
        *
        * 同时要 revoke 被移除项的 previewUrl,避免对象地址泄漏。
        */
-      this._pendingFiles.update((cur) => {
+      bucket.update((cur) => {
         const remain = cur.filter((f) => failedIds.has(f.id));
         for (const f of cur) {
           if (!failedIds.has(f.id) && f.previewUrl) URL.revokeObjectURL(f.previewUrl);
@@ -3048,6 +3136,25 @@ export class ChatService {
    */
   private async sendReal(text: string, localId?: string): Promise<void> {
     if (!this.roomId) throw new Error('会话未就绪,请稍后重试');
+    /*
+     * 🔴 断网时必须**主动判定失败**(2026-11-16 真机实测补)。
+     *
+     * ## 为什么不能只靠 `mx.sendText()` 抛错
+     *
+     * Matrix SDK 的 `client.sendEvent()` 在**离线时会把事件塞进本地队列并正常 resolve**。
+     * 于是 `sendTextInternal` 的 catch 不触发、`markFailed` 不被调用,
+     * 界面那条消息就跟正常发送的一模一样:只显示时间,无失败标识、无重试。
+     *
+     * 真机实测(小米 M2102K1AC / Android 14,飞行模式下发送):
+     *   气泡正常上屏 → 输入框清空 → 20 秒后仍只显示时间 → 与正常消息 DOM 结构完全相同。
+     * 用户会以为消息已经发出去了,实际可能永远停在队列里。
+     *
+     * 所以发送前先看连接状态:不在线就直接抛错,走既有的
+     * `catch → markFailed` 链路(UI 的失败态与重试按钮已就绪,见 m-msg.ts)。
+     */
+    if (this._connection() === 'disconnected') {
+      throw new Error('网络已断开,消息未发送');
+    }
     let sid = this._sessionId();
     if (!sid) {
       /*
@@ -3117,6 +3224,7 @@ export class ChatService {
         const recreated = this.sessions.create(roomId, agentId);
         // 键变了 → 草稿跟着挪(2026-11-14),否则用户打了一半的字会消失
         this.adoptDraft(this._draftKey(), recreated.id);
+        this.adoptPendingFiles(this.pendingFileKey(), recreated.id);
         this._sessionId.set(recreated.id);
         /*
          * 🔴 换了会话标识,内存里属于旧会话的消息必须清掉(2026-11-09)。
@@ -3300,14 +3408,105 @@ export class ChatService {
      *
      * 现在:**历史回填**时容器线程根只归「已经认领过它」的会话 ——
      * 新会话从没认领过任何根,自然什么都拿不到,符合「新建即空白」的预期。
-     * **实时事件**(`live=true`)仍然接纳:那是容器刚刚发出的内容,
-     * 一定是当前这次对话的产出(截图、交付物都在里面)。
+     *
+     * ## 🔴 2026-11-16 真机修复:实时事件也必须过 `ownedRoots` 这一关
+     *
+     * 原实现的 `live` 分支直接 `return !isAppSessionId(m.threadId)`,
+     * **跳过了归属校验** —— 只要线程根不是 App 造的,就归「当前打开的会话」。
+     *
+     * 用户实测反馈:「前一个会话输出的文件,后一个会话也会携带」。
+     * 根因就在这里:用户在会话 A 的时候,容器在 A 的线程根下产生了附件事件;
+     * 用户切到会话 B 后,**A 的线程根若还有新事件实时到达**(延迟投递、
+     * 容器补发、Matrix 重连补同步),B 会把它全部认领 ——
+     * 于是 A 的文件出现在 B 里。
+     *
+     * 向容器 `agent-node-lj-test` 核实(2026-11-16),容器原话:
+     *   「我发文件只针对本次请求里实际生成/引用的路径,不会自动把旧会话的
+     *     文件再发一遍。如果新会话里出现了旧文件,那是……App 端把历史消息
+     *     归到了当前会话。跨会话携带请在 App 端按 thread 根 + event_id 归属过滤。」
+     *
+     * 所以 `live` 降级为「**额外**放行条件」,而不是「**替代**归属校验」:
+     *   · 历史回填 → 必须有 ownedRoots 认领(不变)
+     *   · 实时事件 → 同样必须有 ownedRoots 认领;否则丢弃
+     *
+     * 那「容器刚开的新线程根」怎么办?`_ownedThreadRoots` 在
+     * `openReal` 时会从 timeline 重新计算,而 `isAwaitingReplyAfter`
+     * 那条房间级消息的路径仍会认领**正在等回复时的**无 thread 消息 ——
+     * 容器本轮的正常产出照样进得来。
+     *
+     * 代价(已知且可接受):极少数「容器在本会话首次开新线程根」的实时事件
+     * 可能延迟到下一次回填才出现,而不是实时冒出来。
      */
-    if (live) return !isAppSessionId(m.threadId);
     const roots = ownedRoots ?? this._ownedThreadRoots;
+    if (live) {
+      /*
+       * 已认领的根 → 一定是本会话的,直接放行(最快路径,也是常态)。
+       */
+      if (roots.has(m.threadId)) return true;
+      if (isAppSessionId(m.threadId)) return false;
+      /*
+       * 未认领的容器线程根,实时到达。
+       *
+       * ## 2026-11-16 真机修复(第二版)
+       *
+       * 用户实测反馈「前一个会话输出的文件,后一个会话也会携带」。
+       * 原实现这里的规则是 `return !isAppSessionId(m.threadId)` —— **无条件放行**,
+       * 于是切到会话 B 后,A 的线程根若有事件实时到达,B 会认领成自己的内容。
+       *
+       * ## 为什么第一版修得太狠(已回退)
+       *
+       * 第一版要求「本会话必须正在等回复」才放行,结果真机上
+       * **容器的正常回复整段消失**(会话里只剩用户消息)。
+       * 原因:容器的回复挂在它自己开的线程根下,而这个根不在 `ownedRoots` 里,
+       * 一旦用户消息发出到容器回复之间隔得久一点,回复就被挡掉了。
+       * 宁可少一点隔离,也不能丢消息。
+       *
+       * ## 现在的判据:**只挡「别的会话的根」**
+       *
+       * 容器在 DM 里开的线程根,本质是「本次对话的产出」。要区分它属于谁,
+       * 唯一的线索是**时间**:别的会话的旧线程根,其消息时间早于本会话开启时间。
+       *
+       *   · 本会话**近期有活动**(发过消息 / 在等回复 / 刚收到过消息)→ 放行
+       *     (这就是正常对话进行中的情况,容器产出必须能进来)
+       *   · 本会话**长期闲置**,却来了个陌生根的消息 → 大概率是别处的旧事件
+       *     (切换会话后的延迟投递 / Matrix 重连补同步),挡掉
+       *
+       * `IDLE_GUARD_MS` 取 30 分钟:真实对话中两次「活动」不会隔这么久,
+       * 而切到另一个会话后,A 的旧事件通常在几秒到几分钟内到达 —— 会被挡掉。
+       */
+      return !this.isIdleBeyond(IDLE_GUARD_MS);
+    }
     return roots.has(m.threadId);
   }
 
+  /**
+   * 本会话是否已经「闲置」超过指定时长(2026-11-16)。
+   *
+   * 用于判断一条**未认领线程根**的实时消息该不该收:
+   * 会话正在活跃时,陌生根的消息大概率就是容器本轮的产出,应当收;
+   * 会话长期无动静却来了消息,大概率是别的会话的旧事件被延迟投递,应当挡。
+   *
+   * @returns true = 已闲置超过 `ms`(或会话里没有任何消息)
+   */
+  private isIdleBeyond(ms: number): boolean {
+    const list = this._messages();
+    /*
+     * 🔴 空会话**不算闲置**(2026-11-16)。
+     *
+     * 刚打开的会话、或用户刚进来还没发消息的会话,容器完全可能主动产出内容
+     * (它可能在处理上一轮的后台任务)。把空会话当成「闲置」会把这些产出挡掉,
+     * 真机实测就是「会话里什么都没有」。
+     */
+    if (list.length === 0) return false;
+    let last = 0;
+    for (const m of list) {
+      const t = Date.parse(m.ts) || 0;
+      if (t > last) last = t;
+    }
+    if (!last) return false;
+    return Date.now() - last > ms;
+  }
+
   /**
    * 本会话是否「已发出消息、容器还没回」(2026-11-10,B)。
    *
@@ -3880,7 +4079,7 @@ export class ChatService {
    * 🔴 与 `markFailed` 的区别:那个把消息标红留着重试,
    *    用于「已发出但回执失败」。这里连消息都没有,留着只剩困惑。
    */
-  private rollbackSend(localId: string): void {
+  private rollbackSend(localId: string, pendingBucket: WritableSignal<PendingFile[]>): void {
     const victim = this._messages().find((m) => m.id === localId);
     this._messages.update((list) => list.filter((m) => m.id !== localId));
     /* 文字回填:用户刚打的内容不能丢 */
@@ -3888,7 +4087,7 @@ export class ChatService {
     // 2026-11-14:草稿已按会话分桶,回填写进**当前会话**这一桶
     if (text && !this._draft().trim()) this.writeDraft(text);
     /* 暂存附件清空(上传已失败,重新选比留着更有确定性) */
-    this.clearPendingFiles();
+    this.clearPendingFileBucket(pendingBucket);
   }
 
   private markFailed(id: string, error: string): void {

+ 27 - 0
src/app/mobile/pages/chat/chat.ts

@@ -22,6 +22,7 @@ import { previewKindOf } from '../../../components/preview/file-kind';
 import { LockScrollDirective } from '../../directives/lock-scroll.directive';
 import { BadgeTone, MBadgeComponent, TASK_TONE, TASK_STATUS_TEXT } from '../../components/m-badge/m-badge';
 import { ChatService } from '../../../core/chat.service';
+import { ShareReceiveService } from '../../../core/share-receive.service';
 import { PENDING_DRAFT_KEY } from '../home/home';
 import { LoopGuardService } from '../../../core/loop-guard.service';
 import { Agent, Deliverable, SemanticTone, Task } from '../../../core/api/models';
@@ -909,6 +910,7 @@ export class MbChatPage implements OnDestroy {
   /** 容器成果 → 会话台账的绑定兜底(2026-11-13) */
   protected readonly fileBinding = inject(AgentFileBindingService);
   protected readonly chat = inject(ChatService);
+  private readonly incomingShares = inject(ShareReceiveService);
   protected readonly loop = inject(LoopGuardService);
   /**
    * 任务脉冲(2026-11-14 接入)。
@@ -1215,6 +1217,19 @@ export class MbChatPage implements OnDestroy {
   protected readonly subtitle = computed(() => {
     const a = this.chat.agent();
     if (!a) return '';
+    /*
+     * 🔴 本机断网时**优先报网络**(2026-11-16 真机实测补)。
+     *
+     * `presence()` 反映的是**容器**状态(在线/离线),跟本机网络无关。
+     * 断网时容器数据还是断网前那份,于是顶栏继续显示「lj-test · 在线」——
+     * 用户看着「在线」却发不出去消息,完全不知道为什么。
+     *
+     * 实测(小米 M2102K1AC / Android 14,飞行模式):
+     *   会话页顶栏一直是「在线」,没有任何断网提示。
+     */
+    if (this.chat.connection() === 'disconnected') {
+      return `${a.name} · 网络已断开`;
+    }
     return `${a.name} · ${this.presence().text}`;
   });
 
@@ -1389,6 +1404,18 @@ export class MbChatPage implements OnDestroy {
   }
 
   constructor() {
+    effect(() => {
+      const transfer = this.incomingShares.transfer();
+      const state = this.chat.state();
+      const ready = state === 'ready' || state === 'empty';
+      const agentId = this.chat.agentId();
+      const sessionId = this.chat.sessionId();
+      if (transfer && ready && agentId === transfer.agentId && sessionId === transfer.sessionId) {
+        untracked(() => void this.incomingShares.stageInto(this.chat));
+      } else if (transfer && state === 'error' && agentId === transfer.agentId) {
+        untracked(() => this.incomingShares.cancelTransfer(this.chat.error() || '会话打开失败,请重试'));
+      }
+    });
     /* 提示条「重新发送」(2026-11-11,与桌面同口径) */
     this.alert.onAction((a) => {
       if (a.title === MbChatPage.TIMEOUT_TITLE) this.resendLast();