dsh-mobile-plugin 0.1.76 → 0.1.78

package/README.md

@@ -74,7 +74,16 @@ pnpm add dsh-mobile-plugin@<版本>
 
 新版插件的管理面板提供「本机调试 OTA」卡片，可手动检查并安装中转发布的紧急完整包。入口仅限宿主本机访问，不会由手机或公网触发；安装后通过实现代切换生效，切换失败会恢复上一代。npm 仍是正式发布源；后续 npm 正式版本达到 OTA 版本时会接管该版本。首次发布带此功能的 npm 包需要重启一次 DSH，让稳定外壳加载 OTA 能力。
 
-发布 OTA 完整包时，在插件仓库根目录执行 `npm pack`，再按中转服务器的部署说明上传到 `dsh-hub.wnluo.com`。
+发布一个紧急完整包：在插件仓库根目录 `npm pack`，把打出来的 tgz 原样 POST 给中转（包本身就是 tar.gz，不用再解包重打）：
+
+```sh
+curl -X POST -H "authorization: Bearer <中转的 OTA 发布 token>" --data-binary @dsh-mobile-plugin-0.1.61.tgz \
+  "https://你的中转/api/desktop-plugins/ota/publish?platform=darwin&channel=stable&version=0.1.61"
+```
+
+`platform` 填 `process.platform`（`darwin` / `linux` / `win32`），`channel` 一般 `stable`。发布接口没配 token 时是关闭的，下载不受影响；版本按号比，最后发的那个才是「最新」。
+
+打包时**别用 macOS 默认的 tar 参数**——带 PAX 扩展头，宿主那边的解析器不认，会报「OTA 包结构不完整」。要 `COPYFILE_DISABLE=1 tar --no-xattrs --no-mac-metadata -czf …`，且条目以 `package/` 打头。
 
 ## 开发
 

package/lib/impl.js

@@ -62,9 +62,16 @@ export const name = 'dsh-mobile-plugin'
 //                                                  有，get trap 第一站就命中）。
 // 漏了这两个分支里的任何一个，读 `ctx.apiProxy` 都会抛
 // `cannot get property "apiProxy" without inject`：服务器宿主上 mirror 推送曾整条挂掉。
+//
+// `typertGateway` 必须出现在 inject 里（0.2.0 那一支）：宿主 RPC 全部经它派发，
+// 而它是**后于本插件**装载的服务。只 `ctx.get('typertGateway')` 而不注入，取到的是
+// 装载那一刻的空值，于是每一条事件流都抛「当前宿主版本没有提供该能力」——服务器宿主
+// 上实时推送整条挂掉，而收发消息、会话列表这些走普通请求的功能一切正常，看着像只有
+// 「刷新不实时」的小毛病。注入之后 cordis 会等服务就绪再激活本插件。
+// 旧运行时那一支不加：那版没有这个服务，注入只会让这一行永远 pending。
 export const inject = runtimeProvidesApiProxy()
   ? ['webServer', 'apiProxy', 'sessions']
-  : ['webServer', 'sessions']
+  : ['webServer', 'sessions', 'typertGateway']
 
 export const REMOTE_CONTROL_SETTINGS_NAMESPACE = 'mobile-remote-control'
 export const RemoteControlSettingsSchema = z.object({
@@ -393,6 +400,10 @@ function apply(ctx) {
     // 移动端路由表那边叫它「局域网候选」，取的是同一份私网优先的清单。
     safeLanCandidates: advertisedCandidates,
     lanPortInUse: advertisedLanPort, // LAN 候选用实绑端口
+    // 配对那条路由自己要签凭据：core 是签 token 的实现，pairingApproval 决定这台机器
+    // 收不收新设备（'deny' 时一律拒）。两者本文件都已有，透传给移动端路由。
+    core,
+    pairingApproval,
   })
   ctx.effect(() => {
     const stopWatching = settings.watch(next => {

package/lib/mobile/history-derive.js

@@ -198,26 +198,6 @@ function retryFailure(failure) {
   return out.code !== undefined || out.message !== undefined ? out : null;
 }
 
-/** 上下文行的 label 提取（与桌面 contextProvenance 同口径；取不到为 null）。 */
-function contextLabelOf(source) {
-  const kind = source.kind;
-  if (kind === 'session-reference') {
-    for (const ref of Array.isArray(source.references) ? source.references : []) {
-      if (ref && typeof ref.label === 'string' && ref.label) return ref.label;
-    }
-    return null;
-  }
-  if (kind === 'agent-instructions') {
-    for (const change of Array.isArray(source.changes) ? source.changes : []) {
-      if (change && typeof change.path === 'string' && change.path) return change.path;
-    }
-    return null;
-  }
-  if (kind === 'plugin') return typeof source.plugin === 'string' && source.plugin ? source.plugin : null;
-  if (kind === 'skill-invocation') return typeof source.name === 'string' && source.name ? source.name : null;
-  return typeof kind === 'string' ? kind : null;
-}
-
 /** 列表/概览的 lastMessage 预览只取有 role 的消息项（结构化行不参与预览）。 */
 function lastMessageOf(messages) {
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -229,12 +209,15 @@ function lastMessageOf(messages) {
 /**
  * 从 history 事件折叠出消息与「结构化行」（wire v1 扩展，向后兼容）：
  *  - 普通消息维持现状：{ id, seq, time, role, text, blocks?, images?, clientMessageId? }（user/assistant）；
- *  - compaction：{ kind:'compaction', id, seq, time, state:'running'|'done', summary?, shadowedItemCount?, shadowedTokenCount? }；
+ *  - compaction：{ kind:'compaction', id, seq, time, state:'running'|'done'|'failed', error?, turn?,
+ *    summary?, shadowedItemCount?, shadowedTokenCount? }；
  *    压缩检查点 user/message（source.kind==='plugin' && source.plugin==='compact'）绝不渲染成用户气泡，
  *    渲染成 compaction 行（id=compactionId，state='done'），并用同 compactionId 的 compaction/summary 补 counts；
+ *    compaction/end 给这次尝试落定（带 error → state='failed' + error 原文，否则 'done'）；
+ *    **同一轮里的多次尝试只占一行**（新尝试原地顶替还没落定的那条）—— 宿主一步重试一次，
+ *    不并就是几十条「正在压缩…」；
  *  - retry：{ kind:'retry', id: retryId, seq, time, status:'scheduled'|'started', retry, maxRetries, delayMs?, failure? }；
  *  - turn-error / max-tokens：{ kind:'turn-error', id:'turn-<turn>', message, code? } / { kind:'max-tokens', id:'turn-<turn>' }；
- *  - context：{ kind:'context', id:'ctx-<msgId>', contextRole:'inject'|'recall', contextLabel, text }；
  *  - command：{ kind:'command', id:commandId, name, status:'running'|'done', resultKind?, text? }
  *    （command/run 发出行，command/done 原地升级：name 保 run 的，resultKind/text 取 done 的）。
  * 结构化项与消息按事件 seq 升序混排返回；旧载荷字段缺失时跳过对应项，绝不抛错。
@@ -312,6 +295,8 @@ function deriveMessages(events) {
   };
   // 结构化行按 id 唯一：compactionId → 行索引（检查点行原地替换 start 行）、retryId → 行索引（原地升级）。
   const compactionAt = new Map();
+  // 一轮里的压缩尝试行（turn → 行索引表）：同一轮的多次尝试共用一行，见 pendingCompactionAt。
+  const compactionTurns = new Map();
   const retryAt = new Map();
   // 命令行按 commandId 唯一：command/run 发出行，command/done 原地升级（保 run 的 name，位置随 done 事件 seq 归位）。
   const commandAt = new Map();
@@ -353,12 +338,31 @@ function deriveMessages(events) {
 
   // 放入一行 compaction：同一 compactionId 只保留一行，检查点行原地替换 start 行（最终按 seq 排序归位）。
   const placeCompaction = (item) => {
-    const existing = compactionAt.get(item.id);
-    if (existing !== undefined) out[existing] = item;
-    else {
-      compactionAt.set(item.id, out.length);
+    let index = compactionAt.get(item.id);
+    if (index === undefined) {
+      index = out.length;
       out.push(item);
+    } else out[index] = item;
+    compactionAt.set(item.id, index);
+    if (typeof item.turn === 'number') {
+      const list = compactionTurns.get(item.turn);
+      if (list === undefined) compactionTurns.set(item.turn, [index]);
+      else if (!list.includes(index)) list.push(index);
     }
+    return index;
+  };
+
+  // 同一轮里的多次压缩尝试只占一行：宿主一步重试一次、每次一个新 compactionId，按 id 找必然
+  // 「每次都新增一条」——一次跑几十步就是一个回合几十条「正在压缩…」。新尝试顶替这一轮里还
+  // 没落定的那条（running / failed），已经落地（done）的不顶替：那是真压过一次的记录。
+  const pendingCompactionAt = (turn, id) => {
+    if (compactionAt.has(id)) return compactionAt.get(id);
+    if (typeof turn !== 'number') return -1;
+    for (const index of compactionTurns.get(turn) || []) {
+      const row = out[index];
+      if (row && row.kind === 'compaction' && (row.state === 'running' || row.state === 'failed')) return index;
+    }
+    return -1;
   };
 
   for (const entry of events) {
@@ -388,18 +392,8 @@ function deriveMessages(events) {
         continue;
       }
       if (src && typeof src === 'object' && src.kind !== 'user') {
-        // 上下文注入/召回（session-reference→召回，其余 kind→注入）；无文本或无可唯一 id 则跳过该项。
-        const text = blocksToText(parseBlocks(msg.content));
-        if (text === '' || msg.id == null) continue;
-        out.push({
-          id: `ctx-${String(msg.id)}`,
-          kind: 'context',
-          contextRole: src.kind === 'session-reference' ? 'recall' : 'inject',
-          contextLabel: contextLabelOf(src),
-          text,
-          seq,
-          time,
-        });
+        // 上下文注入/召回（session-reference→召回，其余 kind→注入）：桌面 `isVisibleChatNode`
+        // 只放行携带 tool-addition/tool-removal 的上下文节点，这类提示一律不显示 —— 不下发。
         continue;
       }
       // 普通用户消息（source 缺失或 kind==='user'）沿用原折叠。
@@ -407,8 +401,10 @@ function deriveMessages(events) {
     } else if (e.type === 'assistant/message' && e.data && e.data.message && e.data.message.content) {
       pushMessage(e.data.message, e);
     } else if (e.type === 'compaction/start' && e.data && typeof e.data.compactionId === 'string' && e.data.compactionId !== '') {
-      // 行已由检查点发出（done）时跳过，避免重复行。
-      if (!compactionAt.has(e.data.compactionId)) {
+      // 行已由检查点发出（done）时跳过，避免重复行。同一轮里已有没落定的行就**原地顶替**
+      // （换 id/状态，位置留在第一次尝试那一处）—— 否则一次跑几十步就是几十条行。
+      const idx = pendingCompactionAt(e.data.turn, e.data.compactionId);
+      if (idx < 0) {
         placeCompaction({
           id: e.data.compactionId,
           kind: 'compaction',
@@ -418,7 +414,46 @@ function deriveMessages(events) {
           shadowedTokenCount: null,
           seq,
           time,
+          ...(typeof e.data.turn === 'number' ? { turn: e.data.turn } : {}),
+        });
+      } else {
+        const existing = out[idx];
+        out[idx] = {
+          ...existing,
+          id: e.data.compactionId,
+          state: 'running',
+          error: null,
+          ...(typeof e.data.turn === 'number' ? { turn: e.data.turn } : {}),
+        };
+        compactionAt.set(e.data.compactionId, idx);
+      }
+    } else if (e.type === 'compaction/end' && e.data && typeof e.data.compactionId === 'string' && e.data.compactionId !== '') {
+      // 这次尝试的落定：无 error → done（summary / 检查点随后补齐 counts）、有 error → failed
+      // 带原因。这条以前整条丢掉，于是被拒绝的压缩永远停在「正在压缩…」，失败一次都看不见。
+      const error = typeof e.data.error === 'string' && e.data.error !== '' ? e.data.error : null;
+      const idx = pendingCompactionAt(e.data.turn, e.data.compactionId);
+      if (idx < 0) {
+        placeCompaction({
+          id: e.data.compactionId,
+          kind: 'compaction',
+          state: error ? 'failed' : 'done',
+          error,
+          summary: null,
+          shadowedItemCount: null,
+          shadowedTokenCount: null,
+          seq,
+          time,
+          ...(typeof e.data.turn === 'number' ? { turn: e.data.turn } : {}),
         });
+      } else {
+        const existing = out[idx];
+        out[idx] = {
+          ...existing,
+          id: e.data.compactionId,
+          state: error ? 'failed' : 'done',
+          error,
+        };
+        compactionAt.set(e.data.compactionId, idx);
       }
     } else if (e.type === 'compaction/summary' && e.data && typeof e.data.compactionId === 'string' && e.data.compactionId !== '') {
       // 已有同 compactionId 的行（start 或检查点发出）→ 升级为 done 并补 counts；否则新增 done 行。
@@ -426,6 +461,7 @@ function deriveMessages(events) {
       const existing = compactionAt.has(id) ? out[compactionAt.get(id)] : null;
       if (existing) {
         existing.state = 'done';
+        existing.error = null;
         existing.summary = compactionSummaryText(e.data.summary);
         existing.shadowedItemCount = shadowedCount(e.data.shadowedSeqs);
         existing.shadowedTokenCount = shadowedTokens(e.data.shadowedTokenCount);
@@ -517,7 +553,7 @@ function deriveMessages(events) {
         out.push({ id: `turn-${e.data.turn}`, kind: 'max-tokens', seq, time });
       }
     }
-    // tool/result、compaction/end 等其余类型照旧忽略（compaction 行已由 start 发出）。
+    // tool/result 等其余类型照旧忽略（工具结果在预扫描里配对回填；compaction 行由 start/end 发出）。
   }
   // 严格按事件 seq 升序（与消息混排；compaction 行升级/替换后位置以最终事件为准）。
   out.sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
@@ -601,7 +637,6 @@ module.exports = {
   buildToolResultMap,
   parseBlocks,
   blocksToText,
-  contextLabelOf,
   lastMessageOf,
   MOBILE_PROMPT_RPC_PREFIX,
   clientMessageIdFromSource,

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

@@ -30,15 +30,55 @@ async function* tolerate(frames, what, ctx) {
   }
 }
 
-/** 单会话事件流：follow 的 live 事件（跳过 snapshot，历史走 session.history）。 */
-async function* sessionEventFrames(ctx, sessionId, signal) {
-  const frames = await openStream(ctx, 'session', 'follow', {
-    request: { address: { kind: 'session', sessionId }, maxMessages: 1 },
-  }, signal);
-  for await (const frame of tolerate(frames, `session/${sessionId}`, ctx)) {
-    if (!frame || frame.type !== 'event' || !frame.event) continue;
+/**
+ * follow 流的一帧 → 0..n 个 mux 帧（事件原样转发；实时增量通知合成 assistant/chunk）。
+ *
+ * 0.2.0 的宿主把逐块流式增量从「会话事件」里拿了出去：正文/推理的每个 delta 只以 follow 流的
+ * `assistant-stream` 通知下发，而且**要显式传 `assistantStream: true` 才发**，事件流里只剩
+ * 「一步落定」的 `assistant/message`。不订阅通知的话，正文与运行中明细都只能在一步结束时整块
+ * 出现（真机故障 2026-10-21：回复整段蹦出来、运行中那一行没有实时明细）。
+ *
+ * 合成事件用的是移动协议早已认识的 `assistant/chunk` 形状，但**不带 seq** —— 它没有持久化
+ * 事件的身份，不该参与客户端的 seq 序门、去重与续传水位（App 侧对无 seq 帧一律放行），
+ * turn/step 由最近一次 start 通知补上。设备级推送只看 turn/start、turn/end、session/title
+ * （`lib/mobile/events.js` 的 LIST_EVENT_INNER），合成增量到不了那条通道，不会形成推送风暴。
+ *
+ * `state` 是这条流的记账（{ turn, step, streaming }），由调用方持有 —— 一帧的处理要看
+ * 「之前收到过什么」。snapshot 帧不需要处理：历史走 session.history。
+ */
+function* followFramePayloads(frame, sessionId, state) {
+  if (!frame) return;
+  if (frame.type === 'event') {
+    if (!frame.event) return;
+    // 增量只交付一次：宿主若同时把 chunk 也当成事件发，以通知为准（通知先到）。
+    if (state.streaming && frame.event.type === 'assistant/chunk') return;
     yield { payload: { type: 'session/event', sessionId, event: frame.event } };
+    return;
+  }
+  const notice = frame.type === 'assistant-stream' ? frame.frame : null;
+  if (!notice) return;
+  if (notice.type === 'start') {
+    if (Number.isSafeInteger(notice.turn)) state.turn = notice.turn;
+    if (Number.isSafeInteger(notice.step)) state.step = notice.step;
+    return;
   }
+  if (notice.type !== 'chunk' || !notice.chunk || typeof notice.chunk !== 'object') return;
+  // 块序号在通知帧上，chunk 自己也带一份；自己没带就补上（App 侧按 chunk.index 拼草稿）。
+  const chunk = typeof notice.chunk.index === 'number' || typeof notice.index !== 'number'
+    ? notice.chunk
+    : { ...notice.chunk, index: notice.index };
+  state.streaming = true;
+  yield {
+    payload: {
+      type: 'session/event',
+      sessionId,
+      event: {
+        type: 'assistant/chunk',
+        time: Number.isFinite(notice.time) ? notice.time : Date.now(),
+        data: { turn: state.turn, step: state.step, chunk },
+      },
+    },
+  };
 }
 
 /** 后台任务整帧。宿主 job/list 是流，首帧即全量 rows，之后按变化推。 */
@@ -174,20 +214,23 @@ function muxFrames(ctx, request, signal) {
     }
     const control = openStream(ctx, 'session', 'control', {}, signal).then((frames) => tolerate(frames, 'session/control', ctx));
     const jobs = openStream(ctx, 'job', 'list', { request: { sessionId } }, signal).then((frames) => tolerate(frames, `job/${sessionId}`, ctx));
+    // assistantStream: 逐块增量只走这条流的 assistant-stream 通知（见 followFramePayloads）。
     const follow = openStream(ctx, 'session', 'follow', {
-      request: { address: { kind: 'session', sessionId }, maxMessages: 1 },
+      request: { address: { kind: 'session', sessionId }, maxMessages: 1, assistantStream: true },
     }, signal).then((frames) => tolerate(frames, `session/${sessionId}`, ctx));
     const projections = projectionState();
-    const sources = await Promise.all([control, jobs, follow].map((promise) => promise.then(async function* wrap(iterable) {
+    const followState = { turn: null, step: null, streaming: false };
+    const sources = await Promise.all([['control', control], ['jobs', jobs], ['follow', follow]].map(([source, promise]) => promise.then(async function* wrap(iterable) {
       for await (const frame of iterable) {
-        if (frame && frame.type === 'rows') {
+        if (source === 'follow') {
+          // follow 一帧可能产出 0..n 个 mux 帧（事件原样 + 增量通知合成 chunk 事件）。
+          yield* followFramePayloads(frame, sessionId, followState);
+        } else if (frame && frame.type === 'rows') {
           yield { payload: { type: 'session/jobs', sessionId, jobs: Array.isArray(frame.jobs) ? frame.jobs : [] } };
         } else if (frame && frame.type === 'baseline') {
           yield* applyBaseline(frame, projections, sessionId, ctx);
         } else if (frame && frame.type === 'projection') {
           yield* applyUpdate(frame, projections, sessionId, ctx);
-        } else if (frame && frame.type === 'event' && frame.event) {
-          yield { payload: { type: 'session/event', sessionId, event: frame.event } };
         }
       }
     }).catch((error) => {

package/lib/mobile/pairing.js

@@ -0,0 +1,211 @@
+'use strict';
+
+/**
+ * 移动端配对：手机在中转上用自己的配对码换到 token 与设备凭据。
+ *
+ * **这条路由归宿主，不归中转。**「谁可以进这台机器」是宿主自己的判断，配对码本来就存在
+ * 宿主的 `state` 里；中转只按实例标识把请求转过来。早先这套判断长在独立的中转进程里
+ * （`dsh-mobile-server/server.js` 的 `/pair`），换成 Rust 中转时整块没搬过去，于是手机
+ * 按老地址 POST `/pair`、请求被中转原样转给宿主、宿主没有这条路由，只能回 405。
+ *
+ * 与局域网那条（`lib/relay/lan-proxy.js` 的 `/__lan_pair`）是**同一件事的两个入口**：
+ * 都是「配对码 → 签发凭据」，差别只在网络路径。凭据本身两条路签发的是同一种 HMAC
+ * （都用宿主 lanSecret 签名），所以经中转配对拿到的 token 可以直接用于局域网请求。
+ *
+ * 故意**不**在这里做的事：
+ *  - 不问宿主再确认一次。宿主的配对策略（pairingPolicy）已经决定了它接不接受新设备，
+ *    `deny` 时中转根本连不上；而这条路由本身就跑在宿主进程里。
+ *  - 不做「多台机器撞同一个配对码」的处理。那是中转的职责（它才看得见全部实例），
+ *    在这台宿主上，配对码要么对上要么对不上。
+ */
+
+const { sendJson } = require('../shared/http-util');
+const { safeEqual } = require('../shared/dshtoken');
+
+/** 与局域网那条同口径：连错 5 次锁 60 秒。 */
+const PAIR_MAX_FAILS = 5;
+const PAIR_LOCK_MS = 60_000;
+
+/** ip -> { fails, lockedUntil }。放在模块作用域，两种入口共用同一份额度。 */
+const pairLocks = new Map();
+
+function isPairLocked(ip) {
+  const entry = pairLocks.get(ip);
+  return !!entry && entry.lockedUntil > Date.now();
+}
+
+function recordPairFail(ip) {
+  const entry = pairLocks.get(ip) || { fails: 0, lockedUntil: 0 };
+  entry.fails += 1;
+  if (entry.fails >= PAIR_MAX_FAILS) {
+    entry.lockedUntil = Date.now() + PAIR_LOCK_MS;
+    entry.fails = 0;
+  }
+  pairLocks.set(ip, entry);
+}
+
+function clearPairFails(ip) {
+  pairLocks.delete(ip);
+}
+
+/** 测试用：清空限流计数。 */
+function resetPairLocks() {
+  pairLocks.clear();
+}
+
+/** 请求方 IP。中转会把真实来源放进 x-real-ip（与 nginx 同一约定）。 */
+function clientIp(req) {
+  const headers = (req && req.headers) || {};
+  const raw = headers['x-real-ip'];
+  const header = Array.isArray(raw) ? raw[0] : raw;
+  if (typeof header === 'string' && header.trim()) return header.trim();
+  return (req && req.socket && req.socket.remoteAddress) || '';
+}
+
+/**
+ * 配对码错误 / 策略拒绝统一回同一响应。
+ *
+ * 分开回等于告诉对方「这个码是真的，只是被拒了」，也就是把一个免费的存在性查询送出去。
+ */
+function pairDenied(res) {
+  sendJson(res, 401, { ok: false, error: '配对码错误' });
+}
+
+/**
+ * 读请求体。配对体很小（配对码 + 设备元信息），上限给 16KB。
+ */
+function readBody(req) {
+  return new Promise((resolve) => {
+    if (!req || typeof req.on !== 'function') {
+      resolve({});
+      return;
+    }
+    let raw = '';
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      try {
+        resolve(JSON.parse(raw || '{}'));
+      } catch {
+        resolve(null);
+      }
+    };
+    req.setEncoding('utf8');
+    req.on('data', (chunk) => {
+      raw += chunk;
+      if (raw.length > 16 * 1024) {
+        raw = raw.slice(0, 16 * 1024);
+        req.destroy();
+        finish();
+      }
+    });
+    req.on('end', finish);
+    req.on('error', finish);
+  });
+}
+
+/**
+ * 构造 `/pair` 的 handler。依赖由 impl.js 注入，与移动端其它路由同一形状。
+ *
+ * @param {object} deps
+ * @param {object} deps.state  宿主状态（instanceId / pairingCode / lanSecret）
+ * @param {Function} deps.readJsonBody
+ * @param {object} deps.core    relay/core.js（签 token 用）
+ * @param {object} deps.credentials 设备凭据库（issue 接口）
+ * @param {object} deps.pairingApproval pairing-policy.js（决定这台机器收不收新设备）
+ * @param {(message: string) => void} deps.log
+ */
+function createPairHandler(deps) {
+  const { state, core, credentials, pairingApproval, log } = deps;
+
+  // ⚠️ 签名必须是 `(req, res)` **两个**参数：宿主 webServer 就是 `handler(req, res)` 调的。
+  // 写成 `(_ctx, req, res)` 会把 res 挤成 undefined，而 sendJson 的 catch 会把那个
+  // TypeError 当成「连接已关闭」吞掉——既没报错也没回包，请求永久挂住（/health 踩过）。
+  return async function handlePair(req, res) {
+    const ip = clientIp(req);
+
+    if (isPairLocked(ip)) {
+      sendJson(res, 429, { ok: false, error: '尝试过于频繁，请稍后再试' });
+      return;
+    }
+
+    const body = await readBody(req);
+    if (!body || typeof body !== 'object') {
+      sendJson(res, 400, { ok: false, error: '请求体不是合法 JSON' });
+      return;
+    }
+
+    const code = typeof body.code === 'string' ? body.code.trim() : '';
+    if (!/^\d{6}$/.test(code)) {
+      sendJson(res, 400, { ok: false, error: '配对码需为 6 位数字' });
+      return;
+    }
+
+    const expected = String(state.pairingCode || '');
+    if (!expected || !safeEqual(code, expected)) {
+      recordPairFail(ip);
+      pairDenied(res);
+      return;
+    }
+
+    // 配对码对了，还要宿主自己的策略点头：'deny' 就是明确不收新设备。
+    const decision = pairingApproval.evaluate(state.pairingPolicy, body.device);
+    if (!decision.approved) {
+      recordPairFail(ip);
+      pairDenied(res);
+      return;
+    }
+
+    // **配对码正确时不清限流计数**：被拒的尝试同样要记数，否则猜对码但被策略拒的一方
+    // 可以无限重试。只有真正放行才清零。
+    clearPairFails(ip);
+
+    const instanceId = String(state.instanceId || '');
+    const supplied = body.device && typeof body.device === 'object' ? body.device : {};
+    const device = {
+      ...Object.fromEntries(Object.entries(supplied).filter(([, value]) => value !== undefined)),
+      ip,
+    };
+
+    let issued;
+    try {
+      issued = credentials.issue(instanceId, device, '');
+    } catch (error) {
+      log('pair issue failed:', error && error.message);
+      sendJson(res, 500, { ok: false, error: 'internal error' });
+      return;
+    }
+
+    // 两样都要给，缺一样 App 就停在「配对响应缺少 token/cookie」：
+    //  - `token` 是 **bearer**（`Authorization: Bearer …`），365 天；
+    //  - `cookie` 是**中转路由**用的那张，30 天。
+    // 两者的 TTL 刻意不同，别合成一个常量（见 relay/core.js 的 MOBILE_BEARER_TTL_SEC 注释）。
+    const token = core.signLanToken(state.lanSecret, instanceId, core.MOBILE_BEARER_TTL_SEC);
+    const cookieValue = core.signLanToken(state.lanSecret, instanceId, core.MOBILE_TOKEN_TTL_SEC);
+    const hostPlatform = pairingApproval.hostPlatform().platform;
+    sendJson(res, 200, {
+      ok: true,
+      instanceId,
+      token,
+      // cookie 同时放进 body：RN 的 fetch 读不到 Set-Cookie，App 得自己带上。
+      cookie: `dsh_lan=${cookieValue}`,
+      deviceId: issued.deviceId,
+      deviceCredential: issued.credential,
+      credentialExpiresAt: issued.expiresAt,
+      // 宿主自己的系统标识，不是手机的。键名**必须是 `hostPlatform`**：App 落盘的就是它
+      //（app/src/services/pairApi.ts 读 `body.hostPlatform` 存进 `MobileSession.hostPlatform`），
+      // 局域网那条（lan-proxy.js）给的也是它。`hostPlatform()` 回的是 `{platform}` 对象，
+      // 整块展开就变成 `platform` —— App 收不到，设备行退回通用图标（真机上少的就是企鹅）。
+      ...(hostPlatform ? { hostPlatform } : {}),
+    });
+  };
+}
+
+module.exports = {
+  createPairHandler,
+  resetPairLocks,
+  clientIp,
+  PAIR_MAX_FAILS,
+  PAIR_LOCK_MS,
+};

package/lib/mobile/sessions.js

@@ -42,7 +42,7 @@ const {
 const { resolveEventAttachments } = require('./attachments.js');
 const { updateCompletionStates, confirmCompletionFromHistory } = require('./completion.js');
 const { buildMessagesSnapshot, buildStatsSnapshot, statsProjections, handleMessages } = require('./session-snapshot.js');
-const { safeModelsValue, buildModelsSnapshot, handleModels, handleSelectModel } = require('./session-models.js');
+const { buildModelsSnapshot, handleModels, handleSelectModel } = require('./session-models.js');
 const { buildSingleSessionMirror, buildMirrorWarmSnapshots } = require('./session-mirror.js');
 const { promptOnce, handleSend, handleCommands, handleSessionRead, handleSessionAttachment, handleStop,
   handleRename, handleFork } = require('./session-send.js');
@@ -404,12 +404,6 @@ async function handleNew(ctx, req, res) {
     if (!sessionId) {
       return { status: 500, body: { ok: false, error: { code: 'internal', message: '新建会话未返回 sessionId' } } };
     }
-    // 创建响应携带宿主当前选择；APP 可立即显示，完整目录仍可后台刷新。
-    let models;
-    try {
-      const result = unwrap(await callSessions(ctx, 'models', { sessionId }));
-      if (!result.error) models = safeModelsValue(result.value);
-    } catch { /* 模型目录不可用时仍允许创建会话 */ }
     // 新建的会话要立刻出现在列表里，否则手机端最长 10 秒看不到它。
     invalidateSessionList(ctx);
     return {
@@ -419,7 +413,6 @@ async function handleNew(ctx, req, res) {
         sessionId,
         cwd: payload.cwd || null,
         ...(value && typeof value.agentPreset === 'string' ? { agentPreset: value.agentPreset } : {}),
-        ...(models?.current ? { models } : {}),
       },
     };
   });