dsh-mobile-plugin 0.1.100 → 0.2.0

package/lib/mobile/session-cache.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * 会话侧的按 ctx 隔离状态：十一张表，一个入口。
+ * 会话侧的按 ctx 隔离状态：十三张表，一个入口。
  *
  * 这些表此前全是 sessions.js 的模块级 WeakMap。它们之所以必须按 ctx 隔离，是因为
  * 它们的值属于**宿主进程状态**（某个会话正在跑、某个列表刚构建完、某条发送已经
@@ -42,6 +42,10 @@ const sendIdempotency = new WeakMap();
 // 与 sendIdempotency 分开是因为键与生命周期不同（那边按 sessionId+clientMessageId，60s）。
 const writeIdempotency = new WeakMap();
 
+// 工作区列表的条件刷新短路：上次构建留下的 revision / 生成时刻 / 当时的信号代号。
+// 与 sessionListResponseCache 同一类东西（列表刚构建完的那份是谁），只是按工作区算。
+const workspaceShortcutStates = new WeakMap();
+
 /** 设备维度：同一个 ctx 下多台手机各自一份，缺省用 'legacy'（未带 x-dsh-device 的调用）。 */
 function canonicalDeviceKey(req, fallback = 'legacy') {
   const value = req?.headers?.['x-dsh-device'];
@@ -224,6 +228,19 @@ function clearCompletionForAllDevices(ctx, sessionId, at = Date.now()) {
   return cleared;
 }
 
+/**
+ * 工作区列表短路的记忆体：客户端 rev、上次生成时刻、当时的信号 revision、上次构建时刻。
+ * 与其它表同样按 ctx 隔离 —— 不同宿主的工作区快照互不相干。
+ */
+function workspaceShortcutStateOf(ctx) {
+  let state = workspaceShortcutStates.get(ctx);
+  if (!state) {
+    state = { lastRevision: '', lastGeneratedAt: 0, lastSignalRevision: '', lastBuiltAt: 0 };
+    workspaceShortcutStates.set(ctx, state);
+  }
+  return state;
+}
+
 function completionGenerationOf(ctx, deviceKey) {
   let generations = completionGenerations.get(ctx);
   if (!generations) {
@@ -336,6 +353,7 @@ module.exports = {
   markCompletionRead,
   clearCompletionForAllDevices,
   completionGenerationOf,
+  workspaceShortcutStateOf,
   bumpCompletionGeneration,
   sendIdempotencyStateOf,
   writeIdempotencyStateOf,

package/lib/mobile/session-file.js

@@ -171,12 +171,33 @@ async function handleSessionFile(ctx, req, res) {
   }
 
   const name = path.basename(target);
-  res.writeHead(200, {
+  const header = {
     'content-type': mediaTypeOf(target),
-    'content-length': String(info.size),
     'content-disposition': dispositionOf(name),
     'cache-control': 'no-store',
-  });
+  };
+
+  // 协议 v2：分块信封（§8.3(6)）。
+  //
+  // 套一次性 AEAD 意味着宿主得先把整份读进内存 —— 单文件上限 512MB，那条路不能走。
+  // 所以改成固定分块流式写：宿主仍然边读边发，内存占用还是一块的大小；App 那边今天本来
+  // 就是整份读进 arrayBuffer（上限 200MB），按长度字段切块、逐块解即可，不需要流式解密栈。
+  const opened = req && req.__dshE2ee;
+  if (opened && opened.keys && opened.req) {
+    res.writeHead(200, {
+      ...header,
+      'content-type': 'application/x-dsh-e2ee-chunks',
+      // 这份字节不是原文，`content-length` 得等写完才知道，改用 chunked。
+      'transfer-encoding': 'chunked',
+      'x-dsh-proto': '2',
+      // 真实类型单独给：App 解密之后要拿它决定怎么预览。
+      'x-dsh-content-type': header['content-type'],
+    });
+    await writeEncryptedFile(req, res, target, opened);
+    return;
+  }
+
+  res.writeHead(200, { ...header, 'content-length': String(info.size) });
   if (info.size === 0) return res.end();
 
   const stream = fs.createReadStream(target);
@@ -189,4 +210,57 @@ async function handleSessionFile(ctx, req, res) {
   }
 }
 
-module.exports = { handleSessionFile, SESSION_FILE_MAX_BYTES };
+/**
+ * 按块加密写出去（§8.3(6)）。
+ *
+ * 每块形状：`[4 字节大端长度][12 字节 nonce][密文 + 16 字节 tag]`，长度字段写的是
+ * **「密文 + tag」的长度**（不含 nonce 与长度字段本身）。块大小 64KB，最后一块可以更短。
+ *
+ * AAD 绑这条请求的路径、请求 nonce 与块序号 —— 块序号让中转不能把别的文件（或这一份的
+ * 别的块）的字节搬进来，也不能重排或截断而让 App 察觉不到。
+ */
+async function writeEncryptedFile(req, res, target, opened) {
+  const e2ee = require('../shared/e2ee');
+  const path0 = e2ee.signedPath(req);
+  const requestNonce = opened.req.nonce;
+  let seq = 0;
+  let pending = Buffer.alloc(0);
+  let closed = false;
+  res.on('close', () => { closed = true; });
+  const stream = fs.createReadStream(target, { highWaterMark: FILE_CHUNK_BYTES });
+  try {
+    for await (const chunk of stream) {
+      if (closed) break;
+      pending = pending.length ? Buffer.concat([pending, chunk]) : chunk;
+      while (pending.length >= FILE_CHUNK_BYTES) {
+        const block = pending.subarray(0, FILE_CHUNK_BYTES);
+        pending = pending.subarray(FILE_CHUNK_BYTES);
+        seq += 1;
+        writeBlock(res, e2ee, opened.keys.down, block, e2ee.fileAad(path0, requestNonce, seq));
+      }
+    }
+    // 尾块（可能不足一块）；空文件也给一块，否则 App 拿不到「这是个空文件」的确认。
+    if (!closed) {
+      seq += 1;
+      writeBlock(res, e2ee, opened.keys.down, pending, e2ee.fileAad(path0, requestNonce, seq));
+    }
+    if (!closed) res.end();
+  } catch {
+    try { res.destroy(); } catch { /* 连接已关闭 */ }
+  }
+}
+
+/** 写一块：`[4 字节长度][nonce][密文+tag]`，长度写的是后两段之外的密文长度。 */
+function writeBlock(res, e2ee, key, block, aad) {
+  const sealed = e2ee.seal(key, block, aad);
+  const buf = Buffer.from(sealed);
+  const cipherLen = buf.length - e2ee.NONCE_BYTES;
+  const head = Buffer.alloc(4);
+  head.writeUInt32BE(cipherLen, 0);
+  res.write(Buffer.concat([head, buf]));
+}
+
+/** 交付文件的分块大小。64KB：一块一次 AEAD，太小会让每块的 16+12 字节固定开销占比变高。 */
+const FILE_CHUNK_BYTES = 64 * 1024;
+
+module.exports = { handleSessionFile, SESSION_FILE_MAX_BYTES, FILE_CHUNK_BYTES, writeEncryptedFile };

package/lib/mobile/session-list-shortcut.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * `GET /sessions?rev=` 的条件刷新：上一次构建留下的「这份清单是谁」。
+ *
+ * 只服务短路判断，不拿它当数据源 —— `cache.value` 那条路仍然按原来的规则走。四样
+ * 一起对：客户端手上的 revision、这台设备的完成态代号、清单变更信号、上次构建时刻。
+ * 单拎出来是因为 sessions.js 只剩列表 handler 的骨架，这类「记东西 / 对东西」的纯
+ * 逻辑摆在 handler 中间会让状态和流程混在一起。
+ *
+ * 5 分钟上限只是兜底：`listSignal.watching()` 为假时根本不走短路，正常路径上信号
+ * 一涨就会被判失效，用不到这个上限。
+ */
+
+const { listSignal } = require('../shared/list-signal.js');
+
+const LIST_SHORTCUT_MAX_AGE_MS = 5 * 60 * 1000;
+
+/** 命中就回一份 `unchanged` 身体，否则 null（交回原路重建）。 */
+function listShortcut(cache, rev, generation) {
+  if (!rev || typeof cache.lastRevision !== 'string' || cache.lastRevision !== rev) return null;
+  if (cache.lastGeneration !== generation) return null;
+  if (cache.lastSignalRevision !== listSignal.snapshot().revision) return null;
+  if (!(Date.now() - (cache.lastBuiltAt || 0) <= LIST_SHORTCUT_MAX_AGE_MS)) return null;
+  return { ok: true, revision: rev, generatedAt: cache.lastGeneratedAt };
+}
+
+/** 构建成功之后记下这一份：revision、生成时刻、当时的信号与完成态代号。 */
+function rememberListBuild(cache, body, generation) {
+  if (!body || typeof body.revision !== 'string' || !body.revision) return;
+  cache.lastRevision = body.revision;
+  cache.lastGeneratedAt = body.generatedAt;
+  cache.lastGeneration = generation;
+  cache.lastSignalRevision = listSignal.snapshot().revision;
+  cache.lastBuiltAt = Date.now();
+}
+
+module.exports = { listShortcut, rememberListBuild };

package/lib/mobile/session-model-options.js

@@ -50,6 +50,8 @@ const OPTION_SOURCES = [
 
 const MAX_ROWS = 12;
 const MAX_CHOICES = 32;
+/** 选项说明和模型描述一样，选择器里只画一行；正文没必要按 4KB 下发。 */
+const MAX_CHOICE_DESCRIPTION = 200;
 
 function sourceFor(provider) {
   return OPTION_SOURCES.find((source) => source.provider === provider);
@@ -124,7 +126,7 @@ function safeModelOptions(value) {
         .map((choice) => ({
           id: choice.id.slice(0, 256),
           name: choice.name.slice(0, 512),
-          ...(typeof choice.description === 'string' ? { description: choice.description.slice(0, 4096) } : {}),
+          ...(typeof choice.description === 'string' ? { description: choice.description.slice(0, MAX_CHOICE_DESCRIPTION) } : {}),
         })),
     }));
 }

package/lib/mobile/session-models.js

@@ -22,6 +22,18 @@ function modelText(value, max) {
   return typeof value === 'string' ? value.slice(0, max) : '';
 }
 
+/**
+ * 模型 / 推理档位描述的下发上限。
+ *
+ * 选择器里这两处都是 `numberOfLines={1}`，按屏宽也就显示二三十个字；宿主那边的描述
+ * 却有写到几千字的（能力说明、价格表都有）。整份目录每次启动、每次进对话都会传一遍，
+ * 留着 8KB 的上限等于给每个模型背一段永远读不到的正文。
+ */
+const MODEL_DESCRIPTION_MAX = 200;
+const EFFORT_DESCRIPTION_MAX = 200;
+/** 失败原因只在诊断里看，同样不需要整篇。 */
+const MODEL_FAILURE_MESSAGE_MAX = 512;
+
 function safeModelsValue(value) {
   if (!value || typeof value !== 'object') return {};
   const result = {};
@@ -63,7 +75,7 @@ function safeModelsValue(value) {
           .map((model) => ({
             id: modelText(model.id, 512),
             name: modelText(model.name, 512),
-            ...(typeof model.description === 'string' ? { description: model.description.slice(0, 8192) } : {}),
+            ...(typeof model.description === 'string' ? { description: model.description.slice(0, MODEL_DESCRIPTION_MAX) } : {}),
             ...(model.reasoning && typeof model.reasoning === 'object' && Array.isArray(model.reasoning.efforts)
               ? { reasoning: {
                 efforts: model.reasoning.efforts
@@ -72,7 +84,7 @@ function safeModelsValue(value) {
                   .map((effort) => ({
                     id: modelText(effort.id, 256),
                     name: modelText(effort.name, 512),
-                    ...(typeof effort.description === 'string' ? { description: effort.description.slice(0, 4096) } : {}),
+                    ...(typeof effort.description === 'string' ? { description: effort.description.slice(0, EFFORT_DESCRIPTION_MAX) } : {}),
                   })),
                 ...(typeof model.reasoning.defaultEffort === 'string' ? { defaultEffort: modelText(model.reasoning.defaultEffort, 256) } : {}),
               } }
@@ -89,7 +101,7 @@ function safeModelsValue(value) {
   if (Array.isArray(value.failures)) result.failures = value.failures.slice(0, 64).map((failure) => ({
     ...(typeof failure?.id === 'string' ? { id: modelText(failure.id, 256) } : {}),
     ...(typeof failure?.name === 'string' ? { name: modelText(failure.name, 512) } : {}),
-    ...(typeof failure?.message === 'string' ? { message: modelText(failure.message, 8192) } : {}),
+    ...(typeof failure?.message === 'string' ? { message: modelText(failure.message, MODEL_FAILURE_MESSAGE_MAX) } : {}),
   }));
   if (Number.isSafeInteger(value.revision)) result.revision = value.revision;
   return result;

package/lib/mobile/session-send.js

@@ -13,6 +13,7 @@
  */
 
 const { sendJson, readJsonBody } = require('../shared/http-util');
+const { inlineUploadedImageBlocks } = require('./uploads.js');
 const { unwrap } = require('./envelope.js');
 const { callSessions, mobilePromptRpcId } = require('./rpc.js');
 const {
@@ -25,7 +26,13 @@ const { invoke, UNAVAILABLE: GATEWAY_UNAVAILABLE } = require('./host-bridge/tran
 const readReceipt = require('../read-receipt.cjs');
 const { recordSessionRead } = require('./session-last-turn.js');
 
-const SEND_MAX_BODY = 8 * 1024 * 1024; // /send 请求体上限（图片 base64）
+/**
+ * `/send` 的请求体上限（**明文**字节，图片 base64）。
+ *
+ * 原来是 8MB。协议 v2 的信封让线上变成 4/3，按线上长度直接卡等于砍掉四分之一额度，
+ * 所以按 §8.3(9) 抬到 10.7MB；线上那一侧另有 `MAX_SEALED_BODY` 兜着。
+ */
+const SEND_MAX_BODY = Math.ceil(8 * 1024 * 1024 * 4 / 3);
 
 /** 仅当 content 恰好为一个文本块时返回其文本，否则 null（带图片/多块不回退命令路径）。 */
 function singleTextOf(content) {
@@ -130,13 +137,24 @@ async function handleSend(ctx, req, res) {
         return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: 'text 块内容为空' } });
       }
     } else if (block.type === 'image') {
-      if (!IMAGE_TYPES.has(block.mediaType) || typeof block.data !== 'string' || !block.data) {
-        return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: 'image 块需合法 mediaType 与 base64 data' } });
+      // 两种形状都认：老客户端的 `data`（内联 base64），新客户端的 `uploadId`
+      // （先走分片上传，再由宿主自己读盘）。后者是为了绕开 `session/send` 那 8 秒预算 ——
+      // 4MB 照片内联上传线上接近 7MB，弱网必超时。
+      const inline = typeof block.data === 'string' && block.data.length > 0;
+      const uploaded = typeof block.uploadId === 'string' && block.uploadId.length > 0;
+      if (!IMAGE_TYPES.has(block.mediaType) || (!inline && !uploaded)) {
+        return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: 'image 块需合法 mediaType 与 base64 data 或 uploadId' } });
       }
     } else {
       return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: `不支持的 content 块类型: ${block.type}` } });
     }
   }
+  // ── uploadId → 内联字节（实现在 uploads.js：字节本来就是那边落的盘）──
+  const uploadExpired = await inlineUploadedImageBlocks(content);
+  if (uploadExpired) {
+    return sendJson(res, 400, { ok: false, error: { code: 'upload-not-found', message: uploadExpired } });
+  }
+
   // ── Slash 命令派发 ─────────────────────────────────────────────
   // 已知命令：注册表执行（command/run + command/done 随事件流回传），响应标注 handledAs 供
   // 客户端跳过「乐观 pending 气泡 + running 态」；未知命令/语法不符（execute 返回 undefined）

package/lib/mobile/session-snapshot.js

@@ -15,9 +15,10 @@
 const { sendJson } = require('../shared/http-util');
 const { unwrap } = require('./envelope.js');
 const { callSessions } = require('./rpc.js');
-const { deriveMessages, buildToolResultMap } = require('./history-derive.js');
+const { deriveMessages, thinEntryMessages, toolResultPatchesFor } = require('./history-derive.js');
 const { resolveEventAttachments } = require('./attachments.js');
 const { createTextImageBudget } = require('./local-images.js');
+const { entryWindowPayload } = require('./entry-window.js');
 
 const MESSAGES_DEFAULT_LIMIT = 50;  // /messages 默认条数
 
@@ -140,6 +141,9 @@ async function handleMessages(ctx, req, res) {
   // 上游历史接口都不支持 afterSeq（只认 beforeSeq/maxMessages），故在插件内用较大的窗口
   // 拉最近若干事件后再过滤 seq > afterSeq，覆盖常见轮询缺口；缺口超过窗口时要求客户端全量补齐。
   if (afterSeq !== null) payload.maxMessages = Math.max(limit, 200);
+  // 入口那一发（不带游标）可以要求按内容裁：宿主按轮取整，过程块见 thinEntryMessages。
+  const wantThin = url.searchParams.get('thin') === '1' && beforeSeq === null && afterSeq === null;
+  if (wantThin) entryWindowPayload(payload, limit);
 
   let value;
   let error;
@@ -165,17 +169,14 @@ async function handleMessages(ctx, req, res) {
   const budget = createTextImageBudget();
   const resolvedEvents = await Promise.all(filtered.map((entry) => resolveEventAttachments(ctx, sessionId, entry.event || entry, { budget, referencesOnly: true }).then((event) => entry.event ? { ...entry, event } : event)));
   const messages = deriveMessages(resolvedEvents);
+  const hasMore = !!(value && value.hasMore);
+  const items = wantThin ? thinEntryMessages(messages, { hasMore }) : messages;
   // 工具结果不产生消息行，但会把**缓存里已有的**工具卡从 running 补成最终态。补丁必须
   // 取自整个窗口（不只是 seq > afterSeq 的那一段）：调用方游标可能已经越过结果 seq，
-  // 而工具卡还停在 running；把窗口内所有落定结果都回传，客户端按 callId 幂等打补丁。
-  const toolResults = [...buildToolResultMap(events).entries()].map(([callId, result]) => ({
-    callId,
-    state: result.isError ? (result.code === 'interrupted' ? 'stopped' : 'error') : 'ok',
-    ...(result.output ? { output: result.output } : {}),
-    ...(result.images && result.images.length ? { images: result.images } : {}),
-    ...(result.diffs && result.diffs.length ? { diffs: result.diffs } : {}),
-  }));
-  const hasMore = !!(value && value.hasMore);
+  // 而工具卡还停在 running；客户端按 callId 幂等打补丁。已经随消息块下发的那些只回状态，
+  // 不重复带正文（规则与理由见 history-derive 的 toolResultPatchesFor）。
+  // 入口裁剪那一发不带补丁：过程块已摘掉、补丁无处可打，跟着走等于把工具输出又塞回顶层。
+  const toolResults = wantThin ? [] : toolResultPatchesFor(events, items);
   const seqs = events.map(eventSeqOf).filter((seq) => Number.isSafeInteger(seq) && seq >= 0);
   const oldestSeq = seqs.length ? Math.min(...seqs) : null;
   // A truncated history window is not a complete incremental answer. Keep the
@@ -186,7 +187,7 @@ async function handleMessages(ctx, req, res) {
     : (seqs.length ? Math.max(...seqs) : 0);
   sendJson(res, 200, {
     ok: true,
-    items: messages,
+    items,
     hasMore,
     lastSeq,
     ...(oldestSeq !== null ? { oldestSeq } : {}),

package/lib/mobile/sessions.js

@@ -21,6 +21,7 @@
  *   session-goal.js    目标条动作
  *   session-presets.js Agent 预设目录
  *   session-preview.js 列表行的 lastMessage 预览（按会话指纹复用 + 运行中会话的节流）
+ *   session-list-shortcut.js `?rev=` 条件刷新记住的那份清单是谁
  *
  * 剩下的就是列表：GET /sessions（10 秒缓存 + fresh 绕过 + 完成态确认 + `?rev=` 条件刷新）、
  * GET /session（单会话摘要）、GET /session/head（正文水位探针）、GET /session/stats、
@@ -31,8 +32,10 @@
 const { sendJson, readJsonBody } = require('../shared/http-util');
 const { isFreshRequest } = require('../shared/fresh-request');
 const { listRevision, unchangedListBody } = require('../shared/list-revision.js');
+const { listSignal: sharedListSignal } = require('../shared/list-signal.js');
 // 正文水位信号：session/head 探针直接读它的快照，**不**为了「看起来有值」去现读历史。
 const { sessionSignal } = require('../shared/session-signal.js');
+const { listShortcut, rememberListBuild } = require('./session-list-shortcut.js');
 const { withIdempotency, requestIdOf } = require('./idempotency.js');
 const { listTitle, deriveMessages, lastMessageOf, promptErrorObject, MODEL_UNAVAILABLE_ERROR } = require('./history-derive.js');
 const { unwrap } = require('./envelope.js');
@@ -131,6 +134,21 @@ async function handleSessions(ctx, req, res) {
     return sendJson(res, status, unchanged || body);
   };
 
+  // ── 构建前短路（`rev` 命中且清单确实没变）──
+  //
+  // 手机 15 秒问一次，而「构建这份列表」要几百毫秒（读宿主列表 + 折预览 + 算 revision）。
+  // 大多数轮次清单根本没变，答案就是几十字节的 `unchanged` —— 那就没必要先把它建出来。
+  // 判据三样一起看，缺一不可：
+  //   ① 客户端手上的 revision 与上次构建出来的完全相同；
+  //   ② 清单变更信号没有涨过（镜像推送调度器每 500ms 比一次内容哈希，见 list-signal）；
+  //   ③ 这台设备的完成态代号没变（completed / 失败态按设备算，信号里看不出来）。
+  // 只在**真有观众**（设备级 SSE 或轮询订阅着）时才信任信号：没有观众时推送调度器会
+  // 停止空转构建，信号不再前进，那时宁可老实重建。
+  if (!bypassCache && rev && sharedListSignal.watching()) {
+    const short = listShortcut(cache, rev, generation);
+    if (short) return respond(200, short);
+  }
+
   if (!bypassCache && cache.value && now - cache.updatedAt < SESSION_LIST_CACHE_MS) {
     return respond(200, cache.value);
   }
@@ -160,6 +178,7 @@ async function handleSessions(ctx, req, res) {
         cache.updatedAt = Date.now();
       }
     }
+    if (response.status === 200) rememberListBuild(cache, response.body, completionGenerationOf(ctx, deviceKey));
     return respond(response.status, response.body);
   } finally {
     if (cache.promise === promise) cache.promise = null;
@@ -425,6 +444,7 @@ async function handleQueueUpdate(ctx, req, res) {
 
 // 下面这一组从各子模块转出：它们此前全是 sessions.js 的实现，而 sessions.js 是
 // mobile/ 下被引用最多的模块（其它 handler 与测试都从这里取）。换实现不改路径。
+
 module.exports = {
   // 本文件自己的
   buildSessionsResponse,

package/lib/mobile/stats-collect.cjs

@@ -36,6 +36,17 @@ const COLLECT_INTERVAL_MS = 60_000;
 /** 并发读投影的条数：宿主那侧是内存里读缓存，四条并行不会把它压住。 */
 const CONCURRENCY = 4;
 
+/**
+ * 这一轮先扫「最近还在动」的会话，再按「最久没采过」补老账。
+ *
+ * 之前每一轮都只按最后活动时间倒序扫、1.5 秒到点就停，于是最老的那批永远排在队尾、
+ * 永远采不到（实测七十多条会话从没进过账本，其中大多是子代理）。现在把队列分成两段：
+ * 近 7 天有动作的照旧优先（它们才是数字在变的那批），其余的按 `collectedAt` 升序 ——
+ * 采过的会顺手把时间推到当下、自动排到队尾，于是每一轮的预算都接着上一轮的地方往下走，
+ * 不需要额外持久化一个游标。
+ */
+const RECENT_WINDOW_MS = 7 * 86400_000;
+
 /**
  * 一次采集的时间预算。
  *
@@ -134,6 +145,25 @@ function hasDelta(usage) {
   return Object.values(usage).some((value) => value > 0);
 }
 
+/**
+ * 采集串行化：同一时刻只跑一轮。
+ *
+ * 水位法在**两个请求同时进来**时会重复记账（先把同一份增量各记一遍，之后水位才对上，
+ * 多出来的量就永久留在按天账上）—— 打开统计页又立刻下拉刷新、或者清理已归档和打开页面
+ * 撞在一起，都能走到这条路上。串行而不是合并：清理前那次定向补采要的是它自己那几条，
+ * 直接复用统计页那一轮等于那几条根本没采。
+ */
+let tail = Promise.resolve();
+
+function collectStats(ctx, options = {}) {
+  const run = tail.then(
+    () => collectOnce(ctx, options),
+    () => collectOnce(ctx, options),
+  );
+  tail = run.then(() => undefined, () => undefined);
+  return run;
+}
+
 /**
  * 采一轮。
  *
@@ -141,7 +171,7 @@ function hasDelta(usage) {
  * `force` 跳过 60 秒的最小间隔（用户手动刷新时要真读一次）；
  * `skipPreview` 不读「最后一句」摘要（清理前补采用，见文件头）。
  */
-async function collectStats(ctx, options = {}) {
+async function collectOnce(ctx, options = {}) {
   const now = Date.now();
   const budgetMs = Number.isFinite(options.budgetMs) && options.budgetMs > 0 ? options.budgetMs : DEFAULT_BUDGET_MS;
   const deadline = now + budgetMs;
@@ -161,10 +191,20 @@ async function collectStats(ctx, options = {}) {
     }
   }
 
-  // 最近有动作的排前面：预算不够采完全部时，先把用户真正在用的那几条账补上。
+  // 队列分两段：近 7 天有动作的优先（数字在变的就是它们），其余的按「最久没采过」排 ——
+  // 采完一轮会把 `collectedAt` 推到当下，自动沉到队尾，于是预算每次都接着上一轮往下走。
+  const recentSince = now - RECENT_WINDOW_MS;
   const targets = items
     .filter((item) => !wanted || wanted.has(item.sessionId))
-    .sort((a, b) => num(b.updatedAt) - num(a.updatedAt));
+    .sort((a, b) => {
+      const recentA = num(a.updatedAt) >= recentSince;
+      const recentB = num(b.updatedAt) >= recentSince;
+      if (recentA !== recentB) return recentA ? -1 : 1;
+      if (recentA) return num(b.updatedAt) - num(a.updatedAt);
+      const collectedA = book.sessions[a.sessionId] ? num(book.sessions[a.sessionId].collectedAt) : 0;
+      const collectedB = book.sessions[b.sessionId] ? num(book.sessions[b.sessionId].collectedAt) : 0;
+      return collectedA - collectedB;
+    });
   let cursor = 0;
 
   const worker = async () => {
@@ -228,15 +268,18 @@ async function collectStats(ctx, options = {}) {
         saved.watermark = host;
         saved.collectedAt = now;
         saved.gone = false;
-      }
-
-      const breakdown = projections.contextBreakdown;
-      if (breakdown && typeof breakdown === 'object') {
-        book.composition = {
-          systemTokens: num(breakdown.systemTokens),
-          toolsTokens: num(breakdown.toolsTokens),
-          messageTokens: num(breakdown.messageTokens),
-        };
+        // 上下文构成是**这条会话**的快照：跟着记录走，页面才能说清「这是哪条会话的构成」。
+        // 以前全局只留一份、每轮被最后读完的那条覆盖（四条并发，谁后回是谁），
+        // 于是卡片上的构成跟用户此刻在用的那条毫无关系。
+        const breakdown = projections.contextBreakdown;
+        if (breakdown && typeof breakdown === 'object') {
+          saved.composition = {
+            systemTokens: num(breakdown.systemTokens),
+            toolsTokens: num(breakdown.toolsTokens),
+            messageTokens: num(breakdown.messageTokens),
+            at: now,
+          };
+        }
       }
     }
   };