dsh-mobile-plugin 0.1.89 → 0.1.91

package/lib/impl.js

@@ -32,6 +32,8 @@ const { createPreviewService } = require('./relay/preview.js')
 // 入口按两条盘上布局分别找（嵌在插件包内 / 与插件包同级），见 shared/credentials-entry.js。
 const credentials = require('./shared/credentials-entry.js').credentialsEntry()
 const { createApiProxy } = require('./mobile/host-bridge.js')
+const { installApprovalBridge } = require('./mobile/approvals.js')
+const { installQuestionBridge } = require('./mobile/questions.js')
 // 「手机上最近来过没有」：守卫记、控制面状态读。单独一个模块，装配层只转交。
 const activity = require('./mobile/activity.cjs')
 const { installAutoArchive } = require('./auto-archive.cjs')
@@ -225,7 +227,10 @@ function apply(ctx) {
   // —— host-bridge.js 是翻译到 0.2.0 的 `ctx.get('typertGateway')` 的。所以按运行时
   // 有没有这个包二选一：有就用宿主那份真 apiProxy，没有才装兼容服务。
   // （不能靠 `ctx.get('apiProxy')` 判断：宿主是后于本插件装载的，那时它还不在。）
-  if (!runtimeProvidesApiProxy()) ctx.reflect.provide('apiProxy', createApiProxy(ctx))
+  // 这两条二选一，判据同源：0.1.x 宿主自带真 apiProxy（审批帧与回答都还走得通），
+  // 0.2.x 才需要兼容桥，也才需要审批桥（见 mobile/approvals.js 的文件头）。
+  const hasHostApiProxy = runtimeProvidesApiProxy()
+  if (!hasHostApiProxy) ctx.reflect.provide('apiProxy', createApiProxy(ctx))
 
   const state = core.loadState()
   // 0.2.0 之前是 `ctx.settings.register(REMOTE_CONTROL_SETTINGS_NAMESPACE,
@@ -296,6 +301,8 @@ function apply(ctx) {
 
   // Keep stale project conversations out of the host's session browser.
   // This is deliberately Host-side so it remains active even with no operator present.
+  if (!hasHostApiProxy) ctx.effect(() => installApprovalBridge(ctx), `${name}: host approval bridge`)
+  if (!hasHostApiProxy) ctx.effect(() => installQuestionBridge(ctx), `${name}: host question bridge`)
   ctx.effect(() => installAutoArchive(ctx), `${name}: automatic session archive`)
   ctx.effect(() => {
     // Profiles without the optional tools injection still support core remote control.

package/lib/index.js

@@ -151,6 +151,8 @@ export function apply(ctx) {
     check,
     apply: applyUpdate,
     reload: version => runtime.reload(version),
+    /** 就地把盘上这一份重新装载一遍：版本身份没变也照换（开发机改完代码用，见 runtime 的 reread）。 */
+    reread: () => runtime.reload(undefined, { reread: true }),
     deviceOta,
     setAutoUpdate: enabled => {
       const value = updater.setAutoUpdate(enabled)

package/lib/mirror/pusher.cjs

@@ -194,6 +194,8 @@ function createMirrorPusher(deps) {
 
   // 镜像推送的唯一出口：所有 pushSync 都必须经此，保证状态与真实推送一致。
   const pushMirrorPayload = async (payload) => {
+    // 每一次推上去的清单都顺手记一下规模（含短路那两条路径：手机侧栏看的就是这份清单）。
+    noteMirrorList(payload && payload.sessions);
     if (!tunnelConnected()) {
       recordMirrorPush(false, '隧道未连接，镜像未推送');
       // 没推成镜像，但「正文长到哪儿了」这件事仍然要说给手机听（见 announceSessionActivity）。
@@ -256,6 +258,28 @@ function createMirrorPusher(deps) {
 
   const isHighPriority = (s) => s && (s.running || (s.updatedAt && Date.now() - s.updatedAt < HIGH_PRIORITY_WINDOW_MS));
 
+  /**
+   * 镜像清单本身的规模（自检台账用）：会话总数、其中活跃的、其中子会话。
+   *
+   * 这是插件侧能**诚实**报出的那部分规模——「宿主内存里挂着多少会话、正文占多少」插件看不到
+   * （它住在宿主进程里，没有独立视角，见 lib/mobile/self-check.cjs 的口径段）。清单每 tick 都
+   * 在重建，顺手记三个计数不额外花销。
+   *
+   * 只在真拿到清单时更新：拿不到时保留上一次的读数（连带 `at`），与「清单突然变成 0」区分开。
+   */
+  let mirrorListSessions = 0;
+  let mirrorListActiveSessions = 0;
+  let mirrorListSubagents = 0;
+  let mirrorListAt = 0;
+  const noteMirrorList = (sessionsBody) => {
+    const items = sessionsBody && Array.isArray(sessionsBody.items) ? sessionsBody.items : null;
+    if (!items) return;
+    mirrorListSessions = items.length;
+    mirrorListActiveSessions = items.filter(isHighPriority).length;
+    mirrorListSubagents = items.filter((s) => s && s.origin === 'subagent').length;
+    mirrorListAt = Date.now();
+  };
+
   // Every session snapshot fans out to three Host RPCs. Bound the number of sessions
   // being built globally; event work gets priority, but batch/cold work gets one slot
   // after at most three consecutive event jobs to prevent starvation.
@@ -323,6 +347,33 @@ function createMirrorPusher(deps) {
     // 清单里没有这一行（比如事件先到、清单还没刷出来）时退回 Date.now()：这个值只参与
     // 缓存指纹，不影响正文内容本身。
     const updatedAt = (summary && summary.updatedAt) || Date.now();
+    /**
+     * 子会话的正文**刻意不建**（2026-10-19）。
+     *
+     * 普通历史接口读子会话会被宿主按 durable parent address 拒掉
+     * （`session/agent-busy: subagent Sessions require their durable parent address`），
+     * 而镜像这份正文手机本来就用不到：手机打开子代理读的是子代理那条专用通道（带父会话
+     * 地址与 mode，见 lib/mobile/subagents.js 的文件头）。以前每次都照读、每次都被拒，
+     * 于是 5 秒一次的冷轮转里固定夹着一次注定失败的读取，`skippedBodies` 一路涨
+     * （真机实测 4 分钟 408 → 451），日志里那条 skip 也永远说不清到底哪坏了。
+     *
+     * 这里提前认出清单行上的 `origin === 'subagent'` 就不发那次请求，且 **skipReason 留空**：
+     * 它不是失败，不该进 `skippedBodies` 那本故障账。清单行本身照旧推给手机（App 靠行上的
+     * origin/parentSessionId 认子代理），stats/models 照旧构建，所以镜像载荷的形状与既有的
+     * 「正文缺席」那条路径完全一致。
+     */
+    if (summary && summary.origin === 'subagent') {
+      const [stats, models] = await Promise.all([
+        sessions.buildStatsSnapshot(ctx, sessionId),
+        sessions.buildModelsSnapshot(ctx, sessionId),
+      ]);
+      return {
+        messages: null,
+        skipReason: null,
+        stats: stats?.ok ? stats : null,
+        models: models?.ok ? models : null,
+      };
+    }
     const [messages, stats, models] = await Promise.all([
       sessions.buildMirrorWarmSnapshots(
         ctx,
@@ -707,6 +758,13 @@ function createMirrorPusher(deps) {
       // 正文缺失而清单照推的次数与最近原因：与 ok/pushedAt 分开，避免再把
       // 「某会话正文读不到」误读成「镜像死了」（见 recordMirrorPushSkipped）。
       skippedBodies: mirrorBodySkipCount, skipReason: mirrorBodySkipReason,
+      // 清单规模（自检台账读它）：会话总数 / 其中活跃 / 其中子会话 / 这份读数的时间。
+      // 这是「手机侧栏那份清单有多大」，**不是**「宿主内存里挂着多少会话、正文占多少」——
+      // 后者插件看不到（见 lib/mobile/self-check.cjs 的口径段）。
+      listSessions: mirrorListSessions,
+      listActiveSessions: mirrorListActiveSessions,
+      listSubagents: mirrorListSubagents,
+      listAt: mirrorListAt,
     }),
     /** 失败会话的定向重试账（诊断 + 守卫用）：失败几次、下次什么时候补推。 */
     getPushFailures: () => [...sessionPushFailures.entries()].map(([sessionId, entry]) => ({

package/lib/mobile/approvals.js

@@ -0,0 +1,350 @@
+'use strict';
+
+/**
+ * 手机端审批桥（DSH 0.2.x）。
+ *
+ * ≤0.1.x 的宿主把审批当成 apiProxy 事件流上的 server-request：
+ * `{rpcId, payload:{type:'approval/requested', approvalId, toolName, reason}}`，手机凭**帧级
+ * rpcId** 回答（`/approval/respond` 的 rpcId 就是宿主 `pendingApprovals` 表的键）。0.2.x
+ * 把 apiProxy 整个删了：一次审批 = 会话日志里的 `approval/asked` / `approval/decided` 事件
+ * 对 + 一个**进程内** waterfall 钩子 `approval/request`（`dsh-user-approval` 发起，
+ * `dsh-api-remotes` 把它转给桌面窗口那类 owner 连接，`dsh-acp` 也接同一个钩子）。
+ * 帧级 rpcId 就此消失，而 App 的审批面板**刻意**只认带 rpcId 的帧（不给一个按了必然 409
+ * 的按钮），于是「桌面有卡、手机上一片空白，连一条 409 都没有」。
+ *
+ * 这里按 0.2.x 的形状把那半条通道补起来，**手机端契约一行不改**（App 仍然收
+ * `approval/requested` + 帧级 rpcId，仍然 POST `/approval/respond`）：
+ *
+ *   1. 听 `session/event` 的 `approval/asked`：宿主在发起审批前**必写**这条事件（决定走
+ *      哪条回答通道都不影响它），本桥据此铸一个自己的 rpcId 并把卡推给正在看这个会话的
+ *      手机。approvalId 直接用宿主自己的 id —— App 靠它把 `approval/decided` 对上、自动
+ *      收掉那张卡。
+ *   2. 听 `approval/request` 钩子（**prepend**，见下）：把这台手机挂成候选人并和下游竞速。
+ *      下游（桌面窗口 / ACP / 宿主默认的 fail-closed）照旧拿到请求、卡片照旧出现，
+ *      手机答得早就用手机的，桌面答得早就用桌面的，输的那张卡由结算帧收掉。
+ *   3. `/approval/respond` 拿 rpcId 找到挂起项，把结论交回钩子 —— 这才是真正让 agent
+ *      继续往下跑的那一步。
+ *
+ * ⚠️ 钩子上**没有**宿主 id（既没有 approvalId 也没有 rpcId），而且它和 `approval/asked`
+ * 谁先到取决于宿主的派发顺序（事件在 `request()` 里先 append、钩子随后派发，但两者都走
+ * 微任务）。所以两个来源共用一张挂起项表：先到的建项，后到的补字段（事件补真实
+ * approvalId，钩子补 displayReason 与 signal）。卡片在任一路径上都不等对方。
+ *
+ * ⚠️ 为什么必须 prepend：宿主自己的转发器（`dsh-api-remotes`）在桌面窗口开着时会一直等
+ * 桌面回答、**不调用 next()**，而且那些核心包必然先于本插件装载。老实按注册顺序排在后面
+ * 等于「桌面开着时手机永远收不到」，正是这次要修的现象。prepend 是本桥能生效的前提，
+ * 不是优化。
+ */
+
+const { randomUUID } = require('node:crypto');
+const { sendJson, readJsonBody } = require('../shared/http-util');
+
+/** `/approval/respond` 只认这两种结论（与 App 的两个按钮一一对应）。 */
+const ANSWER_OUTCOMES = new Set(['allowed-once', 'rejected']);
+/** 宿主 `approval/decided` 的结论词表（`dsh-user-approval` 的 OUTCOMES）。 */
+const DECISIONS = new Set(['allowed-once', 'rejected', 'cancelled', 'unavailable']);
+
+/** sessionId → Set<sink>：正在看这个会话的手机连接（每条 SSE 一个 sink）。 */
+const watchers = new Map();
+/** rpcId → entry：回答时按它定位。 */
+const entries = new Map();
+/** sessionId → entry[]（保序）：把钩子上的请求和事件里的审批对上。 */
+const bySession = new Map();
+
+function watcherCount(sessionId) {
+  const set = watchers.get(sessionId);
+  return set ? set.size : 0;
+}
+
+function openEntries(sessionId) {
+  const list = bySession.get(sessionId);
+  return list ? list.filter((entry) => !entry.settled) : [];
+}
+
+/**
+ * 卡片帧。形状严格照 App `utils/approvalFrames.ts` 认的那一种：**帧级 rpcId** + payload 上的
+ * approvalId；reason 为空时 App 会自己落到「工具 X 请求越权执行」，与桌面同一句兜底文案。
+ */
+function cardFrame(entry) {
+  return {
+    type: 'approval/requested',
+    sessionId: entry.sessionId,
+    rpcId: entry.rpcId,
+    approvalId: entry.approvalId,
+    ...(entry.toolName ? { toolName: entry.toolName } : {}),
+    ...(entry.reason ? { reason: entry.reason } : {}),
+  };
+}
+
+/**
+ * 结算帧。App 按 approvalId 比对（`approvalResolved`），所以这条让手机立刻收卡，不必等
+ * 宿主的 `approval/decided` 绕一圈 —— 尤其是手机自己答的那一条，桌面那条路已经不需要了。
+ */
+function resolvedFrame(entry, outcome) {
+  return { type: 'approval/resolved', sessionId: entry.sessionId, approvalId: entry.approvalId, outcome };
+}
+
+function broadcast(sessionId, frame) {
+  const set = watchers.get(sessionId);
+  if (!set) return;
+  for (const sink of set) {
+    // 单条连接写失败（客户端正好走了）不影响别的手机拿到这张卡。
+    try { sink(frame); } catch { /* ignore */ }
+  }
+}
+
+function pushCard(entry) {
+  if (entry.settled || watcherCount(entry.sessionId) === 0) return;
+  broadcast(entry.sessionId, cardFrame(entry));
+}
+
+/**
+ * 取（或建）一条挂起项。两个来源都走这里：按 callId → toolName 配对，配对不上的就新建。
+ *
+ * `unboundOnly` 只给钩子用：钩子绑上一条就已经接管了它（回答由那条钩子的 promise 决定），
+ * 第二条钩子请求绝不能共用同一条挂起项。反过来，事件那一侧必须能认领**已经绑上**的挂起项 ——
+ * 「钩子先到、`approval/asked` 后到」时就是靠这一步把真实的 approvalId 补进去的。
+ */
+function entryFor(sessionId, ask, { unboundOnly = false } = {}) {
+  const open = openEntries(sessionId).filter((entry) => !unboundOnly || !entry.bound);
+  // 两个来源拿到的是宿主**同一个** request 对象（`dsh-user-approval.request()` 把 req 原样
+  // 交给钩子，`approval/asked` 也照它记 toolName/callId），所以按 callId → toolName 配对是
+  // 精确的；配对不上就新建（宁可多一张卡，也不要两条审批共用一张卡）。
+  const match = open.find((entry) => ask.callId && entry.callId === ask.callId)
+    || open.find((entry) => ask.toolName && entry.toolName === ask.toolName);
+  if (match) return match;
+  const entry = {
+    // rpcId 是本桥自己铸的：0.2.x 的宿主不再提供任何可作答的帧级 id，而 App 只认带 rpcId 的帧。
+    rpcId: `m-${randomUUID()}`,
+    sessionId,
+    // 钩子先到时还不知道宿主的 approvalId，先铸一个占位（只用于挂起项身份，回答不看它）；
+    // `approval/asked` 一到就换成真 id，好让 App 能把 approval/decided 对上。
+    approvalId: ask.approvalId || `m-${randomUUID()}`,
+    toolName: ask.toolName,
+    callId: ask.callId,
+    reason: ask.reason,
+    bound: false,
+    settled: false,
+    wait: null,
+    release: null,
+  };
+  entry.wait = new Promise((resolve) => { entry.release = resolve; });
+  entries.set(entry.rpcId, entry);
+  let list = bySession.get(sessionId);
+  if (!list) { list = []; bySession.set(sessionId, list); }
+  list.push(entry);
+  return entry;
+}
+
+/** 结算一条挂起项：唤醒等待中的钩子、撤下挂起项、让手机收卡。重复调用无副作用。 */
+function settle(entry, outcome) {
+  if (entry.settled) return false;
+  entry.settled = true;
+  entries.delete(entry.rpcId);
+  const list = bySession.get(entry.sessionId);
+  if (list) {
+    const index = list.indexOf(entry);
+    if (index >= 0) list.splice(index, 1);
+    if (list.length === 0) bySession.delete(entry.sessionId);
+  }
+  entry.release({ outcome });
+  broadcast(entry.sessionId, resolvedFrame(entry, outcome));
+  return true;
+}
+
+/**
+ * 手机接上/离开某条会话流。接入时补发仍然可作答的卡；断开只摘掉这一个 sink —— 挂起项本身
+ * 继续等（用户可能马上就回来），由宿主的 signal 中止或别人答掉来收尾。
+ */
+function attachSession(sessionId, sink) {
+  let set = watchers.get(sessionId);
+  if (!set) { set = new Set(); watchers.set(sessionId, set); }
+  set.add(sink);
+  // 补发：审批可能在手机还没看这个会话时就挂起了（用户在列表页点了进来），
+  // 而钩子上的请求还在等 —— 那时候这张卡仍然答得动。
+  for (const entry of openEntries(sessionId)) {
+    if (entry.bound) { try { sink(cardFrame(entry)); } catch { /* ignore */ } }
+  }
+  return () => {
+    set.delete(sink);
+    if (set.size === 0) watchers.delete(sessionId);
+  };
+}
+
+/** 会话摘要里的待处理标记（0.2.x 的宿主不会再下发这个字段，见 sessions.js 的用法）。 */
+function hasPending(sessionId) {
+  return openEntries(sessionId).length > 0;
+}
+
+/** 测试用：清空全部进程内状态（真实运行时由插件卸载时的 disposer 收尾）。 */
+function resetForTest() {
+  watchers.clear();
+  entries.clear();
+  bySession.clear();
+}
+
+function sessionIdOf(session) {
+  if (!session || typeof session !== 'object') return null;
+  if (typeof session.id === 'string' && session.id) return session.id;
+  // 宿主自己的两处写法不一致（`dsh-api-session-controller` 用 `session.id`，
+  // `dsh-acp` 用 `session.header.id`）；认不出会话 id 就等于这条审批没人能答，所以两种都认。
+  const header = session.header;
+  return header && typeof header.id === 'string' && header.id ? header.id : null;
+}
+
+function sessionIdOfRequest(request) {
+  const agent = request && request.agent;
+  const session = agent && agent.session;
+  return sessionIdOf(session);
+}
+
+/** 升级卡片的文案：宿主给 `displayReason`（tz 化文案）时优先用它，与桌面同一句。 */
+function displayReasonOf(request) {
+  const display = request && request.displayReason;
+  if (!display || typeof display !== 'object') return undefined;
+  const zh = display.zh;
+  if (typeof zh === 'string' && zh) return zh;
+  return Object.values(display).find((value) => typeof value === 'string' && value);
+}
+
+/** `approval/asked`：宿主记下这次审批。details 见 `dsh-user-approval` 的 `request()`。 */
+function noteAsk(sessionId, data) {
+  const approvalId = typeof data.id === 'string' && data.id ? data.id : null;
+  if (!approvalId) return;
+  const entry = entryFor(sessionId, {
+    approvalId,
+    toolName: typeof data.toolName === 'string' ? data.toolName : undefined,
+    callId: typeof data.callId === 'string' ? data.callId : undefined,
+    reason: typeof data.reason === 'string' ? data.reason : undefined,
+  });
+  if (entry.approvalId === approvalId) { pushCard(entry); return; }
+  // 钩子先到、铸了占位 id：换成宿主的真 id 并重发一次卡（同 rpcId，App 只是换一份内容）。
+  entry.approvalId = approvalId;
+  pushCard(entry);
+}
+
+/** `approval/decided`：这条审批已经有结论了（桌面答的、或被取消），把卡和挂起项一起收掉。 */
+function noteDecided(sessionId, data) {
+  const approvalId = typeof data.id === 'string' && data.id ? data.id : null;
+  if (!approvalId) return;
+  const entry = openEntries(sessionId).find((candidate) => candidate.approvalId === approvalId);
+  if (!entry) return;
+  settle(entry, DECISIONS.has(data.outcome) ? data.outcome : 'unavailable');
+}
+
+/**
+ * 把一条钩子请求绑到挂起项上。
+ *
+ * 绑上才算「答得动」：`/approval/respond` 只结算 bound 的挂起项，否则手机点了按钮而 agent
+ * 那头没人接（比如本桥没装上、请求走的是别的回答者），如实回 409 比假成功好。
+ */
+function bindRequest(entry, request) {
+  entry.bound = true;
+  entry.toolName = entry.toolName || (typeof request.toolName === 'string' ? request.toolName : undefined);
+  entry.callId = entry.callId || (typeof request.callId === 'string' ? request.callId : undefined);
+  const nicer = displayReasonOf(request) || (typeof request.reason === 'string' ? request.reason : undefined);
+  if (nicer) entry.reason = nicer;
+  // 绑上再推一次：`approval/asked` 那条路已经推过一张（可能是占位 id、也可能是没 tz 化的
+  // 原始 reason），这里换成最终那份内容。同一个 rpcId，App 只是替换面板内容。
+  pushCard(entry);
+  const signal = request.signal;
+  if (signal && typeof signal.addEventListener === 'function') {
+    const onAbort = () => { settle(entry, 'cancelled'); };
+    if (signal.aborted) onAbort();
+    else {
+      signal.addEventListener('abort', onAbort, { once: true });
+      // 结算时把监听撤掉：这条 signal 归调用方的 turn 所有，挂着的监听会跟到 turn 结束。
+      const release = entry.release;
+      entry.release = (result) => { signal.removeEventListener('abort', onAbort); release(result); };
+    }
+  }
+}
+
+/**
+ * 挂起这条请求直到有人给结论。
+ *
+ * 下游**先叫**：`next()` 一调，桌面窗口那张卡照旧出现（这条路径的行为一字不改）。手机答得
+ * 早就用手机的；下游答得早就用下游的 —— 谁先给结论谁算数，输的那张卡由结算帧收掉。
+ * 两边都没人答时这里会一直挂着，和今天宿主自己的行为一致（审批本来就等人工）。
+ */
+function holdForPhone(entry, next) {
+  const downstream = Promise.resolve().then(() => next()).then((outcome) => {
+    const value = DECISIONS.has(outcome) ? outcome : 'unavailable';
+    settle(entry, value);
+    return value;
+  });
+  return Promise.race([entry.wait.then((result) => result.outcome), downstream]);
+}
+
+function onApprovalRequest(request, next) {
+  const sessionId = sessionIdOfRequest(request);
+  if (!sessionId) return next();
+  const entry = entryFor(sessionId, {
+    approvalId: undefined,
+    toolName: typeof request.toolName === 'string' ? request.toolName : undefined,
+    callId: typeof request.callId === 'string' ? request.callId : undefined,
+    reason: typeof request.reason === 'string' ? request.reason : undefined,
+  }, { unboundOnly: true });
+  bindRequest(entry, request);
+  return holdForPhone(entry, next);
+}
+
+/**
+ * 装上审批桥（只在 0.2.x 那一侧装：0.1.x 宿主自带 apiProxy，帧和回答都还走得通，装上去
+ * 只会多推一张卡）。
+ */
+function installApprovalBridge(ctx) {
+  const disposers = [
+    ctx.on('session/event', (session, event) => {
+      const sessionId = sessionIdOf(session);
+      if (!sessionId || !event || typeof event !== 'object') return;
+      if (event.type === 'approval/asked') noteAsk(sessionId, event.data || {});
+      else if (event.type === 'approval/decided') noteDecided(sessionId, event.data || {});
+    }, { global: true }),
+    // prepend 是前提不是优化，理由见文件头。
+    ctx.on('approval/request', onApprovalRequest, { prepend: true, global: true }),
+  ];
+  return () => {
+    for (const dispose of disposers) dispose();
+    for (const entry of [...entries.values()]) settle(entry, 'cancelled');
+  };
+}
+
+/**
+ * POST /api/mobile/v1/approval/respond —— `{rpcId, sessionId, approvalId, outcome}`。
+ *
+ * 先查本桥的挂起项；查不到就交回 `ctx.apiProxy.respond`（0.1.x 宿主那份真 apiProxy 才是
+ * 它的归宿；0.2.x 的兼容桥会如实回 `host-unsupported`，于是落到下面那条 409）。
+ */
+async function handleApprovalRespond(ctx, req, res) {
+  const body = await readJsonBody(req);
+  if (!body || typeof body.rpcId !== 'string' || !body.rpcId
+    || typeof body.sessionId !== 'string' || !body.sessionId
+    || typeof body.approvalId !== 'string' || !body.approvalId
+    || !ANSWER_OUTCOMES.has(body.outcome)) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { rpcId, sessionId, approvalId, outcome }' } });
+  }
+  const entry = entries.get(body.rpcId);
+  if (entry && !entry.settled && entry.bound
+    && entry.sessionId === body.sessionId && entry.approvalId === body.approvalId) {
+    settle(entry, body.outcome);
+    return sendJson(res, 200, { ok: true, accepted: true });
+  }
+  const receipt = await ctx.apiProxy.respond({
+    type: 'client-response',
+    rpcId: body.rpcId,
+    result: { ok: true, value: { sessionId: body.sessionId, approvalId: body.approvalId, outcome: body.outcome } },
+  }).catch(() => null);
+  if (!receipt || receipt.accepted !== true) {
+    return sendJson(res, 409, { ok: false, error: { code: 'not-pending', message: '该审批已完成或不可回答' } });
+  }
+  sendJson(res, 200, { ok: true, accepted: true });
+}
+
+module.exports = {
+  installApprovalBridge,
+  handleApprovalRespond,
+  attachSession,
+  hasPending,
+  resetForTest,
+};

package/lib/mobile/questions.js

@@ -1,71 +1,293 @@
 'use strict';
 
 /**
- * dsh-mobile 用户问题回答桥接。
+ * 手机端提问桥（DSH 0.2.x）：`ask_user_question` 与「计划评审」。
  *
- * ask_user_question 通过 apiProxy events mux 以 question/requested 发出，
- * 原生 App 经本端点回传对应 rpcId 的严格回答载荷。
+ * ≤0.1.x 的宿主把提问当成 apiProxy 事件流上的 server-request：
+ * `{rpcId, payload:{type:'question/requested', sessionId, questions}}`，手机凭**帧级 rpcId**
+ * 回答（`/question/respond` 把 rpcId 回给宿主那张 pending 表）。0.2.x 把 apiProxy 删了，
+ * 提问只剩一个**进程内** waterfall 钩子 `user-questions/request`（`dsh-user-questions`
+ * 发起，`dsh-tool-ask-user` 与 `dsh-plan-mode` 是它的两个调用方），帧级 rpcId 随之消失，
+ * 于是手机既收不到卡片、也没有能回传的 id。
+ *
+ * 这里按 0.2.x 的形状把这条通道补起来，**手机端契约一行不改**（App 仍然收
+ * `question/requested` + 帧级 rpcId，仍然 POST `/question/respond`）：
+ *
+ *   1. 听 `user-questions/request` 钩子（**prepend**，理由与审批桥同一条：宿主的转发器
+ *      `dsh-api-remotes` 在桌面窗口开着时会一直等桌面回答、不调用 `next()`）。铸一个自己的
+ *      rpcId，把卡片推给正在看这个会话的手机，然后把请求挂住。
+ *   2. 下游照旧拿到请求（桌面那张卡照旧出现，`dsh-plan-mode` 也一样），两边竞速：
+ *      手机答得早就用手机的，桌面答得早就用桌面的。
+ *   3. `/question/respond` 拿 rpcId 找到挂起项，把回答交回钩子 —— 这才是真正让 agent
+ *      继续往下跑的那一步。落定后广播 `question/resolved`，另一边那张卡被收掉。
+ *
+ * 「计划评审」不走另一条通道：`dsh-plan-mode` 的 `exit_plan_mode` 就是拿
+ * `ctx.userQuestions.ask()` 问的（问题带 `intent.kind='plan-review'`、`detail` 是计划正文、
+ * 选项里有一个「批准」标签），所以这道桥同时修好它。App 的问题面板本来就渲染
+ * `detail` 与 `options`，计划正文直接显示在详情里。
  */
 
+const { randomUUID } = require('node:crypto');
 const { sendJson, readJsonBody } = require('../shared/http-util');
 
-function validAnswer(answer) {
-  if (!answer || typeof answer.id !== 'string' || !Array.isArray(answer.selected)) return false;
-  if (!answer.selected.every((label) => typeof label === 'string')) return false;
-  return answer.custom === undefined || typeof answer.custom === 'string';
+/** sessionId → Set<sink>：正在看这个会话的手机连接（每条 SSE 一个 sink）。 */
+const watchers = new Map();
+/** rpcId → entry：回答时按它定位。 */
+const entries = new Map();
+/** sessionId → entry[]（保序）：接入时补发、摘要里数待处理。 */
+const bySession = new Map();
+
+function watcherCount(sessionId) {
+  const set = watchers.get(sessionId);
+  return set ? set.size : 0;
 }
 
-async function handleQuestionRespond(ctx, req, res) {
-  const body = await readJsonBody(req);
-  if (!body || typeof body.rpcId !== 'string' || !body.rpcId || typeof body.sessionId !== 'string' || !body.sessionId) {
-    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { rpcId, sessionId, answer }' } });
+function openEntries(sessionId) {
+  const list = bySession.get(sessionId);
+  return list ? list.filter((entry) => !entry.settled) : [];
+}
+
+/**
+ * 卡片帧。形状严格照 App `streamFrame.ts` 认的那一种：**帧级 rpcId** + 顶层
+ * `sessionId` + `questions`（每题至少 `id` 与 `question` 两个字符串）。
+ * 只转发 App 认识的字段，宿主的其它内部键（如 `intent` 里的 callId）不外泄。
+ */
+function cardFrame(entry) {
+  return {
+    type: 'question/requested',
+    sessionId: entry.sessionId,
+    rpcId: entry.rpcId,
+    questions: entry.questions.map((question) => ({
+      id: question.id,
+      question: question.question,
+      ...(question.header ? { header: question.header } : {}),
+      ...(question.detail ? { detail: question.detail } : {}),
+      ...(question.options ? { options: question.options } : {}),
+      ...(question.multiSelect ? { multiSelect: question.multiSelect } : {}),
+    })),
+  };
+}
+
+/**
+ * 结算帧。App 按 `questionRpcId` 比对后清掉面板（`streamFrame.ts` 的
+ * `question/resolved` 分支），所以这里必须带上本桥铸的那个 rpcId。
+ */
+function resolvedFrame(entry) {
+  return { type: 'question/resolved', sessionId: entry.sessionId, questionRpcId: entry.rpcId };
+}
+
+function broadcast(sessionId, frame) {
+  const set = watchers.get(sessionId);
+  if (!set) return;
+  for (const sink of set) {
+    // 单条连接写失败（客户端正好走了）不影响别的手机拿到这张卡。
+    try { sink(frame); } catch { /* ignore */ }
   }
-  const answers = body.answer && body.answer.answers;
-  if (!Array.isArray(answers) || !answers.every(validAnswer)) {
-    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: 'answer.answers 格式无效' } });
+}
+
+function pushCard(entry) {
+  if (entry.settled || watcherCount(entry.sessionId) === 0) return;
+  broadcast(entry.sessionId, cardFrame(entry));
+}
+
+function entryFor(sessionId, request) {
+  const entry = {
+    // rpcId 是本桥自己铸的：0.2.x 的宿主不再提供任何可作答的帧级 id，而 App 只认带 rpcId 的帧。
+    rpcId: `m-${randomUUID()}`,
+    sessionId,
+    callId: request && request.wait && typeof request.wait.callId === 'string' ? request.wait.callId : undefined,
+    questions: Array.isArray(request && request.questions) ? request.questions : [],
+    bound: false,
+    settled: false,
+    signalReason: null,
+    wait: null,
+    release: null,
+  };
+  entry.wait = new Promise((resolve) => { entry.release = resolve; });
+  entries.set(entry.rpcId, entry);
+  let list = bySession.get(sessionId);
+  if (!list) { list = []; bySession.set(sessionId, list); }
+  list.push(entry);
+  return entry;
+}
+
+/**
+ * 结算一条挂起项：撤下挂起项、让手机收卡、唤醒等待中的钩子。
+ * `answers` 有值 = 手机给了答案；null = 手机这条路没结论（被取消 / 别人先答了）。
+ */
+function settle(entry, answers) {
+  if (entry.settled) return false;
+  entry.settled = true;
+  entries.delete(entry.rpcId);
+  const list = bySession.get(entry.sessionId);
+  if (list) {
+    const index = list.indexOf(entry);
+    if (index >= 0) list.splice(index, 1);
+    if (list.length === 0) bySession.delete(entry.sessionId);
   }
+  entry.release({ answers });
+  broadcast(entry.sessionId, resolvedFrame(entry));
+  return true;
+}
 
-  const receipt = await ctx.apiProxy.respond({
-    type: 'client-response',
-    rpcId: body.rpcId,
-    result: {
-      ok: true,
-      value: {
-        sessionId: body.sessionId,
-        answer: {
-          answers: answers.map((answer) => ({
-            id: answer.id,
-            selected: answer.selected,
-            ...(answer.custom === undefined ? {} : { custom: answer.custom }),
-          })),
-        },
-      },
-    },
-  });
-  if (!receipt || receipt.accepted !== true) {
-    return sendJson(res, 409, { ok: false, error: { code: 'not-pending', message: '该问题已完成或不可回答' } });
+/**
+ * 手机接上/离开某条会话流。接入时补发仍然可作答的卡；断开只摘掉这一个 sink —— 挂起项本身
+ * 继续等（用户可能马上就回来），由宿主的 signal 中止或别人答掉来收尾。
+ */
+function attachSession(sessionId, sink) {
+  let set = watchers.get(sessionId);
+  if (!set) { set = new Set(); watchers.set(sessionId, set); }
+  set.add(sink);
+  for (const entry of openEntries(sessionId)) {
+    if (entry.bound) { try { sink(cardFrame(entry)); } catch { /* ignore */ } }
   }
-  sendJson(res, 200, { ok: true, accepted: true });
+  return () => {
+    set.delete(sink);
+    if (set.size === 0) watchers.delete(sessionId);
+  };
+}
+
+/** 会话摘要里的待处理标记（0.2.x 的宿主不会再下发这个字段，见 sessions.js 的用法）。 */
+function pendingKind(sessionId) {
+  const open = openEntries(sessionId);
+  if (open.length === 0) return undefined;
+  const planReview = open.some((entry) => entry.questions.some((question) => {
+    const intent = question && question.intent;
+    return intent && typeof intent === 'object' && intent.kind === 'plan-review';
+  }));
+  return planReview ? 'plan-review' : 'question';
+}
+
+/** 测试用：清空全部进程内状态（真实运行时由插件卸载时的 disposer 收尾）。 */
+function resetForTest() {
+  watchers.clear();
+  entries.clear();
+  bySession.clear();
+}
+
+function sessionIdOf(session) {
+  if (!session || typeof session !== 'object') return null;
+  if (typeof session.id === 'string' && session.id) return session.id;
+  const header = session.header;
+  return header && typeof header.id === 'string' && header.id ? header.id : null;
+}
+
+function sessionIdOfRequest(request) {
+  const agent = request && request.agent;
+  const session = agent && agent.session;
+  return sessionIdOf(session);
+}
+
+/** 把回答批次校验成宿主 `AskUserQuestionAnswer` 的形状：每题恰好一条、标题合法。 */
+function normalizeAnswers(questions, answers) {
+  if (!Array.isArray(answers) || answers.length !== questions.length) return null;
+  const byId = new Map();
+  for (const answer of answers) {
+    if (!answer || typeof answer.id !== 'string' || byId.has(answer.id)) return null;
+    if (!Array.isArray(answer.selected) || !answer.selected.every((label) => typeof label === 'string')) return null;
+    if (answer.custom !== undefined && typeof answer.custom !== 'string') return null;
+    byId.set(answer.id, {
+      id: answer.id,
+      selected: [...answer.selected],
+      ...(answer.custom === undefined ? {} : { custom: answer.custom }),
+    });
+  }
+  if (!questions.every((question) => byId.has(question.id))) return null;
+  return questions.map((question) => byId.get(question.id));
+}
+
+/** 绑上钩子请求：从此这条挂起项「答得动」，并接上宿主的取消信号。 */
+function bindRequest(entry, request) {
+  entry.bound = true;
+  pushCard(entry);
+  const signal = request.signal;
+  if (!signal || typeof signal.addEventListener !== 'function') return;
+  const onAbort = () => {
+    entry.signalReason = signal.reason;
+    settle(entry, null);
+  };
+  if (signal.aborted) onAbort();
+  else signal.addEventListener('abort', onAbort, { once: true });
+  const release = entry.release;
+  entry.release = (result) => {
+    signal.removeEventListener('abort', onAbort);
+    release(result);
+  };
+}
+
+/**
+ * 挂起这条请求直到有人回答。
+ *
+ * 下游**先叫**：`next()` 一调，桌面窗口那张卡照旧出现（这条路径的行为一字不改）。手机答得
+ * 早就用手机的；下游答得早就用下游的。手机上那张卡由结算帧收掉。
+ */
+function holdForPhone(entry, next) {
+  const downstream = Promise.resolve().then(() => next()).then(
+    (answer) => { settle(entry, null); return answer; },
+    (error) => { settle(entry, null); throw error; },
+  );
+  const fromPhone = entry.wait.then((result) => {
+    if (result.answers) return { answers: result.answers };
+    // 手机这条路没给出答案（被取消）：按宿主的 abort 语义把原因抛回去，
+    // 别假装成了一个空回答。
+    const reason = entry.signalReason;
+    throw reason instanceof Error ? reason : new Error('ask_user_question aborted');
+  });
+  return Promise.race([fromPhone, downstream]);
 }
 
-async function handleApprovalRespond(ctx, req, res) {
+function onQuestionRequest(request, next) {
+  const sessionId = sessionIdOfRequest(request);
+  if (!sessionId) return next();
+  const entry = entryFor(sessionId, request);
+  bindRequest(entry, request);
+  return holdForPhone(entry, next);
+}
+
+/** 装上提问桥（只在 0.2.x 那一侧装，理由与审批桥相同）。 */
+function installQuestionBridge(ctx) {
+  const dispose = ctx.on('user-questions/request', onQuestionRequest, { prepend: true, global: true });
+  return () => {
+    dispose();
+    for (const entry of [...entries.values()]) settle(entry, null);
+  };
+}
+
+/**
+ * POST /api/mobile/v1/question/respond —— `{rpcId, sessionId, answer:{answers}}`。
+ *
+ * 先查本桥的挂起项；查不到就交回 `ctx.apiProxy.respond`（0.1.x 宿主那份真 apiProxy 才是
+ * 它的归宿；0.2.x 的兼容桥会如实回 `host-unsupported`，于是落到下面那条 409）。
+ */
+async function handleQuestionRespond(ctx, req, res) {
   const body = await readJsonBody(req);
-  const outcomes = new Set(['allowed-once', 'rejected']);
-  if (!body || typeof body.rpcId !== 'string' || !body.rpcId
-    || typeof body.sessionId !== 'string' || !body.sessionId
-    || typeof body.approvalId !== 'string' || !body.approvalId
-    || !outcomes.has(body.outcome)) {
-    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { rpcId, sessionId, approvalId, outcome }' } });
+  if (!body || typeof body.rpcId !== 'string' || !body.rpcId || typeof body.sessionId !== 'string' || !body.sessionId) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { rpcId, sessionId, answer }' } });
+  }
+  const entry = entries.get(body.rpcId);
+  if (entry && !entry.settled && entry.bound && entry.sessionId === body.sessionId) {
+    const answers = normalizeAnswers(entry.questions, body.answer && body.answer.answers);
+    if (!answers) {
+      return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: 'answer.answers 必须每题恰好一条、含合法 selected' } });
+    }
+    settle(entry, answers);
+    return sendJson(res, 200, { ok: true, accepted: true });
   }
   const receipt = await ctx.apiProxy.respond({
     type: 'client-response',
     rpcId: body.rpcId,
-    result: { ok: true, value: { sessionId: body.sessionId, approvalId: body.approvalId, outcome: body.outcome } },
-  });
+    result: { ok: true, value: { sessionId: body.sessionId, answer: { answers: (body.answer && body.answer.answers) || [] } } },
+  }).catch(() => null);
   if (!receipt || receipt.accepted !== true) {
-    return sendJson(res, 409, { ok: false, error: { code: 'not-pending', message: '该审批已完成或不可回答' } });
+    return sendJson(res, 409, { ok: false, error: { code: 'not-pending', message: '该问题已完成或不可回答' } });
   }
   sendJson(res, 200, { ok: true, accepted: true });
 }
 
-module.exports = { handleQuestionRespond, handleApprovalRespond };
+module.exports = {
+  installQuestionBridge,
+  handleQuestionRespond,
+  attachSession,
+  pendingKind,
+  resetForTest,
+};

package/lib/mobile/self-check.cjs

@@ -194,6 +194,14 @@ function createSelfCheck(deps = {}) {
       skipReason: known && typeof push.skipReason === 'string' ? push.skipReason : null,
       // 待补推的会话数（pusher 的失败重试账长度）。
       pushFailures: Array.isArray(failures) ? failures.length : null,
+      // 清单规模：会话总数 / 其中活跃（在跑或 5 分钟内动过）/ 其中子会话 / 这份读数的时间。
+      // 这是插件侧**能诚实报出的**「会话有多少」——手机侧栏读的就是这份清单。
+      // ⚠️ 它**不是**「宿主内存里挂着多少会话、正文占多少」：插件住在宿主进程里，看不到那个
+      // 口径（见文件头）。正文规模只能由 `cachedBytes` 那一格回答「插件自己握着多少」。
+      listSessions: known ? finiteNumber(push.listSessions) : null,
+      listActiveSessions: known ? finiteNumber(push.listActiveSessions) : null,
+      listSubagents: known ? finiteNumber(push.listSubagents) : null,
+      listAt: known ? (finiteNumber(push.listAt) === null ? 0 : finiteNumber(push.listAt)) : null,
       cachedSessions: cache ? cache.entries : null,
       cachedMessages: cache ? cache.messages : null,
       cachedBytes: cache ? cache.bytes : null,

package/lib/mobile/session-send.js

@@ -98,8 +98,8 @@ async function handleSend(ctx, req, res) {
   if (!body || typeof body.sessionId !== 'string' || !body.sessionId) {
     return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { sessionId, content | text }' } });
   }
-  const mode = body.mode === undefined ? 'queue' : body.mode;
-  if (mode !== 'queue' && mode !== 'steer') {
+  const mode = body.mode;
+  if (mode !== undefined && mode !== 'queue' && mode !== 'steer') {
     return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: "mode 必须为 'queue' 或 'steer'" } });
   }
   let content;
@@ -150,7 +150,7 @@ async function handleSend(ctx, req, res) {
   try {
     promptResponse = await promptOnce(ctx, typeof body.clientMessageId === 'string' ? body.clientMessageId : '', {
       sessionId: body.sessionId,
-      mode,
+      ...(mode !== undefined ? { mode } : {}),
       content,
     });
   } catch (error) {

package/lib/mobile/sessions.js

@@ -41,7 +41,7 @@ const {
 } = require('./session-cache.js');
 const { resolveEventAttachments } = require('./attachments.js');
 const { updateCompletionStates, confirmCompletionFromHistory } = require('./completion.js');
-const { buildMessagesSnapshot, buildStatsSnapshot, statsProjections, handleMessages } = require('./session-snapshot.js');
+const { eventSeqOf, buildMessagesSnapshot, buildStatsSnapshot, statsProjections, handleMessages } = require('./session-snapshot.js');
 const { buildModelsSnapshot, handleModels, handleSelectModel } = require('./session-models.js');
 const { buildSingleSessionMirror, buildMirrorWarmSnapshots } = require('./session-mirror.js');
 const { promptOnce, handleSend, handleCommands, handleSessionRead, handleSessionAttachment, handleStop,
@@ -49,6 +49,8 @@ const { promptOnce, handleSend, handleCommands, handleSessionRead, handleSession
 const { handleSessionSearch } = require('./session-search.js');
 const { handleAgentPresets } = require('./session-presets.js');
 const { handleGoalAction } = require('./session-goal.js');
+const approvals = require('./approvals.js');
+const questions = require('./questions.js');
 
 const HISTORY_FOR_ENRICH = 10;      // 补标题/预览时拉取的消息条数（低到足够取最后一条预览，避免每次重活）
 const SESSIONS_PREVIEW_LIMIT = 20;  // 仅为最近/运行中的会话补最后消息预览
@@ -236,13 +238,17 @@ async function buildSessionsResponse(ctx, deviceKey = 'legacy', generation = com
   // 该项是廉价字段；history 仅用于补「最后消息预览」，属于重活，见下方预览子集。
   const rows = allSummaries.map((s) => {
     const completionState = completionStatesForContext.get(s.sessionId);
+    // 待处理标记：宿主摘要里带就用它的（0.1.x / 桌面口径）；0.2.x 的宿主摘要**不带**这个
+    // 字段（桌面上那个标记是桌面客户端自己算的），这时用两道桥的账 —— 少了这一条，手机在
+    // 列表页连黄点都不会亮。审批优先（一次 turn 里审批总是挡在提问前面）。
+    const pendingInteraction = (s.pendingInteraction === 'approval' || s.pendingInteraction === 'plan-review' || s.pendingInteraction === 'question')
+      ? s.pendingInteraction
+      : (approvals.hasPending(s.sessionId) ? 'approval' : questions.pendingKind(s.sessionId));
     const base = {
       sessionId: s.sessionId,
       title: listTitle(s),
       running: !!s.running,
-      ...(s.pendingInteraction === 'approval' || s.pendingInteraction === 'plan-review' || s.pendingInteraction === 'question'
-        ? { pendingInteraction: s.pendingInteraction }
-        : {}),
+      ...(pendingInteraction ? { pendingInteraction } : {}),
       completed: !!completionState?.completed,
       // 上一轮以错误收尾（由 completion.js 从 history 的 turn/end reason.kind 折出）。
       // 侧栏据此画红点：completed 只说「跑完了、待阅读」，说不了「跑挂了」。字段只在

package/lib/mobile/stream.js

@@ -22,11 +22,14 @@ const {
   writeSse: sharedWriteSse,
   waitForDrain,
   ssePadding,
+  shedWithoutSeq,
 } = require('../shared/sse-write.js');
 const { resolveEventAttachments } = require('./sessions.js');
 const { callSessions } = require('./rpc.js');
 const { unwrap } = require('./envelope.js');
 const { normalizeJobs } = require('./jobs.js');
+const approvals = require('./approvals.js');
+const questions = require('./questions.js');
 
 // Android React Native's XHR may buffer tiny chunked responses until its
 // internal progress threshold. Pad each SSE record so onprogress exposes it
@@ -74,9 +77,23 @@ function writeSse(res, payload, frame) {
   return sharedWriteSse(res, payload, {
     frame,
     padding: ssePadding(SSE_FLUSH_PADDING_BYTES),
+    // 审批帧没有 seq，按默认口径会在软水位上被丢掉（见上面那条策略）。但它是「人工决策
+    // 的入口」不是草稿：丢一张，手机就再也看不到那张卡（软水位只在客户端跟不上时到，
+    // 回放也不覆盖这一段）。它一次审批也就一两帧，不是撑爆写队列的那类帧。
+    shedWhenBuffered: (value) => !isApprovalPayload(value) && shedWithoutSeq(value),
   });
 }
 
+/**
+ * 审批卡与它的结算帧，外加提问卡与它的结算帧：都是「人工决策的入口」，一次就一两帧，
+ * 不是撑爆写队列的那类增量，按软水位丢掉就再也补不回来（回放不覆盖这一段）。
+ */
+function isApprovalPayload(payload) {
+  const type = payload && payload.type;
+  return type === 'approval/requested' || type === 'approval/resolved'
+    || type === 'question/requested' || type === 'question/resolved';
+}
+
 /**
  * 解析断线续传位置：
  *  - `Last-Event-ID: <sessionId>:<seq>`（标准 SSE 头）；
@@ -142,6 +159,16 @@ async function handleStream(ctx, req, res) {
   // shutdown 就是这么做的）。测试里的 setInterval 桩没有 unref，所以先判类型。
   if (keepAlive && typeof keepAlive.unref === 'function') keepAlive.unref();
 
+  // 审批卡由审批桥在帧循环之外推进这条连接：宿主那半条通道（`approval/request` 钩子）
+  // 跟 mux 帧流没关系，见 mobile/approvals.js。接入时它会把仍然可作答的卡补发一遍。
+  const detachApprovals = approvals.attachSession(sessionId, (frame) => {
+    writeSse(res, frame, { payload: frame });
+  });
+  // 提问卡同理（见 mobile/questions.js）：`user-questions/request` 钩子与 mux 帧流无关。
+  const detachQuestions = questions.attachSession(sessionId, (frame) => {
+    writeSse(res, frame, { payload: frame });
+  });
+
   const resumeSeq = parseResumeSeq(req, sessionId);
   // 已交付的 seq 水位：从续传位置开始，重连时先回放、后接入实时流，并用它去重。
   let lastDeliveredSeq = resumeSeq != null ? resumeSeq : 0;
@@ -224,6 +251,8 @@ async function handleStream(ctx, req, res) {
     logStream(sessionId, 'mux loop threw', error);
   }
   clearInterval(keepAlive);
+  detachApprovals();
+  detachQuestions();
   try {
     if (!res.writableEnded) {
       // 明确告诉客户端「流到此为止，请带 lastSeq 重连」：它会走已验证可用的 replay

package/lib/routes/control-plane.js

@@ -726,6 +726,33 @@ function registerControlPlaneRoutes(deps) {
     const result = await restartSidecar()
     sendJson(res, result.ok ? 200 : 500, { ...result, status: status() })
   }) })
+  // 开发机专用：就地把**盘上这一份**重新装载一遍，不重启 DSH。
+  //
+  // 与 `/update/apply` 的分界线：那条是「去 npm 装新版」（新目录 → 新 realpath，天然绕开
+  // 全部缓存）；这条是「版本号没变、目录没变，只是文件被改了」。默认那条换代判据看到
+  // 「版本身份一致」就直接返回，于是开发时改完代码触发一次，什么都不会发生 —— 现场就是
+  // 「我改了、也触发了、还是旧行为」。
+  //
+  // 刻意做成**本机接口**（localOnly + POST），而不是包一层开关：它能把这台机器上跑着的
+  // 插件实现换成盘上任意一份代码，权限面与「改 profile 里的文件」等价，只该给本机运维。
+  registerRoute({ kind: 'exact', path: '/api/relay/reload-implementation', handler: localOnly('POST', async (_req, res) => {
+    const runtime = pluginRuntime()
+    // 没有外壳（实现被直接挂载）时换不了：如实说清楚，别假装成功。
+    if (!runtime || typeof runtime.reread !== 'function') {
+      return sendJson(res, 409, runtimeUnavailable)
+    }
+    try {
+      const result = await runtime.reread()
+      return sendJson(res, 200, { ok: true, data: result })
+    } catch (error) {
+      // 装载失败时外壳已经按老规矩回滚到上一代了，这里只把原因与回滚后的状态一起交出去。
+      return sendJson(res, 500, {
+        ok: false,
+        error: { code: 'reload_failed', message: String(error?.message || error) },
+        data: runtime.status(),
+      })
+    }
+  }) })
 }
 
 // 路由字符串清单放在注册区之后，避免被按路由源码切片的契约测试误认为是真正的 handler。
@@ -755,6 +782,8 @@ const WEB_ACCESS_ROUTES = new Set([
   '/api/relay/update/ota/check',
   '/api/relay/update/ota/apply',
   '/api/relay/restart-sidecar',
+  // 开发机的「就地重载」：能换掉本机跑着的实现，属于最该只允许本机调的那一类。
+  '/api/relay/reload-implementation',
 ]);
 
 // `panelDiagnosis` 一并导出，只为让 test/panel-artifact.test.cjs 能拿临时目录跑那三条分支：

package/lib/routes/mobile-api.js

@@ -27,6 +27,7 @@ const agentPresets = require('../mobile/agent-presets.js');
 const stream = require('../mobile/stream.js');
 const events = require('../mobile/events.js');
 const questions = require('../mobile/questions.js');
+const approvals = require('../mobile/approvals.js');
 const workspaces = require('../mobile/workspaces.js');
 const archiveClean = require('../mobile/archive-clean.js');
 const sessionLog = require('../mobile/session-log.js');
@@ -176,7 +177,7 @@ function registerMobileRoutes(deps) {
   route('/api/mobile/v1/session/stream', stream.handleStream)
   route('/api/mobile/v1/events/stream', events.handleDeviceStream)
   route('/api/mobile/v1/question/respond', questions.handleQuestionRespond)
-  route('/api/mobile/v1/approval/respond', questions.handleApprovalRespond)
+  route('/api/mobile/v1/approval/respond', approvals.handleApprovalRespond)
   route('/api/mobile/v1/session/goal', sessions.handleGoalAction)
   route('/api/mobile/v1/session/queue/update', sessions.handleQueueUpdate)
   route('/api/mobile/v1/workspaces', workspaces.handleWorkspaces)

package/lib/shell/runtime.js

@@ -19,7 +19,7 @@
  * 卡住的请求不该拖住一次修复性更新）。
  */
 
-import { importGeneration, resolveGeneration, resolveGenerations } from './manager.js'
+import { importGeneration, invalidateGeneration, resolveGeneration, resolveGenerations } from './manager.js'
 
 /** 换代前等在飞请求归零的上限。 */
 const DRAIN_TIMEOUT_MS = 2000
@@ -118,15 +118,29 @@ export function createRuntime() {
    *
    * 旧代先停、新代后起；新代起不来就回滚把旧代装回去，并把错误留在 `lastError` 里——
    * 「更新把自己弄挂了」必须能被看见，而不是静默少个插件。
+   *
+   * `options.reread` 是给**开发机**的那条路（2026-10-19）：版本号与目录都没变，只是盘上
+   * 那几个文件被改了。默认会走上面那句「身份一致就直接返回」，于是改完代码再触发也没有
+   * 任何变化 —— 开发时看到的「改了不生效」就是这么来的。带上它就先把这一代从
+   * `imported` 里作废、再让 `importGeneration` 清掉 CJS 子树，强制重新读盘。
+   *
+   * 这条**不给市场更新用**：市场每次都是新目录（新 realpath），天然绕开全部缓存，
+   * 走 reread 只是白清一遍缓存。
    */
-  async function reload(preferVersion) {
+  async function reload(preferVersion, options = {}) {
     if (detached) throw new Error('插件已经卸载，不能再换代')
     if (swapping) return swapping
     swapping = (async () => {
       const target = resolveGeneration(preferVersion)
       if (!target) throw new Error('找不到任何一代实现：包内的 lib/impl.js 缺失')
+      const sameGeneration = current
+        && target.version === current.version
+        && target.source === current.source
+        && target.dir === current.hostPath
       // 同版本也可能从 OTA 切到 npm：来源与 realpath 不同就必须重新装载。
-      if (current && target.version === current.version && target.source === current.source && target.dir === current.hostPath) return status()
+      if (sameGeneration && options.reread !== true) return status()
+      // 同一份目录里改了文件：不清缓存的话，重新 import 拿回来的还是内存里那份旧实现。
+      if (options.reread === true) invalidateGeneration(target.version)
 
       await drain()
       const oldFiber = fiber

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.1.89",
+  "version": "0.1.91",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (0.2.0-rc.2 compatible, peers resolved by the host)",
   "license": "MIT",
   "type": "module",