dsh-mobile-plugin 0.2.1 → 0.3.1

package/dsh-mobile-credentials/lib/credentials.js

@@ -269,8 +269,21 @@ function touch(record, info = {}) {
   record.lastSeenAt = now;
   const channel = typeof info.channel === 'string' ? info.channel : '';
   if (channel) record.lastChannel = channel.slice(0, FIELD_MAX);
+  // 身份那几格（2026-10-26）：名字 / 平台 / 系统版本 / App 版本由**每一次请求**带上来，
+  // 顺手刷新。它们以前只在配对那一刻写一次，于是「手机升到新版了、面板还报配对时的旧版本」，
+  // 而旧会话升级写进来的记录干脆什么身份都没有（面板只能画「未知设备」）。
+  // **只写这次真带了值的格子**：老版本 App 不带头，绝不能把已经有的名字冲成空。
+  const meta = deviceMeta(info.meta);
+  let metaChanged = false;
+  for (const key of Object.keys(meta)) {
+    if (record[key] !== meta[key]) {
+      record[key] = meta[key];
+      metaChanged = true;
+    }
+  }
   if (readOnly) return true;
-  if (now - lastTouchFlushAt < TOUCH_FLUSH_MS) return true;
+  // 身份变了必须落盘（那是面板唯一能看到的来源）；只刷新「刚连上过」才走老的一分钟节流。
+  if (!metaChanged && now - lastTouchFlushAt < TOUCH_FLUSH_MS) return true;
   lastTouchFlushAt = now;
   save();
   return true;

package/lib/impl.js

@@ -24,6 +24,7 @@ const { authorized, authOutcome, presentedCredential } = require('./mobile/auth.
 const { readRawBody } = require('./shared/e2ee-request')
 const streamRegistry = require('./mobile/stream-registry.js')
 const { viaChannel } = require('./shared/via-header')
+const { deviceMetaFromHeaders } = require('./shared/device-headers.js')
 const { createSidecarLifecycle } = require('./sidecar-lifecycle.cjs')
 const { createMirrorPusher } = require('./mirror/pusher.cjs')
 const { randomBytes } = require('node:crypto')
@@ -424,12 +425,11 @@ function apply(ctx) {
     readBody: (req) => readRawBody(req),
   }
   const guarded = createGuarded(ctx, authOutcome, activity.note, {
-    // 鉴权通过后立刻记「最近连接 + 走的是哪条路」：两条代理都注入了 `x-dsh-via`。
     onAuthorized: (req) => {
       const presented = presentedCredential(req)
       if (!presented) return
       const record = credentials.lookup(presented, state.instanceId)
-      if (record) credentials.touch(record, { channel: viaChannel(req) })
+      if (record) credentials.touch(record, { channel: viaChannel(req), meta: deviceMetaFromHeaders(req) })
     },
     envelope,
   })

package/lib/mobile/credential-upgrade.js

@@ -113,6 +113,30 @@ async function handleCredentialUpgrade(req, res, deps) {
     });
   }
 
+  // 同一个 keyId 已经登记过一枚（上一次的响应可能在路上丢了，手机又发了一遍）：
+  // **不再签发第二条** —— 手机留着手上这枚凭据、按 v2 签名，宿主按 keyId 验签，链路照样通。
+  // 没有这一条时每次重试都往库里堆一条记录（实测同一台设备 54 分钟里堆了 39 条，
+  // 面板上于是出现一堆同名的行）。
+  const known = presented && typeof store.findByKeyId === 'function'
+    ? store.findByKeyId(instanceId, secret.keyId)
+    : null;
+  if (known) {
+    store.touch(known, { channel: 'upgrade', meta: { ...meta, deviceId: known.deviceId } });
+    return sendJson(res, 200, {
+      ok: true,
+      upgraded: true,
+      proto: 2,
+      instanceId,
+      token: presented,
+      cookie: `dsh_lan=${presented}`,
+      deviceCredential: presented,
+      keyId: known.keyId,
+      deviceId: known.deviceId,
+      credentialExpiresAt: known.expiresAt || null,
+      serverTime: Date.now(),
+    });
+  }
+
   const issued = store.issue(instanceId, { ...meta, deviceId }, '', undefined, {
     deviceKey: secret.deviceKey,
     keyId: secret.keyId,

package/lib/mobile/directory-listing.js

@@ -0,0 +1,144 @@
+'use strict';
+
+/**
+ * 手机端右栏「文件浏览器」的目录列表：**文件与文件夹都列**，每条带类型、大小、修改时间。
+ *
+ * 与 `/directory/list` 的分工：那条是「为设备挑一个工作区目录」用的，走宿主 directoryPicker，
+ * 只列**能进去的目录**、每条只有 `{name,path,hidden}`（见 lib/mobile/workspaces.js）。右栏
+ * 要的是「这个目录里有什么」——文件也是内容，而且要知道类型、大小、修改时间，所以那条路
+ * 一个字段都对不上。老那条**一个字都不改**：选目录那条流程还挂在它上面。
+ *
+ * 这条直接读宿主自己的文件系统，**不经 directoryPicker 网关**。能力面没有因此变大：宿主
+ * 那份 browse 后端与本地兜底原语（lib/mobile/directory-browse.js）本来都是全文件系统范围、
+ * 没有白名单，`workspace.create` 也接受任意已存在目录；而「桌面 profile 宿主 + 手机远程连」
+ * 这一格宿主只服务 native，经网关只会拿到那句 `needs the browse capability`，右栏一个条目
+ * 都没有。策略原语（隐藏项标记、上限、面包屑）直接 import 那份副本，不抄第二份。
+ *
+ * 契约（App 侧 app/src/services/viewmodels/apiPaths.ts 的 directoryListing 同时按这份改）：
+ *   - `path` 可选、绝对路径；缺省 / 空串 / 全空白 = 被控端主目录（os.homedir()）。相对路径
+ *     直接 400 —— 不拿宿主进程的当前目录去猜，那是另一个语义；
+ *   - entries 名字升序（**大小写不敏感**），文件与文件夹混在一份里，分组由客户端做；
+ *   - hidden = 名字以 '.' 开头，照旧标记但返回，过滤交给客户端；
+ *   - kind 由 stat 得出（**跟随符号链接**）：目录是 'folder'，其余是 'file'，指向目录的
+ *     链接算 'folder'；
+ *   - size（字节）/ modified（epoch 毫秒）**只对文件给**；单条 stat 失败（断链、权限）按
+ *     'file' 返回且不带这两格 —— 一个坏条目不许把整条列表带走；
+ *   - 上限复用 directory-browse.js 的 DEFAULT_MAX_ENTRIES，超了截断并置 truncated = true；
+ *   - crumbs 复用 directory-browse.js 的 ancestryCrumbs（根 → 当前），形状与选目录那条一致。
+ * 失败一律 400 + `{ ok:false, error:{ code, message } }`，code 取 bad-request / not-found /
+ * not-directory / permission，message 是简短英文，人话由 App 侧自己的字典翻。
+ */
+
+const { opendir, stat } = require('node:fs/promises');
+const { join, resolve } = require('node:path');
+
+const { sendJson } = require('../shared/http-util');
+const { DEFAULT_MAX_ENTRIES, ancestryCrumbs, fullyQualified, homeDirectory } = require('./directory-browse.js');
+
+/** 400 信封：与其余移动端接口同形，App 按 code 翻人话。 */
+function fail(res, code, message) {
+  return sendJson(res, 400, { ok: false, error: { code, message } });
+}
+
+/** 任意抛出值 → 文案（abort reason 之类可以不是 Error）。 */
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/** 一次失败的 syscall → 契约里那四个码之一。 */
+function codeOf(error) {
+  const raw = error && typeof error === 'object' ? error.code : undefined;
+  if (raw === 'EACCES' || raw === 'EPERM') return 'permission';
+  if (raw === 'ENOENT' || raw === 'ENOTDIR') return 'not-found';
+  return 'bad-request';
+}
+
+/**
+ * 名字升序、大小写不敏感（契约）。折成同一个主权重后仍视为相同的（`README.md` 与
+ * `readme.md`）用码位序兜底：否则比较器回 0，顺序就跟 readdir 的返回顺序走，同一个目录
+ * 两次请求可能给出不同顺序。
+ */
+function compareNames(a, b) {
+  const folded = a.localeCompare(b, undefined, { sensitivity: 'base' });
+  if (folded !== 0) return folded;
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/** 一条列表行：stat 跟到最终目标上，目录为 folder，其余为 file（断了也照样是 file）。 */
+async function listingRow(directory, name) {
+  const path = join(directory, name);
+  const row = { name, path, hidden: name.startsWith('.') };
+  let stats = null;
+  try {
+    stats = await stat(path);
+  } catch {
+    // 断链 / 权限：这一条按 file 返回、不带 size 与 modified，整条列表继续。
+  }
+  if (stats && stats.isDirectory()) {
+    row.kind = 'folder';
+    return row;
+  }
+  row.kind = 'file';
+  if (stats) {
+    row.size = stats.size;
+    row.modified = Math.round(stats.mtimeMs);
+  }
+  return row;
+}
+
+/**
+ * GET /api/mobile/v1/directory/listing?path=…（token，path 缺省 = 被控端主目录）
+ *
+ * 200：`{ ok:true, listing:{ path, home, crumbs, entries, truncated } }`。
+ * 名字必须整体排序（大小写不敏感）才谈得上「升序」，所以这里读全量名字再截断：上限约束的
+ * 是随响应下发的行数与后面逐条 stat 的次数，那两样才是这条路的成本。
+ */
+async function handleDirectoryListing(_ctx, req, res) {
+  const url = new URL(req.url, 'http://x');
+  const asked = (url.searchParams.get('path') || '').trim();
+  if (asked && !fullyQualified(asked)) {
+    return fail(res, 'bad-request', `cannot list "${asked}": not a fully qualified path`);
+  }
+  const home = homeDirectory();
+  const target = resolve(asked || home);
+  let info;
+  try {
+    // 先 stat 一次：它把「不存在」「不是目录」「权限不够」三件事分开，也跟随符号链接
+    //（指向目录的链接按目录列）。opendir 在非目录上的报错各平台不一致，分不出这三种。
+    info = await stat(target);
+  } catch (error) {
+    return fail(res, codeOf(error), `cannot list ${target}: ${messageOf(error)}`);
+  }
+  if (!info.isDirectory()) {
+    return fail(res, 'not-directory', `cannot list ${target}: not a directory`);
+  }
+
+  const names = [];
+  try {
+    const level = await opendir(target);
+    try {
+      for (;;) {
+        const dirent = await level.read();
+        if (dirent === null) break;
+        names.push(dirent.name);
+      }
+    } finally {
+      await level.close();
+    }
+  } catch (error) {
+    return fail(res, codeOf(error), `cannot list ${target}: ${messageOf(error)}`);
+  }
+
+  names.sort(compareNames);
+  const truncated = names.length > DEFAULT_MAX_ENTRIES;
+  const kept = truncated ? names.slice(0, DEFAULT_MAX_ENTRIES) : names;
+  const entries = [];
+  for (const name of kept) entries.push(await listingRow(target, name));
+
+  sendJson(res, 200, {
+    ok: true,
+    listing: { path: target, home, crumbs: ancestryCrumbs(target), entries, truncated },
+  });
+}
+
+module.exports = { handleDirectoryListing };

package/lib/mobile/monitor.js

@@ -10,7 +10,8 @@
  *
  * 这条只回监控需要的那几格：在不在跑、刚完成没有、在等谁回话、上一轮是不是跑挂的、标题。
  * 并支持 `?rev=` 条件刷新：状态位与上次一模一样时回一句 `unchanged`，连 items 都不带
- * （稳态下这一发是几十字节）。
+ * （稳态下这一发是几十字节）。再带上 `?wait=秒` 时，条件刷新的那一发**先挂住**，等状态位
+ * 真的变了才回 —— 安卓后台服务靠它把「定时去问」变成「一有变化立刻送到」。
  *
  * 完成态仍以 completion 状态机为准，与 `/sessions` 用同一本账：常态下这里**不读 history**，
  * 只有「跑过、现在不在跑、结局还没定」的那几条才读一次 —— 那是唯一能把 failedTurn 折出来
@@ -22,6 +23,8 @@
 
 const { sendJson } = require('../shared/http-util');
 const { stableRevision, unchangedListBody } = require('../shared/list-revision.js');
+const { listSignal } = require('../shared/list-signal.js');
+const { sessionSignal } = require('../shared/session-signal.js');
 const { callSessions } = require('./rpc.js');
 const { unwrap } = require('./envelope.js');
 const { listTitle } = require('./history-derive.js');
@@ -29,6 +32,7 @@ const {
   canonicalDeviceKey, deletedSessionIdsOf, completionGenerationOf,
 } = require('./session-cache.js');
 const { updateCompletionStates, confirmCompletionFromHistory } = require('./completion.js');
+const { lastTurnOf } = require('./session-last-turn.js');
 const { sessionPreviewFor } = require('./session-preview.js');
 const { workspaceSessionFlags, pendingInteractionOf } = require('./session-flags.js');
 
@@ -39,16 +43,46 @@ const { workspaceSessionFlags, pendingInteractionOf } = require('./session-flags
  * lastTurnError），因为原生那边解析的是同一套字段：换名字就得同步改 Kotlin，而那段代码
  * 在 App 之外，改错一次是「后台永远不提醒」这种看不见的故障。
  */
-function monitorItem(summary, state) {
+function monitorItem(summary, state, fact) {
+  const running = summary.running === true;
+  // 完成/失败优先用**上一轮事实**（`session-last-turn`），不再等 `state.completed`。
+  //
+  // 为什么：那个按设备记账的完成态要靠「这一次真的读回了 history」才折得出来，而
+  // 「刚跑完」那一刻宿主的镜像推送早把同一份预览按新指纹写进缓存了 —— 监控这一侧
+  // 拿到的是缓存命中（events 为空）、永远折不出来，`completed` 就一直 false，后台
+  // 一条提醒都不会响（2026-10-25 真机：宿主日志里全是「preview cache-hit」）。
+  // 事实那本账由 turn/end 事件当场记下，不依赖预览缓存，所以拿它判完成。
+  //
+  // 已读水位仍然生效：这一轮结束在「这台手机读过」之前就不算提醒。
+  const clearedAt = typeof state?.clearedAt === 'number' ? state.clearedAt : null;
+  const settledForThisDevice = fact != null && (clearedAt === null || fact.endedAt > clearedAt);
+  const completed = fact
+    ? (!running && fact.status === 'completed' && settledForThisDevice)
+    : (state ? state.completed === true : false);
   const item = {
     sessionId: summary.sessionId,
     title: listTitle(summary),
-    running: summary.running === true,
-    completed: state ? state.completed === true : false,
+    running,
+    completed,
   };
   const pending = pendingInteractionOf(summary.sessionId, summary);
   if (pending) item.pendingInteraction = pending;
-  if (state && state.failure) item.lastTurnError = state.failure;
+  const failure = fact
+    ? (fact.status === 'failed' && settledForThisDevice
+      ? { turn: fact.turn, code: fact.code ?? null, message: fact.message ?? null }
+      : null)
+    : (state && state.failure ? state.failure : null);
+  if (failure) item.lastTurnError = failure;
+  // 上一轮事实整份透给原生：它按「轮次前进」判完成 / 失败，比 completed 翻面可靠
+  // （两次轮询之间跑完一整轮时 completed 可能一直是 true）。字段与列表那条同源。
+  if (fact) {
+    item.lastTurn = {
+      turn: fact.turn,
+      endedAt: fact.endedAt,
+      status: fact.status,
+      ...(fact.status === 'failed' ? { code: fact.code ?? null, message: fact.message ?? null } : {}),
+    };
+  }
   return item;
 }
 
@@ -68,7 +102,10 @@ async function buildMonitorState(ctx, deviceKey) {
   const generation = completionGenerationOf(ctx, deviceKey);
   const deleted = deletedSessionIdsOf(ctx);
   const { archived } = await workspaceSessionFlags(ctx);
+  // 子代理会话不参与后台提醒：它们是主轮内部的执行单元，App 侧栏也不列；把它们算进来
+  // 会在后台弹一堆「子代理跑完了」（2026-10-26 真机日志里四十多个 UUID 会话都是这种）。
   const live = summaries.filter((s) => s && typeof s.sessionId === 'string' && s.sessionId
+    && s.origin !== 'subagent'
     && !deleted.has(s.sessionId) && !archived.has(s.sessionId));
 
   // 状态机跟着这份清单走：归档 / 删除的会话在这里被踢掉，与完整列表同一口径。
@@ -85,51 +122,129 @@ async function buildMonitorState(ctx, deviceKey) {
     await Promise.all(unsettled.map(async (summary) => {
       try {
         const preview = await sessionPreviewFor(ctx, summary);
-        if (!preview.events.length) return;
+        if (!preview.events.length) {
+          return;
+        }
         // 读到这些历史的这一刻，别处可能刚发起一次写后刷新（它会 bump 代次）；
         // 用旧快照去确认结局等于把「还在跑的一轮」写成已完成。
-        if (completionGenerationOf(ctx, deviceKey) !== generation) return;
+        if (completionGenerationOf(ctx, deviceKey) !== generation) {
+          return;
+        }
+        const before = states.get(summary.sessionId)?.completed;
         confirmCompletionFromHistory(states.get(summary.sessionId), preview.events, false, ctx, summary.sessionId);
-      } catch {
+      } catch (error) {
         // 这一轮没读到就原样留着：判定条件（没完成、没失败）下一轮仍然成立，会再试。
       }
     }));
   }
 
-  const items = live.map((summary) => monitorItem(summary, states.get(summary.sessionId)));
+  const items = live.map((summary) => monitorItem(
+    summary,
+    states.get(summary.sessionId),
+    lastTurnOf(ctx, summary.sessionId),
+  ));
   // 按 id 排序后再算指纹：宿主是按 updatedAt 排的，聊一句话顺序就换，指纹会跟着每轮都变，
   // 条件刷新等于白做。监控视图不关心顺序。
   items.sort((a, b) => (a.sessionId < b.sessionId ? -1 : a.sessionId > b.sessionId ? 1 : 0));
   return { items, revision: stableRevision(items) };
 }
 
-/** GET /api/mobile/v1/monitor?rev=…（token） */
-async function handleMonitor(ctx, req, res) {
-  const deviceKey = canonicalDeviceKey(req);
-  const url = new URL(req.url, 'http://x');
-  const rev = (url.searchParams.get('rev') || '').trim();
+/** 一次挂起的上限。手机侧每次挂 20 秒，再长没有意义：断线重连比占着一条连接便宜。 */
+const WAIT_MAX_MS = 25_000;
+
+/**
+ * 挂在「有东西变了」的信号上，最多等 timeoutMs。
+ *
+ * 只有两条总线会唤醒它：清单变了（list-signal）、某个会话的正文水位涨了（session-signal）
+ * —— 一轮跑完、跑挂、开始等你回话，都会至少踩中其中一条。两条都是模块级单例，生产端在
+ * 镜像推送链上，不需要认识这条请求。
+ *
+ * 为什么用总线而不是自己轮着算一遍：这里的等待必须是**事件驱动**的，自己定时重算就成了
+ * 换了个地方的轮询，而这条接口存在的全部理由就是让手机不必轮询。
+ */
+function waitForChange(timeoutMs, res) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let releaseList = () => {};
+    let releaseSession = () => {};
+    const timer = setTimeout(() => finish(), timeoutMs);
+    function finish() {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      releaseList();
+      releaseSession();
+      resolve();
+    }
+    releaseList = listSignal.onBump(finish);
+    releaseSession = sessionSignal.onBump(finish);
+    // 手机切网 / 进程被杀时连接会断，没必要再替它挂满整个窗口。
+    if (res && typeof res.once === 'function') res.once('close', finish);
+  });
+}
 
+/** 算一次监控视图，把「宿主出错 / 形状异常」也收成一个可下发的响应。 */
+async function buildMonitorView(ctx, deviceKey) {
   let built;
   try {
     built = await buildMonitorState(ctx, deviceKey);
   } catch (error) {
-    return sendJson(res, 500, {
-      ok: false,
-      error: { code: 'monitor-failed', message: (error && error.message) || '监控视图构建失败' },
-    });
+    return {
+      status: 500,
+      body: { ok: false, error: { code: 'monitor-failed', message: (error && error.message) || '监控视图构建失败' } },
+    };
   }
-  if (built.error) return sendJson(res, 400, { ok: false, error: built.error });
+  if (built.error) return { status: 400, body: { ok: false, error: built.error } };
   if (built.degraded) {
     // 与 /sessions 同一个码：中转见到 5xx 会退回上一份好副本，手机那侧因此是「没收到新东西」
     // 而不是「一台会话都没有」。
-    return sendJson(res, 500, {
-      ok: false,
-      error: { code: 'host-session-list-degraded', message: '宿主会话列表形状异常：响应里没有 items 数组' },
-    });
+    return {
+      status: 500,
+      body: { ok: false, error: { code: 'host-session-list-degraded', message: '宿主会话列表形状异常：响应里没有 items 数组' } },
+    };
+  }
+  return { status: 200, body: { ok: true, generatedAt: Date.now(), revision: built.revision, items: built.items } };
+}
+
+/**
+ * GET /api/mobile/v1/monitor?rev=…[&wait=秒]（token）
+ *
+ * `wait` 是实时那条路：带上它，且状态位与 `rev` 一字不差时，这次请求**先不回**，
+ * 挂到有变化（或挂满）才回。安卓那条前台服务在后台就挂着它，于是「一轮跑完」到
+ * 「手机响」只差一次本地网络往返，不再等下一拍轮询。
+ *
+ * 只挂一次：醒来之后不管变没变都如实回（变没变由 revision 说了算），由手机自己决定
+ * 要不要再挂。这样这里没有循环、没有重试，断线也不会在宿主侧留下一个转不停的请求。
+ */
+async function handleMonitor(ctx, req, res) {
+  const deviceKey = canonicalDeviceKey(req);
+  const url = new URL(req.url, 'http://x');
+  const rev = (url.searchParams.get('rev') || '').trim();
+  const waitSeconds = Number(url.searchParams.get('wait') || 0) || 0;
+  // 没有 rev 就不挂：那不是「确认一下有没有变」，而是「给我一份完整状态」，立刻回。
+  const waitMs = rev ? Math.max(0, Math.min(WAIT_MAX_MS, Math.round(waitSeconds * 1000))) : 0;
+
+  const first = await buildMonitorView(ctx, deviceKey);
+  if (first.status !== 200) {
+    return sendJson(res, first.status, first.body);
   }
+  const unchanged = unchangedListBody(first.body, rev);
+  if (!unchanged) return sendJson(res, 200, first.body);
+  if (waitMs <= 0) return sendJson(res, 200, unchanged);
 
-  const body = { ok: true, generatedAt: Date.now(), revision: built.revision, items: built.items };
-  sendJson(res, 200, unchangedListBody(body, rev) || body);
+  // 头必须在挂起**之前**发出去。走中转那条路上，「等响应头」只有 7 秒
+  // （lib/relay/tunnel.js 的 UPSTREAM_HEADER_TIMEOUT_MS），不先发头，这次挂起会被
+  // 当成死请求掐掉，手机收到的是一次网络错误而不是一次「没变化」。发完头再等，
+  // 中转那边看的是「响应空转 30 秒」，20 秒的挂起正好在它之内。
+  res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', vary: 'accept-encoding' });
+  if (typeof res.flushHeaders === 'function') res.flushHeaders();
+  await waitForChange(waitMs, res);
+  // 手机在这段时间里断了（切网 / 进程被杀）：别为一个没人收的响应再算一遍。
+  if (res.destroyed || res.writableEnded) return;
+  const again = await buildMonitorView(ctx, deviceKey);
+  const body = again.status === 200 ? (unchangedListBody(again.body, rev) || again.body) : again.body;
+  // 头已经出去了，不能再走 sendJson（它会再写一次头）：这里只补正文。
+  try { res.end(JSON.stringify(body)); } catch { /* 连接已断开 */ }
 }
 
 module.exports = { handleMonitor, buildMonitorState, monitorItem };

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

@@ -14,6 +14,13 @@
  */
 
 const { lastTurnFactsOf } = require('./session-cache.js');
+const readReceipts = require('../read-receipt.cjs');
+
+/**
+ * 本进程的起点：只有它**之前**留下的已读水位才需要从盘上补回来（见 `lastTurnOf`）。
+ * 本进程内的读一律由 `recordSessionRead` 当场写进内存那张表，不必再查盘。
+ */
+const PROCESS_STARTED_AT = Date.now();
 
 /**
  * 一轮的结局：纯计算，不碰水位、不碰设备。
@@ -86,6 +93,9 @@ function recordSessionRead(ctx, sessionId, at = Date.now()) {
   const facts = lastTurnFactsOf(ctx);
   const previous = facts.get(sessionId) || {};
   const current = typeof previous.readAt === 'number' ? previous.readAt : 0;
+  // 同时落一份到盘上（lib/read-receipt.cjs）：内存这张表随进程消失，而 App 侧栏的绿点
+  // 靠的正是这里的水位 —— 桌面读过之后宿主一重启，同一轮又被算成未读（2026-10-26 真机）。
+  try { readReceipts.recordRead(sessionId, value); } catch { /* 台账是旁路 */ }
   if (current >= value) return false;
   facts.set(sessionId, { ...previous, readAt: value });
   return true;
@@ -96,11 +106,21 @@ function recordSessionRead(ctx, sessionId, at = Date.now()) {
  *
  * 只回带 `turn` 的那些：表里也可能只存着一个已读水位（读过、但插件重启后还没折过
  * 那一轮的结局），那不是「上一轮发生了什么」，不该下发给 App。
+ *
+ * 进程刚起来时那张表是空的，「桌面读过」只留在盘上那本台账里 —— 不补回来的话 App 会按
+ * 「没人读过」重算，早就读过的一轮又亮成绿点。只补上一次进程留下的那些（本进程里的读
+ * 已经在表里了），补到的值写回表里，让后面的折叠沿用。
  */
 function lastTurnOf(ctx, sessionId) {
-  const fact = lastTurnFactsOf(ctx).get(sessionId);
+  const facts = lastTurnFactsOf(ctx);
+  const fact = facts.get(sessionId);
   if (!fact || typeof fact.turn !== 'number') return undefined;
-  return fact;
+  const restored = readReceipts.readAtOf(sessionId);
+  const current = typeof fact.readAt === 'number' ? fact.readAt : 0;
+  if (!(restored > 0 && restored < PROCESS_STARTED_AT) || current >= restored) return fact;
+  const next = { ...fact, readAt: restored };
+  facts.set(sessionId, next);
+  return next;
 }
 
 module.exports = { settleOutcome, recordLastTurn, recordSessionRead, lastTurnOf };

package/lib/mobile/session-send.js

@@ -24,7 +24,6 @@ const {
 const { promptErrorObject, MODEL_UNAVAILABLE_ERROR } = require('./history-derive.js');
 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');
 
 /**
@@ -215,17 +214,11 @@ async function handleSessionRead(ctx, req, res, fallbackDeviceKey = 'legacy') {
   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);
-  // 桌面端的未读绿点不在宿主里（它在浏览器渲染进程的内存里），这里只记一条水位，
-  // 由插件的客户端半边拉走、在桌面页面里就地清掉。写盘失败不该让「已读」这个动作失败。
-  try {
-    readReceipt.recordRead(body.sessionId);
-  } catch {
-    // 回执台账只是尽力而为的旁路，读不到/写不动都不影响本次已读本身。
-  }
   sendJson(res, 200, { ok: true, accepted: true });
 }