dsh-mobile-plugin 0.1.100 → 0.2.1

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,
+          };
+        }
       }
     }
   };

package/lib/mobile/stats-ledger.cjs

@@ -42,6 +42,15 @@ const MAX_RETIRED = 2000;
 /** 按天的账保留天数（约三年；一天一百多字节，超出的从最老的开始裁）。 */
 const MAX_DAYS = 1100;
 
+/**
+ * 每条会话自己那份「按天用量」保留多少天。
+ *
+ * 它存在只为回答「这张卡片在这个范围里用了多少」：页面的三档范围最大 30 天，
+ * 再留一倍余量足够；更老的日期按天的总账仍然还在，只是卡片不再按那条会话拆得开。
+ * 不封顶的话，两百条会话 × 三年就是一份几十 MB 的 JSON，每次采集都要整份读写。
+ */
+const MAX_DAILY_DAYS = 62;
+
 /**
  * 热力图最多给多少天（52 周）。
  *
@@ -125,6 +134,18 @@ function sanitizeUsage(source) {
   return usage;
 }
 
+/** 上下文构成快照：三条都缺或全 0 就当没有（别在卡片上画一个 0 的环）。 */
+function readComposition(source) {
+  if (!source || typeof source !== 'object') return null;
+  const composition = {
+    systemTokens: num(source.systemTokens),
+    toolsTokens: num(source.toolsTokens),
+    messageTokens: num(source.messageTokens),
+  };
+  if (composition.systemTokens + composition.toolsTokens + composition.messageTokens <= 0) return null;
+  return { ...composition, at: num(source.at) };
+}
+
 function sanitizeLedger(raw) {
   if (!raw || typeof raw !== 'object') return emptyLedger();
   if (raw.version !== VERSION) return emptyLedger();
@@ -141,6 +162,19 @@ function sanitizeLedger(raw) {
   if (raw.sessions && typeof raw.sessions === 'object') {
     for (const [sessionId, value] of Object.entries(raw.sessions)) {
       if (!sessionId || !value || typeof value !== 'object') continue;
+      const daily = {};
+      if (value.daily && typeof value.daily === 'object') {
+        for (const [day, usageOfDay] of Object.entries(value.daily)) {
+          if (!/^\d{4}-\d{2}-\d{2}$/.test(day) || !usageOfDay || typeof usageOfDay !== 'object') continue;
+          daily[day] = sanitizeUsage(usageOfDay);
+        }
+      }
+      const billed = sanitizeUsage(value.billed);
+      // 老账本（2026-10-24 之前）没有每条会话的按天用量：把它的历史量记在它最后一次
+      // 活动那天。这跟「首采回填」是同一条近似，也是一次性回填 —— 之后就只记增量。
+      if (Object.keys(daily).length === 0 && billedOf(billed) > 0) {
+        daily[dayKeyOf(num(value.lastAt) || Date.now())] = { ...billed };
+      }
       ledger.sessions[sessionId] = {
         title: typeof value.title === 'string' ? value.title : '',
         workspaceName: typeof value.workspaceName === 'string' ? value.workspaceName : '',
@@ -152,7 +186,11 @@ function sanitizeLedger(raw) {
         gone: value.gone === true,
         // 退场 = 这条卡片已经不在最近 MAX_SESSIONS 里，只留水位与身份。
         retired: value.retired === true,
-        billed: sanitizeUsage(value.billed),
+        billed,
+        // 这条会话自己那份按天用量：卡片上的数字要跟着页面范围走（见 `rangeUsageOf`）。
+        daily,
+        // 最后一次观测到的上下文构成：跟着会话走，不再全局只留一份。
+        composition: readComposition(value.composition),
         // 水位是「宿主那边这条会话的累计值」，缺省为 null 表示还没采过（首采全量入账）。
         watermark: value.watermark && typeof value.watermark === 'object' ? sanitizeUsage(value.watermark) : null,
       };
@@ -160,6 +198,8 @@ function sanitizeLedger(raw) {
   }
 
   if (raw.composition && typeof raw.composition === 'object') {
+    // 老账本只有一份全局构成（每轮被最后读完的那条覆盖）。留着当兜底：
+    // 没有任何一条会话带自己的构成时才用它。
     ledger.composition = {
       systemTokens: num(raw.composition.systemTokens),
       toolsTokens: num(raw.composition.toolsTokens),
@@ -225,12 +265,40 @@ function trim(ledger) {
       for (const id of pool.slice(MAX_RETIRED)) delete ledger.sessions[id];
     }
   }
+  // 每条会话自己那份按天用量也有上限：它只服务「这张卡片在这个范围里用了多少」，
+  // 最老的那些日子从它自己的账上裁掉，按天的总账不动。
+  for (const record of Object.values(ledger.sessions)) {
+    if (!record.daily) continue;
+    const own = Object.keys(record.daily).sort();
+    if (own.length > MAX_DAILY_DAYS) {
+      for (const day of own.slice(0, own.length - MAX_DAILY_DAYS)) delete record.daily[day];
+    }
+  }
   const days = Object.keys(ledger.days).sort();
   if (days.length > MAX_DAYS) {
     for (const day of days.slice(0, days.length - MAX_DAYS)) delete ledger.days[day];
   }
 }
 
+/** 账本里一条会话记录的初始形状（`applyDelta` 与读盘兜底共用一份）。 */
+function emptySession(at) {
+  return {
+    title: '',
+    workspaceName: '',
+    lastText: '',
+    cwd: '',
+    firstAt: at,
+    lastAt: 0,
+    collectedAt: 0,
+    gone: false,
+    retired: false,
+    billed: emptyUsage(),
+    daily: {},
+    composition: null,
+    watermark: null,
+  };
+}
+
 /**
  * 把一次采集到的增量记进账本（纯函数，原地改并返回它）。
  *
@@ -250,20 +318,12 @@ function applyDelta(ledger, entry) {
   // 与 dsh-context 的 requests 口径差不到一条结算的距离。
   day.requests += delta.steps;
 
-  const record = ledger.sessions[sessionId] || (ledger.sessions[sessionId] = {
-    title: '',
-    workspaceName: '',
-    lastText: '',
-    cwd: '',
-    firstAt: at,
-    lastAt: 0,
-    collectedAt: 0,
-    gone: false,
-    retired: false,
-    billed: emptyUsage(),
-    watermark: null,
-  });
+  const record = ledger.sessions[sessionId] || (ledger.sessions[sessionId] = emptySession(at));
   for (const key of USAGE_KEYS) record.billed[key] += delta[key];
+  // 这条会话自己那份按天用量：卡片的数字要跟页面范围走，所以增量在「记哪一天」这件事上
+  // 必须和按天的总账记在同一个日期上（首采回填也是同一天）。
+  const ownDay = record.daily[date] || (record.daily[date] = emptyUsage());
+  for (const key of USAGE_KEYS) ownDay[key] += delta[key];
   record.lastAt = Math.max(record.lastAt, at);
   if (!record.firstAt) record.firstAt = at;
   // 退场的卡片又有了新用量：回到列表里来（水位一直在，所以这次只记增量）。
@@ -283,11 +343,33 @@ function billedOf(usage) {
   return num(usage.uncachedInputTokens) + num(usage.cacheReadTokens) + num(usage.cacheWriteTokens) + num(usage.outputTokens);
 }
 
+/**
+ * 一条会话在 [startDay, today] 里的用量。
+ *
+ * `startDay` 为 null（`all`）时直接用记录里的累计值 —— 累计值是权威，而它那份按天用量
+ * 只保留最近 `MAX_DAILY_DAYS` 天。
+ */
+function usageInRange(record, startDay, today) {
+  const billed = record.billed || emptyUsage();
+  if (!startDay) return sanitizeUsage(billed);
+  const usage = emptyUsage();
+  const daily = record.daily || {};
+  for (const [day, value] of Object.entries(daily)) {
+    if (day < startDay || day > today) continue;
+    for (const key of USAGE_KEYS) usage[key] += num(value[key]);
+  }
+  return usage;
+}
+
 /**
  * 按范围折算成 App 要的总览（纯函数）。
  *
  * 逐日序列会把范围内**每一天都列出来**（没有活动的补 0）：柱状图靠它保持等距，
  * 由页面决定怎么省略日期标签。
+ *
+ * 三块口径必须对得上（2026-10-24 改）：`kpi` 是范围内总量，`sessions` 里的每张卡片是
+ * **这条会话在同一个范围里**的用量，`retired` / `untracked` 把不在卡片上的那部分明说出来 ——
+ * 卡片加起来永远解释不了总量，是这个页面被读成「数据对不上」的根源。
  */
 function summarize(ledger, range, now) {
   const today = dayKeyOf(now);
@@ -336,6 +418,7 @@ function summarize(ledger, range, now) {
     if (point.requests > 0 || point.turns > 0) kpi.days += 1;
   }
   kpi.activeMs = kpi.llmMs + kpi.toolMs;
+  const rangeBilled = billedOf(kpi);
 
   // 热力图给足最近 52 周（364 天）：手机上只画得下 8 周，iPad 横屏能摊到三十周上下 ——
   // 窗口由页面按自己的宽度截最后几周，宿主这边一律给满，否则宽屏想多画也没有数据。
@@ -346,20 +429,42 @@ function summarize(ledger, range, now) {
     heatmap.push({ day, tokens: source ? billedOf(source) : 0 });
   }
 
-  const rangeStartAt = startDay ? new Date(`${startDay}T00:00:00`).getTime() : 0;
   const sessions = [];
+  let retiredSessions = 0;
+  let retiredBilled = 0;
+  // 构成快照取「最近有动作的那条会话」：每轮只在不是同一条时换，不再被并发读完的最后一条覆盖。
+  let composition = null;
+  let compositionSession = null;
   for (const [sessionId, record] of Object.entries(ledger.sessions)) {
-    // 退场记录只留水位，不上卡片：它的量早就记在按天的账上了。
-    if (record.retired === true) continue;
-    if (rangeStartAt > 0 && num(record.lastAt) < rangeStartAt) continue;
+    const usage = usageInRange(record, startDay, today);
+    if (record.retired === true) {
+      // 退场记录只留水位，不上卡片：它的量早就记在按天的账上了。范围里有量时在汇总行报个数。
+      const billed = billedOf(usage);
+      if (billed > 0) {
+        retiredSessions += 1;
+        retiredBilled += billed;
+      }
+      continue;
+    }
+    if (record.composition && num(record.lastAt) > num(compositionSession && compositionSession.lastAt)) {
+      composition = {
+        systemTokens: num(record.composition.systemTokens),
+        toolsTokens: num(record.composition.toolsTokens),
+        messageTokens: num(record.composition.messageTokens),
+      };
+      compositionSession = { lastAt: num(record.lastAt), sessionId, title: record.title || '' };
+    }
+    const billedTokens = billedOf(usage);
+    // 范围内一个 token、一轮都没有的会话不上卡片：切到「近 7 天」时老会话不该占着位置。
+    if (billedTokens === 0 && num(usage.turns) === 0) continue;
     sessions.push({
       sessionId,
       title: record.title || '',
       ...(record.workspaceName ? { workspaceName: record.workspaceName } : {}),
       ...(record.cwd ? { cwd: record.cwd } : {}),
       ...(record.lastText ? { lastText: record.lastText } : {}),
-      billedTokens: billedOf(record.billed),
-      turns: num(record.billed.turns),
+      billedTokens,
+      turns: num(usage.turns),
       lastAt: num(record.lastAt),
       ...(record.gone ? { gone: true } : {}),
     });
@@ -373,13 +478,25 @@ function summarize(ledger, range, now) {
   });
   kpi.sessions = sessions.length;
 
+  // 卡片 + 退场合计之后仍然少的那一截：老版本把整条记录删掉过（水位与明细都没了），
+  // 按天的账上却还留着那些天。明说出来，别让用户自己拿计算器发现差额。
+  // 只报量、不报条数 —— 那些会话连记录都没了，条数是编不出来的。
+  const tracked = sessions.reduce((sum, row) => sum + row.billedTokens, 0) + retiredBilled;
+  const untrackedBilled = Math.max(0, rangeBilled - tracked);
+
+  // 没有任何一条会话带自己的构成时（升级前的老账本），退回那份全局快照。
+  if (!composition && ledger.composition) composition = { ...ledger.composition };
+
   return {
     generatedAt: now,
     range,
     kpi,
     days,
     heatmap,
-    ...(ledger.composition ? { composition: ledger.composition } : {}),
+    ...(composition ? { composition } : {}),
+    ...(compositionSession ? { compositionSessionId: compositionSession.sessionId } : {}),
+    retired: { sessions: retiredSessions, tokens: retiredBilled },
+    untrackedBilled,
     sessions,
   };
 }
@@ -389,6 +506,7 @@ module.exports = {
   MAX_SESSIONS,
   MAX_RETIRED,
   MAX_DAYS,
+  MAX_DAILY_DAYS,
   HEATMAP_DAYS,
   LAST_TEXT_MAX,
   stateFile,
@@ -403,5 +521,6 @@ module.exports = {
   startDayOf,
   emptyUsage,
   billedOf,
+  usageInRange,
   num,
 };

package/lib/mobile/stream-registry.js

@@ -0,0 +1,73 @@
+'use strict';
+
+/**
+ * 按设备登记的 SSE 流。
+ *
+ * token 换了只保证**下一次请求**被拒；一条已经开着的流不会自己断，被踢的手机还能继续收
+ * 消息，直到它自己重连。不做这一步，「单台吊销」就只完成了一半。
+ *
+ * 登记表按 deviceId 分组：同一台手机可能同时开着两条流（会话流 + 设备级事件流），
+ * 两台手机之间互不影响。收流由吊销那条路径调 `drop`，逐条 `end()` 掉。
+ *
+ * 这里**不做超时与配额**：宿主本来就是给自己那几台设备推东西，流的上限由它们自己的
+ * 打开次数决定，加一层闸只会把「手机连着却收不到」变成一种新的失败形态。
+ */
+const streams = new Map();
+
+/**
+ * 登记一条流。
+ *
+ * @param {string} deviceId 设备 id（凭据记录上的 `deviceId`）
+ * @param {object} res 这条流的响应对象（只需要 `end` 与 `destroy`）
+ * @returns {() => void} 注销函数；流自己关掉时调用，避免表越攒越大
+ */
+function track(deviceId, res) {
+  const key = typeof deviceId === 'string' ? deviceId : '';
+  if (!key || !res) return () => {};
+  let set = streams.get(key);
+  if (!set) {
+    set = new Set();
+    streams.set(key, set);
+  }
+  set.add(res);
+  return () => {
+    const current = streams.get(key);
+    if (!current) return;
+    current.delete(res);
+    if (current.size === 0) streams.delete(key);
+  };
+}
+
+/**
+ * 收掉这台设备上所有已建立的流。
+ *
+ * 先 `end()` 再 `destroy()`：`end` 让对端看到正常的流结束（App 会在下一次请求上收到
+ * `device-revoked`，而不是一个「网络出错」）；对已经卡住的连接 `destroy` 是兜底。
+ *
+ * @returns {number} 实际收掉了多少条
+ */
+function drop(deviceId) {
+  const key = typeof deviceId === 'string' ? deviceId : '';
+  const set = streams.get(key);
+  if (!set) return 0;
+  streams.delete(key);
+  let closed = 0;
+  for (const res of set) {
+    closed += 1;
+    try { res.end?.(); } catch { /* 对端已经走了 */ }
+    try { res.destroy?.(); } catch { /* 同上 */ }
+  }
+  return closed;
+}
+
+/** 测试与自检用：当前登记了多少条流。 */
+function size() {
+  let total = 0;
+  for (const set of streams.values()) total += set.size;
+  return total;
+}
+
+/** 测试用：清空登记表。 */
+function reset() { streams.clear(); }
+
+module.exports = { track, drop, size, reset };