dsh-mobile-plugin 0.1.94 → 0.1.95

package/lib/mobile/completion.js

@@ -7,9 +7,21 @@
  *
  * 旧要求的后果（2026-10-17 真机）：宿主没采到那一瞬间的轮次永远不亮，桌面亮着绿点 /
  * 红点，手机上什么都没有。
+ *
+ * ⚠️ 这里有两笔**性质不同**的账，别混回去：
+ *
+ *   - `completionState*`（按设备）：**哪台手机还没看过这一轮**。它是提醒，只有 App 的
+ *     `/session/read` 能清，天然属于「谁在问」。后台通知（/monitor）还靠它。
+ *   - `lastTurnFactsOf`（不分设备）：**这一轮什么时候结束的、成没成**。它是事实，跟
+ *     谁在问无关，所以列表行可以直接带它去镜像快照 —— 而快照是全局一份、给所有设备读的。
+ *
+ * 之前列表行只带前者，镜像又是用固定设备键构建的，于是快照里那份「未读」永远清不掉：
+ * 手机上点开看过，侧栏的绿点/红点照样挂着，而绕过镜像的那种读又立刻变干净 —— 同一行
+ * 一会儿一个状态。现在 App 侧自己拿事实 + 本机已读水位算「亮不亮」，两笔账各归各位。
  */
 
 const { completionStateOf, completionStateMapsOf } = require('./session-cache.js');
+const { settleOutcome, recordLastTurn } = require('./session-last-turn.js');
 
 /** 本进程起点：比它更早结束的轮次不重播。 */
 const PROCESS_STARTED_AT = Date.now();
@@ -37,7 +49,7 @@ function observeCompletionEvent(ctx, sessionId, event) {
     const priorEvents = Array.isArray(previous.completionEvents) ? previous.completionEvents : [];
     const events = [...priorEvents.filter((item) => item.type !== event.type), event];
     const next = { ...previous, running: event.type === 'turn/end' ? false : previous.running, completionEvents: events };
-    if (event.type === 'turn/end') confirmCompletionFromHistory(next, events, false);
+    if (event.type === 'turn/end') confirmCompletionFromHistory(next, events, false, ctx, sessionId);
     states.set(sessionId, next);
   }
 }
@@ -73,8 +85,14 @@ function updateCompletionStates(ctx, items, deviceKey = 'legacy') {
   return states;
 }
 
-/** 把 history 最后一轮的结局折到 state 上：结束时刻越过 baselineOf 才算提醒。 */
-function confirmCompletionFromHistory(state, events, running) {
+/**
+ * 把 history 最后一轮的结局折到 state 上：结束时刻越过 baselineOf 才算提醒。
+ *
+ * 事实那一半（这一轮什么时候结束、成没成）由 `session-last-turn.js` 记下来，与设备无关；
+ * 这里只维护提醒。传了 `ctx` + `sessionId` 就顺手把事实记进去，**不受已读水位影响** ——
+ * 它说的是「这一轮怎么结束的」，跟哪台手机看过没关系（见文件头）。
+ */
+function confirmCompletionFromHistory(state, events, running, ctx = null, sessionId = null) {
   if (!state || !Array.isArray(events)) return;
   let latestTurn;
   const ends = new Map();
@@ -97,40 +115,30 @@ function confirmCompletionFromHistory(state, events, running) {
   if (running || state.turn === undefined) return;
   const end = ends.get(state.turn);
   if (!end) return;
+  const outcome = settleOutcome({ turn: state.turn, end, assistant: assistants.get(state.turn) });
+  if (ctx && sessionId) recordLastTurn(ctx, sessionId, outcome);
   const baseline = baselineOf(state);
-  const endedAt = typeof end.time === 'number' ? end.time : baseline + 1;
-  if (endedAt <= baseline) return; // 读过的 / 冷启动之前结束的那一轮
-  const assistant = assistants.get(state.turn);
-  const reason = end.data ? end.data.reason : undefined;
-  const kind = reason && typeof reason.kind === 'string' ? reason.kind : undefined;
-  // 本轮以错误收尾：宿主不会再补一条最终消息，但它刚刚追加过 turn/end —— 下面那条
-  // 「assistant 早于 turn/end 就算完成」的规则会把这种轮次判成「已完成待读」，侧栏于是
-  // 把一次失败显示成绿点。失败是宿主列表摘要里没有的信息，只能在这里折出来交给 App。
-  if (kind === 'error') {
-    const error = reason && reason.error && typeof reason.error === 'object' ? reason.error : {};
+  if (outcome.endedAt <= baseline) return; // 读过的 / 冷启动之前结束的那一轮
+  if (outcome.status === 'failed') {
     state.completed = false;
     state.failure = {
-      turn: state.turn,
-      code: typeof error.code === 'string' ? error.code : null,
-      message: typeof error.message === 'string' ? error.message : null,
-      at: typeof end.time === 'number' ? end.time : Date.now(),
+      turn: outcome.turn,
+      code: outcome.code,
+      message: outcome.message,
+      at: outcome.endedAt,
     };
     return;
   }
   // max-tokens / aborted 等：这一轮没跑完，同样不能报完成；但它没有错误码可显示，
   // 所以只清完成标记，不产生红点。
-  if (kind !== undefined && kind !== 'completed') {
+  if (outcome.status === 'incomplete') {
     state.completed = false;
     state.failure = undefined;
     return;
   }
-  // The assistant message must be the settled message for this turn, not an
-  // interrupted partial and not merely a preceding turn's message.
-  if (assistant && assistant.seq <= end.seq && assistant.data.interrupted !== true) {
-    state.completed = true;
-    // 成功收尾的轮次覆盖旧失败：标记必须跟着最新一次运行走。
-    state.failure = undefined;
-  }
+  state.completed = true;
+  // 成功收尾的轮次覆盖旧失败：标记必须跟着最新一次运行走。
+  state.failure = undefined;
 }
 
 module.exports = { observeCompletionEvent, updateCompletionStates, confirmCompletionFromHistory };

package/lib/mobile/monitor.js

@@ -89,7 +89,7 @@ async function buildMonitorState(ctx, deviceKey) {
         // 读到这些历史的这一刻，别处可能刚发起一次写后刷新（它会 bump 代次）；
         // 用旧快照去确认结局等于把「还在跑的一轮」写成已完成。
         if (completionGenerationOf(ctx, deviceKey) !== generation) return;
-        confirmCompletionFromHistory(states.get(summary.sessionId), preview.events, false);
+        confirmCompletionFromHistory(states.get(summary.sessionId), preview.events, false, ctx, summary.sessionId);
       } catch {
         // 这一轮没读到就原样留着：判定条件（没完成、没失败）下一轮仍然成立，会再试。
       }

package/lib/mobile/plugin-update.js

@@ -0,0 +1,199 @@
+'use strict';
+
+/**
+ * 手机端「插件更新」：APP 的「应用更新」页直接给这台电脑上的插件升级。
+ *
+ * ## 为什么手机端要有这条路
+ *
+ * 自动更新（外壳里那个 10 分钟轮询）有一道闸：**有对话在跑就不换文件**，等下一轮。用户在
+ * 手机上聊天时，这道闸几乎永远关着，而更新入口此前只在桌面控制面（`localOnly`）—— 手机
+ * 根本打不到。于是「插件有新版」这件事对手机用户等于不存在。这三条接口就是把它开给已配对
+ * 的手机。
+ *
+ * 能力面是**有意放开**的：手机本来就握着这台宿主的凭据、能发消息，而「换掉宿主上跑的插件
+ * 代码」比发消息重。所以入口只做一件事、且沿用已有的两道既有判据，不新增任何能力：
+ *
+ *  · **来源判据不放开**：`update-install.cjs` 的 `installAllowedFor` 只放行注册表来源
+ *    （`npm`）。本地目录 / `file:` tgz / `workspace:` 装的机器（开发机就是）即便带
+ *    `force` 也会被拒 —— force 只跳过「有对话在跑」和「新发布先晾一会儿」，跳不过来源。
+ *  · **换代仍然就地做**：装完由外壳 `runtime.reload()` 换实现代，不重启 DSH（见 lib/index.js）。
+ *
+ * ## 为什么 apply 只回一句「开始了」
+ *
+ * 装一次要跑包管理器，几十秒到几分钟；装完换代会把**当前这一代实现连同这条路由一起卸掉**，
+ * 旧代码手里的响应发不出去。所以结果不能靠这条请求的返回值，只能靠前端轮询 status。
+ * 顺带一个好处：apply 期间没有在飞请求，换代时 `runtime.drain()` 不用等谁。
+ *
+ * 状态里给的是**身份**而不是时间戳：前端用「运行中版本变了」或「appliedAt 变了」判完成，
+ * 手机与电脑的钟不一定对得上，比较时间会误判。
+ *
+ * ## 三条接口
+ *
+ *  · `GET  /api/mobile/v1/plugin/update/status` 运行中/盘上版本、安装来源、上一轮更新结果
+ *  · `POST /api/mobile/v1/plugin/update/check`  问 npm 注册表有没有新版（与桌面面板同一个实现）
+ *  · `POST /api/mobile/v1/plugin/update/apply`  开始一次强制更新，立即返回
+ */
+
+const path = require('node:path');
+const { sendJson, readJsonBody } = require('../shared/http-util');
+const { checkForUpdate } = require('../update-registry.cjs');
+const { declaredSource } = require('../update-install.cjs');
+const { version: generationVersion } = require('../../package.json');
+
+/** apply 的请求体只有 `force` 一个布尔，给 4KB 都很宽。 */
+const APPLY_BODY_MAX = 4 * 1024;
+
+/**
+ * 响应写出去之后再开装。装一开始就会有人读盘，先让这一发把 202 吐完、inFlight 归零，
+ * 免得换代时 drain 还要等这条请求自己。
+ */
+const APPLY_DEFER_MS = 150;
+
+/**
+ * 同一次安装多久算「还在跑」。装的过程中 `status.swapping` 还是 false（那时还没到换代），
+ * 所以只能自己记一个开始时刻；装的上限是 10 分钟（update-install 的 INSTALL_TIMEOUT_MS），
+ * 这里留两分钟余量。换代完成后这一代模块被整体丢弃，这个变量自然归零。
+ */
+const APPLY_BUSY_MS = 12 * 60 * 1000;
+
+let applyingSince = 0;
+
+/** 外壳服务；拿不到（无头部署 / 实现被直接挂载）就是没有换代能力。 */
+function runtimeOf(ctx) {
+  try {
+    return typeof ctx?.get === 'function' ? ctx.get('dshMobilePluginRuntime') || null : null;
+  } catch {
+    return null;
+  }
+}
+
+/** 上一轮更新的结果：只挑前端要用的几格，`check` 里那一坨注册表原始响应不往手机上搬。 */
+function lastApplyOf(value) {
+  if (!value || typeof value !== 'object') return null;
+  const failure = value.failure && typeof value.failure === 'object'
+    ? { code: typeof value.failure.code === 'string' ? value.failure.code : null, message: String(value.failure.message || '') }
+    : null;
+  return {
+    installed: value.installed === true,
+    skipped: value.skipped === true,
+    state: typeof value.state === 'string' ? value.state : null,
+    beforeVersion: typeof value.beforeVersion === 'string' ? value.beforeVersion : null,
+    installedVersion: typeof value.installedVersion === 'string' ? value.installedVersion : null,
+    swapped: value.swapped === true,
+    retryable: value.retryable === true,
+    failure,
+  };
+}
+
+/**
+ * 现场快照。`declaredSource` 读的是 profile 的依赖声明（同一个判据 installAllowedFor 用的
+ * 就是它），所以「界面说能更新」与「真去装不会被拒」是同一件事。
+ */
+function snapshot(ctx) {
+  const runtime = runtimeOf(ctx);
+  if (!runtime) {
+    return {
+      supported: false,
+      runningVersion: generationVersion,
+      installedVersion: null,
+      source: null,
+      appliedAt: null,
+      lastApply: null,
+      shellChanged: false,
+    };
+  }
+  const s = runtime.status();
+  const profileNodeModules = typeof s.profileNodeModules === 'string' ? s.profileNodeModules : null;
+  return {
+    supported: typeof runtime.apply === 'function',
+    runningVersion: s.version ?? null,
+    installedVersion: s.installedVersion ?? null,
+    // 来源读不到（profile 里没这条依赖）按「不知道」报，前端不拿它当拒绝理由 ——
+    // 那种现场多半是插件压根不是从 profile 装的，装一次反而是修复。
+    source: declaredSource(profileNodeModules ? path.dirname(profileNodeModules) : null) ?? s.marketResult?.source ?? null,
+    appliedAt: typeof s.appliedAt === 'string' ? s.appliedAt : null,
+    lastApply: lastApplyOf(s.lastApply),
+    // 新版本连外壳一起改了：换得掉实现，换不掉外壳，如实报出来（那部分等下次启动）。
+    shellChanged: s.shellChanged === true,
+  };
+}
+
+/** `GET /plugin/update/status` */
+async function handlePluginUpdateStatus(ctx, _req, res) {
+  sendJson(res, 200, { ok: true, status: snapshot(ctx) });
+}
+
+/**
+ * `POST /plugin/update/check`：问 npm 注册表。
+ *
+ * 不要求外壳在场（查不需要换代能力），盘上版本优先取外壳那份，拿不到退回这一代自己的
+ * 版本号 —— 与桌面控制面 `/api/relay/update/check` 同一套口径。
+ */
+async function handlePluginUpdateCheck(ctx, _req, res) {
+  const status = snapshot(ctx);
+  try {
+    const update = await checkForUpdate({
+      installedVersion: status.installedVersion ?? status.runningVersion ?? generationVersion,
+      source: status.source,
+    });
+    sendJson(res, 200, { ok: true, update, status });
+  } catch (error) {
+    sendJson(res, 500, {
+      ok: false,
+      error: { code: 'plugin_update_check_failed', message: String(error?.message || error) },
+      update: null,
+      status,
+    });
+  }
+}
+
+/**
+ * `POST /plugin/update/apply`：开始一次更新。
+ *
+ * 手机点的是「我现在就要更新」，所以固定带 `force`（跳过「有对话在跑」与发布晾置期）。
+ * 没有可换代的外壳时回 409：盘上换了版本、运行中的实现换不掉，等于白装。
+ */
+async function handlePluginUpdateApply(ctx, req, res) {
+  const runtime = runtimeOf(ctx);
+  if (!runtime || typeof runtime.apply !== 'function') {
+    return sendJson(res, 409, {
+      ok: false,
+      error: {
+        code: 'plugin_update_unavailable',
+        message: '这台宿主没有可就地换代的插件外壳，装完没法立即生效；请在电脑上更新后重启 DSH',
+      },
+    });
+  }
+  let body = {};
+  try {
+    body = (await readJsonBody(req, APPLY_BODY_MAX)) || {};
+  } catch {
+    body = {};
+  }
+  if (Date.now() - applyingSince < APPLY_BUSY_MS) {
+    return sendJson(res, 409, {
+      ok: false,
+      error: { code: 'plugin_update_busy', message: '上一次更新还在进行，请等它结束' },
+    });
+  }
+  const before = snapshot(ctx);
+  const force = body.force === true;
+  applyingSince = Date.now();
+  sendJson(res, 200, {
+    ok: true,
+    started: true,
+    force,
+    before: { runningVersion: before.runningVersion, installedVersion: before.installedVersion, appliedAt: before.appliedAt },
+  });
+  setTimeout(() => {
+    // 结果不在这里回给谁：它不落账、也不改 applyingSince 的成功分支 —— 换代之后这一代
+    // 模块整体被丢弃，前端读的是新一代表现出来的 status。
+    runtime.apply({ force }).catch(() => { applyingSince = 0; });
+  }, APPLY_DEFER_MS);
+}
+
+module.exports = {
+  handlePluginUpdateStatus,
+  handlePluginUpdateCheck,
+  handlePluginUpdateApply,
+};

package/lib/mobile/session-cache.js

@@ -32,6 +32,10 @@ const sessionPreviewClock = new WeakMap();
 // 完成提醒属于宿主进程状态：按 ctx 隔离，避免不同宿主/测试上下文互相污染。
 const completionStates = new WeakMap();
 const completionGenerations = new WeakMap();
+// 「上一轮什么时候结束、成没成」——会话自己的事实，**不分设备**。
+// 与 completionStates 的分工见 completion.js 的文件头：那个是「哪台手机还没看过」，
+// 这个只回答「上一轮发生了什么」，所以它必须设备无关：镜像快照是全局一份、给所有设备读。
+const lastTurnFacts = new WeakMap();
 // Prevent duplicate prompt calls when a mobile request is retried after a timeout.
 const sendIdempotency = new WeakMap();
 // 写操作（新建/改名/归档/分叉）的 requestId 重放表：同一次写在换通道重投后不再执行第二遍。
@@ -156,6 +160,19 @@ function completionStateMapsOf(ctx) {
   return [...(completionStates.get(ctx)?.values() || [])];
 }
 
+/**
+ * 会话「上一轮结局」的设备无关台账：`sessionId → { turn, endedAt, kind, error }`。
+ *
+ * 它存在的理由是**镜像快照要给所有设备读**：快照是全局一份，没法按「现在是谁在问」
+ * 去算「你看过没有」。所以列表只带这一份事实（这一轮什么时候结束的、成没成），
+ * 「读过没有」由 App 自己按设备存的水位去比。详见 completion.js 的文件头。
+ */
+function lastTurnFactsOf(ctx) {
+  let facts = lastTurnFacts.get(ctx);
+  if (!facts) { facts = new Map(); lastTurnFacts.set(ctx, facts); }
+  return facts;
+}
+
 /**
  * 标记「这条会话读过了」：记一个水位，把当前的完成 / 失败提醒清掉，返回清掉的条数。
  *
@@ -297,6 +314,7 @@ module.exports = {
   mirrorHistoryStateOf,
   completionStateOf,
   completionStateMapsOf,
+  lastTurnFactsOf,
   markCompletionRead,
   clearCompletionForAllDevices,
   completionGenerationOf,

package/lib/mobile/session-last-turn.js

@@ -0,0 +1,106 @@
+'use strict';
+
+/**
+ * 「上一轮怎么结束的」——会话自己的**设备无关事实**。
+ *
+ * 与 completion.js 的分工：那边是「哪台手机还没看过」的提醒账（按设备），这里是「这一轮
+ * 什么时候结束、成没成」。两者曾是一笔账，于是列表行只能带「未读」这个含义 —— 而列表还要
+ * 喂镜像快照，快照是全局一份、给所有设备读，按设备算的结论在里面永远是同一台假设备的，
+ * 手机上点开看过也不灭。现在 App 拿这份事实 + 本机已读水位自己算点（见
+ * `app/src/services/viewmodels/session-status.ts`）。
+ *
+ * 抽成独立模块的理由与 completion.js 当初一样：它是**纯计算 + 一张表**，不碰 ctx 的其它
+ * 状态，守卫要能单独驱动它（`test/session-last-turn.test.cjs`）。
+ */
+
+const { lastTurnFactsOf } = require('./session-cache.js');
+
+/**
+ * 一轮的结局：纯计算，不碰水位、不碰设备。
+ *
+ * 两条既有铁律照旧：error 收尾不算完成（并带失败信息）；成功那句 assistant 必须是本轮
+ * 已落定的那条（`seq <= end.seq` 且没被打断），不能拿上一轮的冒充。
+ */
+function settleOutcome({ turn, end, assistant }) {
+  const endedAt = typeof end.time === 'number' ? end.time : 0;
+  const reason = end.data ? end.data.reason : undefined;
+  const kind = reason && typeof reason.kind === 'string' ? reason.kind : undefined;
+  // 本轮以错误收尾：宿主不会再补一条最终消息，但它刚刚追加过 turn/end —— 「assistant
+  // 早于 turn/end 就算完成」那条规则会把这种轮次判成「已完成待读」，侧栏于是把一次失败
+  // 显示成绿点。失败是宿主列表摘要里没有的信息，只能在这里折出来交给 App。
+  if (kind === 'error') {
+    const error = reason && reason.error && typeof reason.error === 'object' ? reason.error : {};
+    return {
+      turn,
+      endedAt,
+      status: 'failed',
+      code: typeof error.code === 'string' ? error.code : null,
+      message: typeof error.message === 'string' ? error.message : null,
+    };
+  }
+  // max-tokens / aborted 等：这一轮没跑完，同样不能报完成；但它没有错误码可显示，
+  // 所以只清完成标记，不产生红点。
+  if (kind !== undefined && kind !== 'completed') return { turn, endedAt, status: 'incomplete' };
+  const settled = Boolean(assistant) && assistant.seq <= end.seq && assistant.data.interrupted !== true;
+  return { turn, endedAt, status: settled ? 'completed' : 'incomplete' };
+}
+
+/**
+ * 记下「上一轮事实」：只前进不后退。
+ *
+ * 同一轮会被折叠多次（列表缓存命中、多台设备各自构建清单、事件流与 history 两条路），
+ * 结束时刻往回拨会让 App 侧刚清掉的点重新亮起来，所以更旧的一律丢弃。
+ */
+function recordLastTurn(ctx, sessionId, outcome) {
+  if (!ctx || !sessionId || !outcome) return;
+  const facts = lastTurnFactsOf(ctx);
+  const previous = facts.get(sessionId);
+  if (previous && typeof previous.turn === 'number') {
+    if (outcome.turn < previous.turn) return;
+    if (outcome.turn === previous.turn && outcome.endedAt <= previous.endedAt) return;
+  }
+  facts.set(sessionId, {
+    turn: outcome.turn,
+    endedAt: outcome.endedAt,
+    status: outcome.status,
+    ...(outcome.status === 'failed' ? { code: outcome.code, message: outcome.message } : {}),
+    // 已读水位是**另一件事**的产物（任何一端读过都会推进），换新的事实时必须原样带上，
+    // 否则刚读过的一轮会因为「又折了一次 history」重新亮起来。
+    ...(previous && typeof previous.readAt === 'number' ? { readAt: previous.readAt } : {}),
+  });
+}
+
+/**
+ * 记下「这条会话在某一刻被读过了」——**不分设备**。
+ *
+ * 两端的读都要走到这里：手机点开（`/session/read`，那条本来就只清本设备的提醒）与
+ * 桌面点开（`/api/relay/desktop-read`，清所有设备的提醒）。列表要喂镜像快照，快照是
+ * 全局一份，没法按设备算「你看过没有」，所以只有这个与设备无关的水位能进下行清单。
+ *
+ * 只前进不后退：两端各自报各自的时刻，回拨会让已经看过的点重新亮。返回值是「水位真的
+ * 前进了没有」——调用方据此决定要不要作废列表缓存（重复上报不许每次都抬）。
+ */
+function recordSessionRead(ctx, sessionId, at = Date.now()) {
+  if (!ctx || typeof sessionId !== 'string' || !sessionId) return false;
+  const value = typeof at === 'number' && Number.isFinite(at) && at > 0 ? at : Date.now();
+  const facts = lastTurnFactsOf(ctx);
+  const previous = facts.get(sessionId) || {};
+  const current = typeof previous.readAt === 'number' ? previous.readAt : 0;
+  if (current >= value) return false;
+  facts.set(sessionId, { ...previous, readAt: value });
+  return true;
+}
+
+/**
+ * 某个会话的上一轮事实（没有就返回 undefined）。
+ *
+ * 只回带 `turn` 的那些：表里也可能只存着一个已读水位（读过、但插件重启后还没折过
+ * 那一轮的结局），那不是「上一轮发生了什么」，不该下发给 App。
+ */
+function lastTurnOf(ctx, sessionId) {
+  const fact = lastTurnFactsOf(ctx).get(sessionId);
+  if (!fact || typeof fact.turn !== 'number') return undefined;
+  return fact;
+}
+
+module.exports = { settleOutcome, recordLastTurn, recordSessionRead, lastTurnOf };

package/lib/mobile/session-send.js

@@ -23,6 +23,7 @@ const { promptErrorObject, MODEL_UNAVAILABLE_ERROR } = require('./history-derive
 const { withIdempotency, requestIdOf } = require('./idempotency.js');
 const { invoke, UNAVAILABLE: GATEWAY_UNAVAILABLE } = require('./host-bridge/transport.js');
 const readReceipt = require('../read-receipt.cjs');
+const { recordSessionRead } = require('./session-last-turn.js');
 
 const SEND_MAX_BODY = 8 * 1024 * 1024; // /send 请求体上限（图片 base64）
 
@@ -209,6 +210,9 @@ async function handleSessionRead(ctx, req, res, fallbackDeviceKey = 'legacy') {
   const deviceKey = canonicalDeviceKey(req, fallbackDeviceKey);
   // 只清这台设备自己的提醒；水位留在状态里，读过的轮次就不会再亮回来。
   markCompletionRead(ctx, deviceKey, body.sessionId);
+  // 「这一轮被读过了」还要记一笔**设备无关**的水位：列表要喂镜像快照（全局一份），
+  // 上面那份按设备的提醒进不了下行清单，App 那边根本看不到这次已读（见 session-last-turn.js）。
+  recordSessionRead(ctx, body.sessionId);
   // Invalidate the cache and any build already reading history. Its generation
   // check prevents a stale build from restoring `completed` after this ack.
   invalidateSessionList(ctx, deviceKey);

package/lib/mobile/sessions.js

@@ -44,6 +44,7 @@ const {
 } = require('./session-cache.js');
 const { resolveEventAttachments } = require('./attachments.js');
 const { updateCompletionStates, confirmCompletionFromHistory } = require('./completion.js');
+const { lastTurnOf } = require('./session-last-turn.js');
 const { eventSeqOf, buildMessagesSnapshot, buildStatsSnapshot, statsProjections, handleMessages } = require('./session-snapshot.js');
 const { buildModelsSnapshot, handleModels, handleSelectModel } = require('./session-models.js');
 const { buildSingleSessionMirror, buildMirrorWarmSnapshots } = require('./session-mirror.js');
@@ -192,12 +193,14 @@ async function buildSessionsResponse(ctx, deviceKey = 'legacy', generation = com
     && (archivedOnly === archived.has(item.sessionId)));
   // 状态跟踪覆盖完整列表，不能受预览补全上限影响。
   const completionStatesForContext = updateCompletionStates(ctx, allSummaries, deviceKey);
+  // 设备无关的「上一轮事实」台账：预览读回 history 时顺手记进去（见下面的折叠）。
   // 列表完整返回：侧边栏分组依赖全部会话（工作区 sessionIds 排序 + 未分组兜底），
   // 截断会让工作区/项目下的会话凭空消失。标题直接取 list 摘要的 title 投影
   // （与桌面端侧栏同一来源，正式 session/title 事件折叠，绝不用对话正文冒充标题），
   // 该项是廉价字段；history 仅用于补「最后消息预览」，属于重活，见下方预览子集。
   const rows = allSummaries.map((s) => {
     const completionState = completionStatesForContext.get(s.sessionId);
+    const fact = lastTurnOf(ctx, s.sessionId);
     // 待处理标记：判据与后台监控共用一份（见 session-flags.js），别再在这里写第二份。
     const pendingInteraction = pendingInteractionOf(s.sessionId, s);
     const base = {
@@ -210,6 +213,11 @@ async function buildSessionsResponse(ctx, deviceKey = 'legacy', generation = com
       // 侧栏据此画红点：completed 只说「跑完了、待阅读」，说不了「跑挂了」。字段只在
       // 真有失败时出现，旧 App 忽略未知字段、行为不变。
       ...(completionState?.failure ? { lastTurnError: completionState.failure } : {}),
+      // 上一轮的**设备无关事实**：这一轮什么时候结束、成没成。上面那两个（completed /
+      // lastTurnError）是「这台设备还没看过」的提醒，而列表同时还要喂镜像快照 ——
+      // 快照全局一份、给所有设备读，按设备算的提醒在里面永远是同一台假设备的结论。
+      // App 因此改成拿这一格 + 本机已读水位自己算点，见文件头与 completion.js。
+      ...(fact ? { lastTurn: fact } : {}),
       blank: !!s.blank,
       cwd: s.cwd || null,
       // 会话定档的 Agent 预设（宿主 session.list 摘要里带，用来显示会话当前预设）。
@@ -241,7 +249,7 @@ async function buildSessionsResponse(ctx, deviceKey = 'legacy', generation = com
       const events = preview.events;
       const completionState = completionStatesForContext.get(s.sessionId);
       if (completionGenerationOf(ctx, deviceKey) === generation) {
-        confirmCompletionFromHistory(completionState, events, !!s.running);
+        confirmCompletionFromHistory(completionState, events, !!s.running, ctx, s.sessionId);
       }
       // Only expose completion after the matching turn/end and final
       // assistant/message are both present in the same history snapshot.
@@ -252,6 +260,10 @@ async function buildSessionsResponse(ctx, deviceKey = 'legacy', generation = com
       // 也没有红点），要等下一轮轮询才亮 —— 那正是这个补丁要消灭的「静默」。
       if (completionState?.failure) base.lastTurnError = completionState.failure;
       else delete base.lastTurnError;
+      // 事实那一格同理：它通常在这一步才第一次算出来。
+      const foldedFact = lastTurnOf(ctx, s.sessionId);
+      if (foldedFact) base.lastTurn = foldedFact;
+      else delete base.lastTurn;
       base.lastMessage = preview.lastMessage;
     } catch {
       // 预览失败不影响标题与行数据。

package/lib/routes/control-plane.js

@@ -48,6 +48,7 @@ const { createSelfCheck } = require('../mobile/self-check.cjs');
 const { checkForUpdate } = require('../update-registry.cjs');
 const { declaredSource } = require('../update-install.cjs');
 const { clearCompletionForAllDevices, invalidateSessionList } = require('../mobile/session-cache.js');
+const { recordSessionRead } = require('../mobile/session-last-turn.js');
 
 /** 一次 desktop-read 上报最多带多少个会话 id（防灌爆；客户端半边一次最多也就几个）。 */
 const MAX_DESKTOP_READ_IDS = 200;
@@ -423,11 +424,21 @@ function registerControlPlaneRoutes(deps) {
     if (!ids.length) return sendJson(res, 200, { ok: true, cleared: 0 })
     if (!ctx) return sendJson(res, 200, { ok: true, cleared: 0 })
     let cleared = 0
-    for (const id of ids) cleared += clearCompletionForAllDevices(ctx, id)
+    let advanced = 0
+    const at = Date.now()
+    for (const id of ids) {
+      cleared += clearCompletionForAllDevices(ctx, id, at)
+      // 「这一轮被读过了」还要记一笔**设备无关**的水位：手机侧的点现在由它自己按这份
+      // 水位算（见 mobile/session-last-turn.js）。只清按设备的提醒的话，桌面点开之后
+      // 手机上那个点永远不会灭 —— 那条提醒本来就不在手机读取的路径上。
+      if (recordSessionRead(ctx, id, at)) advanced += 1
+    }
     desktopHalf.noteDesktopRead({ ids: ids.length, cleared })
-    // 有东西真被清掉才作废列表缓存：invalidateSessionList 会抬 generation，
-    // 让镜像推送器重建清单并广播 device/list-changed（见 A3-14）。
-    if (cleared > 0) invalidateSessionList(ctx)
+    // 作废列表缓存要抬 generation，让镜像推送器重建清单并广播 device/list-changed
+    // （见 A3-14）—— 只在**真有东西变了**时才调：已读水位进了下行清单，水位前进同样算
+    // 内容变了；但重复上报（客户端半边每 2s 报一批，多数都是旧的）绝不能每次都抬，
+    // 否则 App 的会话列表缓存会被永久压住。
+    if (cleared > 0 || advanced > 0) invalidateSessionList(ctx)
     return sendJson(res, 200, { ok: true, cleared })
   }) })
   // The process-level error ledger (see lib/host-guard.cjs). "Stop an unknown

package/lib/routes/mobile-api.js

@@ -39,6 +39,7 @@ const subagents = require('../mobile/subagents.js');
 const monitor = require('../mobile/monitor.js');
 const references = require('../mobile/references.js');
 const plugins = require('../mobile/plugins.js');
+const pluginUpdate = require('../mobile/plugin-update.js');
 const uploads = require('../mobile/uploads.js');
 const pairing = require('../mobile/pairing.js');
 const { credentialsEntry } = require('../shared/credentials-entry.js');
@@ -271,6 +272,14 @@ function registerMobileRoutes(deps) {
   // 经 typertGateway 命名空间 pluginInventory 取，见 mobile/plugins.js。
   route('/api/mobile/v1/plugins', plugins.handlePlugins)
 
+  // 插件自更新：APP 的「应用更新」页给这台宿主升级插件版本（见 mobile/plugin-update.js）。
+  // 与桌面控制面 `/api/relay/update/*` 同一套实现，差别只在入口：那三条 localOnly，手机
+  // 永远打不到，而手机上聊天时「有对话在跑」那道闸几乎总关着 —— 自动更新等于不跑。
+  // 能力面有意放开给已配对设备，来源判据（只放行 npm 装的）不放开，理由写在那个文件头。
+  route('/api/mobile/v1/plugin/update/status', pluginUpdate.handlePluginUpdateStatus)
+  route('/api/mobile/v1/plugin/update/check', pluginUpdate.handlePluginUpdateCheck)
+  route('/api/mobile/v1/plugin/update/apply', pluginUpdate.handlePluginUpdateApply)
+
   // 分享文件的落地通道（App 把手机分享进来的文件分片传上来，见 mobile/uploads.js）。
   // 手机端没有「把文件交给宿主」的路：图片能进 session.send 的 base64 内容块，其它格式
   // 一律进不去。四条端点只做「收字节 → 落盘到 ~/.dsh/mobile-inbox/<日期>/<文件名>」，

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.1.94",
+  "version": "0.1.95",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (0.2.0-rc.2 compatible, peers resolved by the host)",
   "license": "MIT",
   "type": "module",