dsh-mobile-plugin 0.1.100 → 0.2.1

package/lib/mobile/session-cache.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * 会话侧的按 ctx 隔离状态：十一张表，一个入口。
+ * 会话侧的按 ctx 隔离状态：十三张表，一个入口。
  *
  * 这些表此前全是 sessions.js 的模块级 WeakMap。它们之所以必须按 ctx 隔离，是因为
  * 它们的值属于**宿主进程状态**（某个会话正在跑、某个列表刚构建完、某条发送已经
@@ -39,9 +39,14 @@ const lastTurnFacts = new WeakMap();
 // Prevent duplicate prompt calls when a mobile request is retried after a timeout.
 const sendIdempotency = new WeakMap();
 // 写操作（新建/改名/归档/分叉）的 requestId 重放表：同一次写在换通道重投后不再执行第二遍。
-// 与 sendIdempotency 分开是因为键与生命周期不同（那边按 sessionId+clientMessageId，60s）。
+// 与 sendIdempotency 分开是因为键与生命周期不同（那边按 sessionId+clientMessageId，
+// 成功之后留到进程结束；这里是每次写各自的 requestId、只活在重投窗口里）。
 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 +229,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) {
@@ -248,6 +266,44 @@ function sendIdempotencyStateOf(ctx) {
   return state;
 }
 
+/**
+ * 同一个投递 id 在一次会话里只真正跑一次：成功之后记录留到进程结束，失败立刻释放。
+ *
+ * 要防的是「请求超时、但那一发其实已经交给宿主了」这一档：App 会拿着同一个
+ * clientMessageId 再发一次（内核重试或用户手点重试），第二次必须拿到第一次的结果，
+ * 而不是让模型 / 子代理把同一句话再说一遍。
+ *
+ * **失败不占位**：`run` 回的信封不是成功（宿主明确拒绝，如 model-unavailable /
+ * agent-busy）就当场删掉记录 —— 一次瞬时错误不能被固化成「这个 id 永远只回这一句错」；
+ * 同理 `run` 抛错（传输层失败）也删。两条都必须是「真的再试一次」，否则活的路径只剩
+ * 用户重开 App。
+ *
+ * @param {object} ctx 插件上下文（状态按 ctx 隔离）
+ * @param {string} key 投递身份：主会话 `sessionId:clientMessageId`，子代理额外加前缀
+ * @param {() => Promise<object>} run 真正发一次，回宿主信封（`{ result: { ok, value | error } }`）
+ */
+function promptOnceFor(ctx, key, run) {
+  const state = sendIdempotencyStateOf(ctx);
+  const existing = state.get(key);
+  if (existing) return existing.promise;
+
+  const promise = Promise.resolve().then(run);
+  const record = { promise };
+  state.set(key, record);
+  const release = () => { if (state.get(key) === record) state.delete(key); };
+  promise.then(
+    (response) => {
+      // 留下的这条记录就是「这一发已经交给宿主了」的回执；宿主明确拒绝（信封 ok 不为真）
+      // 就当场释放 —— 一次业务错误不能被固化成「这个 id 永远只回这一句」。这里只看收没
+      // 收下，不拆错误信封（拆信封在 envelope.js，本文件是零依赖的叶子）。
+      const accepted = Boolean(response && response.result && response.result.ok === true);
+      if (!accepted) release();
+    },
+    release,
+  );
+  return promise;
+}
+
 /** 写操作幂等表（实现在 mobile/idempotency.js，这里只保证按 ctx 隔离）。 */
 function writeIdempotencyStateOf(ctx) {
   let state = writeIdempotency.get(ctx);
@@ -336,7 +392,9 @@ module.exports = {
   markCompletionRead,
   clearCompletionForAllDevices,
   completionGenerationOf,
+  workspaceShortcutStateOf,
   bumpCompletionGeneration,
   sendIdempotencyStateOf,
+  promptOnceFor,
   writeIdempotencyStateOf,
 };

package/lib/mobile/session-file.js

@@ -8,17 +8,24 @@
  *
  * 三条边界同时成立：
  *
- *  1. **只认本会话 present 声明过的路径**：`deliverables/presented` 是模型显式交出来的
- *     那份清单，App 卡片上的每一格都来自它。别把它放宽成「会话工作区里的任意文件」——
- *     移动 API 不暴露任意读，与它不暴露 shell / 任意写入是同一条边界。路径按**字符串
- *     全等**比对声明，所以不存在穿越。
- *  2. **相对路径按会话工作区解析**：声明里既可能是 `src/x.png` 也可能是绝对路径，
- *     相对的那一种只能相对 cwd 解析（cwd 取自会话列表摘要，与 /session 同一个来源）。
+ *  1. **放行面 = 本会话工作区里的文件 ∪ 本会话 present 声明过的路径**（2026-10-25 用户拍板
+ *     的第二条，见 docs/decisions.md）。前者的判法是「解析后的落点在 cwd 之下」：相对路径
+ *     按 cwd 拼、绝对路径原样，然后整条路径必须在 cwd 里 —— 所以 `../x` 这种穿越落在
+ *     cwd 之外，退回旧的那条白名单，不在声明里就 403。后者保持原样（`deliverables/presented`
+ *     里显式声明过的、**字符串全等**），它的用处是工作区之外的文件也能交付（绝对路径、
+ *     cwd 变了的老会话）。
+ *
+ *     **为什么敢放开工作区**：正文里模型写的 `[报告](docs/报告.md)` 就是这条路上的用户预期
+ *     —— 手机上点一下能看，比「点了没反应」有意义得多；而这条会话的模型本来就能读同一个
+ *     工作区，手机与电脑是同一个使用者，放宽的是「同一份工作区能不能在手机上看」，不是
+ *     「能不能读这台电脑上的任意文件」（那仍然是 403，与不暴露 shell / 任意写入同一条边界）。
+ *  2. **相对路径按会话工作区解析**：cwd 取自会话列表摘要（与 /session 同一个来源）。没有
+ *     cwd 的会话只能走 present 那条白名单，相对路径解析不出来就回 409。
  *  3. **流式回写、不在插件进程里缓冲**：几十 MB 的录屏不该整包躺在内存里，与会话日志
  *     导出同一个理由。
  *
- * 取不到时两种失败要分得开：不在声明里回 403（`not-presented`），声明里有、盘上没了
- * 回 404（`missing`）—— 前者是「这一格不该出现」，后者是「文件被挪走了」，文案不同。
+ * 取不到时两种失败要分得开：两条口子都不认这个路径就回 403（`outside-workspace`），
+ * 认了、盘上没了回 404（`missing`）—— 前者是「这个路径不该被读」，后者是「文件被挪走了」。
  */
 
 const fs = require('node:fs');
@@ -26,6 +33,7 @@ const { stat } = require('node:fs/promises');
 const path = require('node:path');
 const { pipeline } = require('node:stream/promises');
 const { sendJson, readJsonBody } = require('../shared/http-util');
+const { signedPath } = require('../shared/e2ee-request');
 const { unwrap } = require('./envelope.js');
 const { callSessions } = require('./rpc.js');
 const { presentedPathsOf } = require('./history-derive.js');
@@ -97,6 +105,19 @@ async function declaredPathsOf(ctx, sessionId) {
   return presentedPathsOf((value && value.events) || []);
 }
 
+/**
+ * 落点在不在工作区里。
+ *
+ * `path.relative` 出来是空的（就是 cwd 本身）或者以 `..` 开头（爬出去了）都算不在，
+ * 这样 `../x`、`a/../../x` 这些写法一并挡住 —— 判的是**解析后的真实落点**，不是输入字符串，
+ * 所以「看起来没写过 ..」最终指到外面的路径同样过不去。
+ */
+function isInsideWorkspace(cwd, target) {
+  if (!cwd) return false;
+  const rel = path.relative(path.resolve(cwd), target);
+  return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
 /** 会话的工作区目录（相对路径的解析基准）。取不到就回空串，由调用方决定怎么办。 */
 async function cwdOf(ctx, sessionId) {
   try {
@@ -124,34 +145,35 @@ async function handleSessionFile(ctx, req, res) {
     return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { sessionId, path }' } });
   }
 
-  let declaredPaths;
-  try {
-    declaredPaths = await declaredPathsOf(ctx, sessionId);
-  } catch (error) {
-    return sendJson(res, 502, {
-      ok: false,
-      error: { code: 'history-failed', message: String((error && error.message) || error) },
-    });
-  }
-  if (!declaredPaths.has(declared)) {
-    return sendJson(res, 403, {
-      ok: false,
-      error: { code: 'not-presented', message: '这个文件不在本会话的交付声明里' },
-    });
-  }
+  // 先把落点算出来：工作区那一侧判的是**解析后的真实路径**，不是输入字符串。
+  const cwd = await cwdOf(ctx, sessionId);
+  let target = path.isAbsolute(declared) ? path.resolve(declared) : '';
+  if (!target && cwd) target = path.resolve(cwd, declared);
 
-  let target;
-  if (path.isAbsolute(declared)) {
-    target = declared;
-  } else {
-    const cwd = await cwdOf(ctx, sessionId);
-    if (!cwd) {
+  // 工作区里的文件直接放行，一次历史都不读 —— 这是正文里点的链接走的那条路。
+  if (!target || !isInsideWorkspace(cwd, target)) {
+    // 工作区之外只剩交付声明这一条口子（绝对路径、或 cwd 变了的老会话）。
+    let declaredPaths;
+    try {
+      declaredPaths = await declaredPathsOf(ctx, sessionId);
+    } catch (error) {
+      return sendJson(res, 502, {
+        ok: false,
+        error: { code: 'history-failed', message: String((error && error.message) || error) },
+      });
+    }
+    if (!declaredPaths.has(declared)) {
+      return sendJson(res, 403, {
+        ok: false,
+        error: { code: 'outside-workspace', message: '这个路径不在本会话的工作区里，手机上打不开' },
+      });
+    }
+    if (!target) {
       return sendJson(res, 409, {
         ok: false,
         error: { code: 'no-cwd', message: '这条会话没有工作区目录，没法解析相对路径' },
       });
     }
-    target = path.join(cwd, declared);
   }
 
   let info;
@@ -171,12 +193,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 +232,60 @@ 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 requestNonce = opened.req.nonce;
+  let seq = 0;
+  let pending = Buffer.alloc(0);
+  let closed = false;
+  res.on('close', () => { closed = true; });
+  // **整段都在 try 里**：调用点已经 `writeHead(200)` 过了，此后任何一步抛错都改不了状态码，
+  // 而 `sendJson` 再想写一个 500 只会撞上「头已发出」被静默吞掉 —— 响应就永远不结束，
+  // 手机上表现成「下载中」一直转、首字节等到超时。所以只能主动断开，让对端按截断处理。
+  try {
+    const path0 = signedPath(req);
+    const stream = fs.createReadStream(target, { highWaterMark: FILE_CHUNK_BYTES });
+    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

@@ -3,21 +3,23 @@
 /**
  * 发消息、slash 命令、会话的读/停/改名/分叉。
  *
- * promptOnce 的幂等窗口是这里唯一非平凡的逻辑：手机端发消息时网络重试与用户连点
- * 会产生同一个 clientMessageId 的多次请求，60 秒内它们共享同一个 prompt，而不是
- * 让模型跑两遍。**只缓存成功**：失败必须能被重试，不能把一次瞬时错误固化成 60 秒的
- * 静默无响应。
+ * promptOnce 的去重是这里唯一非平凡的逻辑：手机端发消息时网络重试与用户连点会产生
+ * 同一个 clientMessageId 的多次请求，同一会话内它们共享同一个 prompt，而不是让模型跑
+ * 两遍。成功之后记录一直留着（不按时间窗过期）：请求超时的那一发很可能已经交给宿主了，
+ * 用户隔几分钟再点一次重试，过期的窗口正好把同一条消息又发一遍。
+ * **只缓存成功**：失败必须能被重试，不能把一次瞬时错误固化成一条永远发不出去的消息。
  *
  * 文本块恰好一个且以 / 开头时派发为 slash 命令（commands.execute，不发给模型）；
  * 未知命令或网关未组合时回退普通消息，与桌面 miss 落入默认 sink 的行为一致。
  */
 
 const { sendJson, readJsonBody } = require('../shared/http-util');
+const { inlineUploadedImageBlocks } = require('./uploads.js');
 const { unwrap } = require('./envelope.js');
 const { callSessions, mobilePromptRpcId } = require('./rpc.js');
 const {
   canonicalDeviceKey, invalidateSessionList, invalidateSessionModels,
-  markCompletionRead, sendIdempotencyStateOf,
+  markCompletionRead, promptOnceFor,
 } = require('./session-cache.js');
 const { promptErrorObject, MODEL_UNAVAILABLE_ERROR } = require('./history-derive.js');
 const { withIdempotency, requestIdOf } = require('./idempotency.js');
@@ -25,7 +27,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) {
@@ -79,25 +87,9 @@ function promptOnce(ctx, clientMessageId, payload) {
   // 因为实时帧里的图还被漏读，张数一对不上就彻底认领不了）。
   const request = clientMessageId ? { ...payload, requestId: rpcId } : payload;
   if (!clientMessageId) return callSessions(ctx, 'prompt', request, rpcId);
-  const state = sendIdempotencyStateOf(ctx);
-  const key = `${payload.sessionId}:${clientMessageId}`;
-  const now = Date.now();
-  const existing = state.get(key);
-  if (existing && now - existing.createdAt < 60_000) return existing.promise;
-  if (existing) state.delete(key);
-
-  const promise = Promise.resolve(callSessions(ctx, 'prompt', request, rpcId));
-  // Keep the short-lived record so an in-flight/concurrent send with the same
-  // clientMessageId shares one prompt. Only cache a SUCCESS: a rejection must
-  // not poison later retries (a transient error should be retryable), so the
-  // record is released on failure.
-  const record = { createdAt: now, promise };
-  state.set(key, record);
-  promise.then(
-    () => { /* resolved stays cached until the 60s window expires */ },
-    () => { if (state.get(key) === record) state.delete(key); },
-  );
-  return promise;
+  // 同一个 clientMessageId 在本会话里只承诺一次：内核重试、以及隔了几分钟用户手点的
+  // 那次，都拿同一份结果（口径见 session-cache 的 `promptOnceFor`）。
+  return promptOnceFor(ctx, `${payload.sessionId}:${clientMessageId}`, () => callSessions(ctx, 'prompt', request, rpcId));
 }
 
 async function handleSend(ctx, req, res) {
@@ -130,13 +122,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,13 @@ 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);
-  // 工具结果不产生消息行，但会把**缓存里已有的**工具卡从 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);
+  const items = wantThin ? thinEntryMessages(messages, { hasMore }) : messages;
+  // 工具结果不产生消息行，但会把**缓存里已有的**工具卡从 running 补成最终态。补丁取自
+  // 整个窗口（调用方游标可能已越过结果 seq）；已随消息块下发的只回状态（见 toolResultPatchesFor）。
+  // 增量那一发（带 afterSeq）一律只回状态：调用方手上已有一份会话，整窗重发等于每 15 秒
+  // 把最近两百条的工具输出再传一次；入口裁剪那一发不带补丁（过程块已摘掉、无处可打）。
+  const toolResults = wantThin ? [] : toolResultPatchesFor(events, items, { bodies: afterSeq === null });
   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 +186,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,