dsh-mobile-plugin 0.1.96 → 0.1.98

package/lib/mobile/stats-ledger.cjs

@@ -0,0 +1,407 @@
+'use strict';
+
+/**
+ * 统计账本：按天累计的用量 + 每条会话的累计与身份（`$DSH_HOME/mobile-stats.json`）。
+ *
+ * 为什么要有这一份、以及它为什么不寄在会话日志上：用户会归档会话、也会清理已归档的
+ * 会话，清理删的是日志本身。统计如果每次现算，清理之后那部分用量就凭空消失（还常常
+ * 表现为「今天的使用量突然掉了一半」）。所以采集一旦读到增量就落进这个文件，之后会话
+ * 在不在都不影响历史数字 —— 那张会话卡片只会被标成「已清理」。
+ *
+ * 口径（与桌面插件 dsh-context 的每日账本一致，但只保留手机用得着的部分）：
+ * - 一天的账落在那**一天完成观测**的日期上（宿主本地日期，`YYYY-MM-DD`）；
+ * - 计费 token = 未命中输入 + 缓存读 + 缓存写 + 输出，四个桶分开存，合并多台设备时
+ *   才可能按同一口径重算计费量与命中率；
+ * - 会话卡片保留最近 `MAX_SESSIONS` 条（按最后活动时间），更老的会话从卡片里消失，
+ *   但它们的量**仍然留在按天的账上**（总量不会因为裁剪而缩水）。卡片退场只是不再展示
+ *   （`retired`），水位留着 —— 水位一丢，这条会话下次再有动作就会被当成首采、把整段
+ *   历史重记一遍，按天的账凭空多出一截。
+ *
+ * 这个文件只做纯数据（读写 + 折算），不碰网络；采集在 stats-collect.cjs，路由在 stats.js。
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const paths = require('../shared/paths');
+
+/** 账本格式版本：将来改结构时据此决定是丢弃还是迁移。 */
+const VERSION = 1;
+
+/** 会话卡片的条数上限（按最后活动时间保留最近的）。 */
+const MAX_SESSIONS = 200;
+
+/**
+ * 退场卡片（已不在最近 200 条里、只留水位与身份）的条数上限。
+ *
+ * 退场记录不展示，存在只为「它再活过来时别重记一遍历史」；每条一百来字节，
+ * 留这么多足够覆盖一台机器几年的会话，再老的真删掉。
+ */
+const MAX_RETIRED = 2000;
+
+/** 按天的账保留天数（约三年；一天一百多字节，超出的从最老的开始裁）。 */
+const MAX_DAYS = 1100;
+
+/**
+ * 热力图最多给多少天（52 周）。
+ *
+ * 页面按自己量到的宽度决定画几周（手机 8 周、iPad 横屏三十周上下），宿主这边一律给满 ——
+ * 只给 56 天的话宽屏想多画也没有数据；只给 26 周则 iPad 那张卡摊到 26 周之后右边还剩
+ * 一格多的空白，白改一场。
+ */
+const HEATMAP_DAYS = 52 * 7;
+
+/** 每张会话卡片上留的最后一条消息摘要长度：卡片一行装得下的大致字数。 */
+const LAST_TEXT_MAX = 120;
+
+/** 用量字段：四个 token 桶 + 轮次/步数/耗时。顺序即写盘顺序，便于人工比对。 */
+const USAGE_KEYS = [
+  'uncachedInputTokens',
+  'cacheReadTokens',
+  'cacheWriteTokens',
+  'outputTokens',
+  'turns',
+  'steps',
+  'llmMs',
+  'toolMs',
+];
+
+function emptyUsage() {
+  const usage = {};
+  for (const key of USAGE_KEYS) usage[key] = 0;
+  return usage;
+}
+
+function emptyDay() {
+  return { ...emptyUsage(), requests: 0 };
+}
+
+function emptyLedger() {
+  return { version: VERSION, updatedAt: 0, days: {}, sessions: {}, composition: null };
+}
+
+/** 账本文件：`$DSH_HOME/mobile-stats.json`（DSH_HOME 在调用时解析，便于测试注入）。 */
+function stateFile() {
+  return path.join(paths.dshHome(), 'mobile-stats.json');
+}
+
+/** 内存缓存；null = 还没读过盘。 */
+let cached = null;
+
+function num(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;
+}
+
+/** 宿主本地日期 `YYYY-MM-DD`。 */
+function dayKeyOf(at) {
+  const date = new Date(at);
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${date.getFullYear()}-${month}-${day}`;
+}
+
+/** 日期字符串按日历加减（用 UTC 解析/格式化，避开夏令时与本地时区偏移）。 */
+function addDays(day, delta) {
+  const [year, month, date] = day.split('-').map((part) => Number(part));
+  const base = Date.UTC(year, month - 1, date);
+  const shifted = new Date(base + delta * 86400000);
+  const shiftedMonth = String(shifted.getUTCMonth() + 1).padStart(2, '0');
+  const shiftedDay = String(shifted.getUTCDate()).padStart(2, '0');
+  return `${shifted.getUTCFullYear()}-${shiftedMonth}-${shiftedDay}`;
+}
+
+/** 范围起点（含）；`all` 返回 null，表示不设下限。 */
+function startDayOf(range, now) {
+  const today = dayKeyOf(now);
+  if (range === '7d') return addDays(today, -6);
+  if (range === '30d') return addDays(today, -29);
+  return null;
+}
+
+function sanitizeUsage(source) {
+  const usage = emptyUsage();
+  if (!source || typeof source !== 'object') return usage;
+  for (const key of USAGE_KEYS) usage[key] = num(source[key]);
+  return usage;
+}
+
+function sanitizeLedger(raw) {
+  if (!raw || typeof raw !== 'object') return emptyLedger();
+  if (raw.version !== VERSION) return emptyLedger();
+  const ledger = emptyLedger();
+  ledger.updatedAt = num(raw.updatedAt);
+
+  if (raw.days && typeof raw.days === 'object') {
+    for (const [day, value] of Object.entries(raw.days)) {
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(day) || !value || typeof value !== 'object') continue;
+      ledger.days[day] = { ...sanitizeUsage(value), requests: num(value.requests) };
+    }
+  }
+
+  if (raw.sessions && typeof raw.sessions === 'object') {
+    for (const [sessionId, value] of Object.entries(raw.sessions)) {
+      if (!sessionId || !value || typeof value !== 'object') continue;
+      ledger.sessions[sessionId] = {
+        title: typeof value.title === 'string' ? value.title : '',
+        workspaceName: typeof value.workspaceName === 'string' ? value.workspaceName : '',
+        lastText: typeof value.lastText === 'string' ? value.lastText.slice(0, LAST_TEXT_MAX) : '',
+        cwd: typeof value.cwd === 'string' ? value.cwd : '',
+        firstAt: num(value.firstAt),
+        lastAt: num(value.lastAt),
+        collectedAt: num(value.collectedAt),
+        gone: value.gone === true,
+        // 退场 = 这条卡片已经不在最近 MAX_SESSIONS 里，只留水位与身份。
+        retired: value.retired === true,
+        billed: sanitizeUsage(value.billed),
+        // 水位是「宿主那边这条会话的累计值」，缺省为 null 表示还没采过（首采全量入账）。
+        watermark: value.watermark && typeof value.watermark === 'object' ? sanitizeUsage(value.watermark) : null,
+      };
+    }
+  }
+
+  if (raw.composition && typeof raw.composition === 'object') {
+    ledger.composition = {
+      systemTokens: num(raw.composition.systemTokens),
+      toolsTokens: num(raw.composition.toolsTokens),
+      messageTokens: num(raw.composition.messageTokens),
+    };
+  }
+  return ledger;
+}
+
+/** 读账本（首次读盘，之后走内存；坏文件当空账本，不阻断统计页）。 */
+function readLedger() {
+  if (cached !== null) return cached;
+  let raw = null;
+  try {
+    raw = JSON.parse(fs.readFileSync(stateFile(), 'utf8'));
+  } catch {
+    raw = null;
+  }
+  cached = sanitizeLedger(raw);
+  return cached;
+}
+
+/** 原子写：先写临时文件再 rename，写一半断电也不会留下半份 JSON。 */
+function saveLedger(ledger) {
+  cached = ledger;
+  ledger.updatedAt = Date.now();
+  const file = stateFile();
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(ledger), { mode: 0o600 });
+    fs.renameSync(tmp, file);
+  } catch {
+    // 落盘失败只影响「重启后还在不在」：内存里这份仍然对当前进程有效，统计页照常能看。
+  }
+}
+
+/** 测试与「换个 DSH_HOME 重读」用。 */
+function forgetLedger() {
+  cached = null;
+}
+
+/**
+ * 裁剪：会话卡片按最后活动时间保留最近的。
+ *
+ * 超出的卡片**不删记录、只标退场**（`retired`）：水位与身份留着，那条会话以后再活跃
+ * 就不会被当成首采、把整段历史重记一遍。退场记录自己也封顶，最老的先删。
+ */
+function trim(ledger) {
+  const sessionIds = Object.keys(ledger.sessions);
+  if (sessionIds.length > MAX_SESSIONS) {
+    // 已经在退场里的不参与排位：它们本来就该往后排，重新算一遍只会来回抖动。
+    const live = sessionIds.filter((id) => ledger.sessions[id].retired !== true);
+    const retired = sessionIds.filter((id) => ledger.sessions[id].retired === true);
+    if (live.length > MAX_SESSIONS) {
+      live.sort((a, b) => num(ledger.sessions[b].lastAt) - num(ledger.sessions[a].lastAt));
+      for (const id of live.slice(MAX_SESSIONS)) ledger.sessions[id].retired = true;
+    }
+    // 退场池按最后活动时间留最新的那一批，其余真删。
+    const pool = [...retired, ...live.slice(MAX_SESSIONS)];
+    if (pool.length > MAX_RETIRED) {
+      pool.sort((a, b) => num(ledger.sessions[b].lastAt) - num(ledger.sessions[a].lastAt));
+      for (const id of pool.slice(MAX_RETIRED)) delete ledger.sessions[id];
+    }
+  }
+  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];
+  }
+}
+
+/**
+ * 把一次采集到的增量记进账本（纯函数，原地改并返回它）。
+ *
+ * `entry.date` 只在「首采回填」时传：一条会话第一次被采到时，它历史上有多少量我们都
+ * 不知道发生在哪天，只能记到它最后一次活动的那天 —— 记到今天会让今天凭空多出一大截，
+ * 记到创建那天又会让所有历史堆在最早一天。两者都是近似，取「最后活动日」更接近直觉。
+ */
+function applyDelta(ledger, entry) {
+  const sessionId = entry.sessionId;
+  const delta = sanitizeUsage(entry.delta);
+  const at = num(entry.at) || Date.now();
+  const date = entry.date || dayKeyOf(at);
+
+  const day = ledger.days[date] || (ledger.days[date] = emptyDay());
+  for (const key of USAGE_KEYS) day[key] += delta[key];
+  // 模型请求数按「步」的增量记：宿主没给独立的请求计数字段，而一步对应一次请求，
+  // 与 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,
+  });
+  for (const key of USAGE_KEYS) record.billed[key] += delta[key];
+  record.lastAt = Math.max(record.lastAt, at);
+  if (!record.firstAt) record.firstAt = at;
+  // 退场的卡片又有了新用量：回到列表里来（水位一直在，所以这次只记增量）。
+  record.retired = false;
+  if (entry.title) record.title = entry.title;
+  if (entry.cwd) record.cwd = entry.cwd;
+  if (entry.workspaceName) record.workspaceName = entry.workspaceName;
+  // 最后一句只留一行的长度：卡片底那行是给人认「这是哪条会话」的，不是正文存档。
+  if (typeof entry.lastText === 'string' && entry.lastText) {
+    record.lastText = entry.lastText.slice(0, LAST_TEXT_MAX);
+  }
+  return ledger;
+}
+
+/** 会话卡片上的计费量：四个桶之和。 */
+function billedOf(usage) {
+  return num(usage.uncachedInputTokens) + num(usage.cacheReadTokens) + num(usage.cacheWriteTokens) + num(usage.outputTokens);
+}
+
+/**
+ * 按范围折算成 App 要的总览（纯函数）。
+ *
+ * 逐日序列会把范围内**每一天都列出来**（没有活动的补 0）：柱状图靠它保持等距，
+ * 由页面决定怎么省略日期标签。
+ */
+function summarize(ledger, range, now) {
+  const today = dayKeyOf(now);
+  const startDay = startDayOf(range, now);
+  const allDays = Object.keys(ledger.days).sort();
+  const firstDay = startDay || allDays[0] || today;
+
+  const days = [];
+  for (let cursor = firstDay; ; cursor = addDays(cursor, 1)) {
+    const source = ledger.days[cursor] || emptyDay();
+    days.push({
+      day: cursor,
+      uncachedInputTokens: num(source.uncachedInputTokens),
+      cacheReadTokens: num(source.cacheReadTokens),
+      cacheWriteTokens: num(source.cacheWriteTokens),
+      outputTokens: num(source.outputTokens),
+      requests: num(source.requests),
+      turns: num(source.turns),
+    });
+    if (cursor >= today) break;
+  }
+
+  const kpi = {
+    sessions: 0,
+    uncachedInputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    outputTokens: 0,
+    turns: 0,
+    steps: 0,
+    llmMs: 0,
+    toolMs: 0,
+    activeMs: 0,
+    days: 0,
+  };
+  for (const point of days) {
+    const source = ledger.days[point.day] || emptyDay();
+    kpi.uncachedInputTokens += num(source.uncachedInputTokens);
+    kpi.cacheReadTokens += num(source.cacheReadTokens);
+    kpi.cacheWriteTokens += num(source.cacheWriteTokens);
+    kpi.outputTokens += num(source.outputTokens);
+    kpi.turns += num(source.turns);
+    kpi.steps += num(source.steps);
+    kpi.llmMs += num(source.llmMs);
+    kpi.toolMs += num(source.toolMs);
+    if (point.requests > 0 || point.turns > 0) kpi.days += 1;
+  }
+  kpi.activeMs = kpi.llmMs + kpi.toolMs;
+
+  // 热力图给足最近 52 周（364 天）：手机上只画得下 8 周，iPad 横屏能摊到三十周上下 ——
+  // 窗口由页面按自己的宽度截最后几周，宿主这边一律给满，否则宽屏想多画也没有数据。
+  const heatmap = [];
+  for (let offset = HEATMAP_DAYS - 1; offset >= 0; offset -= 1) {
+    const day = addDays(today, -offset);
+    const source = ledger.days[day];
+    heatmap.push({ day, tokens: source ? billedOf(source) : 0 });
+  }
+
+  const rangeStartAt = startDay ? new Date(`${startDay}T00:00:00`).getTime() : 0;
+  const sessions = [];
+  for (const [sessionId, record] of Object.entries(ledger.sessions)) {
+    // 退场记录只留水位，不上卡片：它的量早就记在按天的账上了。
+    if (record.retired === true) continue;
+    if (rangeStartAt > 0 && num(record.lastAt) < rangeStartAt) 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),
+      lastAt: num(record.lastAt),
+      ...(record.gone ? { gone: true } : {}),
+    });
+  }
+  sessions.sort((a, b) => {
+    const goneA = a.gone ? 1 : 0;
+    const goneB = b.gone ? 1 : 0;
+    if (goneA !== goneB) return goneA - goneB;
+    if (b.billedTokens !== a.billedTokens) return b.billedTokens - a.billedTokens;
+    return b.lastAt - a.lastAt;
+  });
+  kpi.sessions = sessions.length;
+
+  return {
+    generatedAt: now,
+    range,
+    kpi,
+    days,
+    heatmap,
+    ...(ledger.composition ? { composition: ledger.composition } : {}),
+    sessions,
+  };
+}
+
+module.exports = {
+  VERSION,
+  MAX_SESSIONS,
+  MAX_RETIRED,
+  MAX_DAYS,
+  HEATMAP_DAYS,
+  LAST_TEXT_MAX,
+  stateFile,
+  readLedger,
+  saveLedger,
+  forgetLedger,
+  applyDelta,
+  summarize,
+  trim,
+  dayKeyOf,
+  addDays,
+  startDayOf,
+  emptyUsage,
+  billedOf,
+  num,
+};

package/lib/mobile/stats.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * GET /api/mobile/v1/stats/overview?range=7d|30d|all[&fresh=1]（token）
+ *
+ * 统计页的唯一接口：先采一轮（水位差记账），再把账本按范围折算成页面要的那份。
+ *
+ * 采集失败**不**让整页报错：账本里已有的数字照样是真的，宁可让用户看到一份偏旧的统计，
+ * 也不要为了「这次没采上」把整页变成错误页。要重新采就用 `fresh=1`（下拉刷新那条）。
+ *
+ * 范围词只有三档，别的值一律按 `7d`：多一档就要在页面和这里各维护一份日历口径。
+ */
+
+const { sendJson } = require('../http/routing.js');
+const { collectStats, DEFAULT_BUDGET_MS } = require('./stats-collect.cjs');
+const ledger = require('./stats-ledger.cjs');
+
+const RANGES = new Set(['7d', '30d', 'all']);
+
+function normalizeRange(value) {
+  return typeof value === 'string' && RANGES.has(value) ? value : '7d';
+}
+
+async function handleStatsOverview(ctx, req, res) {
+  const url = new URL(req.url, 'http://x');
+  const range = normalizeRange(url.searchParams.get('range'));
+  const fresh = url.searchParams.get('fresh') === '1';
+  try {
+    // 带预算采：到点就用已经采到的那部分出数，别让手机等十几秒（见 stats-collect 的同名常量）。
+    await collectStats(ctx, { force: fresh, budgetMs: DEFAULT_BUDGET_MS });
+  } catch {
+    /* 采集是旁路：账本还在，统计页照常出数 */
+  }
+  const overview = ledger.summarize(ledger.readLedger(), range, Date.now());
+  sendJson(res, 200, { ok: true, overview });
+}
+
+module.exports = { handleStatsOverview, normalizeRange };

package/lib/mobile/stream.js

@@ -263,7 +263,18 @@ async function handleStream(ctx, req, res) {
   let loopEnded = false;
 
   try {
-    // 断线续传：先回放 history 中 seq > resumeSeq 的事件（收敛状态）。
+    // **先开实时流、再回放**：之前是先 replay 再 mux，两步之间的 follow 还没订阅，
+    // 这段时间发生的事件既不在 replay 快照里、也不在实时流里，只能等下一次重连补。
+    // 现在先让 mux 把 follow 订阅建立起来（第一帧在 `firstFrame` 里等着，尚未消费），
+    // 再回放 history；回放与 follow 的重叠由 `seq <= lastDeliveredSeq` 去重。
+    // 注意：payload 里带 sessionId（0.2.0 兼容桥据此收窄成单会话 follow + 投影 + 任务）。
+    const frames = ctx.apiProxy.events.mux({ rpcId: 'mobile-stream', payload: streamAddress }, ac.signal);
+    const frameIterator = frames[Symbol.asyncIterator]();
+    // 立刻踢一脚让上游订阅开始；回放期间不消费，事件由 follow 连续读入并在这里排队。
+    let firstFrame = frameIterator.next();
+    firstFrame.catch(() => { /* 错误在下面统一收口，这里只避免回放期间未处理的 rejection */ });
+
+    // 断线续传：回放 history 中 seq > resumeSeq 的事件（收敛状态）。
     if (resumeSeq != null && resumeSeq > 0) {
       const replay = await replaySince(ctx, sessionId, resumeSeq, res, ac.signal, (seq) => { lastDeliveredSeq = Math.max(lastDeliveredSeq, seq); }, streamAddress);
       if (replay.gap && !ac.signal.aborted) {
@@ -274,13 +285,6 @@ async function handleStream(ctx, req, res) {
     }
 
     if (!clientGone) {
-      // payload 里带 sessionId：0.2.0 的宿主没有设备级事件流了，兼容桥据此收窄成
-      // 这一条会话的 follow + 投影 + 任务三条流（见 mobile/host-bridge.js 的 muxFrames）。
-      // 不带就是设备级视角，只会给工作区基线与全局投影 —— 这里反正只要单会话。
-      // 子会话必须带上父会话（`parentSessionId` + `mode`）：宿主对 origin==='subagent'
-      // 的会话拿普通地址订阅一律回 agent-busy，表现是「页面打得开、内容不更新」。
-      // 地址的拼装与历史那条同源，见 host-bridge/event-synthesis.js 的 sessionAddress。
-      const frames = ctx.apiProxy.events.mux({ rpcId: 'mobile-stream', payload: streamAddress }, ac.signal);
       // 写一帧并把三种结果统一收口：丢增量、需要等 drain、该收尾。
       // 「需要等 drain」这一步是这次 OOM 的正解 —— 写不动就停手，等底层消化完再继续，
       // 而不是把帧继续往内存里塞。
@@ -294,7 +298,11 @@ async function handleStream(ctx, req, res) {
         }
         return 'sent';
       };
-      for await (const frame of frames) {
+      for (;;) {
+        const step = firstFrame ? await firstFrame : await frameIterator.next();
+        firstFrame = null;
+        if (step.done) break;
+        const frame = step.value;
         const p = frame.payload;
         if (!p || p.sessionId !== sessionId) continue;
         // 增量事件保持原 wire：data 仍是原事件 JSON，SSE 元数据独立于 data。
@@ -347,7 +355,7 @@ async function handleStream(ctx, req, res) {
       // 明确告诉客户端「流到此为止，请带 lastSeq 重连」：它会走已验证可用的 replay
       // 路径补上缺口，而不是把静默断流当成正常状态。
       if (!ac.signal.aborted && !clientGone) {
-        writeSse(res, { type: 'session/resync-required', sessionId, oldestSeq: lastDeliveredSeq + 1 });
+        writeSse(res, { type: 'session/resync-required', sessionId, oldestSeq: lastDeliveredSeq + 1, final: true });
       }
       res.end();
       logStream(sessionId, `stream closed (loopEnded=${loopEnded}, aborted=${ac.signal.aborted}, clientGone=${clientGone}, deliveredSeq=${lastDeliveredSeq})`, null);

package/lib/mobile/uploads.js

@@ -132,23 +132,39 @@ async function uniquePath(dir, name) {
   return path.join(dir, `${stem}-${Date.now()}${ext}`);
 }
 
-/** 清掉过期残片；尽力而为，失败不影响本次上传。 */
+/**
+ * 清掉过期残片；尽力而为，失败不影响本次上传。
+ *
+ * 返回删掉了几个、腾了多少字节 —— `begin` 那条路不看它（`void` 掉），但收件目录的清理
+ * 与占用读数要拿它报数，所以别改成只在内部记账。
+ *
+ * **这条清扫只在 `begin` 时跑**：手机不再上传的那台机器上，残片就一直躺着（实测过：
+ * 一份 12MB 的 `.part` 从 10-20 睡到今天）。所以 `mobile/inbox-clean.js` 的清理与启动
+ * 收尾也会调它，TTL 判据只有这一份。
+ */
 async function sweepStaging(stagingDir) {
   let entries;
   try {
     entries = await fsp.readdir(stagingDir, { withFileTypes: true });
   } catch {
-    return;
+    return { deleted: 0, bytes: 0 };
   }
   const cutoff = Date.now() - STAGING_TTL_MS;
-  await Promise.all(entries.map(async (entry) => {
-    if (!entry.isFile() || !entry.name.endsWith('.part')) return;
+  const removed = await Promise.all(entries.map(async (entry) => {
+    if (!entry.isFile() || !entry.name.endsWith('.part')) return null;
     const target = path.join(stagingDir, entry.name);
     try {
       const stat = await fsp.stat(target);
-      if (stat.mtimeMs < cutoff) await fsp.unlink(target);
-    } catch { /* 已被别人清掉 */ }
+      if (stat.mtimeMs >= cutoff) return null;
+      await fsp.unlink(target);
+      return stat.size;
+    } catch {
+      // 已被别人清掉，或者删不掉：都不算这次腾出来的量。
+      return null;
+    }
   }));
+  const sizes = removed.filter((size) => typeof size === 'number');
+  return { deleted: sizes.length, bytes: sizes.reduce((sum, size) => sum + size, 0) };
 }
 
 function fail(res, status, code, message) {
@@ -263,7 +279,9 @@ module.exports = {
   handleUploadAbort,
   sanitizeName,
   inboxRoot,
+  sweepStaging,
   sweepExpiredUploads,
+  STAGING_TTL_MS,
   CHUNK_BYTES,
   CHUNK_MAX_BYTES,
 };

package/lib/mobile/workspaces.js

@@ -23,6 +23,7 @@ const { invalidateSessionList } = require('./sessions.js');
 const { withIdempotency, requestIdOf } = require('./idempotency.js');
 const { canonicalDeviceKey } = require('./session-cache.js');
 const { unwrap } = require('./envelope.js');
+const { describeProjectGit } = require('./git-repos.js');
 
 /** 调宿主 apiProxy.host.*（directory-picker 的 browse 能力）。 */
 function callHost(ctx, method, payload) {
@@ -38,6 +39,22 @@ function callWorkspace(ctx, method, payload) {
  * GET /api/mobile/v1/workspaces（token）
  * 列出被控端当前所有工作区，供侧边栏「工作区」区块渲染与重命名/删除判定。
  */
+/**
+ * 给每条工作区挂上 Git 仓库标记（`git`）。
+ *
+ * 只有带 `path` 的条目才查：没有路径的条目连目录都没有，给它一个「不是仓库」的结论
+ * 只是把「我不知道」说成「我查过了」。识别本身不抛错、按目录缓存，所以这里不再包
+ * try —— 包了只会把真 bug 藏起来。
+ */
+async function attachGitMarkers(items, options) {
+  return Promise.all(items.map(async (item) => {
+    if (!item || typeof item !== 'object') return item;
+    const path = typeof item.path === 'string' ? item.path.trim() : '';
+    if (!path) return item;
+    return { ...item, git: await describeProjectGit(path, options) };
+  }));
+}
+
 /**
  * 构建工作区快照 body（供移动端镜像同步推送复用）。
  *
@@ -45,8 +62,10 @@ function callWorkspace(ctx, method, payload) {
  * 但此前这里只保留 `items`，把它整个丢掉。于是 App 点完「归档会话」拿不到任何
  * 归档状态，侧边栏那一行永远不消失——归档在移动端表现为一次没有反馈的空操作。
  * 它同时也是将来做「取消归档」入口的唯一数据来源。
+ *
+ * `options.fresh` 透传给仓库识别，跳过它那 15 秒的目录缓存（写后刷新 / 下拉刷新）。
  */
-async function buildWorkspacesBody(ctx) {
+async function buildWorkspacesBody(ctx, options = {}) {
   const { value, error } = unwrap(await callWorkspace(ctx, 'list', {}));
   if (error) return { ok: false, error };
   // 宿主报「成功」却没有给出清单数组，这是**没取到**，不是「你没有工作区」。
@@ -67,17 +86,19 @@ async function buildWorkspacesBody(ctx) {
   const archivedSessionIds = value && Array.isArray(value.archivedSessionIds)
     ? value.archivedSessionIds.filter(id => typeof id === 'string')
     : [];
+  const marked = await attachGitMarkers(items, { fresh: Boolean(options.fresh) });
   return {
     ok: true,
-    items,
+    items: marked,
     archivedSessionIds,
     // 与 sessions 快照同款的新鲜度/空态契约（见 lib/mobile/sessions.js 的说明）：
     // App 把 generatedAt + revision 存进快照用于展示「数据时间」，emptyConfirmed
     // 让「用户真的删光了工作区」不必再靠连续两次空去猜。
     generatedAt: Date.now(),
     // 归档集合也是工作区快照语义的一部分；仅它变化时也必须让镜像推送判为新版本。
-    revision: stableRevision({ items, archivedSessionIds }),
-    emptyConfirmed: items.length === 0,
+    // 仓库标记也在里面：换分支是这份快照的一部分，变了就该推新版本。
+    revision: stableRevision({ items: marked, archivedSessionIds }),
+    emptyConfirmed: marked.length === 0,
   };
 }
 
@@ -93,8 +114,11 @@ async function buildWorkspacesBody(ctx) {
 async function handleWorkspaces(ctx, req, res) {
   const url = new URL(req.url, 'http://x');
   const rev = (url.searchParams.get('rev') || '').trim();
-  const body = await buildWorkspacesBody(ctx);
-  const unchanged = isFreshRequest(req.url) ? null : unchangedListBody(body, rev);
+  const fresh = isFreshRequest(req.url);
+  // 仓库识别也认这一个 `fresh`：写后刷新 / 下拉刷新必须看见刚新建的仓库，
+  // 不能被识别那 15 秒的目录缓存挡回去。
+  const body = await buildWorkspacesBody(ctx, { fresh });
+  const unchanged = fresh ? null : unchangedListBody(body, rev);
   sendJson(res, 200, unchanged || body);
 }