dsh-mobile-plugin 0.2.0 → 0.2.1

package/README.md

@@ -138,7 +138,7 @@ npm test
 1. 跑 `node scripts/bump-version.mjs` 更新版本号（演示页的 `DEMO_VERSION` 会一起改，别手改）。
 2. 改过 `React/` 就跑 `cd React && pnpm run build`。
 3. 提交这次发版该带的文件，别 `git add -A`。
-4. 在**主仓**的插件目录跑 `npm run release:check`。它按固定顺序查六件事：是不是在主仓里（跨仓对账要读 `app/`）、版本号与 tag（三段 `0..999`、这个 tag 没打过、不比上一版低）、工作区干不干净、面板产物有没有跟上面板源码、整套测试、真打一次包看文件清单。任何一步红就停，并说明该修哪里。**它要求在提交之后跑**，因为查的是「发出去的那一份」。
+4. 在**主仓**的插件目录跑 `npm run release:check`。它按固定顺序查六件事：是不是在主仓里（跨仓对账要读 `app/`）、版本号与 tag（三段 `0..999`、这个 tag 没打过、不比上一版低）、工作区干不干净、面板产物跟不跟得上源码（拿当前源码真重建一次，与盘上那份逐字节比）、整套测试、真打一次包看文件清单。任何一步红就停，并说明该修哪里。**它要求在提交之后跑**，因为查的是「发出去的那一份」。
 5. 把提交同步到公开仓库 `WNLUO/dsh-mobile-plugin`。
 6. 推一个与版本号同名的 tag（版本 0.1.99 就推 `v0.1.99`）。那个仓库的 `.github/workflows/publish.yml` 会跑测试并直接发布，不需要人在浏览器里点二次验证 —— 它走 npm 的 trusted publishing（OIDC），npm 认的是这条流水线而不是某个令牌。
 7. 等流水线绿。它末尾自己会核 `npm view dsh-mobile-plugin version`，你也可以手动看一眼。

package/lib/impl.js

@@ -27,7 +27,7 @@ const { viaChannel } = require('./shared/via-header')
 const { createSidecarLifecycle } = require('./sidecar-lifecycle.cjs')
 const { createMirrorPusher } = require('./mirror/pusher.cjs')
 const { randomBytes } = require('node:crypto')
-const { lanUrls, advertisedCandidates, orderCandidates, ipv6Candidates } = require('./relay/lan-network.cjs')
+const { lanUrls, advertisedCandidates, phoneCandidates, ipv6Candidates } = require('./relay/lan-network.cjs')
 const { resolvePort } = require('./relay/port-allocator.cjs')
 const { createPreviewService } = require('./relay/preview.js')
 // 本机设备凭据库：/api/relay/revoke-all 必须同时吊销局域网直连的 dshc_ 凭据，
@@ -98,6 +98,8 @@ export const RemoteControlSettingsSchema = z.object({
   // 手机优先用哪条地址：空 = 不指定（按宿主网卡优先级排）。选择只挪候选顺序、不删候选，
   // 理由与边界见 relay/lan-network.cjs 的 orderCandidates 与 relay.json 那条地图条目。
   preferredLanAddress: z.string().max(64).default(''),
+  // 用户手填的直连地址（`manualLanUrl`，内网穿透域名）也随二维码一起走，见 lan-network.cjs。
+  manualLanUrl: z.string().max(200).default(''),
 })
 
 
@@ -115,6 +117,7 @@ function configOf(state) {
     // 不会把它回显给手机、二维码或日志。
     registerSecret: typeof state.registerSecret === 'string' ? state.registerSecret : '',
     preferredLanAddress: typeof state.preferredLanAddress === 'string' ? state.preferredLanAddress : '',
+    manualLanUrl: typeof state.manualLanUrl === 'string' ? state.manualLanUrl : '',
   }
 }
 
@@ -173,7 +176,9 @@ function createConfigStore(state) {
 function pairingPayload(state, lanPort) {
   const port = Number.isInteger(lanPort) ? lanPort : state.lanPort
   // 面板上选过的「手机优先用这条」在这里兑现：只挪到最前，其余继续当兜底（App 按顺序挨个试）。
-  const candidates = state.lanEnabled ? orderCandidates(advertisedCandidates(port), state.preferredLanAddress) : []
+  const candidates = state.lanEnabled
+    ? phoneCandidates(advertisedCandidates(port), { preferred: state.preferredLanAddress, manual: state.manualLanUrl })
+    : []
   const urls = candidates.map(candidate => candidate.url).filter(Boolean)
   const relayUrl = state.relayUrl || ''
   const payload = {
@@ -468,8 +473,8 @@ function apply(ctx) {
     // 一进来就 ReferenceError。同一个 apply() 里给 createStatusView 传的是
     // `sidecarLifecycle.getSnapshot`，两处不一致才让这个笔误活了下来。
     getSidecarSnapshot: sidecarLifecycle.getSnapshot,
-    // 移动端路由表那边叫它「局域网候选」，取的是同一份私网优先的清单。
-    safeLanCandidates: advertisedCandidates,
+    // 移动端那边的「局域网候选」：私网优先的清单 + 用户手填的直连地址（网卡扫不出的域名）。
+    safeLanCandidates: (port) => phoneCandidates(advertisedCandidates(port), { manual: state.manualLanUrl }),
     // IPv6 直连候选单独一份：App 拿它单开一条通道、和公网中转比速度，不掺进上面那份的排序。
     safeIpv6Candidates: ipv6Candidates,
     lanPortInUse: advertisedLanPort, // LAN 候选用实绑端口

package/lib/index.js

@@ -158,7 +158,8 @@ export function apply(ctx) {
     .then(() => {
       log('info', 'dsh-mobile-plugin: 已装载 %s（来源 %s）', runtime.status().version, runtime.status().source)
       // 每 10 分钟让已落盘的正式版接管 OTA，并补上「盘上比运行中新」的那一次换代；
-      // 自动安装仍由开关控制。补换代不受开关管：它不下载任何东西，只是让已经在盘上的代码生效。
+      // 自动安装仍由开关控制，开着就**不等正在跑的对话**（`auto` 那一档，见 update-install）。
+      // 补换代不受开关管：它不下载任何东西，只是让已经在盘上的代码生效。
       const timer = setInterval(() => {
         deviceOta.reconcileOfficial()
           .then(() => updater.reconcileInstalledGeneration({ runtime, log }))

package/lib/mobile/credential-upgrade.js

@@ -14,10 +14,16 @@
  * 不这么做就只能让用户重新扫一次码。升级之后所有流量仍由这把钥匙端到端加密。
  *
  * 换成什么不在本次判断里：拿到完整一套（凭据 + 密钥 + 标识）才回补丁，缺一样就当没升级。
+ *
+ * **请求体必须现读**（2026-10-25 修）：这条路服务的恰好是协议 v1 的老会话，而老会话发的
+ * 是明文 —— 守卫只为「带信封」的那条路预先解好 `req.body`，明文请求的字节还挂在 socket 上
+ * 没人读过。原来这里直接取 `req.body`，于是永远拿到空对象、宿主每次都回「没升级」，手机
+ * 那边一次都没成功过（真机表现是「App 与插件都更新了，设备行仍旧写链路未加密」）。
+ * 现在与其它移动端路由同一条读法（`readJsonBody`：`req.body` 有就用，没有就读流）。
  */
 
 const crypto = require('node:crypto');
-const { sendJson } = require('../shared/http-util.js');
+const { sendJson, readJsonBody } = require('../shared/http-util.js');
 const { DEVICE_KEY_RE, KEY_ID_RE } = require('../shared/e2ee-pair.js');
 
 /** 请求出示的设备凭据：独立头优先，`Authorization` 只用于兼容早期客户端。 */
@@ -51,14 +57,16 @@ function deviceSecretOf(body) {
  * @param {object} res
  * @param {{ instanceId: string, store: object, log?: Function }} deps
  */
-function handleCredentialUpgrade(req, res, deps) {
+async function handleCredentialUpgrade(req, res, deps) {
   const instanceId = String((deps && deps.instanceId) || '');
   const store = deps && deps.store;
   if (!store) return sendJson(res, 503, { ok: false, error: { code: 'unavailable', message: '凭据库不可用' } });
 
   const presented = presentedCredential(req);
   const record = presented ? store.lookup(presented, instanceId) : null;
-  const body = req.body && typeof req.body === 'object' ? req.body : {};
+  // 见文件头：明文请求的体没人读过，必须在这里现读（读法与其它移动端路由一致）。
+  const parsed = await readJsonBody(req, 64 * 1024);
+  const body = parsed && typeof parsed === 'object' ? parsed : {};
   const meta = body.device && typeof body.device === 'object' ? body.device : body;
   const deviceId = String(meta.deviceId || meta.id || (record && record.deviceId) || '');
 

package/lib/mobile/history-derive.js

@@ -170,8 +170,14 @@ function buildToolResultMap(events) {
  * `items` 里的 tool-call 块本来就是同一张表构出来的，输出/图片/diff 再传一遍等于同一份
  * 工具输出在一条响应里走两趟。客户端打补丁时状态照写、正文只在给了的时候才覆盖，所以
  * 那几格省掉是安全的；消息块不在这份窗口里时才带全。
+ *
+ * `bodies: false`（增量拉取）连「消息块不在这份窗口里」的那些也只回状态。理由是同一个：
+ * 增量拉取的调用方手上已经有一份完整的会话，缺的只是「这几次调用结束了没有」；把整窗的
+ * 工具输出再灌一遍，等于每 15 秒把最近两百条消息里的工具输出重发一次（读文件、跑命令的
+ * 输出几十到几百 KB 很常见）。要全文的那条路是入口整份拉取（无游标）与展开时重新拉。
  */
-function toolResultPatchesFor(events, items) {
+function toolResultPatchesFor(events, items, options = {}) {
+  const bodies = options.bodies !== false;
   const delivered = new Set();
   for (const item of items || []) {
     if (!item || !Array.isArray(item.blocks)) continue;
@@ -183,7 +189,7 @@ function toolResultPatchesFor(events, items) {
   }
   return [...buildToolResultMap(events).entries()].map(([callId, result]) => {
     const state = result.isError ? (result.code === 'interrupted' ? 'stopped' : 'error') : 'ok';
-    if (delivered.has(callId)) return { callId, state };
+    if (!bodies || delivered.has(callId)) return { callId, state };
     return {
       callId,
       state,
@@ -373,6 +379,19 @@ function deriveMessages(events) {
     if (bucket.length > 0) presentedByTurn.set(data.turn, bucket);
   }
 
+  /**
+   * 这一轮**被 write / edit 动过**的文件，按轮攒。
+   *
+   * 为什么按轮而不是按单条消息：一份文件是一轮里某一步写的，而收尾答复那条消息自己一个
+   * 写操作都没有 —— 按消息算的话，正文里提到刚写好的文件时那份清单永远是空的（2026-10-25
+   * 现场：手机上那个文件名一直是灰的，数一遍 54 条消息只有 4 条带得动这份清单）。
+   * 桌面 `dsh-client-ui-deliverables` 的 `selectProducedFiles(owner)` 也是按**整轮**取。
+   *
+   * 攒完在循环之后回填：同一轮里先发的消息也要能看到这一轮后几步才写出来的文件。
+   */
+  const producedByTurn = new Map();
+  const producedItems = [];
+
   // 单步计时预扫描：为每条 assistant 消息派生「本轮」的 ttft / decode / 输出 token
   // （对齐桌面 turn-metrics/assistant-timing：ttftMs = 首个非空 delta − step/start；
   // decodeMs = 落定 − 首个 delta；outputTokens = assistant/message.usage.outputTokens）。
@@ -490,17 +509,27 @@ function deriveMessages(events) {
       seq: e.seq,
       time: e.time,
     };
-    const producedFiles = blocks.filter((block) => block.type === 'tool-call' && (block.name === 'write' || block.name === 'edit') && block.state === 'ok').map((block) => {
-       try {
-         const args = JSON.parse(block.argsRaw || '{}');
-         return typeof args.path === 'string' ? args.path : typeof args.file_path === 'string' ? args.file_path : null;
-       } catch { return null; }
-     }).filter((path) => typeof path === 'string');
-     if (producedFiles.length > 0) item.producedFiles = [...new Set(producedFiles)];
-     // 这一轮模型显式声明的交付文件：轮尾那张交付卡的唯一依据（与 producedFiles 分开，
-     // 后者只给收尾正文的行内引用解析用）。事件没有 turn 号的（老日志）不挂。
-     const turn = e.data && typeof e.data.turn === 'number' ? e.data.turn : undefined;
-     if (turn !== undefined) {
+    // 这一轮的轮号（老日志没有）：产出清单与交付声明都按它归并。
+    const turn = e.data && typeof e.data.turn === 'number' ? e.data.turn : undefined;
+    // 本条消息自己写 / 改过的文件：并进**这一轮**的那一份，不单独挂在它自己头上。
+    const ownWrites = blocks
+      .filter((block) => block.type === 'tool-call' && (block.name === 'write' || block.name === 'edit') && block.state === 'ok')
+      .map((block) => {
+        try {
+          const args = JSON.parse(block.argsRaw || '{}');
+          return typeof args.path === 'string' ? args.path : typeof args.file_path === 'string' ? args.file_path : null;
+        } catch { return null; }
+      })
+      .filter((path) => typeof path === 'string');
+    if (turn !== undefined && ownWrites.length > 0) {
+      const bucket = producedByTurn.get(turn) || new Set();
+      for (const path of ownWrites) bucket.add(path);
+      producedByTurn.set(turn, bucket);
+    }
+    // 回填要等循环跑完（这一轮后面几步写的也要算进来），先把这条记下来。
+    if (turn !== undefined) producedItems.push({ item, turn });
+     // 这一轮模型显式声明的交付文件：轮尾那张交付卡的唯一依据（与产出的清单分开）。
+    if (turn !== undefined) {
        const presented = presentedByTurn.get(turn);
        if (presented && presented.length > 0) item.presentedFiles = presented.map((file) => ({ ...file }));
      }
@@ -756,6 +785,16 @@ function deriveMessages(events) {
     }
     // tool/result 等其余类型照旧忽略（工具结果在预扫描里配对回填；compaction 行由 start/end 发出）。
   }
+  // 产出清单按轮回填：这一轮所有 write / edit 的并集，挂到这一轮每条 assistant 消息上。
+  // 挂「整轮」而不是「从写那一刻起」，与桌面 `selectProducedFiles(owner)` 同口径；正文里
+  // 提到这一轮写的文件就能解析成可点（App 侧按文件名或整条路径唯一命中才画，见
+  // `viewmodels/file-mentions`）。
+  if (producedItems.length > 0) {
+    for (const { item, turn } of producedItems) {
+      const bucket = producedByTurn.get(turn);
+      if (bucket && bucket.size > 0) item.producedFiles = [...bucket];
+    }
+  }
   // 严格按事件 seq 升序（与消息混排；compaction 行升级/替换后位置以最终事件为准）。
   out.sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
   return out;

package/lib/mobile/host-bridge/event-synthesis.js

@@ -304,19 +304,31 @@ function projectionState() {
  * `Array.isArray(items)` 判定失败、整帧被静默丢弃 —— 排队条一次都不显示。
  *
  * `next-turn`（等下一轮才开始的消息）→ `placement: 'queued'`，QueueDock 只认这一个值。
- * `next-step`（本步末尾注入的插话）暂不合成 `steering`：手机发起的插话已有本地待发气泡
- * （`useChatStream` 的 `pending-<clientMessageId>`）与落定后的正文行，多推一份会在同一处
- * 多画一条用户气泡。`message.id` 用宿主行自己的 id，App 靠它与正文去重（chatRenderRows）。
+ * `next-step`（已收下、等本步末尾注入的插话）→ `placement: 'steering'`：排队条与正文列表都
+ * 只认 `queued`，所以它不会多画一行；它的用处是「宿主已经收下了」这条回执 —— 插话从发出去
+ * 到真被插进去中间可能隔着好几个工具往返，此前手机上只挂着一颗「发送中…」。页脚那排插话
+ * 气泡会把本机自己发的那几条排掉（`steeringForFooter`），不会与待发气泡双画。
+ * `message.id` 用宿主行自己的 id，App 靠它与正文去重（chatRenderRows）。
  */
 function queueItems(inbox, ctx) {
-  const rows = inbox && Array.isArray(inbox['next-turn']) ? inbox['next-turn'] : [];
   const items = [];
   let dropped = 0;
-  for (const message of rows) {
-    if (!message || typeof message !== 'object') continue;
-    const id = typeof message.id === 'string' && message.id ? message.id : '';
-    if (!id) { dropped += 1; continue; } // 没有 id 的行没法被 session.updateQueue 定位，别发出去
-    items.push({ id, placement: 'queued', message: { id, content: message.content } });
+  /**
+   * 摊平一组待发行。`placement` 只标语义：`queued` 进排队条，`steering` 只是回执。
+   * 没有 id 的行丢弃并计数（理由见下面的注释）。
+   */
+  const absorb = (rows, placement) => {
+    if (!Array.isArray(rows)) return;
+    for (const message of rows) {
+      if (!message || typeof message !== 'object') continue;
+      const id = typeof message.id === 'string' && message.id ? message.id : '';
+      if (!id) { dropped += 1; continue; } // 没有 id 的行没法被 session.updateQueue 定位，别发出去
+      items.push({ id, placement, message: { id, content: message.content } });
+    }
+  };
+  if (inbox && typeof inbox === 'object') {
+    absorb(inbox['next-turn'], 'queued');
+    absorb(inbox['next-step'], 'steering');
   }
   // 丢弃必须留痕：旧实现是裸 continue，手机上少一条待发消息而宿主侧一行日志都没有，
   // 只能靠人对着桌面端数气泡。凭空造 id 更糟——App 的 session.updateQueue 按 id 定位，

package/lib/mobile/relay-control.js

@@ -75,6 +75,7 @@ function configView(state) {
     lanPort: Number.isInteger(state.lanPort) ? state.lanPort : 18787,
     pairingPolicy: pairingApproval.normalize(state.pairingPolicy),
     preferredLanAddress: typeof state.preferredLanAddress === 'string' ? state.preferredLanAddress : '',
+    manualLanUrl: typeof state.manualLanUrl === 'string' ? state.manualLanUrl : '',
     /** 注册密钥设没设（值本身不回）。 */
     registerSecretSet: typeof state.registerSecret === 'string' && state.registerSecret !== '',
   };
@@ -129,6 +130,16 @@ function configPatch(body) {
     }
     patch.preferredLanAddress = body.preferredLanAddress.trim();
   }
+  // 用户手填的直连地址：**空串是合法值**（= 清掉这条，回到只认网卡候选）。
+  // 与 `relayUrl` 一样只挡类型与长度，格式由 `relay/lan-network.cjs` 的 `manualCandidate`
+  // 在产候选那一步判 —— 这里拒掉一条「看着不像地址」的字符串，只会让手机上那句错误提示
+  // 指向一个它自己也说不清的规则。
+  if (body.manualLanUrl !== undefined) {
+    if (typeof body.manualLanUrl !== 'string' || body.manualLanUrl.length > 200) {
+      return { ok: false, message: '直连地址必须是 200 字以内的字符串（空串表示清掉）' };
+    }
+    patch.manualLanUrl = body.manualLanUrl.trim().replace(/\/+$/, '');
+  }
   if (Object.keys(patch).length === 0) return { ok: false, message: '没有任何可改的字段' };
   return { ok: true, patch };
 }
@@ -194,6 +205,8 @@ function createRelayControlHandlers(deps) {
       lan: lanCandidates(port),
       public: publicCandidates(port),
       ipv6: ipv6Candidates(port),
+      /** 用户手填的那条直连地址（空串 = 没填）。与上面三份并列给出，界面不用拼。 */
+      manual: typeof state.manualLanUrl === 'string' ? state.manualLanUrl : '',
     };
   }
 

package/lib/mobile/session-cache.js

@@ -39,7 +39,8 @@ 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 / 生成时刻 / 当时的信号代号。
@@ -265,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);
@@ -356,5 +395,6 @@ module.exports = {
   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;
@@ -221,14 +243,17 @@ async function handleSessionFile(ctx, req, res) {
  */
 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 里**：调用点已经 `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;

package/lib/mobile/session-send.js

@@ -3,10 +3,11 @@
 /**
  * 发消息、slash 命令、会话的读/停/改名/分叉。
  *
- * promptOnce 的幂等窗口是这里唯一非平凡的逻辑：手机端发消息时网络重试与用户连点
- * 会产生同一个 clientMessageId 的多次请求，60 秒内它们共享同一个 prompt，而不是
- * 让模型跑两遍。**只缓存成功**：失败必须能被重试，不能把一次瞬时错误固化成 60 秒的
- * 静默无响应。
+ * promptOnce 的去重是这里唯一非平凡的逻辑：手机端发消息时网络重试与用户连点会产生
+ * 同一个 clientMessageId 的多次请求，同一会话内它们共享同一个 prompt，而不是让模型跑
+ * 两遍。成功之后记录一直留着（不按时间窗过期）：请求超时的那一发很可能已经交给宿主了，
+ * 用户隔几分钟再点一次重试，过期的窗口正好把同一条消息又发一遍。
+ * **只缓存成功**：失败必须能被重试，不能把一次瞬时错误固化成一条永远发不出去的消息。
  *
  * 文本块恰好一个且以 / 开头时派发为 slash 命令（commands.execute，不发给模型）；
  * 未知命令或网关未组合时回退普通消息，与桌面 miss 落入默认 sink 的行为一致。
@@ -18,7 +19,7 @@ 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');
@@ -86,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) {

package/lib/mobile/session-snapshot.js

@@ -171,12 +171,11 @@ async function handleMessages(ctx, req, res) {
   const messages = deriveMessages(resolvedEvents);
   const hasMore = !!(value && value.hasMore);
   const items = wantThin ? thinEntryMessages(messages, { hasMore }) : messages;
-  // 工具结果不产生消息行，但会把**缓存里已有的**工具卡从 running 补成最终态。补丁必须
-  // 取自整个窗口（不只是 seq > afterSeq 的那一段）：调用方游标可能已经越过结果 seq，
-  // 而工具卡还停在 running；客户端按 callId 幂等打补丁。已经随消息块下发的那些只回状态，
-  // 不重复带正文（规则与理由见 history-derive 的 toolResultPatchesFor）。
-  // 入口裁剪那一发不带补丁：过程块已摘掉、补丁无处可打，跟着走等于把工具输出又塞回顶层。
-  const toolResults = wantThin ? [] : toolResultPatchesFor(events, items);
+  // 工具结果不产生消息行，但会把**缓存里已有的**工具卡从 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