dsh-mobile-plugin 0.1.90 → 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/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/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

@@ -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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.1.90",
+  "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",