dsh-mobile-plugin 0.4.4 → 0.4.6

package/lib/client.js

@@ -50,7 +50,7 @@ window.__ModuleLoader__.load({
       document.head.appendChild(tag);
     }
 
-    /* ── 一：桌面工作区展开态同步（语义与原实现一字未改，只是搬进函数） ── */
+    /* ── 一：桌面工作区展开态同步 ── */
     /** 桌面端持久化键：`dsh.workspace.view.v5`（版本号可能上浮，取版本最大的那个）。 */
     const STORAGE_KEY_RE = /^dsh\.workspace\.view\.v(\d+)$/;
     /** 轮询间隔：展开/折叠是低频操作，2s 足够跟手又不费电。 */
@@ -501,7 +501,8 @@ window.__ModuleLoader__.load({
      * 保持一个薄卡片：一个网页版入口，以及一个可信本机开关，控制网页管理是否短时向公网开放。
      * 界面本体仍在宿主吐出的 HTML（源码 `React/`，产物 `lib/panel/index.html`）。
      *
-     * 本机设置项半边来自渲染器的 `node_modules`，不可热替换；插件更新仍走 DSH 市场。
+     * 本机设置项半边来自渲染器的 `node_modules`，不可热替换；插件本体由外壳自己装新版
+     * （`lib/update-install.cjs`），刷新页面才看得到这一半的变化。
      * 开关只影响控制面网页路由，不改移动 API、配对凭据或隧道状态。
      */
     function MobileSettingsSection({ t }) {

package/lib/desktop-half-stats.cjs

@@ -17,7 +17,7 @@
  *   - `desktopViewPosts`：同一个半边、同一套 fetch 的**已知可用**对照组（侧栏展开态），
  *     它涨而别的两个不涨，等于「半边活着，是那两条 effect 没跑」。
  *
- * 刻意不做上限/轮转：三个整数加三个时刻，涨到天荒地老也只是几个数字。
+ * 刻意不做上限/轮转：几个整数计数器加对应时刻，涨到天荒地老也只是几个数字。
  */
 
 const state = {

package/lib/git/exec.js

@@ -9,7 +9,7 @@
  *      边界仍然成立；
  *   2. **失败不当异常抛**。非零退出是常态（没有上游、坏分支名、钩子拒绝），调用方要拿退出码
  *      和 stderr 判断，所以一律 resolve 成 `{ code, stdout, stderr }`，只有「git 根本没装」
- *      与「超时被杀」单独立成 `error` 字段；
+ *      「超时被杀」「输出超限」单独立成 `error` 字段；
  *   3. **按仓库串行**。手机上一次点两下就会并发两次写，撞上 `.git/index.lock` 会互相踩死；
  *      锁的粒度是仓库根，主仓库与它下面的独立子仓库各排各的队。
  *

package/lib/host-guard.cjs

@@ -40,7 +40,7 @@ function describeError(err) {
  * @param {(line: string) => void} [options.log] 注入日志，便于测试
  * @param {(code: number) => void} [options.exit] 注入退出，便于测试
  * @returns {{handleUncaughtException: Function, handleUnhandledRejection: Function,
- *            record: Function, faults: Function, stats: Function, clear: Function,
+ *            recordFault: Function, faults: Function, stats: Function, clear: Function,
  *            isFatal: Function}}
  */
 function createGuard(options = {}) {

package/lib/host-patches.cjs

@@ -1,8 +1,8 @@
 'use strict'
 
 /**
- * 无头宿主拼 patch 层时的两处修正。抽成独立文件是为了能直接测：host.js 一 import
- * 就 `boot()` 整个 Cordis 宿主，测试碰不得。
+ * 无头宿主拼 patch 层时的一处修正：摘掉按裸包名挂载本插件的那一行。抽成独立文件是为了能
+ * 直接测：host.js 一 import 就 `boot()` 整个 Cordis 宿主，测试碰不得。
  */
 
 /**

package/lib/impl.js

@@ -41,6 +41,9 @@ const { installQuestionBridge } = require('./mobile/questions.js')
 // 「手机上最近来过没有」：守卫记、控制面状态读。单独一个模块，装配层只转交。
 const activity = require('./mobile/activity.cjs')
 const { installSessionCleanup } = require('./session-cleanup.cjs')
+// 统计的定期采集：账本在 mobile/stats-ledger.cjs，采集规则在 stats-collect.cjs，定时器在
+// stats-scheduler.cjs —— 装配层只挂一下（按天归属靠的就是这个节奏）。
+const statsScheduler = require('./mobile/stats-scheduler.cjs')
 // 扩展卡的宿主侧：`extension_present` 工具与卡状态账本（见 mobile/extensions.js）。
 const { installExtensions } = require('./mobile/extensions.js')
 const { activeGuard } = require('./host-guard.cjs')
@@ -88,8 +91,8 @@ export const RemoteControlSettingsSchema = z.object({
   lanPort: z.number().step(1).min(1024).max(65535).default(18787),
   name: z.string().default(''),
   // Pairing approval policy; see lib/relay/pairing-policy.js for the two modes and
-  // why 'code' is not the old popup. Kept in the settings schema so the host UI and
-  // /api/relay/config can change it, and so an unknown value is rejected on write.
+  // why 'code' is not the old popup. Kept in the config schema so /api/relay/config
+  // can change it, and so an unknown value is rejected on write.
   pairingPolicy: z.union(pairingApproval.POLICIES.map(value => z.const(value))).default(pairingApproval.DEFAULT_POLICY),
   // 中转注册密钥（对偶于中转的 TUNNEL_REGISTER_SECRET）。桌面版拿不到 shell
   // 环境变量，所以它和其他配置一样存在 relay.json（0600），由 /api/relay/config
@@ -345,6 +348,7 @@ function apply(ctx) {
     }
     return undefined
   }, `${name}: extension tool`)
+  ctx.effect(() => statsScheduler.start(ctx), `${name}: stats collect`)
 
   const status = createStatusView({
     state,
@@ -461,11 +465,6 @@ function apply(ctx) {
     hostMetadata,
     // 取值器而非快照对象：snapshot 会被 applySidecarConfig 整体替换，闭包捕获对象会让
     // 连接信息永远停在进程启动那一刻。
-    //
-    // 曾经这里写的是 `() => sidecarSnapshot` —— 那个标识符在本文件作用域里根本不存在
-    // （它只在 lib/sidecar-lifecycle.cjs 内部），于是 GET /api/mobile/v1/connection-info
-    // 一进来就 ReferenceError。同一个 apply() 里给 createStatusView 传的是
-    // `sidecarLifecycle.getSnapshot`，两处不一致才让这个笔误活了下来。
     getSidecarSnapshot: sidecarLifecycle.getSnapshot,
     // 移动端那边的「局域网候选」：私网优先的清单 + 用户手填的直连地址（网卡扫不出的域名）。
     safeLanCandidates: (port) => phoneCandidates(advertisedCandidates(port), { manual: state.manualLanUrl }),

package/lib/index.js

@@ -17,9 +17,9 @@
  *
  * ## 更新来源
  *
- * 正式 npm 更新由 `shell/updater.js` 处理（自动安装默认关闭）；紧急完整包由
+ * 正式 npm 更新由 `shell/updater.js` 处理（自动更新默认开启，面板可关）；紧急完整包由
  * `shell/device-ota.js` 经本机控制面激活，正式版成功接管前保留 OTA 回退包。
- * `updateState` 记录 npm 查装结果；`marketResult` 是旧外壳保留的兜底状态。
+ * `updateState` 记录查装结果；对外的 `marketResult` 就是它的 `result`。
  */
 
 import path from 'node:path'

package/lib/mirror/pusher.cjs

@@ -4,8 +4,8 @@
  * 镜像推送调度器：把宿主的会话状态推到中转，手机端才看得到列表与消息。
  *
  * 三条不能丢的约束：隧道没连上就不构建快照（否则 503 刷屏，真故障被淹没）；空清单/空快照
- * 不许广播（「没取到」与「被删光」形状相同，放行会让手机侧整行消失且零报错）；推送成功后
- * 先 `sessionSignal.bump` 再 `announceSessionsRevision`，顺序反了手机会来取上一份镜像。
+ * 必须过守卫（没有 `emptyConfirmed` 的「没取到」不许推，否则手机侧整行消失且零报错）；
+ * 镜像先推上去，再广播清单 revision（`announceSessionsRevision`），顺序反了手机会来取上一份镜像。
  *
  * 必须是 .cjs：包根声明 type=module，而 lib/mirror/ 没有自己的 `{"type":"commonjs"}`。
  */

package/lib/mobile/events.js

@@ -23,7 +23,7 @@ const DEDUP_WINDOW = 2048;
 const HEARTBEAT_MS = 15_000;
 
 /**
- * 诊断日志。失败路径一条都不许静默：手机把兜底轮询降成 60s，宿主日志里却查不到这条流是
+ * 诊断日志。失败路径一条都不许静默：手机把兜底轮询降成 3 分钟，宿主日志里却查不到这条流是
  * 正常收尾、被客户端断开，还是循环抛错。会话级流早有 logStream，这里是它的设备级对偶。
  */
 function logDeviceStream(message, error) {
@@ -203,7 +203,7 @@ async function handleDeviceStream(ctx, req, res) {
    * 连上就先补一帧「当前状态」。
    *
    * 这条流没有 Last-Event-ID 续传，断流窗口里发生的清单变更与正文水位必须在重连后补上，
-   * 否则手机 state 是空的，而兜底轮询已经因为「流活着」被降到 60s。
+   * 否则手机 state 是空的，而兜底轮询已经因为「流活着」被降到 3 分钟。
    *
    * 只读两条信号总线已经广播过的最近值，既不 bump 也不前移基准，所以不会制造新变更；
    * App 对同 revision / 同水位幂等，重连补发不会引发重复刷新。
@@ -231,7 +231,7 @@ async function handleDeviceStream(ctx, req, res) {
   const keepAlive = setInterval(() => {
     try { res.write(': keepalive\n\n'); } catch { ac.abort(); return; }
     // 心跳必须是**数据帧**：注释帧 App 看不见，而 App 只有「最近真的收到过帧」才敢把
-    // 兜底轮询降到 60s（见 app/src/services/viewmodels/signal-liveness.ts）。
+    // 兜底轮询降到 3 分钟（见 app/src/services/viewmodels/signal-liveness.ts）。
     if (!writeFrame({ type: 'device/heartbeat', at: Date.now() })) ac.abort();
   }, HEARTBEAT_MS);
   // 定时器不该拖住进程退出（同 lib/sidecar-facade-worker.cjs 的 shutdown）。测试里的

package/lib/mobile/host-bridge/event-synthesis.js

@@ -6,7 +6,7 @@
  * 旧 mux 一次给出「这个设备正在发生的一切」，0.2.0 没有对应端点（事件已拆成
  * session/follow、session/control、workspace/follow），这里按 payload 里有没有 sessionId
  * 合成同形帧：带 sessionId → 该会话的 follow + job 整帧 + 投影整帧；不带 → 设备级的
- * 工作区基线 + 全局投影整帧。调用方（stream.js / events.js / index.js 的 mirror）本来就
+ * 工作区基线 + 全局投影整帧。调用方（stream.js / events.js / lib/mirror/pusher.cjs）本来就
  * 按 frame.payload 里的 type 分发，形状对上了它们一行都不用改。
  */
 
@@ -295,10 +295,23 @@ function projectionState() {
  * `next-turn` → `placement: 'queued'`（排队条只认这个值）；`next-step` → `'steering'`，
  * 它只是「宿主已经收下了」的回执，不会多画一行。`message.id` 用宿主行自己的 id，App 靠它
  * 与正文去重。
+ *
+ * **只摊平用户本人说的话。** 宿主把系统注入（后台任务结束、时间/环境上下文、子代理消息、
+ * 模型切换提示这些）也当 user 行塞进同一份 inbox，来源标在 `source.kind` 上（不是 `user`）。
+ * 那一列在正文里由历史投影按来源丢掉，但队列帧的条目形状**没有 source 这一格**：原样摊平
+ * 出去，手机上这些注入就会以「我发出去的气泡」出现（`placement:'steering'` 在 App 侧画的
+ * 正是用户气泡）。所以这里按来源筛掉，注入一条都不进帧 —— 它们不需要排队条，也不需要
+ * 回执翻转。缺 source 的老宿主按普通用户消息处理，与历史投影同一口径。
  */
 function queueItems(inbox, ctx) {
   const items = [];
   let dropped = 0;
+  /** 这一行是不是用户本人发的（缺 source 视为用户，对齐 history-derive 的口径）。 */
+  const fromUser = (message) => {
+    const source = message && typeof message === 'object' ? message.source : null;
+    if (!source || typeof source !== 'object') return true;
+    return source.kind === undefined || source.kind === 'user';
+  };
   /**
    * 摊平一组待发行。`placement` 只标语义：`queued` 进排队条，`steering` 只是回执。
    * 没有 id 的行丢弃并计数（理由见下面的注释）。
@@ -307,6 +320,7 @@ function queueItems(inbox, ctx) {
     if (!Array.isArray(rows)) return;
     for (const message of rows) {
       if (!message || typeof message !== 'object') continue;
+      if (!fromUser(message)) continue;
       const id = typeof message.id === 'string' && message.id ? message.id : '';
       if (!id) { dropped += 1; continue; } // 没有 id 的行没法被 session.updateQueue 定位，别发出去
       items.push({ id, placement, message: { id, content: message.content } });

package/lib/mobile/host-bridge/shims.js

@@ -134,7 +134,7 @@ async function workspaceListViaFollow(ctx, signal) {
   }
   // 流「正常结束却没吐 baseline」不是「你没有工作区」，而是没取到。原先这里返回
   // ok({ items: [] })，与真成功在下游完全无法区分：宿主正在初始化 / 正忙 / 网关给了
-  // 空流时都会走到这里，于是 { ok: true, items: [] } 一路畅通地通过 lib/index.js 的
+  // 空流时都会走到这里，于是 { ok: true, items: [] } 一路畅通地通过 lib/mirror/pusher.cjs 的
   // 镜像守卫、被当作权威清单推给中转，手机侧表现为工作区整行消失、会话全塌进
   // 「未分组」，且中转只会附一个 App 根本不看的 stale 标记，不会有任何报错。
   // 拿不到就是拿不到，如实走错误通道，让调用方去重试或保留上一次结果。
@@ -159,7 +159,7 @@ function projectionValues(item) {
 /**
  * 子代理目录的投影基线预算，比通用合成流（SYNTHETIC_DEADLINE_MS）更紧。
  *
- * 手机端一次请求的总预算只有 8 秒（app/src/api.ts 的 REQUEST_TIMEOUT_MS），走中转还要
+ * 手机端一次请求的总预算只有 8 秒（app/src/api/core.ts 的 REQUEST_TIMEOUT_MS），走中转还要
  * 多一个 RTT。基线开不出来并不致命 —— session.list 摘要内联的是同一份 values，退回它
  * 就行，所以宁可慢的时候少等几秒，也别把整次 subagents.list 拖成客户端超时。
  */

package/lib/mobile/inbox-clean.js

@@ -36,8 +36,9 @@ function autoClearFile() {
 }
 
 /**
- * 读自动清理开关。读不到 / 读坏了都当「关」—— 无人值守删盘这种事，
- * 缺省必须在用户这一侧（与 `updater.js` 的 `autoUpdateEnabled` 同一条口径）。
+ * 读自动清理开关。读不到 / 读坏了都当「关」—— 无人值守删盘这种事，缺省必须在用户这一侧。
+ * 自动更新那个开关刻意相反（文件不在就当作开，见 `lib/shell/updater.js` 的
+ * `autoUpdateEnabled`）：装新版可回退，删文件不可回退，两个缺省因此不该相同。
  */
 function autoClearEnabled() {
   try {

package/lib/mobile/relay-control.js

@@ -602,10 +602,16 @@ function createRelayControlHandlers(deps) {
    * 一条（时间 + 一句话 + 当时要切过去的地址），不带堆栈 —— 宿主内部路径对手机没用。
    *
    * **不搬堆栈**：台账的 message 只取第一行，截断 300 字。
+   *
+   * 2026-10-27 起多四格：`host` / `relay` / `sidecar` / `mirror`。手机那个「延迟浮窗」里的
+   * 「诊断」块就是把这几格抄成几行人话 —— 用户问「这台电脑到底怎么了」时，光有故障台账
+   * 答不了「插件是哪一版、后台服务重启过几回、镜像还推不推得动」。
+   * **仍然只读、仍然只进不出**：注册密钥、配对码、`lanSecret`、访问 token 一格都不出现。
    */
   async function handleRelayDiagnostics(_ctx, _req, res) {
     if (!wired) return unavailable(res);
     const snapshot = typeof status === 'function' ? status() : {};
+    const text = (value) => (typeof value === 'string' ? value : '');
     sendJson(res, 200, {
       ok: true,
       faults: faultsView(),
@@ -620,6 +626,28 @@ function createRelayControlHandlers(deps) {
       },
       /** 隧道为什么被拒那几条判断（宿主那边按中转错误文案推出来的）。 */
       tunnel: snapshot?.tunnel ?? null,
+      /** 这台电脑上跑着的插件与宿主：版本、平台、网页端口，报障时对方第一句就会问这些。 */
+      host: {
+        plugin: text(snapshot?.appVersion),
+        platform: text(snapshot?.platform),
+        arch: text(snapshot?.arch),
+        osVersion: text(snapshot?.osVersion),
+        webPort: Number.isInteger(snapshot?.localPort) && snapshot.localPort > 0 ? snapshot.localPort : null,
+      },
+      relay: { enabled: snapshot?.enabled === true },
+      /** 后台服务（sidecar）：换配置要重启它，重启失败正是「保存成功却连不上」的那一档。 */
+      sidecar: {
+        state: text(snapshot?.sidecar?.state),
+        restarts: Number.isInteger(snapshot?.sidecar?.restarts) ? snapshot.sidecar.restarts : 0,
+        restartedAt: Number.isInteger(snapshot?.sidecar?.restartedAt) ? snapshot.sidecar.restartedAt : 0,
+        restartError: text(snapshot?.sidecar?.restartError) || null,
+      },
+      /** 镜像推送：手机上看到的列表为什么停住不动，答案在这三格里。 */
+      mirror: {
+        pushedAt: Number.isInteger(snapshot?.mirror?.pushedAt) ? snapshot.mirror.pushedAt : 0,
+        ok: snapshot?.mirror?.ok === undefined ? null : snapshot.mirror.ok === true,
+        error: text(snapshot?.mirror?.error) || null,
+      },
     });
   }
 

package/lib/mobile/session-delivery.js

@@ -0,0 +1,68 @@
+'use strict';
+
+/**
+ * 「这一发到底进没进」：按 `clientMessageId` 回查会话正文。
+ *
+ * 为什么要有这一条：手机端有一条**离线发件箱**（见 App 侧 `services/outbox.ts`）——
+ * 点发送时没网或者电脑够不着，那条消息先留在手机上、标成「等待网络」，等网回来自动重发。
+ * 重发沿用同一个 `clientMessageId`，插件侧本来就会按它去重（`session-cache.js` 的
+ * `promptOnceFor`）。但那份去重记录**只在进程内存里**：插件重启过、或者 App 在「宿主
+ * 已经收下、还没等到回包」那一刻被杀掉，手机这边就分不清「重发会补上」还是「重发会重复」。
+ *
+ * 所以这里从**会话日志**里查：日志是持久的，重启也在。查到就是进过了，App 直接把发件箱
+ * 那一条划掉；查不到才真的重发。这比让 App 发完再拉一整段历史对账便宜，也比「相信内存里
+ * 那份去重表」稳。
+ *
+ * 只读、只听 token、只看最近这一窗：发件箱里的条目最多躺几天，`maxMessages` 取它够用的
+ * 上限；更早的不查 —— 查不到就按「没进」走重发，而重发那一步仍有插件的去重兜着。
+ *
+ * 不解析附件：这里只认「有没有这条 user 消息」，标题、图片字节都不需要
+ * （`deriveMessages` 之外的附件解析是这条端点唯一可能变贵的地方，刻意不走）。
+ */
+
+const { sendJson } = require('../shared/http-util');
+const { unwrap } = require('./envelope.js');
+const { callSessions } = require('./rpc.js');
+const { deriveMessages } = require('./history-derive.js');
+
+/** 一次回查读多少条事件：发件箱的条目只可能出现在最近这几天。 */
+const DELIVERY_HISTORY_WINDOW = 200;
+/** 两个参数的长度上限（与 `clientMessageId` 的生成形状同一个量级）。 */
+const PARAM_MAX = 200;
+
+/**
+ * GET /api/mobile/v1/session/delivery?sessionId=…&clientMessageId=…（token）
+ * → { ok, delivered, seq? }
+ *
+ * 宿主没有这条会话（被删 / 换了机器）时回 404：那是「查不到」，不是「没送到」——
+ * App 据此把发件箱里那条标成失败，而不是永远重试。
+ */
+async function handleSessionDelivery(ctx, req, res) {
+  const url = new URL(req.url, 'http://x');
+  const sessionId = (url.searchParams.get('sessionId') || '').trim();
+  const clientMessageId = (url.searchParams.get('clientMessageId') || '').trim();
+  if (!sessionId || !clientMessageId || sessionId.length > PARAM_MAX || clientMessageId.length > PARAM_MAX) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { sessionId, clientMessageId }' } });
+  }
+  const { value, error } = unwrap(await callSessions(ctx, 'history', { sessionId, maxMessages: DELIVERY_HISTORY_WINDOW }));
+  if (error) {
+    const missing = error.code === 'session-not-found';
+    return sendJson(res, missing ? 404 : 502, {
+      ok: false,
+      error: {
+        code: typeof error.code === 'string' ? error.code : 'host-call-failed',
+        message: typeof error.message === 'string' && error.message ? error.message : '读取会话历史失败',
+      },
+    });
+  }
+  const events = (value && Array.isArray(value.events)) ? value.events : [];
+  const messages = deriveMessages(events);
+  const hit = messages.find((message) => message.clientMessageId === clientMessageId);
+  sendJson(res, 200, {
+    ok: true,
+    delivered: Boolean(hit),
+    ...(hit && typeof hit.seq === 'number' ? { seq: hit.seq } : {}),
+  });
+}
+
+module.exports = { handleSessionDelivery, DELIVERY_HISTORY_WINDOW };

package/lib/mobile/session-log.js

@@ -8,6 +8,10 @@
  * 的 127.0.0.1 上，手机既直连不到、也没有 `<a download>`，所以这里由插件代取并
  * 原样转发宿主 `apiProxy.downloads.sessionLog` 的 application/zip 流。
  *
+ * 0.2.x 的兼容桥没有这条端点（host-bridge.js 的 `downloads.sessionLog` 直接回
+ * `host-unsupported`），所以这一代宿主上本路由只能如实回 502；等宿主把导出能力重新
+ * 暴露出来，上面这段转发才真的走得到。
+ *
  * 与桌面客户端保持同一口径：`includeDescendants` 缺省即 true —— 导出的是「当前会话
  * + 子会话 + 附件」的整棵会话树，而不是单个会话。
  */

package/lib/mobile/session-snapshot.js

@@ -80,7 +80,7 @@ async function buildStatsSnapshot(ctx, sessionId) {
  * 0.2.0 把整帧投影从 history/page 的返回值里拆走了，「拉一条历史顺带取投影」这条路断了；
  * 改走 `apiProxy.sessions.projections({ request: { sessionId } })`，返回值是
  * `{ asOfSeq, values }`。顺带把 plan 归一化成 planMode（排队条与计划条读它）。
- * 历史轮询是每 5 秒一次的热路径，多背一次投影 RPC 划不来，所以统计单独走投影端点。
+ * 历史轮询是每 15 秒一次的热路径，多背一次投影 RPC 划不来，所以统计单独走投影端点。
  */
 async function statsProjections(ctx, sessionId) {
   // 显式给 signal：宿主部分方法内部直接读 signal.aborted，不做 undefined 兜底。

package/lib/mobile/stream.js

@@ -538,6 +538,8 @@ async function handleStream(ctx, req, res) {
           // 先吸工具名再减：结果自己不带工具名，正文留不留取决于它（见 wire-cut.js）。
           toolNames.absorb(event);
           event = cutEvent(event, toolNames);
+          // 整条不上线路的事件（`tool/call`、参数被砍空之后的工具增量帧）：见 wire-cut.js。
+          if (!event) continue;
           const chunk = event.data && event.data.chunk;
           if (seq !== null || !chunk || typeof chunk.type !== 'string') {
             // 持久事件（或不是增量的会话事件）：先把攒着的草稿写掉，再按原样写这一帧。
@@ -651,6 +653,8 @@ async function replaySince(ctx, sessionId, sinceSeq, res, signal, onDelivered, a
       const e = entry?.event || entry;
       const resolved = await resolveEventAttachments(ctx, sessionId, e, { referencesOnly: true });
       const event = cutEvent(resolved, toolNames);
+      // 回放与直播同一副眼镜：整条不上线路的事件这里也跳过（见 wire-cut.js）。
+      if (!event) continue;
       // Keep replay data identical to live SSE data: the client reducer consumes
       // the event's own type (turn/start, assistant/message, etc.).
       const payload = { type: 'session/event', sessionId, event };

package/lib/mobile/wire-cut.js

@@ -10,6 +10,10 @@
  * 料 —— 计划卡读 `exit_plan_mode` 的 `plan`、扩展卡读 `extension_present` 的 `extension`、
  * 定时任务卡解析 `schedule_create` 结果的 JSON。
  *
+ * 除了「内容」还要收「帧数」：手机只回答「在干什么」，所以参数被砍空之后的工具增量帧
+ * （一次调用几十帧、每窗补 2KB）与没人消费的 `tool/call` 事件整条丢掉 —— 一个工具调用
+ * 在线上只剩**一帧身份**（`id` + `name`）加一帧结果。
+ *
  * 直播帧循环（stream.js）与历史派生（history-derive.js）调的是同一份实现。同一条规则写两份，
  * 迟早漂成「直播里还带着推理、拉一次历史又没有了」。
  */
@@ -111,29 +115,34 @@ function cutAssistantEvent(event) {
 }
 
 /**
- * 一条 `tool/call` 事件：与 tool-call 块同一条规则 —— 只为三张轮尾卡的工具留 `arguments`
- * （其余一律只留 `callId` / `name`）。宿主把这条事件原样追进会话日志，手机今天收得到每一次
- * 调用的完整参数（bash 命令行、文件路径都在里面），而 App 对这条事件没有任何消费者。
- * 认不出工具名时按「不留」处理：宁可少一份参数，也不把别的调用原样发出去。
+ * 一条 `tool/call` 事件：**整条不下发**。
+ *
+ * 手机端对这条事件没有任何消费者：调用名由工具块的身份帧带到，状态与图片由 `tool/result`
+ * 回填，三张轮尾卡的料取自 `assistant/message` 里的 tool-call 块（见 App 的 `turn-tail-cards`）。
+ * 而它带 seq，属于「其余帧补满整份」那一类 —— 一帧就是 2KB 注释，一个长任务几十次调用、
+ * 两次报路（宿主→中转→手机）都是白走的。
  */
-function cutToolCallEvent(event) {
-  const data = event && event.data;
-  if (!data || typeof data !== 'object') return event;
-  if (typeof data.name === 'string' && ARGUMENT_KEEP_TOOLS.has(data.name)) return event;
-  if (data.arguments === undefined) return event;
-  const { arguments: _droppedArguments, ...rest } = data;
-  return { ...event, data: rest };
+function cutToolCallEvent() {
+  return null;
 }
 
 /**
- * 一块流式增量：`tool-call-delta` 的参数正文不下发，帧本身照留（App 靠它知道有工具开始了，
- * `index` / `id` / `name` 也就是配对要用的那几个字段）。这条是整个减法里最贵的一笔 ——
- * `write` / `edit` 的参数就是整份文件内容，按 token 一帧地推给手机。
+ * 一块流式增量：`tool-call-delta` 只留**身份帧**，其余整帧丢掉。
+ *
+ * 参数正文不下发（`write` / `edit` 的参数就是整份文件内容，按 token 一帧地推），于是同一块
+ * 后面那些帧只剩 `{ type, index }` —— 而 `index` 对手机没有用处，它要的是「有个工具开始了」
+ * 和那个工具叫什么。这些空壳在线上按 200ms 一窗合并、每窗补到 2KB（见 `stream.js`），
+ * 一个改文件的调用光参数流式那十几秒就能白走几十上百 KB。
+ *
+ * 判据只看这一帧自己带不带身份（`id` / `name`），不记状态：宿主把名字放在第一帧，也有的
+ * 宿主分开给，两种都留得住。
  */
 function cutAssistantChunkEvent(event) {
   const data = event && event.data;
   const chunk = data && data.chunk;
   if (!chunk || typeof chunk !== 'object' || chunk.type !== 'tool-call-delta') return event;
+  const identifies = chunk.id !== undefined || typeof chunk.name === 'string';
+  if (!identifies) return null;
   if (chunk.argumentsDelta === undefined) return event;
   const { argumentsDelta: _droppedArguments, ...rest } = chunk;
   return { ...event, data: { ...data, chunk: rest } };
@@ -141,7 +150,7 @@ function cutAssistantChunkEvent(event) {
 
 /**
  * 事件类型 → 这条事件该怎么减：能减的类型走对应的一条规则，其余原样透传。
- * 直播帧循环与回放都调它，一次判完，避免两处各判一半。
+ * **返回 null = 这条事件整条不上线路**，调用方必须跳过它（见 `stream.js` 的两处）。
  */
 function cutEvent(event, names) {
   if (!event || typeof event !== 'object') return event;